也许未来不再需要 IDA 了
原创 Yak 2026-11-19 15:48 四川

Yak 安全基础设施新版图:反编译器


序言:YakSSA 是中心
熟悉yaklang.io的朋友们应该了解, 我们本身是做 “编译器”的团队,前段时间也和大家分享了大量的ssa2llvm代码编译方向的进展。
其实在很早之前我就考虑,是否可以做一个二进制分析工具呢?基于这一套YakSSA进行二进制的代码上升和各个平台的接入。当时还在比较早期,AI也并没有普及,“做一个反编译器” 这种工作量较大的想法也就搁置了。
AI Agent的出现改变了大量的代码编写的过程和项目研发的思路。
在AI大量将项目研发变成代码流水线的时候, 大部分的苦力活,可以让agent快速开发、测试。 特别是“反编译” 这种容易设计回归测试并且算法、开源实现也比较成熟的方向, AI Agent可以在完成绝大部分的功能。
而另一方面, AI发展让我们原本 “安全能力融合” 的话题更加有优势,在目前, “一个独立分发的逆向分析器” 也是目前市面上绝大部分接入IDAPro/Ghidra的AI逆向增强项目所需要的。
于是,基于我们的YakSSA 我们实现了一套逆向分析方案。

可以看到,目前YakSSA的版图已经支持多种语言接入,支持查询和编译。现在也补上了又一块能力: 从各种文件结构和汇编构架中反编译代码。
所以,Reify 不是另起一套 IR,而是给 YakSSA 增加一条从机器码进入的前端路径,以及一条面向 源码 的输出路径。
大家可以在yaklang仓库构建使用:
https://github.com/yaklang/yaklang/tree/main/common/yak/reify/cmd/reify


一、整体图
YAK
1.1 整体图解释

图 1:文件 → Loader → Artifact → Parser/asm2lowir → LowIR → SSAIR → 源码。

