也许未来不再需要 IDA 了

· 2026-11-19 15:48 · 9 阅读

原创 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。

主链路可以拆成四段:

阶段输入输出主要工作
Loader文件Artifact、BoundaryHints识别容器、节、符号、起址
asm2lowir + Parser函数区域LowIR解码、收集 leader、切块、提升
lowir2ssaLowIRSSAIR物化寄存器、内存、标志、调用
ssa2sourceSSAIR伪源码恢复区域、分支、循环、打印
⟷ 左右滑动查看完整表格⟷ 左右滑动查看完整表格

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.Loader
3      parsers map[core.Architecture]core.Parser
4  }

•一个文件格式对应一个 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 rax
2  v2 = read_register rbx
3  v3 = add v1, v2
4  write_register rax, v3
5  v4 = intrinsic flags.add v1, v2
6  write_register rflags, v4

这样后续 pass 能看见依赖,不需要猜“这条指令偷偷改了哪个标志”。

二、Loader 与 Parser

YAK

2.1 Loader 的设计和格式

Loader 只回答“这个文件是什么形状”:

Go

1  type Loader interface {
2      Kind() Format
3      Name() string
4      Description() string
5      Match(prefix []byte) bool
6      Check(*ByteReader) (*CheckResult, error)
7      Load(context.Context, *ByteReader) (*Artifact, error)
8  }

它解析:

•文件头、节表、段表。

•符号表、动态符号、导入符号。

•入口点、基址、对象类型。

•重定位表里能用于命名的信息。

•异常表、函数起址表。

•可执行节范围。

Loader 的产出是 BoundaryHints:

Go

 1  type BoundaryHints struct {
 2      ExecSections   []Region
 3      FunctionStarts []uint64
 4      EHFrame        []byte
 5      EHFrameAddr    uint64
 6      InitTargets    []uint64
 7      PLTTargets     []PLTEntry
 8      GOTRelocs      map[uint64]uint64
 9      ModeRegions    []ModeRegion
10  }

这些字段都是“格式能提供的事实”,不是“已经算出来的函数”。例如:

•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() Architecture
3      Name() string
4      Available() bool
5      Check(Target) error
6      Parse(context.Context, ParseRequest) (*ParseResult, error)
7  }

可选能力:

•Disassembler:输出汇编文本。

•BoundaryDiscoverer:从代码区域发现函数边界。

•ArchFactsProvider:声明栈、寄存器、canary 事实。

Parser 的输入是 ParseRequest:

Go

1  type ParseRequest struct {
2      Target       Target
3      Address      uint64
4      Reader       *ByteReader 
5      Syntax       AsmSyntax
6      WithAssembly bool
7  }

Address 是 Reader 偏移零对应的映像地址。Parser 只在这个有界区域内读取,不拥有 reader,也不关闭它。

Parser 还声明架构事实:

Go

1  type ArchFacts struct {
2      Frame     FrameModel
3      Registers RegisterModel
4      Canary    CanaryModel
5  }

lowir2ssa 的 pass 和转换器读这些事实。这样架构差异留在 parser,不散落在每个 pass 里。

YAK

2.3 打开一个文件时发生什么

Plain Text

1  NewByteReader
2    → 读取前 64 字节(ProbeSize)
3    → 每个 Loader.Match(prefix)
4    → 0 个匹配:ErrUnsupportedFormat
5    → 多个匹配:ErrAmbiguousFormat
6    → 1 个匹配:Loader.Check / Loader.Load
7    → 按 Target.Architecture 选 Parser
8    → 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  arm64
2  riscv32  riscv64
3  mips  mips64
4  ppc  ppc64
5  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  symbol
2    > eh_frame
3    > function_start
4    > init_array
5    > plt
6    > entry
7    > call_target
8    > 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:把目标加入 queue
7      遇到直接 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 rax
2  v2 = read_register rbx
3  v3 = add v1, v2
4  write_register rax, v3
5  v4 = intrinsic flags.add v1, v2
6  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, v1
2  write_register rax, v2
3  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 给出参数寄存器顺序:

架构参数寄存器
amd64rdi, rsi, rdx, rcx, r8, r9
armr0-r3
arm64x0-x7
riscv32/64x10-x17
mips/64a0-a3
ppc/64r3-r10
s390xr2-r6
loong64r4-r11

返回值

返回寄存器来自 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     string
3      operands []core.ValueID
4  }

cond.* 读取记录:

•cmp / cmn:直接生成比较。

•test / tst:先 and,再与 0 比较。

•其他:取最后一个操作数与 0 比较。

