先还原一个很普通的下午。你在自己的 Ubuntu 虚拟机上写了一个程序:读入一个名字,打印一句问候,然后退出。输入「张三」,正常;输入「Li Si」,正常;输入两百个字母 A,终端只留下一行 Segmentation fault (core dumped),程序没了。再执行 echo $?,得到 139。
很多人第一次遇到这个现象,第一反应是「程序写错了,加个长度判断就行」。这个判断没有错,但它只回答了「怎么让程序不崩」,没有回答「为什么一段数据能让程序走到一个不该去的地方」。二进制安全(常被叫作 PWN)研究的正是后一个问题:当输入能影响内存里的内容时,程序的控制流会不会被改写,改写之后能做到什么,以及怎样在设计上堵住它。
这篇不教你拿某个真实站点练手,也不给任何现成利用代码。它只做三件事:把崩溃这件事拆开看清楚,说明这门技术为什么必须限定在授权环境,再给出一组今天就能在自己机器上跑的实验。
先把现场还原
为了不让问题被「默认开启的保护」提前挡住,第一段代码故意关掉栈保护、关掉地址随机化相关的编译选项。程序只做一件事:从标准输入读最多 200 字节,放进一个只有 16 字节的数组。
/* crash.c:只用于本机实验 */
#include <unistd.h>
int main(void) {
char name[16];
write(1, "name: ", 6);
read(0, name, 200); /* 这里故意允许写 200 字节 */
write(1, "hello\n", 6);
return 0;
}
编译命令只关栈保护、保留调试符号、固定代码段基址。这三个开关的意义后面几篇会逐一解释,现在先照着做:
gcc -O0 -g -fno-stack-protector -no-pie crash.c -o crash
python3 -c "print('A'*8)" | ./crash; echo $?
python3 -c "print('A'*200)" | ./crash; echo $?
在一台标准 x86-64 Ubuntu 上,第一组输入会打印问候并返回 0;第二组会触发段错误,退出码 139。这里有一个容易忽略的细节:139 不是程序自己返回的值,而是 shell 把「进程被 11 号信号终止」翻译成了 128 加 11。11 号信号是 SIGSEGV,也就是段错误。真正做决定的是内核,不是你的 printf。
把这条链路拆成五步,看起来就清楚了:
最后一步是整个现象的关键。函数执行完要回到调用它的地方,这个「回哪里」就存在栈上的一个固定位置。输入把那个位置改成了 0x4141414141414141(四个 A 的字节重复),CPU 执行 ret 时就把这个值当成地址去取指令,取不到,内核发 SIGSEGV。所谓「栈溢出」,溢出的不是抽象概念,而是这块用来记录「回哪里」的内存。
崩溃到底是谁干的
在 Linux 上,一个进程的死法有好几种,每种对应不同的信号。二进制安全里最先要练的,就是不看源码、只从现场判断「它是怎么死的」。
SIGSEGV,退出码 139
访问了没有权限或者没有映射的地址。最常见的原因是解引用空指针、访问已释放的内存,或者返回地址被改成了乱值。core dump 打开后能看到崩溃瞬间的寄存器。
SIGABRT,退出码 134
程序自己调用了 abort(),或者 glibc 在检测到堆/栈被破坏后主动终止。看到 stack smashing detected、free(): double free detected 这类提示,基本都是这一类。
打开 core dump 之后,用 gdb 看现场,通常两条命令就能定性:
ulimit -c unlimited
python3 -c "print('A'*200)" | ./crash
ls core*
gdb -q ./crash core
(gdb) info registers rip rsp rbp
(gdb) x/4gx $rsp
(gdb) bt
如果 rip 是 0x4141414141414141,说明返回地址被输入直接覆盖,属于最典型的线性栈溢出。如果 rip 落在一个合法但奇怪的库地址,可能是函数指针或调用链上的某个位置被改写。如果程序根本没进 core,而是打印一行 stack smashing detected 后退出,那是编译器插的栈保护发现了异常,跟「返回地址已经被改写」是两件不同的事。
这里要先建立一个习惯:崩溃只是结果,不是原因。PWN 的排查顺序永远是「谁写了内存、写了多少、写到了哪个变量/哪个地址、这个地址在程序里承担什么角色」。只盯着「怎么不让它崩」,会错过真正有价值的信息。
从「会崩」到「能控」
会崩的程序很多,但不是每个都能变成安全问题。判断一个内存错误是否值得当成安全漏洞,通常看四个条件:写入的长度能不能控制,写入的内容能不能控制,越界的位置能不能稳定命中,命中的目标在运行时是否可预测。四个条件满足得越多,问题的严重性越高。
举个对照。一个数组越界读,读到脏数据后打印出来,最多算信息泄露;如果读的位置刚好是栈上的返回地址或某个指针,泄露的就是绕过地址随机化需要的材料。一个数组越界写,如果只能多写一个字节,可能只是破坏相邻变量;如果能连续写几百字节,就能一路写到返回地址。攻击面的大小,取决于「可控程度」,而不是「有没有越界」。
这四层也是后面几篇的顺序。第二篇讲运行时层的内存布局,第三篇讲源码层的栈溢出,第四篇讲编译产物层和系统层的几种保护,第五、第六篇分别讲在保护之下怎么复用代码、堆上的错误长什么样,第七篇把调试工具串成工作流,第八篇用一道自建靶场题把流程走一遍。
为什么换个环境结果就变
初学者最常卡住的地方不是原理,而是「教程里能打通,我这里不行」。同一份源码,换一台机器、换一个编译器版本、换一个 libc,栈帧布局、函数地址、保护开关都可能变。尤其要注意三件事。
第一,Ubuntu 从很多年前开始就默认开启 PIE、栈保护和 NX。你在教程里看到的 -no-pie、-fno-stack-protector,是为了教学方便临时关掉保护,不是生产环境的常态。第二,libc 版本会影响函数内部实现和堆管理行为,同样的偏移在 2.31 和 2.35 上可能完全不一样。第三,地址随机化(ASLR)会让每次运行的栈地址、库地址都变,gdb 默认又会关掉随机化,所以「gdb 里地址稳定、直接运行地址乱跳」是正常现象。
所以看到一个二进制,第一步不是找漏洞,而是确认它是在什么环境下编出来的、开了哪些保护、跑在什么 libc 上。这个动作在第七篇会用工具固化成习惯;现在只要记住:环境不确认,后面所有数字都不可信。
现象对照表
下面这张表覆盖了入门阶段最常见的六种现场。遇到问题时先对号,再决定往哪一层查。
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 输入一长串字符,进程直接 Segmentation fault,退出码 139 | 返回地址被覆盖成非法地址,ret 时跳到不可执行/未映射区域 | echo $?、dmesg | tail、gdb 里看 rip 和 $rsp |
| 输入 16 字节没事,17 字节就崩 | 刚好越过缓冲区,改坏了相邻的局部变量或保存的栈帧指针 | 反汇编看 sub rsp 后的缓冲区偏移,确认边界到底在哪 |
运行提示 stack smashing detected,退出码 134 | 编译器默认开启栈保护,canary 被写坏后调用 __stack_chk_fail | checksec、readelf -s ./crash | grep stack_chk |
| 同样的程序在自己机器上不崩,在靶场上崩 | 编译器默认选项、libc 版本、内核随机化策略不同 | 对比 gcc -v、ldd ./crash、checksec 输出 |
| 崩溃地址每次都不一样 | ASLR 随机化了栈、堆和共享库的基址,PIE 还会随机化程序自身 | cat /proc/sys/kernel/randomize_va_space,gdb 里 vmmap |
| 程序没崩,但输出了奇怪内容,或者权限判断失效 | 覆盖的不是返回地址,而是长度变量、函数指针、标志位等数据 | 看崩溃点附近的变量布局,确认写入范围越过了哪个对象 |
这张表不是让你背结论,而是训练排查顺序:先确认死法,再确认被改写的对象,最后才谈怎么利用或者怎么修。顺序反了,就会陷入「照着教程改数字」的循环。
边界与代价
先说边界。二进制安全的技术本身是中性的,同一套调试方法,用来给自己的程序找 bug 是工程能力,用来打没有授权的系统就是另一回事。合法场景只有三类:自己的机器和自编译程序、明确授权的测试目标、公开的 CTF 靶场。授权要落实到纸面,至少写清目标范围、测试时间、允许的动作、发现问题的披露方式。口头一句「你可以试试」在出了事之后很难作为依据。
再说代价。第一是环境成本:要维持一个可复现的 Linux 环境,固定 libc 版本,记录编译命令,否则今天调通的偏移明天就失效。第二是时间成本:大部分时间花在读反汇编、确认内存布局、排除干扰,真正「构造输入」反而是最后一步。第三是知识成本:不熟悉 C 的指针和数组、不熟悉 x86-64 的函数调用约定,看栈帧就像看天书,硬背 payload 只会越学越乱。第四是防护成本:Canary、PIE、Full RELRO、堆上的 safe-linking、部分平台开始启用的控制流保护,会让老教程里的手法直接失效;学到后面必须持续更新。
但它也有明确的回报。会看二进制的人,排查线上崩溃比只看日志快得多;能给开源项目提交可复现的崩溃样本;能在设计阶段就知道哪种写法会把攻击面放大。这些是防御侧的真实价值,也是这门技术值得学的原因。
真实踩坑与防御点
纸面上的 139 和实际跑出来的 139 之间,隔着几个很容易踩的坑。第一个是编译参数没生效。如果你把编译拆成两步——先 gcc -c 生成 .o,再链接成可执行文件——那么 -fno-stack-protector 必须加在编译那一步,加在链接命令上完全不起作用,因为插桩发生在生成目标文件的时候。Makefile 里改完 CFLAGS 却忘了清理旧的 .o,增量编译会继续复用带着保护的目标文件,现象就是「我明明关了 canary,它还是报 stack smashing」。
判断方法很直接:执行 readelf -s ./crash | grep stack_chk。输出里出现 __stack_chk_fail,说明保护确实被编进去了;一行都没有,才是真的关掉。不要拿「我记得我加了参数」当证据,工具输出才算证据。
第二个坑是平台。我在本机用 MSYS2 的 gcc 16.2 编了同一份逻辑的程序(把 read 换成 fread),用 objdump -d 看 main,缓冲区在 rbp-0x10,也就是输入 24 字节就覆盖到保存的 rbp,32 字节覆盖返回地址;而 Linux 上同样的写法,常见值是 40。两个数字都不是「标准答案」,它们只是各自环境的布局结果。把 Windows 上量到的偏移抄到 Linux 靶场,或者反过来,必然对不上。
同一台机器上还跑了两组对照,可以当作「现象」的参照。48 个 A 直接运行:Windows 上退出码是 -1073741819(0xC0000005,访问冲突),在 gdb 里能看到 rbp 变成 0x4141414141414141;换成 -fstack-protector-all 重新编译,同样的输入先打印 *** stack smashing detected ***: terminated,退出码 -1073740791(0xC0000409)。这两组在 Linux 上也复现了:同一份程序放进 Debian 12 虚拟机(gcc 12.2.0、glibc 2.36),关掉保护、保留符号编译,40 个 A 正常返回 0,41 个和 48 个都被 SIGSEGV 终止,echo $? 是 139;gdb 停在 ret 前,rbp 和 rsp 指向的值都是 0x4141414141414141。加 -fstack-protector-strong 再编,同样的 48 个 A 打印 *** stack smashing detected ***: terminated,退出码 134。四个数字——Windows 的 0xC0000005 / 0xC0000409、Linux 的 139 / 134——现在都是本机跑出来的,不是按信号语义推的。
所以判断一个崩溃,不要只记「它崩了」,要按四路对号。运行后 echo $? 得到 139,说明进程被 SIGSEGV 终止,方向是访问了非法地址,先去 gdb 看 rip;得到 134 并且屏幕上出现 stack smashing detected,说明是 canary 先发现了异常,返回地址可能还没被真正用到,方向是查保护而不是查利用;退出码是 0 但输出内容乱了,说明被改写的是普通变量而不是控制流,方向是查数据布局;gdb 里 rip 正好等于你输入的那串字节(比如 0x4141414141414141),才是「返回地址被直接覆盖」这一种。
对应的防御点在实际项目里很具体。解析外部输入的函数一律先校验长度再拷贝,用 fgets、snprintf、std::vector 的 at() 这类自带边界的接口,而不是 strcpy、gets、手写下标;编译默认加 -fstack-protector-strong、-D_FORTIFY_SOURCE=3,链接加 -Wl,-z,relro,-z,now;CI 里让 ASAN/UBSAN 跑一遍单测,再对解析器做几天模糊测试。这些做法和本篇的调试方法是同一套知识的两面:你能看懂栈帧被怎么改,才知道该在哪一层加检查。
当天能做的练习
下面五条都能在自己的虚拟机里完成。做完之后,你应该能独立回答「这个程序是怎么死的」。
- 把
crash.c编译两遍:一遍带-fno-stack-protector -no-pie,一遍用默认选项。分别输入 8、17、200 个字符,记录退出码和终端提示,比较两种编译结果的差异。 - 执行
ulimit -c unlimited后复现崩溃,用gdb ./crash core打开,执行bt、info registers rip rsp rbp、x/8gx $rsp,把看到的值抄下来,解释每个值对应什么。 - 用
readelf -h ./crash看Type是EXEC还是DYN,再用readelf -l ./crash | grep GNU_STACK看栈的权限是RW还是RWE。这两条分别对应 PIE 和 NX。 - 写一个只打印局部变量地址的小程序,连续运行五次,观察地址变化;再用
setarch $(uname -m) -R ./demo关掉随机化跑五次,对比结果。 - 用
python3生成 8 到 64 字节、步长 8 的输入,逐组运行,记录「正常 / 崩溃 / 被栈保护拦截」,画一张长度与结果的对照表。
小结
三句话收一下:程序崩溃是内核按信号终止进程,139 和 134 分别对应段错误和主动终止;二进制安全关心的不是「怎么让它不崩」,而是「输入能不能稳定改写内存里的关键对象」;这门技术只能在授权环境里练,越界的代价是法律问题,不是技术问题。
下一篇进入内存布局。今天你已经看到「返回地址」这个词,但它到底存在栈的哪个位置、栈和堆谁往上谁往下、为什么代码地址和栈地址差了几个数量级,这些问题不搞清楚,后面看反汇编会一直靠猜。下一篇文章会把一个进程的地址空间完整铺开,并用 /proc/self/maps 在你自己的机器上验证一遍。如果你现在还是 Windows、手里没有 Linux 环境,先跳到第七篇的环境一节把 WSL2 或 Docker 装好,后面的命令才有地方跑。