图 2:LowIR pass 与 SSA pass 的默认顺序;两段 pass 都只改 IR。
主链路可以拆成四段:
LowIR 保留地址、显式寄存器读写和效果位。YakSSA 保留值、定义关系和类型。伪源码保留块结构、vN 值名和地址注释。三层都保留上一层的来源,任何一层出问题都能回到具体地址。
LowIR 和 YakSSA 都有稳定的文本形式。前者用于逐条核对机器语义,后者用于检查值、类型和控制流。
主链路之外还有一段 pass:LowIR 先做 canary、返回块、栈帧和顺序整理;SSA 再做类型、调用和返回类型收敛。pass 不改变文件格式,也不重新解码,只是对IR进行等效的转换、处理。
YAK
1.2 Loader 和 Parser 的分离设计
Reify 没有“Linux/amd64、Windows/arm64、Darwin/amd64”这样的目录矩阵。它把问题拆成两个注册表:
Go
1 type Catalog struct {2 loaders map[core.Format]core.Loader3 parsers map[core.Architecture]core.Parser4 }
•一个文件格式对应一个 Loader。
•一个指令集对应一个 Parser。
•操作系统、位数、字节序、ABI、执行模式放在 Target 里。
这样,ELF 里的 ARM64 和 Mach-O 里的 ARM64 用同一个 parser;新增文件格式不需要改 13 个架构;新增架构也不需要改 6 个格式。Loader 只读文件并解析格式,Parser 只读字节码并解析得到汇编指令,两者通过 Artifact 和 BoundaryHints 交接。
YAK
1.3 多层指令的设计
多层不是把同一件事重复做四遍。每一层降低一种不确定性:
•Loader 降低“文件怎么装”的不确定性。
•Parser 降低“字节是什么指令”的不确定性。
•LowIR 降低“指令读写什么状态”的不确定性。
•YakSSA 降低“值从哪里来”的不确定性。
•伪源码降低“控制流与可读性”的不确定性。
一条机器指令可以展开成多条 LowIR。例如 add rax, rbx 不直接变成一个加法节点,而是显式读写寄存器并记录标志:
Plain Text
1 v1 = read_register rax2 v2 = read_register rbx3 v3 = add v1, v24 write_register rax, v35 v4 = intrinsic flags.add v1, v26 write_register rflags, v4
这样后续 pass 能看见依赖,不需要猜“这条指令偷偷改了哪个标志”。
二、Loader 与 Parser
YAK
2.1 Loader 的设计和格式
Loader 只回答“这个文件是什么形状”:
Go
1 type Loader interface {2 Kind() Format3 Name() string4 Description() string5 Match(prefix []byte) bool6 Check(*ByteReader) (*CheckResult, error)7 Load(context.Context, *ByteReader) (*Artifact, error)8 }
它解析:
•文件头、节表、段表。
•符号表、动态符号、导入符号。
•入口点、基址、对象类型。
•重定位表里能用于命名的信息。
•异常表、函数起址表。
•可执行节范围。
Loader 的产出是 BoundaryHints:
Go
1 type BoundaryHints struct {2 ExecSections []Region3 FunctionStarts []uint644 EHFrame []byte5 EHFrameAddr uint646 InitTargets []uint647 PLTTargets []PLTEntry8 GOTRelocs map[uint64]uint649 ModeRegions []ModeRegion10 }
这些字段都是“格式能提供的事实”,不是“已经算出来的函数”。例如:
•ELF 提供 .eh_frame 原始字节,具体 FDE 解析交给架构边界扫描器。
•PE 提供异常表里的 RUNTIME_FUNCTION 起始地址。
•Mach-O 提供 LC_FUNCTION_STARTS。
•COFF 提供符号表里的函数符号。
•MZ 提供可执行区域和重定位表符号。
YAK
2.2 Parser 的设计和格式
Parser 只回答“这段机器码是什么指令”:
Go
1 type Parser interface {2 Kind() Architecture3 Name() string4 Available() bool5 Check(Target) error6 Parse(context.Context, ParseRequest) (*ParseResult, error)7 }
可选能力:
•Disassembler:输出汇编文本。
•BoundaryDiscoverer:从代码区域发现函数边界。
•ArchFactsProvider:声明栈、寄存器、canary 事实。
Parser 的输入是 ParseRequest:
Go
1 type ParseRequest struct {2 Target Target3 Address uint644 Reader *ByteReader5 Syntax AsmSyntax6 WithAssembly bool7 }
Address 是 Reader 偏移零对应的映像地址。Parser 只在这个有界区域内读取,不拥有 reader,也不关闭它。
Parser 还声明架构事实:
Go
1 type ArchFacts struct {2 Frame FrameModel3 Registers RegisterModel4 Canary CanaryModel5 }
lowir2ssa 的 pass 和转换器读这些事实。这样架构差异留在 parser,不散落在每个 pass 里。
YAK
2.3 打开一个文件时发生什么
Plain Text
1 NewByteReader2 → 读取前 64 字节(ProbeSize)3 → 每个 Loader.Match(prefix)4 → 0 个匹配:ErrUnsupportedFormat5 → 多个匹配:ErrAmbiguousFormat6 → 1 个匹配:Loader.Check / Loader.Load7 → 按 Target.Architecture 选 Parser8 → ValidateArtifact
Check 是“只看头”,Open 是“真正加载”。强制格式用 --format,主要处理没有魔数的输入:
•COM 文件没有头部,必须显式指定 mz。
•COFF 目标文件没有魔数,靠 machine、节数和可选头大小判断。
•MZ 和 PE 都以 MZ 开头,PE loader 先验证 DOS stub。
•Mach-O fat 的 magic 和 Java class 冲突,loader 额外验证架构数量与 CPU 类型。
YAK
2.4 支持范围
6 种格式:
•ELF:32/64 位,可执行文件、共享对象、可重定位目标文件。
•PE:PE32/PE32+,amd64、386、arm64、arm;拒绝 .NET IL。
•Mach-O:thin 和 fat,fat 优先 ARM64,其次 AMD64。
•COFF:Windows 目标文件,i386、amd64、ARM、ARMNT、ARM64。
•ar:静态库,成员按自己的格式加载。
•MZ/COM:DOS 实模式,8086,16 位。
13 种架构:
Plain Text
1 386 8086 amd64 arm arm642 riscv32 riscv643 mips mips644 ppc ppc645 s390x loong64
每个 parser 都实现解码、反汇编、边界发现和架构事实。共享实现按指令族拆分:
•internal/x86 服务 8086、386、amd64。
•internal/riscv 服务 riscv32/64。
•internal/mips 服务 mips/mips64。
•internal/ppc 服务 ppc/ppc64。
•ARM、ARM64、S390X、Loong64 各有自己的实现。
三、asm2lowir:把机器码变成 LowIR
asm2lowir 是一个编排层。它不做 ISA 解码,也不读节表。它的工作主要是:
1.选函数边界。
2.把边界映射成文件区域。
3.每个函数调用一次 parser进行真正的解码与解析到LowIR。
4.给结果补符号名、编号和诊断。
真正的解码在 loader/arch 里。
YAK
3.1 函数边界划分
反编译最危险的错误之一,是把数据当代码。Reify 用 8 种来源投票:
Plain Text
1 symbol2 > eh_frame3 > function_start4 > init_array5 > plt6 > entry7 > call_target8 > scan
优先级从强到弱:
•symbol:符号表明确说这是函数。
•eh_frame:异常表的 FDE 说明这里有一段函数。
•function_start:Mach-O、PE 的函数起址表。
•init_array:构造器数组里的函数指针。
•plt:PLT 桩。
•entry:镜像入口。
•call_target:直接调用目标。
•scan:最后的空隙扫描。
同一地址被多个来源报告时,高优先级覆盖名字和大小,低优先级只补空缺。

