接着上一篇的现场往下走。一个函数里有个 32 字节的数组,程序允许往里面读 128 字节。你输入 31 个或 32 个字符,没事;输入 33 个,有时看起来也没事,过一会儿才崩;输入 48 个以上,返回地址被覆盖,崩溃地址可能变成 0x4141414141414141。同一个漏洞,不同的输入长度,表现并不一样。
这篇要把「越界之后到底覆盖了什么」讲清楚。重点不是记住某个固定偏移,而是学会在反汇编和调试器里自己量出来。因为换编译器、换优化等级、换 libc,偏移就可能变;只会背数字的人,换一台机器就寸步难行。
stack 程序。把同样的输入发到任何没有书面授权的服务上,都可能构成对他人系统的攻击;靶场题目也只在题目指定的实例和时间内操作。先把栈帧摆出来
实验程序故意留下一个长度不受控的读操作。编译时关掉栈保护、保留帧指针、固定代码地址,目的只有一个:先把最干净的模型看清楚。
/* stack.c:只用于本机实验 */
#include <stdio.h>
#include <unistd.h>
void vuln(void) {
char buf[32];
puts("input:");
read(0, buf, 128); /* 故意:数组 32 字节,却允许读 128 字节 */
printf("you said: %s\n", buf);
}
int main(void) {
vuln();
puts("bye");
return 0;
}
gcc -O0 -g -fno-stack-protector -no-pie stack.c -o stack
objdump -d -M intel ./stack | sed -n '/<vuln>:/,/^$/p'
反汇编会给出类似这样的序言。具体地址随编译变化,但结构是固定的:
0000000000401156 <vuln>:
401156: 55 push rbp
401157: 48 89 e5 mov rbp,rsp
40115a: 48 83 ec 20 sub rsp,0x20
40115e: 48 8d 45 e0 lea rax,[rbp-0x20]
...
4011a0: c9 leave
4011a1: c3 ret
关键信息只有三条:函数给局部变量留了 0x20 字节;数组的起始地址是 rbp-0x20;函数结尾用 leave 加 ret 返回。由此可以画出这块栈帧的布局:
[rbp+8] 返回地址,函数结束后要跳回这里[rbp] 保存的调用者 rbp[rbp-0x20] 到 [rbp-1],32 字节的 bufrsp 指向的栈顶,函数调用时临时使用从 buf 的第一个字节到返回地址,距离是 32 字节的数组加 8 字节保存的 rbp,也就是 40 字节。这就是这个版本程序里「偏移」的来源。输入的第 41 个字节,会落到返回地址的第一个字节上。
要强调一句:40 不是通用常数。编译器可能因为 16 字节对齐把 buf 放在 rbp-0x30,也可能插入 canary,或者在优化后直接省掉帧指针。每次换编译选项,都要重新看反汇编。
越界写入按什么顺序破坏
read 从 buf 的起始地址开始,一个字节一个字节往高地址写。写满 32 个字节后,再写就进入 [rbp] 的位置;写满 40 个字节后,再写就进入 [rbp+8] 的返回地址。整个过程没有任何边界检查,因为 read 只知道自己要读 128 字节,不知道调用者给的缓冲区只有 32 字节。
这里有个容易混淆的点:覆盖了保存的 rbp,为什么不是立刻崩?因为 leave 执行的是 mov rsp, rbp,用的是寄存器里仍然有效的旧 rbp,不是栈上那个被改坏的值。真正把坏值装进 rbp 的是紧接着的 pop rbp。这条指令只改寄存器,不访问内存,所以不会立刻触发段错误;下一条 ret 从栈上弹出被改写的返回地址,CPU 试图跳到那里取指令,才会崩。
如果输入长度刚好停在 40 字节,只覆盖了保存的 rbp,返回地址还是原值,函数能正常返回,但调用者的 rbp 已经变成了垃圾值。调用者后面如果用 rbp 寻址,就可能在一个奇怪的地方读写,表现为「程序没立刻崩,过一会儿才崩」。这类延迟崩溃在现场排查时最容易被误判。
如果输入长度到 48 字节,返回地址被完整覆盖。之后程序执行到 ret,rip 就变成输入的最后 8 个字节。用 8 个 B(0x42)填充,崩溃地址就是 0x4242424242424242;这比只看「程序崩了」有用得多,因为它证明了你确实控制到了返回地址。
崩溃地址为什么是 0x4141414141414141
很多教程直接写「输入 40 个 A,再输入 8 个 B,rip 就会变成 0x4242424242424242」。这句话在原理上没错,但省略了两个细节:小端序,以及 8 字节对齐。
x86-64 是小端序,一个 64 位整数在内存里是低字节在前。你写进去的 8 个 B 在内存里是 42 42 42 42 42 42 42 42,CPU 把它当成地址读出来,就是 0x4242424242424242。如果你只写了 4 个 B,后面 4 个字节还是原来的值,地址就变成 0x0000000042424242 之类的混合值。这也是为什么偏移必须精确到字节,差一个字节,覆盖的就是相邻字段。
另一个细节是,返回地址是 8 字节。如果输入长度是 41 到 47 字节之间,只会覆盖返回地址的低几个字节,高位保留原值。这在某些场景下反而有用(比如只改低两字节做部分覆盖),但对入门阶段来说,先保证「刚好覆盖完整的 8 字节」更容易理解。
崩溃地址本身也有诊断价值。看到 0x4141414141414141,基本可以确定返回地址被 A 覆盖;看到 0x00000041414141,说明只覆盖了低 3 个字节,可能是输入长度不够或者对齐有偏差;看到 0x7f... 这样的合法库地址,说明覆盖的不是返回地址,而是某个函数指针或调用链上的对象。不要只记「崩了」,要读 rip 的值。
偏移不能靠猜,要靠量
最稳的测量方式是在 ret 指令执行前停下来,看 rsp 指向什么。此时 [rsp] 就是即将被弹出的返回地址。具体步骤:
gdb -q ./stack
(gdb) set disassembly-flavor intel
(gdb) disassemble vuln
(gdb) break *0x4011a1 ; 换成你环境里 ret 的实际地址
(gdb) run < input.txt
(gdb) info registers rsp rbp rip
(gdb) x/8gx $rsp
如果输入是一串有规律的标记,比如 40 个 A 后面跟 8 个 B,x/8gx $rsp 第一行就会显示 0x4242424242424242。把输入换成 pwntools 的 cyclic 模式,崩溃后可以用 cyclic_find 直接算出偏移:
python3 -c "from pwn import *; print(cyclic(100))" > pattern.txt
# 在 gdb 里 run < pattern.txt,把 $rsp 上的值抄下来
python3 -c "from pwn import *; print(cyclic_find(<刚才抄下的值>))"
本机在 Debian 12 虚拟机里把这段走了一遍:gcc -O0 -g -fno-stack-protector -no-pie stack.c -o stack 编译(buf[32] 加 read(0, buf, 128)),objdump 里是 sub rsp,0x20、缓冲区 [rbp-0x20],所以到保存的 rbp 是 32 字节、到返回地址是 40 字节。在 ret 前下断点,喂 48 个 A:
Breakpoint 1, 0x0000000000401190 in vuln () at stack.c:9
rsp 0x7fffffffeb08 0x7fffffffeb08
rbp 0x4141414141414141 0x4141414141414141
rip 0x401190 0x401190 <vuln+74>
0x7fffffffeb08: 0x4141414141414141 0x0000000000000001
#0 0x0000000000401190 in vuln () at stack.c:9
#1 0x4141414141414141 in ?? ()
直接运行的结果也对得上:40 个 A 退出码 0,只覆盖了保存的 rbp;41 个 A 和 48 个 A 都是 139。41 字节那组更细,ret 前 [rsp] 是 0x401141,也就是原来的返回地址 0x401191 被改掉了最低一个字节,高位原样保留。换成 cyclic(100),[rsp] 上是 0x6161616c6161616b,cyclic_find 返回 40。这里有个容易踩的坑:gdb 打印的 rip 仍然是 0x401190,即 ret 那条指令本身,因为跳到非规范地址时 fault 停在 ret 上;反查偏移要用 $rsp 上的值,拿 rip 去做 cyclic_find 会得到 -1。
cyclic 生成的是每 4 个字节都不重复的字符串,所以从崩溃地址反推偏移不会撞车。如果本机没装 pwntools,也可以自己写一个小脚本生成递增标记,或者手动二分:先用 48 字节确认能改到 rip,再用 40、44、46 逐组缩小范围。手动方法慢,但能让你真正理解「偏移」是什么。
注意 gdb 默认会关闭地址随机化,而且 run 时的环境变量、输入方式可能和直接运行不同。量出来的偏移在 gdb 里成立,到了真实运行还要复核一次;如果偏移差了几个字节,优先怀疑编译选项、栈对齐和环境变量长度。
为什么有时 33 字节就崩,有时 64 字节才崩
同样是越界,崩溃点不同,通常不是玄学,而是下面几种原因之一。第一种是只覆盖了保存的 rbp,返回地址没动,函数还能返回,但调用者之后用坏掉的 rbp 访问内存才崩。第二种是编译器插入了 canary,越界写到 canary 时就被检测到,程序在函数结尾主动 abort,根本走不到 ret。第三种是栈对齐或编译器把数组放在不同偏移,导致你算的 40 和实际的 56 对不上。第四种是输入里含有换行、空格或结束符,read 收到的是被截断的数据,长度根本没有你想象的那么多。
把这几种情况分开的方法很简单:先看程序是收到 SIGSEGV 还是 SIGABRT,再看崩溃时的 rip 是不是 0x4141...,最后看 checksec 有没有 Canary。三个信息凑齐,基本就能定位。
现象对照表
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 输入 40 字节正常,41 字节崩溃 | 偏移刚好是 40,第 41 字节开始改写返回地址 | 反汇编里 [rbp+8] 减去 buf 的起始偏移 |
崩溃时 rip 是 0x4141414141414141 | 返回地址被 8 个 A 完整覆盖,ret 跳向该地址 | 在 ret 下断点,x/gx $rsp 看即将弹出的值 |
程序没在 ret 崩,而是稍后崩在别处 | 只覆盖了保存的 rbp,调用者用坏掉的栈帧指针寻址 | info registers rbp,看 rbp 是否变成输入字符 |
输入很长,但提示 stack smashing detected,退出码 134 | Canary 被覆盖,函数结尾的检查失败后调用 abort | checksec、readelf -s 查 __stack_chk_fail |
| 本地偏移 40,靶场二进制偏移 56 | 编译器版本、优化等级或栈对齐不同,缓冲区实际位置发生变化 | 对靶场二进制重新反汇编,不要套用本地数字 |
| 输入里有换行,实际写入长度比预期短 | read 或输入函数在分隔符处截断,后面的字节没进内存 | 在 read 返回后看缓冲区的实际内容和返回值 |
这六条覆盖了入门阶段九成以上的「为什么和教程不一样」。真正要养成的习惯是:每次崩溃都记录输入长度、信号、rip、rsp 和目标二进制保护,四项缺一不可。
边界与代价
栈溢出的原理不复杂,但把它变成稳定可控的结果,代价很高。第一,偏移依赖环境:同一份源码在不同编译器、不同优化等级下可能差 8 到 32 字节,靶场上给的二进制必须重新测量,不能照搬。第二,现代程序默认有 Canary、PIE、NX,直接覆盖返回地址通常走不通,需要先泄露地址、绕过检查,复杂程度成倍上升。第三,覆盖返回地址只是第一步,跳过去之后要执行什么、参数怎么传、栈怎么对齐,每一步都可能让进程提前崩溃。第四,也是最容易被忽略的:真实软件里,能稳定触发越界写的输入往往受协议、长度字段、字符过滤限制,「理论上有洞」和「实际能打」是两回事。
法律边界再强调一次:栈溢出是攻击链里最基础的一环,拿它去测试任何没有授权的系统,性质就从「学习」变成「入侵」。合法练习只有自己的二进制、官方靶场和书面授权目标;靶场也要看清规则,不要扫别的队伍、不要打平台以外的地址。
从防御角度看,这篇的价值在于知道「长度检查该放在哪」。只要在写入前把长度限制在缓冲区大小以内,这条攻击路径就断了。真正难的是把所有输入路径都找全,而不是知道要检查。
真实踩坑与判断方法
第一个坑是编译选项只加在了链接命令上。把 gcc -c 和链接分开写时,-fno-stack-protector 必须跟编译那一步,因为插桩是在生成目标文件时做的;只加在链接命令上,编译器不认,最后出来的二进制照样带 canary。判断不看命令行,看产物:readelf -s ./stack | grep __stack_chk_fail,有输出说明保护在里面,没有才算真的关掉。另一个同类问题是没有清理旧的 .o,增量编译复用了带保护的旧目标文件。
第二个坑是优化等级。-O2 常常省略帧指针(-fomit-frame-pointer),这时「buf 到 [rbp+8] 的距离」这套算法就没法直接用了,反汇编里也看不到 push rbp; mov rbp, rsp。判断方法:看函数开头,如果没有 push rbp,说明帧指针被省了,要么改用 -O0 或 -fno-omit-frame-pointer 重编,要么按 rsp 相对偏移重新算。
第三个坑是平台和工具状态。同一份源码,用 MSYS2 gcc 16.2 编成 Windows PE 时,objdump 显示缓冲区在 rbp-0x10,24 字节覆盖保存的 rbp、32 字节覆盖返回地址;换成 Debian 12 虚拟机里的 gcc -O0 -g -fno-stack-protector -no-pie,缓冲区在 [rbp-0x20],两个数字分别变成 32 和 40。实测也对得上:40 个 A 正常返回 0,41 个就收到 SIGSEGV,退出码 139;48 个 A 时 gdb 停在 ret 前,rbp 和 [rsp] 都是 0x4141414141414141,bt 的第一层已经成了 #1 0x4141414141414141 in ?? ()。Windows 侧 48 个 A 的退出码是 -1073741819(0xC0000005),加 -fstack-protector-all 后是 -1073740791(0xC0000409);Linux 侧对应的 139 和 134 也在同一台机器上实测到了,canary 版本打印的是 *** stack smashing detected ***: terminated。
判断一次溢出到底改到了什么,按四路走就够了。输入后 echo $? 得到 139,且 gdb 里 rip 是 0x4141...,说明返回地址被完整覆盖;得到 139 但 rip 是个像栈或堆的地址,说明只改坏了几字节、控制流被带到了别处;得到 134 并且出现 stack smashing detected,说明 canary 先一步拦下,返回地址根本没被用到;退出码 0 而输出错乱,说明改的是普通变量,此时该看相邻局部变量的布局,而不是找 ret。另外别忘输入末尾的换行符也占一个字节,用 sendline 时偏移要按多一个 \n 算。
第四个坑是拿「有没有崩」当唯一的判断依据,这一条比前面都容易被忽略。覆盖到保存的 rbp 之后,函数不一定立刻崩:如果编译器在结尾用 leave(即 mov rsp, rbp; pop rbp),rsp 会先被改成你写入的垃圾值,接下来 pop rbp 就访问非法地址;但如果这个函数被内联、或者结尾直接 add rsp, N; ret,被改坏的 rbp 可能一直没被用到,程序会正常退出,错误要等到更外层函数返回才暴露。所以判断偏移要看反汇编里 [rbp+8] 的位置,或者用 gdb 在 ret 前看 rsp 指向的内容,不要用「输入多少个字节会崩」反推。
真实项目里的对应防御点有三层。代码层,所有拷贝前先比长度,用 fgets、snprintf、strlcpy 这类有边界的接口,禁止 gets、strcpy 进主干;构建层,默认开 -fstack-protector-strong、-D_FORTIFY_SOURCE=3、PIE 和 NX,发布前用 checksec 卡一道;测试层,CI 里跑 ASAN,它会把越界直接报成 stack-buffer-overflow 并指出哪一行写超了,比等线上崩溃再查便宜得多。做到这三点,剩下的风险主要在第三方库和漏掉的输入路径上。
靶场里能验证的练习
- 编译
stack.c,用objdump找到buf的偏移和ret的地址,算出「缓冲区开头到返回地址」的字节数,并和实际发送 40、41、48 字节的结果对照。 - 在
ret前下断点,分别输入 40 个A、40 个A加 8 个B、48 个A加 8 个C,记录rsp上的值和最终的rip,解释每组结果。 - 用
cyclic(100)生成模式串,在 gdb 里复现崩溃,再用cyclic_find反推偏移;和你从反汇编算出的数字对比。 - 把编译选项换成默认(带栈保护),重复上面的输入,观察程序是收到 SIGSEGV 还是 SIGABRT,提示语有什么不同。
- 用
-O2再编译一次,重新反汇编,看帧指针是否还在、偏移有没有变化,解释变化的原因。
小结
三句话收一下:栈帧里局部数组在低地址,保存的 rbp 和返回地址在高地址,线性越界会按这个顺序覆盖;偏移等于「数组起点到 [rbp+8]」的距离,必须从反汇编里量,不能背常数;崩溃地址能告诉你控制了哪一段,0x4141... 说明返回地址已经被完整改写。
下一篇要面对现实:现代二进制默认开着 NX、Canary、PIE、RELRO,你刚学会的「覆盖返回地址跳过去」会被其中好几项挡住。先弄清楚每项防护到底拦住了什么、哪些只是提高成本、哪些能通过别的漏洞绕过,才知道下一步该往哪走。动手之前如果还没有 Linux 靶场,先看第七篇的环境一节。