wul7chaos/vmp-reverse-skill

vmp-reverse

还原代码虚拟化保护(VMP)——把 handler 虚拟机翻译回可读语义。适用于自研 VM、VMProtect 风格的 x86 VM、Android/so 的 ARM64 线程化 VM。方法:IDA 静态底座定位 dispatcher 与锚点寄存器 + trace 动态执行切 handler + P-code/微码两代 IR(静态骨架 + trace 折叠影子)+ 面向 LLM 的无损压缩 + Z3 判定防幻觉。当用户给出被虚拟化保护的 so/dll/exe/驱动、要求跟 VIP/handler、切 trac…

Quelltext ansehen

Verwendung

  1. Installationsbefehl kopieren und das Quellpaket vor der Installation in der eigenen Agentenumgebung prüfen.
  2. Benötigte Werkzeuge, Zugangsdaten und Hosts im Original prüfen.
  3. Eingabe und gewünschtes Ergebnis beschreiben und die Ausgabe mit den Quellen abgleichen.
npx skills add https://github.com/wul7chaos/vmp-reverse-skill --skill vmp-reverse

Vor dem Start

  • Die Installation umfasst weder Modellabo noch API-Kontingent oder Dateizugriffsrechte.
  • Sterne und Installationen zeigen Aktivität, keine unabhängige Qualitäts- oder Sicherheitsprüfung.
Originales Skill-Dokument

Aus dem Quell-Repository gerendert; Überschriften, Beispiele, Code, Tabellen, Links und Bilder bleiben erhalten.

VMP 还原工作流

目标:把「一堆看不懂的跳转」变成「可读的、被验证过的语义」。不是"跑通一个框架就算完"。

方法论的转向:Unpacking Virtualization Obfuscators(WOOT 2009)的六步法则(逆向解释器 → 找虚拟化入口 → 写字节码反汇编器 → 反汇编字节码 → 编译器式优化 → 重生成代码)今天仍然正确,但它是一场和厂家的时间竞赛:啃完这一版,下版 handler 全变,重来一遍。

今天更省命的路子是:从汇编与地址热点出发,用动态 trace 把执行"拍平",再回头用 IR 把语义钉死。 VMP 的 handler 结构极为规范 —— 固定入口模式、固定指令序列、固定出口跳转;而 trace 已经记录了所有执行结果。 所以你不需要搞懂 handler 内部每一条运算,只需要知道这段指令是哪个 handler。本质上这是把"逆向虚拟机保护"降维成填空游戏:工具问"这是啥 handler?",你答 "STORE_REG",工具说"好的继续"。


十三条铁律

  1. 先跑通,再抬 IR,再谈优化。 顺序反了必然产出"看起来对、其实自我感动"的东西。
  2. 锚点在 varnode 层找,不在指令层找。 汇编层 ldr w9, [x23] 是「引用了 x23」;P-code 层 x23 只是一条 COPY 的源,真正读内存那条 LOAD 的地址是个 unique。按 space==register and name==x23 扫 inputs 只会收上来一堆 COPY。
  3. 按 offset 认寄存器,不按名字、更不按值。 x23 与 w23 同 offset(0x40b8)不同 size;同一个 handler 在不同 VM 调用里锚点寄存器的值都不一样(ctx 分配位置不同)。按值认锚点,躲过一次记一辈子。
  4. 混淆代码上不要信 Hex-Rays 伪代码。 它常常给你"看着合理、其实错"的逻辑。信指令、信 microcode、信 P-code。
  5. 没有真 flags 就别造假 cmp/jcc。 很多"双沿"只是历史里见过两个后继地址,不等于 CPU 的"零标志置位就跳"。造假的代价:屏幕上全是瞎编的分支,比没有分支更坑。
  6. 没有"我觉得等价"这个档位。 等价性只有三种结论:PROVEN(求解器证明)/ REFUTED(有反例)/ FUZZED(差分测试没找到反例,可信度低一档)。验证不了就写 UNVERIFIED,不假装。
  7. O3 不是成绩单。 要"这个函数在虚拟机里一步步干了啥"就上 full 模式,一步 handle 都别丢;优化器的活是删"没用"的东西,你语义还没钉死,它删得越狠你越像还原失败。
  8. handle 地址 ≠ 导入函数。 unk_iat_func(0x1406…) 说的是"虚拟机跳进了某块 handler",不是"调用了 ZwXxx"。真 API 只能靠动态绑桩或 IAT 对照。
  9. trace 不记 flags 和「内存地址 → 值」。 控制流穿透(cbz/tbz/csel)和追内存 key 会在这两处断,动手前先接受这个边界。
  10. 分类必须在扫的过程中做。 unique 的 offset 只在单条指令内有效且会被复用;"先整条流扫一遍、回头统一分类"时那一格早被后面的指令覆盖了。
  11. 折叠与切块的 arch 语义不能想当然。 x86 上 jl 是条件跳转(不是链接跳转)、call rel32 是 5 字节、handler 用直接 jmp 串成多段链 —— 把 arm64 那套"BL + 4"搬过去,实测会静默折掉 99.8% 的行(现象:200 个 handler 每个只剩一行 jmp rXX),而且一句报错都没有。静默出错的折叠比不折叠更糟;--fold-bl 现在会在残留返回地址 / 过度折叠时打警告,别忽略。
  12. 每个 VM 函数的锚点寄存器都不一样。 arm64 上是"同一个 handler 名字固定、跨调用值变";x86-64 实测是名字本身都不同:一套 handler 用 r9 当字节码指针、r11 当 rolling key,另一套用 rbx / r8 / rsi。锚点必须逐个 VM 函数单独标定(按 offset),跨函数套用同一套结论必然翻车。
  13. 加壳产物先自检,再谈分析。 自造样本的头号杀手不是反调试而是打包参数:<Protection Options="0"> 会清空默认保护选项 → 打包器跳过 Saving startup code → 入口点没被改写(原代码已被搬走)→ 产物是死件,而日志一路 100%、Compilation completed,一句警告都没有。两项自检:日志里必须有 startup code;readelf -h 的入口必须与输入不同。