图 3:8 种边界来源按可信度排序。
YAK
3.2 函数调用图
只靠符号表不够。很多二进制被 strip,或者函数只被直接调用。
算法:
Plain Text
1 queue = 已知边界2 while queue 非空:3 取一个起点4 limit = 下一个边界或函数自带大小5 在 [起点, limit) 内解码6 遇到直接 CALL:把目标加入 queue7 遇到直接 JMP:在范围内继续走目标8 遇到 RET / TRAP:停止9 记录实际结束地址
这是一种“受限递归下降”:
•它跟着直接调用走,能发现符号表没有的函数。
•它不跨函数无限制递归,避免内存爆炸。
•它只在当前函数的地址范围内走,避免把相邻函数吞进来。
对于间接调用(寄存器、GOT),能静态解析的直接目标也会加入;不能解析的保留为动态调用。
YAK
3.3 调用 Parser
Go
1 parsed, err := artifact.Parser.Parse(ctx, core.ParseRequest{2 Target: target,3 Address: region.Address,4 Reader: reader,5 Syntax: config.Syntax,6 })
这样做有三个收益:
•内存:峰值由最大函数决定,不是整个文件。
•失败隔离:一个函数解码失败,只丢一个函数。
•模式隔离:ARM 镜像可以给每个函数设置 ARM 或 Thumb 模式。

图 4:边界、区域、ParseRequest、Parser、LowIR 的关系;每个函数独立解码,失败隔离。
YAK
3.4 Parser 内部实现
以 x86 为例:
1.线性解码:从函数起点开始,按指令长度一直解到区域末尾。
2.收集 leader:
•函数入口。
•直接跳转/分支的目标。
•条件跳转或 jmp 的下一条指令。
•终止指令的下一条指令。
•落在区域内的直接调用目标。
3.切块:按 leader 把线性指令序列切成基本块。
4.提升:逐条指令变成 LowIR。
5.补终止符:没有终止符的块补 jump;最后一个块补 trap。