•s/ns:与 0 比较后取反。

条件码映射:

cc操作
e/eq/z==
ne/nz!=
l/lt/b/c/cc/lo<
le/be/ls<=
g/gt/a/hi>
ge/ae/cs/hs>=

当前实现有一个近似:有符号和无符号条件没有区分,都映射到同一个 SSA 比较。这会让源码更好读,但极端边界值上可能偏离机器语义。

YAK

4.4 类型还原

LowIRYakSSA
integer 8/16/32/64i8/i16/i32/i64
integer 1i1
pointer 64ptr64
float 32/64f32/f64
未知any
ppc/64r3-r10
s390xr2-r6
loong64r4-r11

类型只用于打印、参数渲染和指针推断,不参与值语义判断。

YAK

4.5 LowIR Pass

通过Pass的形式对LowIR进行转换,当然这些都是可选的修改:

Pass作用
remove-canary识别并删除cannary检查  提高源码的可读性
remove-stackframe识别并删除栈帧构建语句,提高源码的可读性
reverse-postorder标准化循环的控制流结构,为循环的解析做准备。
⟷ 左右滑动查看完整表格⟷ 左右滑动查看完整表格

五、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  遇到循环头 → emitLoop
2  遇到 If    → 输出条件前指令,再 emitIf
3  遇到 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 支配 tail
2    则 header 是循环头,tail 是回边
3    循环体 = 从 tail 沿前驱反向可达的块
4    出口   = 循环体内指向体外的第一个后继

不可归约循环没有“头支配回边”的性质,会退化成普通分支,甚至需要前向声明兜底。

图 9:LowIR 回边 → SSA 循环头 Phi → 源码 while;Phi 初值变初始化,回边值变循环体赋值。

LowIR 里,循环是一个头块加一条回边;到 SSA 后,循环头需要把两侧的值合并:

Plain Text

 1  prepareLoopPhis(header)
 2    → 每个循环携带内存键一个 Phi
 3    → 初值边 = 进入循环前的变量值
 4  
 5  循环头读寄存器
 6    → 按需创建 reg:<name> Phi
 7  
 8  回边
 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 指令渲染

SSA输出
常量使用点内联
TypeCast使用点内联
BinOp / UnOpvN = expr;
CallvN = f(args); 或 f(args);
UndefinedvN = undefined;
ParametervN = parameter;
Returnreturn ...;
Phi/Jump/If结构化器处理

恒等式折叠:

Plain Text

1  x ^ x = 0
2  x - x = 0
3  x & x = x
4  x | 0 = x
5  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 在渲染前运行:

Pass作用
apply-function-define用 C 签名表设置返回类型、参数类型,截断多余实参
infer-types最多 12 轮指针类型传播
trim-internal-calls按真正使用的形参数量裁剪内部调用实参,上限 6
mark-void-returns结果无人使用且返回弱值时,把函数改成 void
refine-return-types全指针 → ptr64,全整数 → i64,否则 any
simplify-partial-writes(old & ~0xff)|(low & 0xff) 折叠为 low
redefine-type-value字符串参数的常量地址替换成字符串常量
⟷ 左右滑动查看完整表格⟷ 左右滑动查看完整表格

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 = 0
 3  初始化 i = 0
 4  循环头:
 5    比较 i 和 n
 6    条件跳转到循环体或退出
 7  循环体:
 8    读取 a[i]
 9    s = s + a[i]
10    i = i + 1
11    跳回循环头
12  退出:
13    返回 s

LowIR 的示意(寄存器仍是显式读写,未插入 Phi):

Plain Text

 1  v1 = read_register rdi
 2  v2 = read_register esi
 3  v3 = constant 0
 4  write_register rax, v3
 5  write_register r10, v3
 6  ...
 7  block b2:
 8    v30 = read_register r10
 9    v31 = slt v30, v2
10    branch v31 -> b3, b4
11  block b3:
12    v17 = mul v30, 8
13    v18 = add v1, v17
14    v20 = load (v18)
15    v33 = read_register rax
16    v34 = add v33, v20
17    write_register rax, v34
18    v35 = add v30, 1
19    write_register r10, v35
20    jump -> b2
21  block b4:
22    v40 = read_register rax
23    return v40

YakSSA 的示意(循环头出现 Phi):

Plain Text

1  v10 = phi(v3, v22)
2  v11 = lt v10, v2
3  if v11 -> b3, b4
4  ...
5  v22 = add v10, v3
6  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」,查看原文。版权归原作者所有,如有侵权请联系删除。