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…

Vedi sorgente

Come usare

  1. Copia il comando e controlla il pacchetto prima di installarlo nel tuo ambiente agente.
  2. Controlla strumenti, credenziali e ambienti richiesti nel documento originale.
  3. Descrivi input e risultato desiderato; confronta l’output con le fonti.
npx skills add https://github.com/wul7chaos/vmp-reverse-skill --skill vmp-reverse

Prima di iniziare

  • L’installazione non include abbonamenti, quote API o accesso ai file.
  • Stelle e installazioni indicano attività, non un test indipendente di qualità o sicurezza.
Documento Skill originale

Contenuto dal repository con titoli, esempi, codice, tabelle, link e immagini preservati.

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 —— 六步法则、四篇出处、相关工作与文献位置