图 5:先线性解码,再把入口、分支目标、fallthrough、终止符后继等位置变成 basic block 的 leader。
YAK
3.5 提升到 LowIR
以 add rax, rbx 为例:
Plain Text
1 v1 = read_register rax2 v2 = read_register rbx3 v3 = add v1, v24 write_register rax, v35 v4 = intrinsic flags.add v1, v26 write_register rflags, v4
机器指令只有一条,LowIR 可能有五条,拆分的更细。这样做的好处:
•寄存器读写是显式的。
•标志更新是显式的。
•后续转换可以精确知道依赖关系。
代价是 IR 变大,但这是可以接受的:反编译的分析价值远高于 IR 体积。
每条 LowIR 指令还带效果位:读内存、写内存、读寄存器、写寄存器、可能调用、可能异常、不可消除、原子、未知。效果位不是装饰;它告诉后续 pass 哪些变换需要额外证明,哪些操作不能随便删除或重排。
YAK
3.6 符号命名
asm2lowir 用loader解析得到的符号表: Image.Symbols 给函数和调用目标补名字:
•直接调用常量地址命中符号 → 用符号名。
•没有符号 → sub_0x<地址>。
这一步只影响可读性,不影响语义。
四、lowir2ssa:从机器状态到 SSA
YAK
4.1 SSA 提高
LowIR 里,寄存器和内存是显式可变的:
Plain Text
1 write_register rax, v12 write_register rax, v23 v3 = read_register rax
你无法直接知道 v3 是 v1 还是 v2,除非按顺序解释。YakSSA 需要的是“值”和“定义关系”。
转换器的任务不是“把机器码翻译成 C”,而是:
把机器状态物化成 SSA 变量,把能证明的纯计算变成 SSA 值,把不能建模的部分保留成可见标记。
变量转换

图 6:寄存器、内存、标志、调用、分支分别转换
控制流与循环
普通控制流:
•jump 有唯一块内目标 → EmitJump。
•间接跳转 → 不伪造目标,结束当前块。
•branch → If,true 目标在前,false 在后。
•return 没有显式值 → 取当前 ABI 返回寄存器。
•trap → Panic + Return。
•每个块结束兜底 EmitReturn(nil)。
循环识别:
Plain Text
1 对每条 jump/branch 的目标2 若目标块位置 <= 当前块位置3 则目标是循环头
这是“回边”近似。前置条件是 lowir部分的pass: reverse-postorder 已经把块顺序重排,让循环头排在循环体之前。在ssa2source 内会用支配关系重新验证自然循环。
YAK
4.2 函数调用、参数和返回值
目标
•常量地址 → sub_0x<地址>。
•符号 → 符号名。
•其他值 → 间接调用目标。
直接目标会创建一个外部函数函数桩。桩没有函数体,文本渲染跳过,但 Call 指令本身是真实的。
参数
参数由两部分拼接:
1.指令显式操作数。
2.自上次调用以来写过的 ABI 参数寄存器。
RegisterModel.Arguments 给出参数寄存器顺序:
返回值
返回寄存器来自 RegisterModel.Return:amd64 是 rax,arm64 是 x0,riscv 是 x10,等等。
YAK
4.3 IF 语句还原
机器码里,cmp 只写标志,jne 只读标志。如果直接降低,源码会变成:
C
1 if (rflags) { ... }这不是人想看的。
Reify 分两步恢复:
1.Lifter 把 cmp、test、add 等写成 flags.* intrinsic,操作数是参与运算的值。
2.转换器把 cond.* intrinsic 还原成比较。
flagInfo 记录:
Go
1 type flagInfo struct {2 name string3 operands []core.ValueID4 }
cond.* 读取记录:
•cmp / cmn:直接生成比较。
•test / tst:先 and,再与 0 比较。
•其他:取最后一个操作数与 0 比较。
•s/ns:与 0 比较后取反。
条件码映射:
当前实现有一个近似:有符号和无符号条件没有区分,都映射到同一个 SSA 比较。这会让源码更好读,但极端边界值上可能偏离机器语义。
YAK
4.4 类型还原
类型只用于打印、参数渲染和指针推断,不参与值语义判断。
YAK
4.5 LowIR Pass
通过Pass的形式对LowIR进行转换,当然这些都是可选的修改:
五、ssa2source:把图变回结构化文本
ssa2source 的目标是:
把 SSA 图排成一段人看得懂的程序形状,同时保留值名、块结构痕迹等逻辑。
YAK
5.1 原理:CFG、支配和区域
先建立 CFG:
Plain Text
1 blocks、order、succs、preds然后计算支配关系:
Plain Text
1 dom[entry] = {entry}2 dom[n] = {n} ∪ ⋂ dom[p] p ∈ preds(n)
再计算后支配:
Plain Text
1 pdom[n] = {n} ∪ ⋂ pdom[s] s ∈ succs(n)2 pdom[exit] = {exit} // 虚拟出口 0
ipdom[n] 取后支配集合中最大的那个。
直觉:
•支配:从入口到 n 的所有路径都必须经过 d。
•后支配:从 n 到出口的所有路径都必须经过 p。
•直接后支配:分支结束后第一个“大家都会到”的块。
这个“大家都会到”的块,就是 if/else 的合流点。

