这篇能做出什么
拿一个没有源码的二进制文件——可能是自己写的练手程序、一道 CTF 题、一个老旧内部工具的可执行文件——在不重新编译的前提下,改掉里面的几个字节,让它按你期望的方式运行。整个过程由编码智能体(能读文件、能跑命令的 CLI agent 或 IDE 插件)辅助完成:它读 hex dump 定位关键字节,给出补丁计划,你把它固化成脚本,再用反汇编和回归用例验证结果。
做完之后手上会有四样东西:
1. 一份带文件偏移、虚拟地址、ASCII 视图的 hex dump 注释文件;
2. 一份 patches.json 补丁清单,明确每个补丁的偏移、原字节、新字节和理由;
3. 一个可复现的 patch.py,对同一版本二进制重复执行结果一致,原字节不匹配就拒绝写入;
4. 一套验证记录:反汇编前后对比 + 回归用例通过情况。
举个贯穿全文的具体例子。假设目标程序里有一段判断:输入密码长度等于 8 才走成功分支,反汇编大致是 cmp dword [rbp-0x4], 0x8 后面跟一个 jne。你希望改成"任意长度都走成功分支"。要动的可能只是 cmp 的立即数,也可能是 jne 的 opcode,或者把整个比较用 NOP 填掉。到底是哪一种,取决于你想让程序变成什么样,也取决于改动后有多少字节可以腾挪。
先说清边界:这套方法只用于你有权修改的二进制——自己的程序、明确授权的渗透测试目标、CTF 题目、需要做兼容性适配的内部软件。改动他人软件的分发版本通常违反许可协议,也可能触碰法律,动手前先确认授权。
前置条件清单
权限与素材
- 目标二进制文件,以及一个明确到"改完之后程序行为应该变成什么样"的目标描述。目标越具体,智能体定位越准。
- 同版本的原始备份,以及
sha256sum记录。补丁脚本要靠这个哈希防止打错版本。
工具链
```bash
Debian/Ubuntu 系
sudo apt install binutils file xxd python3 git
macOS 上用 Homebrew 装 binutils,命令名会带 g 前缀
brew install binutils
```
反汇编用 objdump -d 就够入门;想更舒服可以装 rizin 或 Ghidra,用官方文档当前版本为准。Python 3 用于写 dump 脚本和补丁脚本。
编码智能体的能力要求
- 能读工作目录里的文件(而不是你把内容复制粘贴进对话框);
- 能执行 shell 命令并把输出读回去;
- AI 词典:上下文窗口">上下文窗口足够放下一段几百行的反汇编;
- 支持在同一个会话里持续迭代。
一个能跑起来的验证环境
至少一条命令,能在打补丁前跑出确定结果,打补丁后跑出另一个确定结果。比如:
```bash
./target --check secret8 ; echo "exit=$?"
```
分步骤
第 1 步:建立可复现基线
先固定住"原始状态",后面所有对比都以它为参照。
```bash
cp target target.orig
sha256sum target.orig | tee baseline.sha256
file target.orig
./target.orig --check secret8 ; echo "exit=$?"
./target.orig --check abc ; echo "exit=$?"
```
把两条命令的退出码和输出记下来。这一步看着啰嗦,但它决定了后面能不能判断"改动到底生效了没有"。
第 2 步:让智能体先建地址地图,不要直接看 hex
新手最容易犯的错是让智能体从 0 偏移开始读 hex dump。二进制文件开头通常是 ELF/PE 头,真正要改的代码在几 KB 之后,直接喂 hex 既浪费上下文又容易让它编出偏移。
正确的顺序是先搞清楚"文件偏移"和"虚拟地址"的对应关系:
```bash
readelf -h target.orig # 入口地址、架构、位数
readelf -S target.orig # 各节的 sh_addr 与 sh_offset
readelf -l target.orig # 段级别的映射关系
```
对 ELF 来说,同一个字节有两种坐标:
- 文件偏移:在磁盘文件里的位置,
xxd、Pythonseek用的是它; - 虚拟地址:加载到内存后的地址,
objdump -d打印的是它。
换算公式(用节头信息):
```
文件偏移 = 虚拟地址 - sh_addr + sh_offset
```
例如 .text 节 sh_addr = 0x1140、sh_offset = 0x1140,那么反汇编里 0x11a6 那条指令,在文件里的偏移也是 0x11a6。很多小程序两者恰好相等,一旦节有对齐填充就会错开,所以每次都要实际算一遍,不能凭感觉。
让智能体读 readelf 输出,产出一张表:
| 节 | sh_addr | sh_offset | 大小 | 内容 |
|---|---|---|---|---|
| .text | 0x1140 | 0x1140 | 0x1a5 | 代码 |
| .rodata | 0x2000 | 0x2000 | 0x2c | 字符串常量 |
这张表是后面所有定位工作的坐标系。
第 3 步:从语义锚点定位候选区域
不要从"字节长什么样"入手,从"程序里有什么可读的东西"入手。
```bash
strings -t x target.orig | head -50
```
-t x 输出的是文件偏移(十六进制)。假设看到:
```
2a10 Access granted
2a20 Access denied
```
那么 0x2a10 这个字符串一定在某个地方被引用。用反汇编找交叉引用:
```bash
objdump -d -M intel target.orig > target.dis
grep -n "2a10" target.dis
```
在 x86-64 上,引用常常长这样:
```
11a6: lea rdi,[rip+0x1843] # 2a10 <...>
11ad: call 10a0 <puts@plt>
```
11a6 就是候选位置。把这段反汇编连同前后 40 行一起交给智能体,让它解释控制流:什么条件下跳到 puts("Access granted"),什么条件下落到 puts("Access denied")。
关键提示词要点:
- 给它完整的函数边界,不要只给一条指令;
- 明确告诉它"目标是让
--check abc也走 granted 分支"; - 要求它输出"要改的指令、该指令的字节、字节所在的文件偏移",并说明推算是怎么来的;
- 禁止它凭印象给偏移,要求每个偏移都能被
readelf或objdump的输出佐证。
第 4 步:生成带注释的 hex dump,只喂窗口
定位到候选地址后,取一个窗口就够了,不要整文件 dump。
```bash
xxd -s 0x1180 -l 128 -g 1 target.orig
```
-s 起始偏移,-l 长度,-g 1 每字节分组。想看反汇编和字节并排,用下面这个小脚本生成更友好的视图:
```python
#!/usr/bin/env python3
"""生成带文件偏移 / 虚拟地址 / ASCII 的注释 hex dump,供编码智能体阅读。"""
import sys
def dump(path, file_off, length, vaddr=None, width=16):
with open(path, "rb") as f:
f.seek(file_off)
data = f.read(length)
for i in range(0, len(data), width):
chunk = data[i:i + width]
hexpart = " ".join(f"{b:02x}" for b in chunk)
ascii_part = "".join(chr(b) if 32 <= b < 127 else "." for b in chunk)
va = f"{vaddr + i:08x} " if vaddr is not None else ""
print(f"{file_off + i:08x} {va}{hexpart:<{width * 3}} |{ascii_part}|")
if __name__ == "__main__":
path = sys.argv[1]
off = int(sys.argv[2], 0)
length = int(sys.argv[3], 0)
va = int(sys.argv[4], 0) if len(sys.argv) > 4 else None
dump(path, off, length, va)
```
用法:
```bash
python3 hexview.py target.orig 0x1180 0x60 0x1180
```
输出每行左边是文件偏移,中间是虚拟地址,右边是 ASCII。把这一段贴进会话,智能体不用再做心算换算,出错概率会明显下降。
第 5 步:让智能体产出结构化的补丁计划
要求它输出 JSON,而不是自然语言描述。自然语言里"把 0x11a6 处的 je 改成 jmp"这句话,落地时很容易在字节层面走样。
```json
{
"source_sha256": "<baseline.sha256 里的值>",
"target_behavior": "--check 任意输入均返回 exit=0",
"patches": [
{
"id": "p1",
"file_offset": "0x11a6",
"vaddr": "0x11a6",
"old": "74 12",
"new": "eb 12",
"reason": "0x74 是 je rel8,0xeb 是 jmp rel8,位移字节保持不变,语义从条件跳转变为无条件跳转",
"confidence": "high",
"verify": "反汇编 0x11a6 应显示 jmp 0x11ba"
}
]
}
```
几个要点:
old字段必须是从实际字节里抄出来的,不是推算的;new与old长度必须相等,这是原地替换的前提;- 每条补丁都带一个
verify字段,说明改完之后反汇编应该长什么样。这个字段是第 7 步的检查清单。
x86 上常见的等长替换组合:
| 原字节 | 含义 | 新字节 | 含义 |
|---|---|---|---|
74 xx | je rel8 | eb xx | jmp rel8 |
75 xx | jne rel8 | 90 90 | 两个 NOP,直接贯穿 |
0f 84 xx xx xx xx | je rel32 | e9 xx xx xx xx | jmp rel32 |
0f 85 xx xx xx xx | jne rel32 | 90 × 6 | 全部 NOP |
注意 74 → eb 这种改法位移字节不动,跳转目标不变,只是条件变成无条件;而 75 → 90 90 是让程序不跳、顺着往下走,落到哪个分支取决于原布局。两种改法语义完全不同,选哪个要看你想让程序变成什么样。
第 6 步:写成脚本应用补丁,禁止手工改
补丁脚本的核心不是"写字节",而是写之前校验原字节。手一抖偏移错一位,改出来的文件还能跑,但行为完全不可预期。
```python
#!/usr/bin/env python3
"""按 patches.json 应用等长字节补丁;原字节不匹配则整体拒绝执行。"""
import hashlib
import json
import pathlib
import sys
def sha256(path):
h = hashlib.sha256()
with open(path, "rb") as f:
for blk in iter(lambda: f.read(1 << 20), b""):
h.update(blk)
return h.hexdigest()
def main(src, plan_path, dst):
plan = json.loads(pathlib.Path(plan_path).read_text(encoding="utf-8"))
expect = plan.get("source_sha256")
actual = sha256(src)
if expect and expect != actual:
sys.exit(f"源文件哈希不匹配:期望 {expect},实际 {actual}")
buf = bytearray(pathlib.Path(src).read_bytes())
for p in plan["patches"]:
off = int(p["file_offset"], 0)
old = bytes.fromhex(p["old"].replace(" ", ""))
new = bytes.fromhex(p["new"].replace(" ", ""))
if len(old) != len(new):
sys.exit(f"[{p['id']}] 长度不一致,拒绝执行")
if buf[off:off + len(old)] != old:
got = buf[off:off + len(old)].hex(" ")
sys.exit(f"[{p['id']}] 偏移 0x{off:x} 原字节不匹配:期望 {p['old']},实际 {got}")
buf[off:off + len(old)] = new
print(f"[ok] {p['id']} @ 0x{off:x}: {old.hex(' ')} -> {new.hex(' ')}")
pathlib.Path(dst).write_bytes(buf)
print(f"写出 {dst},sha256={sha256(dst)}")
if __name__ == "__main__":
main(sys.argv[1], sys.argv[2], sys.argv[3])
```
执行:
```bash
python3 patch.py target.orig patches.json target.patched
chmod +x target.patched
```
原文件不动,输出到新文件。这一步之后,target.patched 的 sha256 也记下来——同一个输入永远应该得到同一个哈希,不相同就说明脚本或清单有问题。
第 7 步:反汇编验证,确认改的是你以为的那条指令
不看反汇编就运行,等于闭着眼睛改。
```bash
objdump -d -M intel --start-address=0x1190 --stop-address=0x11c0 target.patched
```
对照 patches.json 里每条补丁的 verify 字段逐条核对。原来显示 je 0x11ba 的地方,现在应该显示 jmp 0x11ba。如果显示成别的东西——比如指令边界乱了、后面几条指令全变成 (bad)——说明改动长度和原指令不匹配,或者起始偏移算错了。
再做个整体对比,确认只动了预期的地方:
```bash
cmp -l target.orig target.patched
```
cmp -l 输出"字节位置(十进制)、原字节(八进制)、新字节(八进制)"三列。预期只出现你清单里的那几个位置,多出来任何一个都要查清原因。
第 8 步:跑回归用例
```bash
./target.patched --check abc ; echo "exit=$?"
./target.patched --check secret8 ; echo "exit=$?"
./target.patched --help ; echo "exit=$?"
```
第一行是你要改变的行为,第二行是原本就应该正常的行为(确认没改坏),第三行是边界——很多补丁把某个分支改通之后,相邻的错误处理路径也被顺带破坏了,跑一遍才知道。
把这套验证写成脚本,和补丁放在一起:
```bash
#!/usr/bin/env bash
verify.sh —— 补丁后回归检查
set -u
BIN="${1:-./target.patched}"
fail=0
check() {
local desc="$1" expect="$2" ; shift 2
"$@" >/dev/null 2>&1
local got=$?
if [ "$got" -eq "$expect" ]; then
echo "[pass] $desc (exit=$got)"
else
echo "[fail] $desc 期望 exit=$expect 实际 exit=$got"
fail=1
fi
}
check "任意输入走成功分支" 0 "$BIN" --check abc
check "原密码仍然成功" 0 "$BIN" --check secret8
check "帮助信息正常" 0 "$BIN" --help
check "缺参数报错" 2 "$BIN"
exit $fail
```
第 9 步:沉淀成可复查的资产
目录结构建议:
```
patch-project/
├── README.md # 目标、背景、授权说明
├── baseline.sha256 # 原始文件哈希
├── target.orig # 原始文件(或说明获取方式)
├── target.dis # 原始反汇编快照
├── patches.json # 补丁清单
├── patch.py # 应用脚本
├── hexview.py # dump 工具
└── verify.sh # 回归用例
```
README.md 里写清三件事:为什么要改、每条补丁对应哪条指令、怎么复现验证。三个月后回头看,没有这三样基本等于重做。
常见坑与排错
偏移算错,改到了别的指令中间
症状:cmp -l 显示改动位置符合预期,但运行立刻段错误,反汇编里出现 (bad)。原因几乎都是虚拟地址直接当文件偏移用了。回去用 readelf -S 重新算 文件偏移 = 虚拟地址 - sh_addr + sh_offset,并对改动前后的字节做 xxd 肉眼比对。
改了立即数,长度变了,后面全错位
x86 是变长指令集。把 cmp eax, 0x8(83 f8 08,立即数 1 字节)改成 cmp eax, 0x100(3d 00 01 00 00 或 81 f8 00 01 00 00)长度就变了,后面所有指令地址整体平移,程序必然崩。解决办法只有两个:一是等长替换,用 90(NOP)填掉多余字节;二是把改动搬到节末尾的空白区(代码洞),再在远处改一条跳转指过去。后者复杂得多,初学阶段优先选等长替换。
大小端搞反
x86 是小端。mov eax, 0x1234 的机器码是 b8 34 12 00 00,不是 b8 12 34 00 00。看到智能体给出的字节序列,先按小端倒着读一遍确认数值对得上。
PIE 程序按运行时地址算偏移
现代 Linux 默认编译 PIE 可执行文件,运行时地址每次都不一样。objdump -d 打印的是文件里的相对虚拟地址,gdb 里 p &main 看到的是加载后的实际地址,两者差一个随机基址。定位阶段一律用 objdump 的地址,不要用调试器里的地址倒推文件偏移。
智能体给出一个"看起来很合理"的偏移
这是使用编码智能体时最容易踩的坑。模型会根据上下文"推测"偏移应该是多少,而不是从工具输出里读。防范办法有三条:要求每条补丁必须引用 objdump 或 xxd 的真实输出行;用第 6 步脚本的 old 校验兜底(不匹配直接拒绝写入);关键补丁换一个新会话让它独立复核一遍,两次结论不一致就人工介入。
上下文太长导致中间信息丢失
几百行反汇编加 hex dump 塞进一个会话,模型容易忘记前面的约束,开始自由发挥。做法是分块:先用反汇编定位函数,再单独取那个函数的 hex 窗口,每次只让它处理一个函数。
改了文本段,但程序有完整性校验
ELF 一般没有自校验,但固件镜像、部分商业软件、带签名的安装包会有 CRC 或数字签名。补丁后程序不启动、或者启动后报"文件损坏",先查有没有校验和。固件的 CRC 需要按厂商规定的算法重算并写回校验字段,这部分要查具体设备的文档。对带数字签名的二进制,改一个字节签名就失效,这种情况需要回到"是否有权修改"这个前提问题上来。
改了代码但权限没跟上
patch.py 写出的新文件默认没有执行位,./target.patched 会报 Permission denied。chmod +x 一下即可,别误以为是补丁失败。
忘记确认"改坏了的用例"
只验证"原本失败的现在成功了"是不够的。补丁最常见的副作用是把相邻的错误分支、参数校验、清理逻辑一起改掉。回归脚本里必须包含原本就该通过的用例和原本就该失败的用例。
下一步建议
把硬编码偏移换成符号级定位。 现在 patches.json 里写的是绝对偏移,换个编译选项就全废。可以引入 pyelftools、LIEF、pefile 这类库,用"节名 + 节内偏移"或"函数符号 + 指令序号"来定位,补丁清单的可移植性会明显提升。
把定位过程也脚本化。 objdump 输出 + grep + 人工阅读,在目标多起来之后会很累。rizin 和 Ghidra 都提供脚本接口,可以写一个"给定字符串地址,自动列出所有引用它的指令及其字节"的小工具,让智能体只负责解释结果,不负责找位置。
建立补丁评审清单。 每次打补丁前过一遍:原字节校验通过了吗?长度相等吗?反汇编对比做了吗?cmp -l 的差异只有预期那几处吗?回归用例覆盖了"该通过的"和"该失败的"两类吗?这份清单比任何工具都管用。
想清楚什么时候不该打补丁。 二进制补丁本质是用不可维护的方式换一次性效果。如果目标软件还在维护、还有源码,改源码重新编译永远优于改字节;如果只是临时验证一个假设、或者对方不再发布更新,补丁才是合理选择。判断标准写进 README,将来接手的人会感谢你。
