上一阶段的实验里,你把一段机器码写进栈上的缓冲区,再把返回地址改成缓冲区地址,程序确实跳过去了,但在取第一条指令时就崩了。原因不是机器码写错,而是栈所在的页被标成不可执行。NX 把「自己写代码」这条路封住了。
但程序里本来就有大量已经编译好的指令,libc 里也有。如果能把返回地址改成这些指令的地址,让它们按顺序执行,同样能达到控制程序行为的目的。这套思路叫 ROP(Return-Oriented Programming,面向返回的编程)。它不注入新代码,只借已有代码,所以 NX 拦不住。
rop_demo,目标函数只打印一行提示,不启动 shell、不连接任何外部地址。把这套方法用到没有授权的真实服务上属于攻击行为;ROP 本身是双刃剑,学习时只碰自己的靶场。从「写代码」换成「借代码」
先想清楚一个函数调用需要什么:一段可执行的指令、正确的参数、合法的返回路径。ROP 把这三件事拆开:指令从程序和 libc 里借,参数放在栈上,返回路径用下一段栈数据串起来。因为每个片段最后都以 ret 结尾,执行完一段就会弹出栈上的下一个地址,继续跳到下一段。
这里的关键变化是:栈不再只是数据,它变成了「指令地址和参数组成的脚本」。你控制的每一个 8 字节,都是下一步要跳到哪、或者某个寄存器要装什么值。理解这一点,ROP 就不神秘了。
gadget 是什么
gadget 指一段以 ret 结尾的短指令序列。它不需要是完整的函数,甚至可以从一条指令的中间开始。最常见的是 pop rdi; ret:先把栈顶的值弹进 rdi(x86-64 的第一个参数寄存器),然后返回,继续执行链上的下一项。
用 objdump 或 ROPgadget 可以在自己的二进制里找:
ROPgadget --binary ./rop_demo --only "pop|ret" | grep "pop rdi"
# 典型输出:0x00000000004011eb : pop rdi ; ret
也可以用 pwntools 的 ROP 模块自动搜索:
from pwn import *
elf = ELF('./rop_demo')
rop = ROP(elf)
print(rop.find_gadget(['pop rdi', 'ret']))
为什么 pop rdi; ret 这么重要?因为 System V AMD64 调用约定把第一个整数/指针参数放在 rdi,第二个放 rsi,第三个放 rdx。想调用 puts("/bin/sh") 或 system("..."),第一步就是把参数放进对应寄存器。没有合适的 gadget,就得找别的指令序列,或者换一个更大的二进制。
gadget 不一定干净。pop rdi; ret 可能藏在某条指令的字节中间,也可能带额外的副作用,比如顺带改 rax 或访问内存。找到一个地址不等于它能用,必须看完整反汇编,确认它执行时不会提前崩。
链的排布由调用约定决定
以「调用一个只有一个参数的函数」为例,链的结构是:填充到返回地址、gadget 地址、参数字节、函数地址、函数返回后的地址。执行过程是:ret 跳到 gadget;gadget 的 pop 把下一个 8 字节装进 rdi;gadget 的 ret 再弹出一个地址,跳到目标函数;目标函数执行完,用自己的 ret 弹出链上预留的返回地址。
| 链上的位置 | 内容 | 作用 |
|---|---|---|
| 填充区 | A 重复若干字节 | 从缓冲区开头走到返回地址,不改变控制流 |
| 第一个返回地址 | pop rdi; ret 的地址 | 把下一个值装进第一个参数寄存器 |
| 参数槽 | 要传给函数的指针或整数 | 被 pop rdi 弹进寄存器 |
| 第二个返回地址 | 目标函数地址 | gadget 的 ret 跳到这里 |
| 返回地址槽 | 目标函数结束后要去的地方 | 通常放 exit 或一个安全地址,避免函数返回后乱跳 |
如果目标函数不需要参数,链可以更短:填充区、函数地址、返回地址槽。但「返回地址槽」不能省。函数执行完会执行 ret,如果你没在栈上准备一个合法地址,它就会跳到垃圾值上,表现为「目标函数明明执行了,程序随后还是崩了」。
栈对齐:为什么崩在 movaps
很多人第一次搭 ROP 链,会遇到一个很迷惑的崩溃:链明明跳到了正确的函数,参数也对,程序却停在 libc 里一条 movaps 指令上,提示地址没对齐。movaps 要求操作数是 16 字节对齐的,而它操作的那块栈地址对不对齐,取决于进入函数时 rsp 的余数。
System V AMD64 的约定是:执行 call 之前 rsp 要 16 字节对齐;call 压入 8 字节返回地址后,被调函数入口的 rsp 除以 16 余 8。正常函数调用会自动满足这个条件,但 ROP 链是直接 ret 进去的,栈上的排布等价于少了一次压栈,余数可能变成 0。于是 libc 里用 movaps 访问栈的指令就炸了。
解决办法通常很简单:在跳进目标函数之前多放一个只含 ret 的 gadget,把 rsp 再往下挪 8 字节。这个 gadget 不改变任何寄存器,只调整对齐。很多题解里写的「加一个 ret 就好了」,说的就是这件事。
注意,这不是万能公式。不同的 libc 版本、不同的函数入口,要求的对齐可能不同;正确的做法是在 gdb 里看崩溃时 rsp 的低 4 位,再决定要不要加、加几个。看到 movaps 崩溃,先怀疑对齐,而不是怀疑 gadget 找错了。
ret2win:最小可验证的链
为了不把问题扯进 libc 版本和地址泄露,先做一个最小实验:程序里有一个正常情况下不会被调用的 win(),它只打印一行字然后退出。目标是用溢出把返回地址改成 win() 的地址。这个手法叫 ret2win,是 ROP 的入门形态,不涉及 shell,也不涉及真实目标。
/* rop_demo.c:只用于本机实验 */
#include <stdio.h>
#include <unistd.h>
void win(void) {
puts("you win (local demo only)");
_exit(0);
}
void vuln(void) {
char buf[32];
read(0, buf, 128);
}
int main(void) {
vuln();
puts("bye");
return 0;
}
gcc -O0 -g -fno-stack-protector -no-pie rop_demo.c -o rop_demo
checksec --file=./rop_demo
# NX 开着,Canary 和 PIE 关着,方便先看链本身
objdump -d -M intel ./rop_demo | grep -A2 "<win>:"
偏移仍然是 32 字节缓冲区加 8 字节保存的 rbp,共 40。用 pwntools 组装本地 payload:
from pwn import *
context.log_level = 'info'
elf = ELF('./rop_demo')
io = process('./rop_demo')
offset = 40
ret = ROP(elf).find_gadget(['ret']).address
payload = b'A' * offset + p64(ret) + p64(elf.symbols['win'])
io.sendline(payload)
print(io.recvall(timeout=2).decode(errors='replace'))
这里多放了一个 ret,目的只是调整对齐,让 win() 里调用 puts 时栈满足要求。如果偏移不对,程序会崩在 ret 或 win 入口;如果对齐不对,会崩在 libc 的 movaps。两种失败的现象不同,正好用来练排查。预期输出是 you win (local demo only),然后进程正常退出。
这段脚本只对本地文件有效,不要改一个 remote 就去连别的地址。真实目标有 PIE、ASLR、不同的 libc,地址不可能和你本机一样;要打通需要先泄露地址,再根据远端环境重新计算,那是另一个层级的问题。
下面是本机 Debian 12 虚拟机里 rop_demo 的真实结果,可以拿来校正预期:
$ ROPgadget --binary ./rop_demo --only 'pop|ret'
Gadgets information
============================================================
0x000000000040112d : pop rbp ; ret
0x0000000000401016 : ret
0x0000000000401042 : ret 0x2f
Unique gadgets found: 3
$ ROPgadget --binary ./rop_demo | grep -c 'pop rdi ; ret'
0
$ nm ./rop_demo | grep -E ' T (win|vuln)$'
0000000000401163 T vuln
0000000000401146 T win
$ python3 exploit_ret2win.py
you win (local demo only)
脚本没有等提示就 sendline,recvall 只收到 26 字节,就是这一行;收到它说明返回地址已经可控,控制流确实落到了 win。
注意两个数字:整个程序只有 3 个以 ret 结尾的 gadget,pop rdi ; ret 的数量是 0,pwntools 的 find_gadget(['pop rdi','ret']) 也返回 None。这不是脚本写错,而是二进制太小,编译器没有生成那串字节。没有参数要传时,链上只要 ret(0x401016)加 win(0x401146)两格就够;要传参就得换一个有 pop rdi 的二进制,或者借 libc、ret2csu,这一点下一节还会讲。
再往前走:泄露、libc 和更长的链
真实二进制通常开着 PIE 和 ASLR,你不知道 win() 或 system() 这次落在哪。常见做法是先利用一个输出型漏洞泄露某个函数的真实地址,比如让程序打印 puts 在 GOT 里的值;拿到这个地址后,用已知的 libc 版本算出基址,再拼第二条链。这个过程叫 ret2libc,核心仍是 ROP,只是多了「先泄露、再计算」这一步。
还有两类常见变化。一类是栈空间不够放长链,需要把 rsp 迁移到一块可控的内存上,叫栈迁移(stack pivot),常见指令序列是 leave; ret。另一类是没有合适的 pop rdi,只能用 ret2csu 之类的技巧,借程序里的通用启动代码设置寄存器。这些都属于进阶内容,先把 ret2win 和栈对齐吃透,再往上走。
另外要提一句防御侧的新变化:部分平台开始启用影子栈(CET),硬件会单独保存返回地址,ret 时校验是否与调用时一致。普通 ROP 依赖「改写栈上的返回地址」,在影子栈开启后会被拦下。这说明 ROP 不是永恒的通路,防护和利用一直在拉锯。
现象对照表
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 跳到栈上的地址,取指令时立刻崩 | NX 生效,栈页不可执行 | checksec 的 NX 行,/proc/pid/maps 里栈的权限 |
| 链跳到了 gadget,但目标函数的参数不对 | 链上参数槽的位置错了,或者 pop 用的寄存器不是目标参数寄存器 | gdb 里在目标函数入口看 rdi、rsi,再回头核对链的排布 |
崩在 libc 的 movaps 指令 | 进入函数时 rsp 没有满足 16 字节对齐 | 看崩溃时 rsp 的低 4 位,在链里加一个 ret gadget |
| 目标函数执行了,打印完还是崩 | 函数返回时栈上没有合法的返回地址 | 检查链尾是否放了 exit 或另一个合法地址 |
| 本地地址有效,远程同样的链失败 | PIE、ASLR 或 libc 版本不同,地址整体偏移 | 核对两端 checksec、libc 版本,先做地址泄露 |
找不到 pop rdi; ret | 二进制太小或编译优化减少了可用字节序列 | 用 ROPgadget 搜整个文件,或改用 libc 里的 gadget、ret2csu |
这张表里最值得记住的是第三条和第四条:ROP 失败往往不是「地址算错」,而是「链的结构不完整」。一个能执行的链,必须同时满足控制流、参数、返回路径和对齐四个条件。
边界与代价
ROP 把「内存写」升级成了「任意代码复用」,能力比栈溢出本身大得多,所以边界要更严格。只在自己的二进制、官方靶场和书面授权目标上实验;不要把本地调通的链直接指向任何线上地址;不要为了「验证」去扫描、探测不属于你的服务。技术上能跑通,不等于法律上可以做,这两件事必须分开。
代价体现在稳定性上。真实环境的 ASLR 会让链上的绝对地址失效,必须配合泄露;不同 libc 版本里 gadget 的偏移不同,换一台机器就要重找;栈对齐、环境变量长度、输入方式都会影响偏移;影子栈、沙箱、系统调用过滤会让链在最后一步失败。一个在本地「一次成功」的链,离「稳定可复现」还有很长的距离。
从防御角度,ROP 说明「关掉栈执行」还不够。真正有效的做法是减少可控的返回地址改写(canary、影子栈)、减少信息泄露、限制可用 gadget(CFI),以及把高危操作放进沙箱。单靠一项防护,挡不住一条完整的链。
真实踩坑与判断方法
第一个坑出在工具接口上。pwntools 的 ROP(elf).find_gadget(['ret']) 返回的已经是地址本身,不少教程写成 find_gadget(['ret'])[0].address,运行时会得到 AttributeError: 'int' object has no attribute 'address'。看到这个报错不是没找到 gadget,而是多取了一层。另一头,ROPgadget 命令行打出的地址是文件里的偏移,PIE 程序运行时还要加上基址,直接抄进脚本必然崩。输出太多时先用 --only "pop|ret" 过滤;看到 leave; ret 也别急着当普通 ret 用,它会改 rsp,链的走向完全不同。
第二个坑是「相对」和「绝对」混用。非 PIE 的二进制里,gadget 地址就是运行时地址,抄下来能用;一旦换成 PIE,同一串字节的地址每次都在变,链上写死 0x401234 会跳到没映射的地方。判断很直接:崩溃时 rip 等于你链上那个很小的地址,而 info proc mappings 里代码段在 0x55...,说明你用的是文件偏移而不是运行时地址,需要先泄露基址再加上去。
第三个坑是链的结构不完整。ret2win 有三种典型失败,现象完全不同:崩在 ret 本身,说明返回地址被写成了无效值,回去检查偏移和字节序;崩在 win 入口,说明控制流到了但参数或对齐不对;win 打印完又崩,说明链尾没放合法返回地址,函数返回时又跳到了垃圾值。能把这三种分开,比「链不通」三个字有用得多。
第四个坑是「靶场能过、本地不行」和反过来。常见原因不是脚本逻辑,而是 libc 版本和输入时序:远端用 2.35、本地用 2.31,system 的偏移差了几万字节;或者远端先打印提示再读输入,脚本却一口气把 payload 全发过去,recvuntil 没对齐。判断方法:把 context.log_level 设成 debug 看实际收发字节;用 ldd ./demo 对比两端 libc 版本;先用最简单的 ret2win 验证链路通不通,再加复杂步骤。换题之前先把二进制哈希和 libc 版本这两个前提确认掉,能省掉一半的无效调试。
第五个坑是启用 CET 之后的 endbr64 前缀。较新的编译器会在函数入口插入 4 字节的 f3 0f 1e fa,ROPgadget 搜出来的地址可能落在前缀中间,跳过去执行会直接触发控制保护异常;也可能你从别人 writeup 里抄的地址比实际少了 4 字节。判断:反汇编那个地址,如果看到的是半条指令或者 endbr64 的位置不对,按函数真实入口重新取。
防御点在真实项目里对应四件事:编译和运行尽量启用影子栈(CET),让 ret 校验返回地址,从硬件层掐断普通 ROP;减少二进制里的可用 gadget 和危险函数,别把 system、exec* 这类调用留在不需要它的进程里;严控信息泄露,日志不打指针、错误页不返回完整栈;用 seccomp 收窄进程能用的系统调用,即使链打通了也执行不了下一步。这四条加上 canary 和 PIE 才是完整组合,单靠任何一项都挡不住。
靶场里能验证的练习
- 编译
rop_demo,用ROPgadget找出至少三个以ret结尾的 gadget,记录地址和完整指令,说明各自能改哪个寄存器。 - 先不加额外的
ret,直接构造「填充 + win 地址」,观察是否崩在movaps;再加上一个ret,对比结果。 - 把
win改成接收一个字符串参数并打印,用pop rdi; ret把参数传进去,验证你对调用约定的理解。 - 编译一个开 PIE 的版本,重复上面的链,观察地址变化导致失败;然后在 gdb 里用
info proc mappings解释为什么必须泄露基址。 - 用
ROP(elf).dump()打印 pwntools 自动找到的 gadget 列表,和你手动用 ROPgadget 的结果对照,看看哪些它没选、为什么。
checksec、objdump、ROPgadget、cyclic_find 和 ret2win 脚本都在 Debian 12 虚拟机(gcc 12.2.0、gdb 13.1、pwntools 4.15.0)上跑通。示例 rop_demo 的 win 是 0x401146、ret gadget 是 0x401016、偏移 40;这个程序里没有 pop rdi ; ret,ROPgadget 统计为 0。换二进制、换 libc 之后这些数都会变,请以你自己反汇编出来的结果为准。小结
三句话收一下:NX 让注入的代码不能执行,ROP 改为复用程序里已有的、以 ret 结尾的指令片段;链的排布由调用约定决定,参数放寄存器、返回地址放栈上,缺一项就会崩;栈对齐和链尾的合法返回地址,是新手最容易忽略的两个坑。
下一篇换一个战场:不在栈上做文章,而是看堆。堆上没有返回地址那么直观的目标,错误的表现也更隐蔽,释放后继续用、重复释放、越界写一个字节,都可能导致分配器在某个完全不相干的位置崩溃。理解堆块的生命周期,是读懂这些现象的前提。动手复现前,先按第七篇的环境一节把 Linux 和 pwntools 装好。