图 7:CFG 的 dom / pdom / ipdom;join 是 if 的分支合流点。
结构化器不是按块顺序打印,而是递归发射区域:
Go
1 emitRegion(id, indent, stop)stop 是不许进入的块集合,典型成员是:
•分支合流点。
•循环出口。
•循环头。
状态:
•emitted:防止重复输出。
•rendered:允许同一块在必要时输出两次。
主循环:
Plain Text
1 遇到循环头 → emitLoop2 遇到 If → 输出条件前指令,再 emitIf3 遇到 Jump → 输出块指令,再输出目标4 其他 → 输出块指令,再输出第一个后继
YAK
5.2 判断语句还原
join = ipdom[block],但不是拿到就用。以下任一情况把 join 置 0:
•join 在 stop 里。
•join 已经输出过。
•true 或 false 分支无法在不穿过 stop、循环头、return、panic 的情况下到达 join。
join 有效时:
•true == join → if (!(cond)) { false 分支 }。
•false == join → if (cond) { true 分支 }。
•其他 → 完整 if/else。
•最后继续输出 join。

图 8:LowIR 分支 → SSA If;join 处标出 Phi 位置,普通合流不插 Phi;右侧输出 if/else。
join 无效时,直接输出完整 if/else,不再输出合流后的代码。这样可以避免把不可结构化 CFG 硬塞进错误缩进。
YAK
5.3 循环语句还原
先找自然循环。对每条边 tail → header:
Plain Text
1 若 header 支配 tail2 则 header 是循环头,tail 是回边3 循环体 = 从 tail 沿前驱反向可达的块4 出口 = 循环体内指向体外的第一个后继
不可归约循环没有“头支配回边”的性质,会退化成普通分支,甚至需要前向声明兜底。