环境

项说明
自检python3 scripts/doctor.py —— 先跑,别在缺依赖的路径上猜
venvbash scripts/mkvenv.sh → 建到 <skill>/.venv。Arch/Debian 系统 pip 是 externally-managed,必须 venv
依赖pypcode(Ghidra SLEIGH 的 Python 绑定)+ keystone(明文汇编→机器码)+ z3-solver。实测 pypcode 4.0.0 / keystone 0.9.2 / z3 5.1.0
IR 通道主:pypcode 的 P-code。备:IDA 的 Hex-Rays microcode(idaq exec 可直接拿,见 scripts/ida_microcode.py)
静态底座idaq(IDA Pro 9.x,来自 ida-reversing skill):analyze/info/funcs/disasm/xrefs/strings/names/semz/exec,全部输出 JSON
编译/执行需要真跑样本时用 unidbg(Android so)或真机;本 skill 只处理它吐出来的 trace
取 traceARM64:unidbg / 真机。Linux x86-64:`scripts/trace_x86.py`(ptrace 单步,实测约 30 µs/步;实测 VMP 的 Linux runtime 不检测 ptrace)。qemu-user / rr / perf / Intel PT 经常没装,别指望
自造样本要"已知答案"的样本就自己加壳:references/harness.md(探针设计 + 加壳自检 + x86 handler 形态),工程样例在 VMP-unpack/vmp-lab
handler 分类scripts/vmp_classify.py —— 按七类判据把每个 handler 段定性(给 slot / 宿主寄存器 / 立即数),自己探测 vmCode / vmStack / vmRegBase;判据表与算法出处见 references/handler-classes.md
bash
export VMPPY=$HOME/.dsh/skills/vmp-reverse/.venv/bin/python
IDAQ=idaq
bash scripts/selftest.sh      # 31 条断言回归(自带 demo 数据),改过脚本就跑一遍

阶段 A — 静态摸底(别急着看伪代码)

bash
$IDAQ -b target.so analyze
$IDAQ -b target.so info                      # 架构/位数/段/函数数/字符串数
$IDAQ -b target.so funcs --limit 200         # 找体量大的函数
$IDAQ -b target.so strings --minlen 8 --filter 'bytecode' --limit 20
$IDAQ -b target.so disasm 0x... --limit 80   # 混淆代码上看汇编,不看伪代码

要拿到的四件事:① handler 表基址(ldr xN, [base + idx*8] 那条的表);② VM 上下文(VmContext)放在哪个寄存器/结构里;③ VIP(虚拟机 IP)与 VSP 的位置;④ dispatch 的形态(threaded / call-threaded / switcher)。

IDA 侧唯一可靠的"带地址的 IR"是 microcode:

bash
$IDAQ -b target.so exec "FUNC='sub_1234'
$(cat scripts/ida_microcode.py)"

它给你 blocks[].insns[{ea, op, text}] —— 每条 minsn_t 都带 ea,可与 P-code 互证(VMP handler 上 decompile 常常直接失败,microcode 通常还能出)。


