你可能已经遇到过一次典型的挫败:照着教程写好 payload,在本机跑得好好的,换到靶场给的二进制上,程序只回了一行 stack smashing detected 就退出;或者返回地址明明改对了,执行到那儿却收到段错误,因为那块内存根本不允许执行。这不是你的偏移算错了,而是二进制上开了防护。
现代 Linux 发行版编译出来的程序,默认就带好几层保护。它们不是「有漏洞就没法利用」的魔法,而是在攻击链的不同环节加了一道检查。这篇逐个说明:每一项防的是什么、在什么现象下会被它拦住、怎样确认它是否开启,以及它真正的局限。
先学会读 checksec
checksec 不是系统自带的命令,装了 pwntools 之后可以用 pwn checksec,也有独立的脚本版本。它读取 ELF 头和程序头,把几项关键属性汇总成四行。一个典型的现代 Ubuntu 二进制输出如下:
$ checksec --file=./demo
[*] '/home/user/demo'
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
四行分别对应四种防护。先不要背结论,先记住它们各自检查的是 ELF 里的什么字段:
| 输出行 | 看的字段 | 含义 |
|---|---|---|
| RELRO | GNU_RELRO 段、BIND_NOW 标志 | 部分或完全只读重定位,决定 GOT 能不能被改写 |
| Stack | 符号表里的 __stack_chk_fail | 是否插入栈保护 canary |
| NX | GNU_STACK 段的权限 | 栈和堆是否可执行 |
| PIE | ELF 类型是 DYN 还是 EXEC | 程序自身加载地址是否随机化 |
用 readelf 也能逐项确认,不必依赖 checksec:readelf -h 看 Type,readelf -l 看 GNU_STACK 和 GNU_RELRO,readelf -d 看 BIND_NOW,readelf -s 找 __stack_chk_fail。这五条命令在第七篇会放进固定工作流。
NX:把栈和堆标成不可执行
NX(No eXecute,也叫 DEP)的作用很直接:让栈和堆所在的内存页只有读写权限,没有执行权限。上一篇里你把返回地址改成 0x4141... 会崩,把返回地址改成自己写在栈上的机器码地址,同样会崩,而且这次是页权限错误。CPU 在取指阶段就拒绝了。
确认方式:
readelf -l ./demo | grep -A1 GNU_STACK
# 正常:RW;关闭后:RWE
cat /proc/$$/maps | grep -E 'stack|heap'
# 正常:rw-p;关闭后:rwxp
NX 拦的是「在数据区执行代码」这条路径。它并不阻止你改写返回地址,也不阻止你跳到程序里已有的代码。于是攻击思路被迫从「注入一段自己的代码」转成「复用程序或 libc 里已有的指令片段」。这就是第五篇 ROP 的由来。换句话说,NX 把问题从「写什么代码」变成了「怎么把已有代码串起来」,成本提高了,但门没有完全关死。
代价:JIT 编译器、某些模拟器需要可执行内存,它们会显式申请 PROT_EXEC 页,不能简单地全局关 NX。对普通业务程序来说,NX 几乎是零成本的,现代工具链默认开启,只有教学演示才会用 -z execstack 关掉。
Canary:在返回地址前放一个哨兵
栈保护的做法是:函数入口在栈上放一个随机值,通常位于 [rbp-8],紧挨着保存的 rbp;函数返回前把这个值和线程局部的原始值比较,不一致就调用 __stack_chk_fail,进程收到 SIGABRT,终端上通常打印 stack smashing detected。
为什么它能挡住上一篇的线性溢出?因为输入要从缓冲区一路写到返回地址,必然先经过 canary。你不知道这个随机值,写进去就会改坏它,函数在返回前就自杀了,根本走不到 ret。
gcc -O0 -g -fstack-protector-strong demo.c -o demo_canary
readelf -s ./demo_canary | grep stack_chk
# 能看到 __stack_chk_fail 和 __stack_chk_guard 相关符号
Canary 有几个现实边界。第一,-fstack-protector-strong 只保护「有数组或取地址的局部变量」的函数,不是所有函数;-fstack-protector-all 才是全保护。第二,canary 的最低字节通常是 0x00,这让它不容易被字符串函数直接写出,但遇到能逐字节写或能泄露内存的漏洞,仍然可能被读出来再原样填回去。第三,canary 只在函数返回时检查,如果函数在检查前就调用了别的函数、而攻击者改的是函数指针,canary 可能根本不起作用。
代价:每个受保护函数多几条指令和一次内存读,开销很小;对性能极端敏感的热点函数可以用属性关闭,但一般不值得。
PIE:让程序自己的地址也不固定
PIE(Position Independent Executable)让可执行文件像共享库一样,可以被加载到任意基址。开着 PIE 时,readelf -h 的 Type 是 DYN,程序里的函数地址、全局变量地址都相对于基址;关掉 PIE 时是 EXEC,代码段固定在 0x400000 附近。
它和 ASLR 容易混。ASLR 是内核的行为,负责随机化栈、堆、共享库和 PIE 程序的加载基址;PIE 是二进制本身的属性,决定「程序自己能不能被随机加载」。没有 PIE 的程序,即使系统开了 ASLR,代码段地址仍然固定;有 PIE 但系统关了 ASLR,基址也会固定。两者要一起看。
readelf -h ./demo | grep Type
# DYN 表示 PIE,EXEC 表示非 PIE
file ./demo
# PIE 版本通常显示 "pie executable"
PIE 挡住的是「直接写死某个函数地址」的做法。你不知道这次运行的基址,就不能把返回地址精确指过去;必须先通过某个漏洞泄露一个地址,算出基址,再构造第二次输入。这把一次攻击拆成了「泄露 + 利用」两步,提高了门槛。
代价:PIE 会让代码多一层地址计算,通常有 1% 到 3% 的性能开销;绝大多数桌面和服务端程序可以接受。注意 PIE 不是万能的:如果程序里存在只改低字节就能命中的部分覆盖,或者有信息泄露,PIE 仍然可能被绕过。
RELRO:把 GOT 锁成只读
动态链接的程序有一张 GOT(全局偏移表),用来存放外部函数的实际地址。默认的延迟绑定会让 GOT 在第一次调用前保持可写,攻击者如果有一个任意写漏洞,就能把某个函数的 GOT 项改成自己的目标,等程序下次调用该函数时劫持控制流。
RELRO 分两档。Partial RELRO 只把 .got 的一部分(非 .plt 相关项)设为只读,.got.plt 仍可写;Full RELRO 在程序启动时完成全部重定位,然后用 mprotect 把整张 GOT 改成只读,并设置 BIND_NOW 立即绑定。开启 Full RELRO 后,任何往 GOT 写的尝试都会触发段错误。
readelf -l ./demo | grep GNU_RELRO
readelf -d ./demo | grep -E 'BIND_NOW|FLAGS'
# Full RELRO 通常能看到 BIND_NOW 或 FLAGS 里的 NOW 位
它挡的是「改写 GOT 劫持函数调用」这条路径,对栈溢出本身没有直接作用。Partial 和 Full 的差别在「能不能写 .got.plt」,很多老教程里的 GOT 覆盖手法在 Full RELRO 上会直接失效。
代价:Full RELRO 让程序启动时一次性解析所有符号,启动时间略微增加;对大多数程序可以忽略。它也不保护其他可写函数指针(比如 C++ 虚表、回调数组),所以不能把它当成「控制流完整性」。
还有哪些防护,以及它们共同的局限
除了这四项,实际环境里还会遇到:FORTIFY_SOURCE 在编译期把部分危险函数替换成带检查的版本;seccomp 限制进程能调用的系统调用;栈对齐和影子栈(CET)在硬件层校验返回地址;地址空间布局随机化还有更细的粒度。它们共同说明一件事:防护是分层叠加的,目标是提高攻击成本、缩短可利用窗口,而不是宣称「绝对安全」。
防护能做的
让最常见的线性溢出在到达返回地址前就被发现;让注入的机器码无法执行;让写死的地址失效;让 GOT 覆盖失败。它能把大量脚本化的攻击挡在门外。
防护做不到的
不能修复逻辑漏洞,不能阻止信息泄露,不能阻止 ROP 复用已有代码,也不能保证所有函数都被 canary 覆盖。一个能稳定泄露地址、能重复触发的漏洞,仍然可能把几层防护逐一拆掉。
所以看到 Full RELRO + Canary + NX + PIE 不应该得出「这个程序安全」的结论,只能得出「利用成本更高」。反过来,看到 No Canary + No PIE + NX disabled 也不要兴奋,那通常意味着这是一个专门给初学者准备的靶场二进制,真实系统很少这样配置。
现象对照表
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
输入较长后提示 stack smashing detected,退出码 134 | Canary 被覆盖,函数返回前的检查失败,调用 __stack_chk_fail | checksec 的 Stack 行,readelf -s 找 __stack_chk_fail |
| 返回地址改到栈上的地址,仍然段错误 | NX 生效,栈页没有执行权限 | readelf -l 的 GNU_STACK,/proc/pid/maps 的权限位 |
| 教程里写死的函数地址,在靶场上每次都不一样 | PIE 加 ASLR 随机化了程序基址 | readelf -h 的 Type,checksec 的 PIE 行 |
| 往 GOT 写值时直接段错误 | Full RELRO 把 GOT 设为只读 | readelf -l 的 GNU_RELRO,readelf -d 的 BIND_NOW |
checksec 显示 Canary found,但溢出没有触发检测 | -fstack-protector-strong 只保护部分函数,当前函数可能不在保护范围 | 反汇编看序言有没有取 fs:0x28 并放到 [rbp-8] |
| 本地能打通,远程同样的输入失败 | 两端二进制保护不同,或 libc 版本不同导致偏移变化 | 分别对本地和远程二进制跑 checksec,核对 libc 版本 |
这六条里的任何一条,都可以用自己编译的两个版本对照验证:一个全开,一个全关。对照实验比背结论有用得多。
边界与代价
讲防护容易产生两个误解。第一个是「开了防护就安全」:防护只覆盖它设计的那条路径,逻辑漏洞、信息泄露、配置错误都不在它的范围内。第二个是「防护都能绕过,所以没用」:绕过每一项都需要额外的漏洞或信息,攻击链的长度和稳定性都会下降,这就是防护的真实价值。
从工程角度看,代价主要在兼容性和可维护性。Full RELRO 会影响启动时符号解析,个别老程序依赖延迟绑定;PIE 对极少数手写汇编或固定地址布局的程序不友好;关闭 NX 的需求通常来自 JIT 或模拟器,必须用 mprotect 精确控制范围,而不是全局放开。把这些开关当成「编译选项随手加」是不对的,应该按程序的实际需求选择。
法律边界不变:验证防护只对自己的二进制做。看到靶场二进制的保护配置,也不意味着可以对它所在平台的其他服务做任何事。靶场规则通常明确写了允许的目标和端口,超出范围就是越界。
真实踩坑与判断方法
第一个坑:编译和链接分开时,参数加错了阶段。-fno-stack-protector、-fstack-protector-strong 是编译选项,必须加在 gcc -c 那一步;-z execstack、-z relro、-z now 是链接选项,必须加在链接那一步。把两组混在一条命令里多数情况下能跑,但在 Makefile 或 CMake 里被拆开之后,就会出现「我明明写了,保护却没变」。
判断永远看产物,不看命令行:checksec --file=./demo 四行分别是 PIE、Stack、NX、RELRO;想追根就 readelf -d ./demo | grep BIND_NOW、readelf -l ./demo | grep GNU_STACK、readelf -s ./demo | grep __stack_chk_fail。三项都能对得上,才说明你的参数真的生效了。
第二个坑是 -fstack-protector-strong 的保护范围。它只给「有数组、有取地址操作」这类函数插 canary,一个只用标量和指针的小函数可能完全没有。于是 checksec 显示 Canary found,你却在自己写的那段溢出里看不到任何拦截。判断方法很直接:反汇编那个函数,序言里如果有从 fs:0x28 取值并放到 [rbp-8] 再在结尾与它比较,就是被保护了;没有就是没被选中。要覆盖全部函数,用 -fstack-protector-all。
第三个坑和 PIE 的两个开关有关。 -fPIE 是编译选项,-pie 是链接选项,只加一个在某些平台上也能链接成功,但产物不一定完全位置无关。判断:readelf -h ./demo | grep Type,DYN 才是 PIE,EXEC 是固定地址;再运行两次看函数地址是否变化,变了才说明随机化真的在起作用。
我在本机把四个组合都编了一遍,对照结果比只看单项可靠。全关版本(-fno-stack-protector -no-pie -z execstack)的 checksec 是 NX unknown - GNU_STACK missing 加 Stack: Executable,readelf -l 里 GNU_STACK 权限是 RWE;只开 NX 后变成 NX enabled、权限 RW;只开 canary(-fstack-protector-all)时 Stack: Canary found,readelf -s 里 __stack_chk_fail 从 0 条变 1 条;全开版本的 Type 从 EXEC 变 DYN、RELRO 从 Partial 变 Full,readelf -d 里出现 BIND_NOW 与 FLAGS_1: NOW PIE。运行同一组 48 个 A:全关和只开 NX 都是 SIGSEGV、退出码 139;两个带 canary 的版本都是 *** stack smashing detected ***: terminated、退出码 134。Windows PE 上的对应值是 -1073741819(0xC0000005)和 -1073740791(0xC0000409),和 Linux 的 139/134 一一对应。
$ for b in p_off p_nx p_canary p_full; do checksec --file=./$b; done # 每段只留关键行
p_off RELRO: Partial RELRO Stack: No canary found
NX: NX unknown - GNU_STACK missing PIE: No PIE (0x400000)
Stack: Executable RWX: Has RWX segments
p_nx RELRO: Partial RELRO Stack: No canary found
NX: NX enabled PIE: No PIE (0x400000)
p_canary RELRO: Partial RELRO Stack: Canary found
NX: NX enabled PIE: No PIE (0x400000)
p_full RELRO: Full RELRO Stack: Canary found
NX: NX enabled PIE: PIE enabled
$ readelf -h ./p_full | grep Type
Type: DYN (Position-Independent Executable file)
$ readelf -l ./p_off | grep -A1 GNU_STACK | tail -1
0x0000000000000000 0x0000000000000000 RWE 0x10
# 同一组 48 个 A:
p_off exit=139 (Segmentation fault)
p_nx exit=139 (Segmentation fault)
p_canary exit=134 *** stack smashing detected ***: terminated
p_full exit=134 *** stack smashing detected ***: terminated
还有一个容易被漏掉的坑:-D_FORTIFY_SOURCE=3 必须配合 -O1 及以上才有意义。它在编译期把 strcpy、memcpy 这类调用换成带长度检查的版本,优化级别不够时这些替换不会发生,checksec 里也不会体现,你会以为开了保护实际上一点没加。判断:反汇编里看有没有 __*_chk 结尾的符号被调用,有才算生效。
判断一个防护到底挡没挡住,按结果分四路:同一输入在全关版本里 139、在只开 Canary 版本里 134 且提示 smashing,说明 canary 生效;两个版本都是 139 但全开版本的 rip 不是 0x4141...,说明 PIE 让写死的地址失效了;把 rip 指到栈上仍然 139,说明 NX 拦住了执行;向 GOT 写值时立刻 139,说明 Full RELRO 把页设成了只读。四种结果分别对应四项防护,比笼统地说「被挡住了」有用得多。
防御点在工程上是一套固定动作:把加固选项收进构建系统的一个变量(比如 CMake 的 CMAKE_C_FLAGS 集中注入),而不是靠每个人手写;CI 里把 checksec 当门禁,发布产物必须满足 PIE、NX、Canary、Full RELRO 四项;系统层面及时更新 libc 和内核,启用支持 CET 的编译与运行环境;对确实需要可执行内存的模块(JIT、模拟器)用 mprotect 局部放开并单独评审,别为它全局关掉 NX。
靶场里能验证的练习
- 准备一个带溢出的小程序,编译四个版本:全关(
-fno-stack-protector -no-pie -z execstack)、只开 NX、只开 Canary、全开(-fstack-protector-all -pie -fPIE -Wl,-z,relro,-z,now)。对四个文件分别跑checksec,把输出抄成一张表。 - 对每个版本重复同一组输入,记录「正常返回 / SIGSEGV / SIGABRT / 提示语」,解释每个结果对应哪项防护。
- 用
readelf -l和readelf -d找出GNU_STACK、GNU_RELRO、BIND_NOW三个字段,确认它们和 checksec 的结论一致。 - 在 gdb 里对一个 Partial RELRO 和 Full RELRO 的程序分别执行
vmmap,找到 GOT 所在页,比较权限是rw还是r。 - 把
-fstack-protector-strong换成-fstack-protector-all,再对一个没有数组的函数做溢出实验,观察 canary 是否出现。
0xC0000005 / 0xC0000409。两个平台的退出码编码方式不同,不能直接互换。小结
三句话收一下:NX 让栈和堆不可执行,逼着攻击者复用已有代码;Canary 在返回地址前放哨兵,挡住线性溢出;PIE 和 ASLR 让地址不可预测,RELRO 把 GOT 锁成只读,分别针对写死地址和 GOT 覆盖。四项叠加只提高成本,不修复漏洞本身。
下一篇就进入 NX 之后的世界:既然不能自己写代码执行,那就把程序里已有的指令片段串起来。ROP 的核心问题是「怎么用返回地址链控制寄存器、怎么调用已有函数」,也是从「会溢出」到「能控制」的分水岭。要动手验证防护开关,先有 Linux 环境,步骤在第七篇的环境一节。