图 9:LowIR 回边 → SSA 循环头 Phi → 源码 while;Phi 初值变初始化,回边值变循环体赋值。
LowIR 里,循环是一个头块加一条回边;到 SSA 后,循环头需要把两侧的值合并:
Plain Text
1 prepareLoopPhis(header)2 → 每个循环携带内存键一个 Phi3 → 初值边 = 进入循环前的变量值45 循环头读寄存器6 → 按需创建 reg:<name> Phi78 回边9 → 把当前变量值追加为 Phi 的边10 → 把 Phi 赋回变量
循环携带内存键只取 load ∩ store:
1.找最后一个回到头的边,确定循环范围 [header, last]。
2.扫描范围内所有 load/store 的结构键。
3.取交集:既被读又被写的槽。
4.headerStore 防重复;loopPhiDone 只补一次回边。
ssa2source 再把 Phi 变成 while:
•循环头的 If 变成 while 条件;哪一侧在体内决定是否取反。
•Phi 的进入边变成 while 之前的初始化。
•Phi 的回边值变成循环体末尾的赋值。
•多条边时,进入取第一条,回边取最后一条;Phi 按边数降序输出。
•true 在体内、false 在体外 → while (cond)。
•false 在体内、true 在体外 → while (!(cond))。
•两侧都在体内 → 取 true 侧为入口,仍输出 while (cond)。
•没有 If 或找不到体内后继 → while (true)。
YAK
5.5 指令渲染
恒等式折叠:
Plain Text
1 x ^ x = 02 x - x = 03 x & x = x4 x | 0 = x5 x + 0 = x
类型名使用 C 风格:uint64_t、int32_t、void *、float、double,i1 输出 bool。
YAK
5.6 文本清理
结构化输出后,只做一件事:删除没有使用者的赋值。
算法:
1.统计每个 vN 在函数内的使用次数。
2.没有使用者、没有副作用的赋值,删除。
3.副作用只认 Call、Panic。
4.有使用者的赋值保留。
这一步不重写地址,不改变块结构,只让输出短一些。
YAK
5.7 SSA pass
ssa2source 的 pass 在渲染前运行:
redefine-type-value 是最有“反编译感”的一步:
C
1 puts(0x402000);变成:
C
1 puts("hello");它读取 artifact 的可打印字符串,只替换 NUL 结尾、UTF-8、长度不超过 128 字节的内容。
六、反编译实践
下面用一个求和循环做概念演示。实际输出会包含更多 vN 和类型转换。
C 源码:
C
1 int sum(int *a, int n) {2 int s = 0;3 for (int i = 0; i < n; i++)4 s += a[i];5 return s;6 }
机器码的抽象形状:
Plain Text
1 保存寄存器2 初始化 s = 03 初始化 i = 04 循环头:5 比较 i 和 n6 条件跳转到循环体或退出7 循环体:8 读取 a[i]9 s = s + a[i]10 i = i + 111 跳回循环头12 退出:13 返回 s
LowIR 的示意(寄存器仍是显式读写,未插入 Phi):
Plain Text
1 v1 = read_register rdi2 v2 = read_register esi3 v3 = constant 04 write_register rax, v35 write_register r10, v36 ...7 block b2:8 v30 = read_register r109 v31 = slt v30, v210 branch v31 -> b3, b411 block b3:12 v17 = mul v30, 813 v18 = add v1, v1714 v20 = load (v18)15 v33 = read_register rax16 v34 = add v33, v2017 write_register rax, v3418 v35 = add v30, 119 write_register r10, v3520 jump -> b221 block b4:22 v40 = read_register rax23 return v40
YakSSA 的示意(循环头出现 Phi):
Plain Text
1 v10 = phi(v3, v22)2 v11 = lt v10, v23 if v11 -> b3, b44 ...5 v22 = add v10, v36 jump -> b2
伪源码的示意:
C
1 uint64_t sum(uint64_t arg0, uint64_t arg1) {2 v3 = 0x0;3 v10 = v3;4 v21 = v3;5 while (v10 < arg1) {6 v20 = *(uint64_t *)(arg0 + v10 * 8);7 v21 = v21 + v20;8 v22 = v10 + 1;9 v10 = v22;10 }11 return v21;12 }
这段文本不是原始 C,但它把“循环、数组访问、累加”都表达出来了。分析者可以据此继续判断参数类型、结构体布局和业务语义。
END
Memfit:是万径安全旗下Yaklang团队研发的面向长程渗透测试、漏洞挖掘、应急响应等全链路攻防任务的生产级安全领域Agent系统
Yakit:是万径安全旗下Yaklang 团队开源的一款完全国产的交互式安全测试平台
YAK官方资源
Yakit官网下载地址:
https://yaklang.com/
Github地址:
https://github.com/yaklang/yakit
Yakit 视频教程:
https://space.bilibili.com/437503777
Memfit下载地址:
https://memfit.ai/
IRify下载地址:
https://ssa.to/
YTray下载地址:
https://yaklang.io/ytray/


本文转载自微信公众号「Yak Project」,查看原文。版权归原作者所有,如有侵权请联系删除。