跳到主内容
快讯直播
AI智模界
教程

用编码智能体做十六进制级二进制补丁:从定位到校验

这篇能做出什么

拿一个没有源码的二进制文件——可能是自己写的练手程序、一道 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、Python seek 用的是它;
  • 虚拟地址:加载到内存后的地址,objdump -d 打印的是它。

换算公式(用节头信息):

```

文件偏移 = 虚拟地址 - sh_addr + sh_offset

```

例如 .text 节 sh_addr = 0x1140、sh_offset = 0x1140,那么反汇编里 0x11a6 那条指令,在文件里的偏移也是 0x11a6。很多小程序两者恰好相等,一旦节有对齐填充就会错开,所以每次都要实际算一遍,不能凭感觉。

让智能体读 readelf 输出,产出一张表:

节sh_addrsh_offset大小内容
.text0x11400x11400x1a5代码
.rodata0x20000x20000x2c字符串常量

这张表是后面所有定位工作的坐标系。

第 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 xxje rel8eb xxjmp rel8
75 xxjne rel890 90两个 NOP,直接贯穿
0f 84 xx xx xx xxje rel32e9 xx xx xx xxjmp rel32
0f 85 xx xx xx xxjne rel3290 × 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,将来接手的人会感谢你。

AI 生成本文由 AI 基于公开信息自动生成,仅供参考。