阶段 B — 找锚点(varnode 层)

静态找不出锚点就上动态;有 trace 更好。锚点只有三类,都靠"地址根"识别:

bash
$VMPPY scripts/varnode_anchor.py --asm handler.s --arch arm64 --base 0x2e87e8 --auto
# 手工指定更准:
$VMPPY scripts/varnode_anchor.py --asm handler.s --arch arm64 --base 0x2e87e8 \
    --seed x23=ip --seed x24=regf --seed x25=table

判读表(实测复现):

判定含义
LOAD 地址带 ip 色读 IP
STORE 地址带 ip 色写 IP,`inputs[2]` 就是新 IP
LOAD 地址带 regf 色读虚拟寄存器 regs[idx]
STORE 地址带 regf 色写虚拟寄存器
LOAD 地址带 table 色尾巴那次 dispatch(查下一个 handler)

候选排序的经验:既被 LOAD 读、又被 STORE 写回同一基址的那个通常是 IP 指针槽;[base + idx*8] 形态最密的是虚拟寄存器文件;尾部只出现一次、用于 LOAD 出 pc 的是 dispatch 表。


阶段 C — 拿 trace,切 handler

trace 是标准产出(unidbg / 真机 / x64dbg)。Linux x86-64 本机取 trace 用 `scripts/trace_x86.py`:ptrace 单步,约 30 µs/步,实测 VMP 的 Linux runtime 不检测 ptrace(gdb 下也一样跑完)。格式用「序号 TAB 绝对地址 TAB RVA TAB "asm" TAB {读} TAB {写} TAB {内存}」。 PC 锚点一律用 RVA(第三列),不能用绝对地址(ASLR 漂移)。

bash
$VMPPY scripts/trace_slice.py --trace run.tsv --arch arm64 --top 20 --split
$VMPPY scripts/trace_slice.py --trace run.tsv --fold-bl --dump-handlers ./handlers/

原理:dispatch 模式是固定的 —— 从 dispatch table 加载下一个 handler 地址然后间接跳转,跳转之后紧邻的地址就是 handler 入口。所以不需要匹配 handler 内部任何指令模式,只要在 trace 里找间接跳转就能切块。

--fold-bl 处理 handler 自调用(BL 嵌套):返回地址栈驱动,压 rva+4,命中栈顶出栈,栈非空时只放行 handler 入口与 BR。基于 offset 匹配,不依赖 RET(trace 里可能根本看不到 RET),支持任意深度嵌套。 但它只在 arm64 上成立:x86-64 实测 VMP 3.5.1 的 handler 内部没有自调用(整条 trace 只有 2 次 call,都在 startup),而 jl 在 x86 上是条件跳转——当成链接跳转会压入一个永不出现的返回地址,随后折掉 99.8% 的行(现象:200 个 handler 每个只剩一行 jmp rXX)。现在脚本会在「返回地址栈未闭合」和「折叠率异常」时打印警告,看到就别当成没发生。

--dump-handlers 把每个 handler 的指令序列落盘,直接喂下一阶段。


阶段 D — 两代 IR(影子轨道)

两代同源同 varnode,别混成一个东西:

  • 第一代 = 原始汇编 → SLEIGH → P-code。语义完整的"真身",静态骨架,不产值,只回答"这段指令长啥样"。
  • 第二代 = 第一代 + trace 值 → varnode 折叠 → P-code。带具体值的"影子",做向导、做穿透。
bash
$VMPPY scripts/pcode_lift.py --asm handlers/handler_2e87e8.s --arch arm64 \
    --base 0x2e87e8 --trace run.tsv --mode both --json h.json

折叠的本质:把 varnode 从 register space 踢到 const space。两步,顺序不能反 —— 先折输入,再常量化简(unique 的值 trace 不记,只能靠输入折成常量之后被化简消掉)。

读列折源、写列折目标,两者绝不混用。 把 read/write 合并成一张表,写列会覆盖读列,于是 add w9, w9, #1(W9: 0x0 → 0x1)被算成 0x1+0x1=0x2 —— 这种错误无声无息,后面全错。

影子穿透长什么样(本机实测,帖子 §7 那条 handler 的真实 trace 值):

0x2e8808  smaddl x8, w9, w12, x11
    INT_ADD   const[0x7c4f75c200:8] = [const[0x7c4f75c1d0:8], const[0x30:8]]   ; base + IP*0x30
    # 折源 w9=0x1 / w12=0x30 / x11=0x7c4f75c1d0
0x2e8820  ldr x11, [x25, x11, lsl #3]
    LOAD      const[0x2e8a000:8] = [(ram), const[0x7853c70468:8]]             ; 下一个 handler 入口

静态骨架负责"长什么样",动态值负责"跑起来是什么" —— 两条合起来,handler 的地址是自己算出来的,不用人肉跟。


阶段 E — handler 语义填空(四类)

工具切完块,剩下的就是"填空"。先让分类器把能钉的钉死:

bash
$VMPPY scripts/vmp_classify.py --trace run.tsv --arch x64 --top 12 --json classes.json
# vmRegBase = 0x7ffcc71cdae8   vmCode = RBX   vmStack(direct) = RDI   vmStack(off) = RSP
# vPushReg  50 | vPopReg  44 | vLogicalOp 3 | vWriteMem 3 | (init+dispatch) 1
# seg 1  0x84b451  vPushReg  slot=2 reg=RBX    L/S=5/3  n=48
# seg 14 0xa39495  vLogicalOp slot=18           L/S=6/5  n=37

它按七类判据(vPushReg / vPopReg / vPushImm / vReadMem / vWriteMem / vLogicalOp / vExit)给每段定性,并给出 slot、宿主寄存器、立即数 —— 产出的是 有类型的 VM 指令流,不再是"一堆看不懂的跳转"。同时它自己探测 vmCode / vmStack / vmRegBase(含两种 vmStack 寻址模式),并把候选排名打出来供核对。

判据表、两道门卫(语义 STORE/LOAD 的定义、vmStack 与 vmRegFile 的先后排除)、 死代码消除算法、术语对照与算法出处,全在 references/handler-classes.md。

判不出来的那部分(unknown)再按下面四类手工处理:

  1. 普通 handler:找主要寄存器(普通/浮点 32/浮点 64),锚点定位后做反向污点,从最终操作回溯来源,产出结构化 IR。
  2. 控制流 handler:锚点在 IP 或字节码指针操作上。推荐原样记录(方案有局限,别硬猜语义)。
  3. 复合 handler:多个锚点、多轮操作。关键是先钉死当前 handler 的 IO 边界,否则层次泄漏、最终 IR 与实际不符。
  4. CALL 类 handler:handler 内封装对原始函数的调用。三档输出由你选:@CALL{Addr} / 记录被调函数内的调用列表与深度 / @CALL{Addr[arg1,arg2,arg3]}。ARM64 每条 4 字节,靠这个规律识别函数边界。

输出阶段不要做代数化简。 IR 是为了保证原有语义的正确性;化简在后续阶段做,不能在这一级产物上做。


阶段 F — 喂给 LLM 之前先压缩(无损语义)

别把原始汇编倒进上下文(上下文爆炸是"最可能的结局")。用五层无损编码:

bash
$VMPPY scripts/compact.py enc --asm handler.s --arch arm64 \
    --out c.txt --out-consts consts.json --emit-dict dict.md --verify
$VMPPY scripts/compact.py dec --asm c.txt --arch arm64 --consts consts.json

五层:L1 助记符短码 / L2 寄存器单字符 / L3 重复常量与符号入表 / L4 序列字典(dispatcher 骨架存一份,引用 ^1)/ L5 地址差分。

`--verify` 是出生证明:编码 → 展开 → 与原文逐条比对,差一条就整条流水线停摆。实测(帖子里的玩具 VM,45 条指令):761 字符 → 476 字符,roundtrip 通过。

映射表随包发(--emit-dict 产出):LLM 不需要在预训练里"学过"这套编码,相当于现场发教材、开卷考试,而不是闭卷猜谜。这份表同时是编码器字典、文法文档、LLM 教材 —— 一份表三处用,全部代码生成,杜绝手工漂移。


阶段 G — 判定,不许"我觉得等价"

三层信任:流水线是机械的(可信)→ LLM 是提议器(会幻觉,只产假设)→ 求解器是裁判(它说等价才是等价)。

LLM 的产出不允许是自然语言结论,必须写成可执行断言:

json
{"block": "0x4012A0",
 "claim": "x10 == ROR(XOR(x0, 0x9E3779B9), 13)",
 "intent": "rolling key 更新(这段自然语言只给人看,永不参与判定)"}
bash
$VMPPY scripts/z3_verify.py --asm handler.s --arch arm64 --base 0x2e87e8 \
    --claim 'x10 == XOR(x0, x1)' --target x10 --timeout 10000

双通道对照:通道 B(真值) 把 block 符号执行成精确位向量公式;通道 C(claim) 编译到同一 SMT 平面;问 Z3「存在让两者不同的输入吗」。

结果含义下一步
UNSAT → PROVEN数学证明等价放行
SAT → REFUTED有反例把反例连同 claim 打回给 LLM:"这个输入下你错了,修正"(CEGIS,预期 2~3 轮收敛)
超时 → FUZZED降级具体值差分(随机+边界值)标注可信度低一档
建不了模 → UNVERIFIED如实拒收暴露给报告,不假装

退出码:0 PROVEN / 2 REFUTED / 3 FUZZED / 4 UNVERIFIED,可直接进 CI。

能力边界(诚实声明):软肋不在 LLM,而在真值通道本身 —— 抗符号执行混淆(SMT-hard 谓词、路径爆炸炸弹)攻击的正是符号执行。本工具把符号执行限制在 block 级、控制爆炸半径;对刻意构造的对抗样本,真值通道仍可能超时,这时整块降级为 FUZZED。验证不了就承认验证不了,这是和"LLM 觉得等价"之间的最后一条底线。


阶段 H — 输出与回编译

你想问什么看什么
优化器眼里还剩啥hybrid / O3 小文件(别当业务还原)
完整 handle 过程是啥full 大文件(一步一记,unk_iat_func 占位)
真系统调用打到谁动态 IAT 绑桩(handle 地址永远不等于导入函数)

后续 IR 三条路,按需求选:

  1. 继续用 P-code 向上反编译 —— 直接接 Ghidra(开源、好接入)。
  2. 产出 LLVM IR —— 编成 so/obj,回 IDA/Ghidra/BN 里反编译。注意 LLVM 是中转站与工程化出口,不是万能:虚拟机语义很脏时它优化起来会"帮倒忙",想完美还原业务逻辑最终还得靠自己的语义表 + 数据流。
  3. 自己写 CFG/DFG/SSA,还原到伪 C —— 最难,也最有挑战。

命名纪律:未知占位函数叫 unk_iat_func 这类一眼看得出是占位/未知体的名字,别叫 vmp_step(别人会以为是官方探针),更别跟 CreateFile 这种真导入混在一起。


遇到 AI 协作时的钉死条目

跟模型协作时把这七条写进对话里钉死,否则它很爱给你"看起来很专业"的假分支:

text
1. 先 Python 模拟冒烟,确认真的进了虚拟化区
2. 批量扫,按「分发有多勤」选最大目标,别只看函数方块大小
3. 动态轨迹 + 静态补洞 → 虚拟指令流
4. decode 一定要吃双沿信息;VIP 范围按当前样本标,别抄旧样本
5. 看结果要分层:要过程 → full;要真 API → 动态 IAT;O3 空壳 → 只当「副作用还剩啥」
6. 没真标志位就别造 jcc
7. handle 地址永远别直接当成导入函数名

参考文件(按需读,不要一次全加载):

  • references/ir-foundations.md —— P-code / varnode / 折叠 / 影子轨道 / 三个必踩的坑(含本机实测差异)
  • references/trace-driven-handlers.md —— trace 格式、dispatch 固定模式、四类 handler、BL 折叠、输出层级
  • references/llm-z3-pipeline.md —— 五层编码文法、roundtrip、双通道验证、CEGIS、教练模块、能力边界
  • references/pipeline-engineering.md —— 工程化流水线、full/hybrid/O3、双沿与假 cmp、IAT 静动对照、踩坑实录
  • references/pitfalls.md —— 跨篇合并的坑总表(动手前扫一眼能省几天)
  • references/environment.md —— 工具链、venv、idaq 与 microcode 通道、本机实测数据
  • references/harness.md —— 自造 VMP 样本:探针设计、加壳产物自检(Options 陷阱/隐式 .vmp/注册 ini)、Linux x86-64 取 trace、实测的 x86-64 handler 形态与 arm64 对照表
  • references/related-tools.md —— 三个公开项目的定位与可借鉴点:VmpHelper(IDA 插件,VMP3.5 x86)、DisassembleVmp(x86-64 分析引擎,7 类 handler 判据 + Unicorn + LLVM 出口)、vmp3-import-fix(IAT 修复);含与本 skill 的逐项对照表与缺口清单
  • references/handler-classes.md —— handler 分类判据表:七类判据与两道门卫(语义 STORE/LOAD 的定义、vmStack 与 vmRegFile 的先后排除)、vmRegBase/vmCode/vmStack 自动探测、死代码消除算法、术语对照(vmCode/vmStack/vmRegFile ↔ IP/VSP/regf)与算法出处
  • references/papers.md —— 六步法则、四篇出处、相关工作与文献位置