Files

baradok609hecl1pq6qi da24c2bd20 reverse-skills-max: initial public release (restored, redacted, hardened)

2026-10-20 02:17:15 +03:00

140 KiB

Raw Blame History

逆向工程技能库（re-skills）实现计划

For agentic workers: REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (- [ ]) syntax for tracking.

Goal: 构建可发布的逆向工程技能库——46 个技能（1 入口 + 8 网关 + 37 原子）+ npx 安装器 + 多工具转换器 + 结构测试。

Architecture: 三层技能体系（入口 → 大类网关 → 原子技能），技能间通过 [[链接]] 交叉引用；发布层为 npm 包（零依赖 Node ≥18 CLI）+ .claude-plugin/marketplace.json + 标准 .claude/skills/ 目录；validate.mjs 用 node:test 做结构冒烟测试；规则类工具（Cursor/Copilot/Windsurf）由 convert.mjs 转换 SKILL.md 生成。

Tech Stack: Node.js ≥18（node:test，零依赖）、POSIX sh（probe.sh）、Markdown + YAML frontmatter（技能本体）。

Global Constraints

所有技能 frontmatter：name 必须以 re- 前缀且与目录名一致；description 含中英触发词
原子技能（目录下无子技能目录的）必须含 ## 工具准备 章节：每工具 apt/dnf/pacman/brew/pip/cargo/choco 安装命令 + 验证命令 + OS 分支（Linux/macOS/Windows/WSL）
技能正文纯 Markdown，禁止任何工具私有语法
所有 [[链接]] 必须指向仓库内真实存在的技能名（validate 硬检查）
默认空白环境：工具未装时按「工具准备」引导安装，绝不中断流程
默认沙箱：一切动态分析强制前置 re-sandbox（平台经验库最高优先级条目）
默认转储优先：内存读取默认 gcore 转储，直读仅两个特例
Node 脚本零第三方依赖，测试用 node:test；npm test = node --test tests/
probe.sh 为 POSIX sh、可执行（chmod +x）
发布顺序：npm test 通过 → git tag → npm publish → 同步 marketplace.json 版本

Phase 1：基础设施

Task 1: 仓库脚手架

Files:

Create: package.json
Create: LICENSE
Create: .gitignore
Create: bin/.gitkeep, tests/.gitkeep

Interfaces:

Consumes: 无（空仓库，git 已 init）
Produces: package.json（name re-skills，bin re-skills → bin/install.mjs，scripts.test = node --test tests/）——后续所有 CLI 任务依赖
Step 1: 写 package.json

{
  "name": "re-skills",
  "version": "0.1.0",
  "description": "通用逆向工程 AI 技能库：46 个技能 + 多工具安装器（Claude Code/Gemini/Cline/Codex/Cursor/Copilot/Windsurf）",
  "type": "module",
  "bin": { "re-skills": "bin/install.mjs" },
  "scripts": { "test": "node --test tests/" },
  "engines": { "node": ">=18" },
  "license": "MIT",
  "keywords": ["reverse-engineering", "skills", "malware-analysis", "firmware", "claude-code"]
}

Step 2: 写 LICENSE（MIT 全文，版权行 Copyright (c) 2026 DslsDZC）

MIT License

Copyright (c) 2026 DslsDZC

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

Step 3: 写 .gitignore

node_modules/
*.log
.DS_Store
/dist/
/coverage/

mkdir -p bin tests
touch bin/.gitkeep tests/.gitkeep
node -e "const p=require('./package.json'); if(p.name!=='re-skills'||p.bin['re-skills']!=='bin/install.mjs') process.exit(1); console.log('package.json OK')"

Expected: package.json OK

Step 5: 提交

git add package.json LICENSE .gitignore bin/.gitkeep tests/.gitkeep
git commit -m "chore: 仓库脚手架(package.json/LICENSE/.gitignore)"

Task 2: validate.mjs 结构校验器 + 测试（TDD）

Files:

Create: tests/fixtures/good-skill/SKILL.md
Create: tests/fixtures/bad-name/SKILL.md（name 与目录名不符）
Create: tests/fixtures/no-tools/SKILL.md（叶子技能缺工具准备）
Create: tests/fixtures/broken-link/SKILL.md（链接指向不存在技能）
Create: tests/validate.test.mjs
Create: validate.mjs

Interfaces:

Consumes: 无
Produces: validate.mjs 导出 parseFrontmatter(md) -> {name, description, body}、checkSkillDir(dir) -> {errors: string[]}、collectSkills(root) -> string[]；CLI 入口 node validate.mjs 退出码 0/1。后续 Task 7-14 每个技能任务结束时运行它
Step 1: 写 fixtures

tests/fixtures/good-skill/SKILL.md:

---
name: good-skill
description: 测试用合法技能。Trigger: test。
---

# Good Skill

## 何时使用 / 何时不用

测试用。

## 工具准备

```sh
# Linux
apt install example-tool

操作步骤

常见坑与陷阱

跨域联合


`tests/fixtures/bad-name/SKILL.md`:

```markdown
---
name: wrong-name
description: 名字与目录不符。
---

# Bad Name

## 工具准备

tool

tests/fixtures/no-tools/SKILL.md:

---
name: no-tools
description: 缺工具准备章节。
---

# No Tools

## 操作步骤

nothing

tests/fixtures/broken-link/SKILL.md:

---
name: broken-link
description: 含死链接与合法 references 链接。
---

# Broken Link

## 工具准备

tool

## 跨域联合

引用 [[re-does-not-exist]] 和 [[platform-tips]]

tests/fixtures/gateway-skill/SKILL.md（type: gateway，豁免工具准备检查）:

---
name: gateway-skill
description: 网关型技能，无工具准备章节。
type: gateway
---

# Gateway Skill

## 完整工作流

workflow

Step 2: 写失败测试 tests/validate.test.mjs

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { parseFrontmatter, checkSkillDir, collectSkills, SKILL_PREFIX } from '../validate.mjs';

const FIX = new URL('./fixtures/', import.meta.url).pathname;

test('parseFrontmatter 解析合法 frontmatter', () => {
  const md = `---\nname: re-abc\ndescription: 测试。\n---\n\n# 标题\n\n正文`;
  const { name, description, body } = parseFrontmatter(md);
  assert.equal(name, 're-abc');
  assert.equal(description, '测试。');
  assert.match(body, /^# 标题/);
});

test('parseFrontmatter 拒绝缺失 name/description', () => {
  assert.throws(() => parseFrontmatter('---\nname: x\n---\n'), /description/);
  assert.throws(() => parseFrontmatter('# no frontmatter'), /frontmatter/);
});

test('good-skill 通过全部检查', () => {
  const { errors } = checkSkillDir(FIX + 'good-skill');
  assert.deepEqual(errors, []);
});

test('bad-name 报名字不一致错误', () => {
  const { errors } = checkSkillDir(FIX + 'bad-name');
  assert.ok(errors.some(e => e.includes('name') && e.includes('wrong-name')));
});

test('no-tools 叶子技能报缺工具准备', () => {
  const { errors } = checkSkillDir(FIX + 'no-tools');
  assert.ok(errors.some(e => e.includes('工具准备')));
});

test('broken-link 报死链接但放行 references 链接', () => {
  const { errors } = checkSkillDir(FIX + 'broken-link', {
    knownSkills: ['re-abc'],
    knownRefs: new Set(['platform-tips']),
  });
  assert.ok(errors.some(e => e.includes('re-does-not-exist')));
  assert.ok(!errors.some(e => e.includes('platform-tips')));
});

test('gateway-skill 豁免工具准备检查', () => {
  const { errors } = checkSkillDir(FIX + 'gateway-skill');
  assert.ok(!errors.some(e => e.includes('工具准备')));
});

test('collectSkills 收集全部技能目录名', () => {
  const names = collectSkills(FIX);
  assert.deepEqual([...names].sort(), ['bad-name', 'broken-link', 'gateway-skill', 'good-skill', 'no-tools']);
});

Step 3: 运行测试确认失败

node --test tests/

Expected: FAIL（Cannot find module '../validate.mjs'）

Step 4: 写实现 validate.mjs

#!/usr/bin/env node
// validate.mjs — 技能库结构校验器。npm test 与 CI 入口。
import { readdirSync, readFileSync, existsSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';

export const SKILL_PREFIX = 're-';
const HERE = dirname(fileURLToPath(import.meta.url));

export function parseFrontmatter(md) {
  const m = md.match(/^---\n([\s\S]*?)\n---\n*([\s\S]*)$/);
  if (!m) throw new Error('missing frontmatter');
  const fm = {};
  for (const line of m[1].split('\n')) {
    const kv = line.match(/^(\w+):\s*(.*)$/);
    if (kv) fm[kv[1]] = kv[2];
  }
  if (!fm.name) throw new Error('frontmatter missing name');
  if (!fm.description) throw new Error('frontmatter missing description');
  return { name: fm.name, type: fm.type, description: fm.description, body: m[2] };
}

export function isLeafSkill(dir) {
  return !readdirSync(dir, { withFileTypes: true })
    .some(e => e.isDirectory() && !e.name.startsWith('.') && e.name !== 'references');
}

export function collectSkills(root) {
  // 不加前缀过滤：测试 fixture 目录无 re- 前缀，须全部收集
  return readdirSync(root, { withFileTypes: true })
    .filter(e => e.isDirectory())
    .map(e => e.name);
}

// references/*.md 文件名（去扩展名）也作为合法 [[链接]] 目标，如 [[platform-tips]]
export function collectReferences(root) {
  const refs = new Set();
  for (const dir of readdirSync(root, { withFileTypes: true })) {
    if (!dir.isDirectory() || !dir.name.startsWith(SKILL_PREFIX)) continue;
    const refDir = join(root, dir.name, 'references');
    if (!existsSync(refDir)) continue;
    for (const f of readdirSync(refDir)) {
      if (f.endsWith('.md')) refs.add(f.replace(/\.md$/, ''));
    }
  }
  return refs;
}

export function checkSkillDir(dir, opts = {}) {
  const errors = [];
  const name = dir.split(/[\\/]/).pop();
  const mdPath = join(dir, 'SKILL.md');
  if (!existsSync(mdPath)) { errors.push(`SKILL.md missing in ${name}`); return { errors }; }
  let fm;
  try { fm = parseFrontmatter(readFileSync(mdPath, 'utf8')); }
  catch (e) { errors.push(`${name}: ${e.message}`); return { errors }; }
  if (fm.name !== name) errors.push(`${name}: frontmatter name '${fm.name}' != dir name`);
  if (!fm.description.trim()) errors.push(`${name}: empty description`);
  // 注：re- 前缀由 main() 目录遍历（仅校验 re-* 目录）与 name==dir 检查共同保证，此处不再单独检查
  // 工具准备检查：仅原子技能（无 type 或 type: atomic）且为叶子。入口(type: entry)/网关(type: gateway)豁免
  const type = fm.type ?? 'atomic';
  if (type === 'atomic' && isLeafSkill(dir) && !fm.body.includes('## 工具准备')) {
    errors.push(`${name}: atomic skill missing '## 工具准备' section`);
  }
  if (!['atomic', 'entry', 'gateway'].includes(type)) errors.push(`${name}: invalid type '${type}' (atomic/entry/gateway)`);
  const known = new Set(opts.knownSkills ?? []);
  for (const link of fm.body.matchAll(/\[\[([a-z0-9-]+)\]\]/g)) {
    if (!known.has(link[1]) && !(opts.knownRefs?.has(link[1]))) {
      errors.push(`${name}: broken [[${link[1]}]] link`);
    }
  }
  return { errors, name };
}

function main() {
  const root = join(HERE, '.claude', 'skills');
  if (!existsSync(root)) { console.error(`skills dir not found: ${root}`); process.exit(1); }
  const known = collectSkills(root);
  const knownRefs = collectReferences(root);
  let failed = 0;
  for (const dir of readdirSync(root, { withFileTypes: true })) {
    if (!dir.isDirectory() || !dir.name.startsWith(SKILL_PREFIX)) continue;
    const { errors } = checkSkillDir(join(root, dir.name), { knownSkills: known, knownRefs });
    for (const e of errors) { console.error(`FAIL: ${e}`); failed++; }
  }
  if (failed) { console.error(`${failed} problem(s) found`); process.exit(1); }
  console.log(`OK: ${known.length} skills validated`);
}

if (process.argv[1] && process.argv[1].endsWith('validate.mjs')) main();

Step 5: 运行测试确认通过

node --test tests/

Expected: 8 tests PASS

Step 6: 提交

git add validate.mjs tests/
git commit -m "feat: 技能结构校验器 validate.mjs(TDD)"

Task 3: probe.sh 环境探测脚本

Files:

Create: .claude/skills/re-analyze/references/probe.sh
Test: 本机直接运行

Interfaces:

Consumes: 无
Produces: 可执行 POSIX sh，stdout 输出 OS: / ARCH: / CORES: / MEM_GB: / HAVE:/MISS: 行；Windows 无 uname 时输出 OS: Windows 并跳过探测。re-analyze（Task 6）调用它
Step 1: 写 probe.sh

#!/bin/sh
# probe.sh — 环境探测：OS 平台 / CPU / 内存 / 已装逆向工具
# 输出约定：OS: / ARCH: / CORES: / MEM_GB: / HAVE:tool / MISS:tool
# 通用原则：空白环境（无任何工具）也必须正常输出，绝不中断。

echo "== ENV =="
if command -v uname >/dev/null 2>&1; then
  case "$(uname -s)" in
    Linux)
      if grep -qi microsoft /proc/version 2>/dev/null; then
        echo "OS: WSL-Linux"
      else
        echo "OS: Linux"
      fi
      ;;
    Darwin) echo "OS: macOS" ;;
    MINGW*|MSYS*|CYGWIN*) echo "OS: Windows(msys)" ;;
    *) echo "OS: $(uname -s)" ;;
  esac
  echo "ARCH: $(uname -m)"
  if command -v nproc >/dev/null 2>&1; then echo "CORES: $(nproc)"; else echo "CORES: unknown"; fi
  if command -v free >/dev/null 2>&1; then
    echo "MEM_GB: $(free -g 2>/dev/null | awk '/^Mem:/{print $2}')"
  else
    echo "MEM_GB: unknown"
  fi
else
  echo "OS: Windows"
  echo "ARCH: unknown"
  echo "CORES: unknown"
  echo "MEM_GB: unknown"
fi

echo "== TOOLS =="
for t in ghidra radare2 rizin rz-bin gdb lldb x64dbg frida frida-server \
         binwalk unblob qemu-system-x86_64 qemu-system-aarch64 qemu-aarch64 \
         jadx apktool angr z3 capa floss strings objdump readelf file; do
  if command -v "$t" >/dev/null 2>&1; then
    echo "HAVE: $t"
  else
    echo "MISS: $t"
  fi
done

echo "== HINT =="
echo "已装工具(H)优先使用；未装工具(M)按对应技能的「工具准备」章节引导安装，不中断分析流程。"

Step 2: 赋予可执行权限并验证输出格式

chmod +x .claude/skills/re-analyze/references/probe.sh
sh .claude/skills/re-analyze/references/probe.sh

Expected: 输出含 == ENV ==、OS: Linux、ARCH:、CORES:、MEM_GB:、== TOOLS ==、若干 HAVE:/MISS: 行、== HINT ==。本机已装 ghidra/gdb/objdump 等应显示 HAVE:。

Step 3: 提交

git add .claude/skills/re-analyze/references/probe.sh
git commit -m "feat: 环境探测脚本 probe.sh"

Phase 2：入口 re-analyze

Task 4: platform-tips.md 平台经验知识库

Files:

Create: .claude/skills/re-analyze/references/platform-tips.md

Interfaces:

Consumes: 规格 2.5 节全部内容（下表 5 平台分支 + vsyscall 极端段 + 直读转储决策矩阵 + 默认沙箱 + 默认转储）
Produces: 被 ≥10 个技能引用的共享经验库；Task 7-14 的技能「工具准备」「常见坑与陷阱」引用它
Step 1: 写 platform-tips.md（内容 = 规格 2.5 节原文表格 + 决策矩阵 + 关键经验，逐字录入，结构如下）

# 平台经验知识库

> 跨大类共享的实战经验。所有技能的工具准备与操作步骤按 OS 分支执行。
> 原则：**先给最轻的可行方案**（Wine 直读 > 用户态仿真 > 全系统虚拟化 > 物理机）。

## 最高原则：默认沙箱

一切动态分析/运行样本默认在沙箱中执行（强制前置）：虚拟机快照 / 容器（Docker、firejail）/ 专用沙箱（Cuckoo/CAPE）；网络隔离（INetSim、fake DNS、断网）。静态分析可免沙箱，一切动态执行默认在沙箱内，分析结束后恢复快照。此原则优先于本文件所有其他条目。

## 平台分支

### 所有平台
- 动态分析默认沙箱（见上）。

### Linux
- 分析 Windows PE 程序：**Wine 直读进程内存**——wine 运行 PE → `gdb attach` 或读 `/proc/<pid>/mem`，无需整机虚拟化；脱壳/读内存直接对 Wine 进程操作。
- 跑非本机架构程序：QEMU 用户态仿真（`qemu-<arch>`）优先，全系统仿真仅必要时用。

### Linux 内存转储极端段
- `[vsyscall]`（固定地址 `0xffffffffff600000`，只执行 `--xp`）、`[vdso]`/`[vvar]`：`/proc/<pid>/mem` 读取失败、gdb 访问报错均属正常。
- 转储前必须按 `/proc/<pid>/maps` 过滤这些段（只 dump `r--p`/`rw-p` 可读映射），否则 dump 含垃圾页、脱壳/分析全被污染。
- 识别特征：`maps` 中 `[vsyscall]`/`[vdso]`/`[vvar]` 名称、地址落在 `0xffffffffff6xxxxx` 高段、无文件路径的匿名 `00:00` 映射。

### Windows
- 读目标进程内存：需装 Sysinternals 套件（`procdump`）/ `DumpIt` 做内存转储 + Volatility 分析；attach 需要管理员权限。
- 常用工具链：x64dbg、Process Explorer（替代 System Informer）、APIMonitor。

### macOS
- attach/调试：SIP 与 TCC 限制，调试工具需授权（Developer Tools 权限），`lldb` attach 前检查。

### WSL
- WSL 无法直接 attach Windows 进程——跨边界分析走 Windows 侧工具，WSL 内只做文件/静态分析。

## 「直读 vs 转储」决策（默认转储优先）

一次转储获得完整内存布局 + 寄存器/线程状态（ELF notes），可导入 Ghidra/IDA、可存档复现；后续所有定向提取（密钥搜索、脱壳段、DEX 挖掘）都从转储产物里做。

| 场景 | 方案 |
|---|---|
| 默认（任何需要读内存的任务） | **转储** `gcore` → ELF core；取证/存档用全量转储 + manifest |
| 需要完整布局 + 寄存器/线程（导入调试器、事后复现） | **转储** `gcore`（含 ELF notes） |
| 进程已死 | 直接分析已有 core（`kernel.core_pattern` / systemd-coredump / 容器 runtime dump） |
| ptrace 被禁 / 沙箱容器 / attach 失败 | 转储兜底（不依赖 `/proc/<pid>/mem` 权限路径） |
| 特例①：进程必须保持运行、实时交互调试 | **直读** `/proc/<pid>/mem`：先读 maps 定址 → SIGSTOP 防竞态 → chunked `pread` 只取目标区段 |
| 特例②：只需极小特定区段且性能敏感 | **直读** 单区段，同上流程 |

**关键经验**：转储时机——脱壳须等进程运行到 OEP 完全解密后再 dump；直读前必须先查 maps；dump 前过滤 `[vsyscall]`/`[vdso]`。

Step 2: 运行 validate 确认通过

node validate.mjs

Expected: OK: 1 skills validated（此时仅 re-analyze 目录存在，且其下 SKILL.md 尚不存在——若报错属预期，本任务只建 references 文件；Task 6 建 SKILL.md 后通过）

Step 3: 提交

git add .claude/skills/re-analyze/references/platform-tips.md
git commit -m "feat: 平台经验知识库 platform-tips.md"

Task 5: preferences.md + triage.md

Files:

Create: .claude/skills/re-analyze/references/preferences.md
Create: .claude/skills/re-analyze/references/triage.md

Interfaces:

Consumes: 规格 2.1 ②（问题集与反编译器选择依据）、2.4（联合场景）
Produces: re-analyze（Task 6）的问答与编排依据；全部网关（Task 7-14）的「跨域联合」章节引用 triage.md
Step 1: 写 preferences.md

# 偏好询问：问题集与默认值

入口在执行任务编排前，按以下顺序询问。**一次完成**，结果存入会话状态，贯穿本次分析全程。

## 必答问题（第一项）

### 1. 分析目标（自然语言，必答）
想达成什么？示例：
- 判定这个样本是否为恶意、会不会回连
- 脱壳后提取干净样本
- 找到密钥/注册码/算法
- 还原某函数逻辑
- 确认是否存在漏洞

目标不明确时追问，直到可执行。目标决定 triage.md 的选择路径。

## 选择问题

### 2. 反编译器选择
| 选项 | 依据 |
|---|---|
| Ghidra（默认推荐） | 免费开源、跨平台、Linux 最顺 |
| IDA | 商业付费（有 7.x 免费版）、Windows 生态最强、插件丰富；用户明确选或目标为 Windows 闭源软件时推荐 |
| radare2/rizin | 命令行轻量、终端友好、脚本化强；内存紧张或 CLI 工作流 |

内存 <4GB → 提示 Ghidra 可能吃力，建议 radare2 或先加内存。
**推荐依据与已装工具无关**（通用场景默认未装任何工具）。

### 3. 分析深度
- 快速结论 / 标准分析 / 深度报告

### 4. 输出报告
- 要（走报告流程：IOC/YARA 等）/ 不要

### 5. 平台确认
- 自动识别（有文件时按文件格式）/ 手动指定

## 状态传递

探测结果（probe.sh）与上述答案存入会话变量：`RE_OS`、`RE_ARCH`、`RE_MEM_GB`、`RE_TOOLS`（HAVE/MISS 列表）、`RE_GOAL`、`RE_DECOMPILER`、`RE_DEPTH`、`RE_REPORT`、`RE_TARGET_PLATFORM`。被调用技能读取这些变量（如 `RE_DECOMPILER=ghidra` → 反编译步骤直接走 re-ghidra；某工具 `MISS` → 先执行其「工具准备」安装步骤）。

Step 2: 写 triage.md

# 任务识别决策表

入口根据「分析目标 + 输入文件」选择编排路径。目标命中多个大类时按依赖顺序串联。

## 目标 → 编排路径

| 目标（用户描述） | 编排路径（按顺序） |
|---|---|
| 判定恶意行为 / 会不会回连 | re-malware 网关 → 默认沙箱(re-sandbox) → 行为(re-behavior) → C2(re-protocol: netcap/proto-rev/crypto-*) → IOC/报告(re-ioc) |
| 样本带壳 / 脱壳 | re-anti-analysis 网关 → 壳识别(re-packer-id) → 脱壳(re-unpack-simple/advanced) → 验证 |
| 破解 / 授权绕过 / 注册码 | re-cracking 网关 → （若带壳）re-anti-analysis → 授权定位(re-license) → 补丁/注册机(re-patching/re-keygen) |
| 分析固件 / IoT 设备 | re-firmware 网关 → 提取(re-fw-extract) → rootfs(re-fw-rootfs) → 仿真(re-fw-emulate) →（若见通信）re-protocol |
| 分析网络流量 / 未知协议 | re-protocol 网关 → 捕获(re-netcap) → 解析(re-proto-rev) → 加密(re-crypto-id/keys/decrypt) |
| 移动 App 分析 | re-mobile 网关 → APK(re-apk) / iOS(re-ios) → 动态(re-frida) →（若含原生库）re-binary-core |
| 一般软件逆向 / 看逻辑 | re-binary-core 网关 → 初勘(re-triage) → 格式(re-format-*) → 反编译(re-ghidra/ida/radare2) → 按需动态 |
| CTF 赛题 | re-ctf 网关 → 题型识别 → re-angr / re-z3 / 反混淆(re-deobfuscate) →（底座）re-binary-core |

## 复合任务示例

- "脱壳 → 静态 → 动态 → C2 协议 → 报告"：re-anti-analysis → re-binary-core → re-malware(re-sandbox) → re-protocol → re-ioc
- 每个环节完成后检查是否有新证据改变后续路径（如动态分析发现加壳 → 回退 re-anti-analysis）。

Step 3: 提交

git add .claude/skills/re-analyze/references/
git commit -m "feat: 偏好问题集与任务识别决策表"

Task 6: re-analyze 入口 SKILL.md

Files:

Create: .claude/skills/re-analyze/SKILL.md

Interfaces:

Consumes: probe.sh（Task 3）、platform-tips.md（Task 4）、preferences.md + triage.md（Task 5）
Produces: 唯一入口；[[链接]] 指向 8 个网关（Task 7-14 必须存在，否则 validate 报死链——本任务提交在网关创建前，validate 允许入口先提交、网关后补，但最终必须全部存在）
Step 1: 写 SKILL.md（完整内容）

---
name: re-analyze
type: entry
description: >
  逆向分析唯一入口。流程：环境探测(probe.sh) → 偏好询问(分析目标/反编译器/深度/报告/平台) →
  任务识别(triage.md) → 编排调用大类网关。
  触发词：分析、逆向、reverse、RE、帮我看看这个文件、这个样本是干什么的、
  脱壳、找密钥、破解、固件分析、恶意软件分析、analyze this binary。
---

# 逆向分析入口

<HARD-GATE>
按以下四步执行，每步完成后再进下一步。禁止跳过探测直接分析。
</HARD-GATE>

## 第〇步：环境探测

运行 `references/probe.sh`（或本机手动执行等价命令），记录：
- `RE_OS` / `RE_ARCH` / `RE_CORES` / `RE_MEM_GB`（探测失败→询问用户）
- `RE_TOOLS`：HAVE 列表（已装，优先使用）与 MISS 列表（未装，**不中断流程**，用到的技能会引导安装）
- 参考 [[platform-tips]] 中本平台分支的经验

## 第一步：偏好询问

按 `references/preferences.md` 顺序询问（一次完成）：
1. **分析目标**（必答，第一项）——不明确就追问
2. 反编译器：Ghidra(默认) / IDA / radare2
3. 深度：快速结论 / 标准分析 / 深度报告
4. 报告：要 / 不要
5. 平台确认：自动 / 手动

结果存入会话变量（`RE_GOAL`、`RE_DECOMPILER`、`RE_DEPTH`、`RE_REPORT`、`RE_TARGET_PLATFORM`），本次分析全程有效，被调用技能读取。

**安全底线**：目标涉及运行样本 → 提醒默认沙箱原则（见 [[platform-tips]] 最高原则）。

## 第二步：任务识别

按 `references/triage.md` 决策表，把 `RE_GOAL` + 输入文件映射到一条编排路径。复合目标按依赖顺序串联多个大类。

## 第三步：编排分派

调用对应大类网关技能（`[[re-binary-core]]` `[[re-malware]]` `[[re-firmware]]` `[[re-protocol]]` `[[re-mobile]]` `[[re-anti-analysis]]` `[[re-cracking]]` `[[re-ctf]]`），网关内部自行选择原子技能。每个环节完成后检查新证据，必要时回退调整路径（见 triage.md 复合任务示例）。

## 何时使用 / 何时不用

- 用：任何逆向/恶意软件/固件/协议/移动/破解/CTF 分析请求
- 不用：已被具体技能触发的精确请求（如"用 Ghidra 分析这段代码"可直接走 [[re-ghidra]]）

## 常见坑与陷阱

- 探测不是摆设：内存 <4GB 却选了 Ghidra → 提示改用 radare2
- 目标是"看逻辑"却直接上沙箱 → 静态优先，动态按需
- 用户没装任何工具是常态——不要因为 MISS 卡住，按「工具准备」引导安装

Step 2: 运行 validate 确认通过（此刻网关尚未创建，死链接预期存在；本步验证语法）

node validate.mjs

Expected: 输出 FAIL: re-analyze: broken [[re-binary-core]] link 等 9 条死链错误（预期，网关在 Task 7-14 补齐后消除）；其余检查通过

Step 3: 提交

git add .claude/skills/re-analyze/SKILL.md
git commit -m "feat: 入口技能 re-analyze"

Phase 3：技能内容（模板 + 8 网关 + 37 原子）

Task 7: 技能模板规范 + re-binary-core 网关 + 13 原子技能

Files:

Create: docs/skill-template.md（模板规范，供内容编写与发布文档引用）
Create: .claude/skills/re-binary-core/SKILL.md（网关）
Create: 13 个原子技能目录（re-triage、re-format-pe、re-format-elf、re-format-macho、re-imports、re-ghidra、re-ida、re-radare2、re-gdb、re-x64dbg、re-lldb、re-tracing、re-memdump），各含 SKILL.md（可含 references/）
Test: node validate.mjs

Interfaces:

Consumes: platform-tips.md（Task 4）
Produces: re-binary-core 为全库公共底座，被 re-mobile/re-ctf 网关引用；13 个原子技能被本网关及跨域场景引用

模板规范 docs/skill-template.md（本任务 Step 1 写定，所有技能任务照此执行）：

# 技能模板规范

## 原子技能结构
每个技能目录：`SKILL.md`（必含）+ 可选 `references/`（深度知识、gotchas）。

SKILL.md 章节（顺序固定）：
1. frontmatter：`name`（=目录名，re- 前缀）、`type`（原子技能可省略或 `atomic`；入口用 `entry`；网关用 `gateway`）、`description`（中英触发词 + 何时使用）
2. `# 标题`（中文，如 "脱壳：压缩壳（UPX/ASPack/FSG）"）
3. `## 何时使用 / 何时不用` —— 明确边界，防误触发
4. `## 工具准备` —— 必含：每个工具给出 apt / dnf / pacman / brew / pip / cargo / choco 安装命令 + 验证命令 + OS 分支（Linux/macOS/Windows/WSL 替代方案）；引用 [[platform-tips]] 相关分支
5. `## 操作步骤` —— 可执行、具体，沿用 porting-minecraft-mod 的硬性执行风格（不省略、不"类似处理"）
6. `## 跨域联合` —— 本技能在哪些复合任务中被其他大类引用（写 [[技能名]] 链接）
7. `## 常见坑与陷阱` —— 至少 3 条具体经验（来源：platform-tips + Task 15/16 调研产出）

## 网关技能结构
1. frontmatter（同原子技能，description 声明"网关"）
2. `# 标题`
3. `## 完整工作流` —— 该大类从头到尾的流程（步骤编号）
4. `## 何时用哪个原子技能（选择树）` —— 按输入特征/目标列选择分支
5. `## 跨域联合` —— 规格 2.4 的联合场景表（该网关相关行），含 [[链接]]
6. `## 常见坑与陷阱`

## 多工具兼容约束
- 正文纯 Markdown，禁止工具私有语法
- frontmatter 标准 YAML
- 引用统一用 `[[技能名]]`

re-binary-core 网关 SKILL.md 完整内容（本任务 Step 2）：

---
name: re-binary-core
type: gateway
description: >
  软件逆向核心网关（公共底座）。编排：初勘 → 格式解析 → 反编译 → 调试/跟踪 → 内存。
  子技能：[[re-triage]] [[re-format-pe]] [[re-format-elf]] [[re-format-macho]]
  [[re-imports]] [[re-ghidra]] [[re-ida]] [[re-radare2]] [[re-gdb]] [[re-x64dbg]]
  [[re-lldb]] [[re-tracing]] [[re-memdump]]。
  触发词：静态分析、看这个程序的逻辑、反编译、逆向这个二进制、binary analysis。
---

# 软件逆向核心

## 完整工作流

1. 环境：探测 + 偏好（若未走 [[re-analyze]] 入口，先补做，读取 `RE_*` 会话变量）
2. 初勘：[[re-triage]] —— file/hash/熵/strings，确认文件类型与架构
3. 格式解析：按类型走 [[re-format-pe]] / [[re-format-elf]] / [[re-format-macho]]
4. 导入导出：[[re-imports]] —— 库指纹、IAT/符号，识别链接了什么
5. 反编译：按 `RE_DECOMPILER` 走 [[re-ghidra]] / [[re-ida]] / [[re-radare2]]（未装 → 按对应技能「工具准备」安装；默认推荐 Ghidra）
6. 动态（按需，默认沙箱）：[[re-gdb]] / [[re-x64dbg]] / [[re-lldb]]（按 OS）+ [[re-tracing]] + [[re-memdump]]
7. 产出：结论 / 报告（按 `RE_REPORT`）

## 何时用哪个原子技能（选择树）

- 刚拿到文件，不知是什么 → [[re-triage]]
- 已知 PE / ELF / Mach-O，要理解结构 → 对应格式技能
- 要知道程序链接了哪些库/API → [[re-imports]]
- 要读懂函数逻辑 → 反编译三选一（[[re-ghidra]] 默认）
- 要看运行行为、设断点 → 按 OS 选调试器（Linux [[re-gdb]]、Windows [[re-x64dbg]]、macOS [[re-lldb]]）
- 要跟踪系统调用/函数调用 → [[re-tracing]]
- 要读/转储进程内存 → [[re-memdump]]（默认转储优先，见 [[platform-tips]]）
- 怀疑带壳 → 转 [[re-anti-analysis]]

## 跨域联合

- [[re-mobile]]：移动 App 原生 .so 库分析 → 本网关 [[re-format-elf]] + [[re-ghidra]]
- [[re-ctf]]：CTF 逆向题 → 本网关技能为底座
- [[re-anti-analysis]]：静态发现混淆/壳 → 转入脱壳域
- 本网关技能被 [[re-malware]] 深度逆向环节引用

## 常见坑与陷阱

- 探测到内存 <4GB 仍选 Ghidra → 提示 [[re-radare2]]
- strings 输出被加密/压缩干扰 → 用熵值（re-triage）判断是否先脱壳
- 直读 `/proc/<pid>/mem` 前必须查 maps（见 [[platform-tips]]）

13 个原子技能 frontmatter 与内容要求（每个技能按模板写，本表为必须覆盖的内容）：

技能	description（含触发词）	工具准备必须覆盖	操作步骤必须覆盖	坑与陷阱至少含
`re-triage`	文件初步勘察：file/哈希(sha256/md5)/熵/strings/架构识别。触发词：先看看这文件、triage、初勘、这是什么文件、hash	file、strings、objdump（readelf）、xxd；熵计算（`ent` 或 python）	① file 判定格式 ② sha256 计算（存证） ③ strings 提取关键串 ④ 熵评估（>7 可疑加壳/加密） ⑤ 决定下一步：格式解析 or 脱壳域	熵高≠必然加壳（压缩数据也高）；strings 中文环境编码；hash 先做再动文件
`re-format-pe`	PE 格式解析：DOS/NT 头、节表、导入导出、TLS 回调、Rich Header、证书表。触发词：PE格式、解析exe、section表	objdump、readelf（非直接）、pefile(pip)、CFF Explorer(Windows)	① e_lfanew 定位 PE 头 ② 节表与 RVA/文件偏移映射 ③ 导入表（IAT 大小异常=壳特征） ④ TLS 回调检查（比入口点更早执行） ⑤ Rich Header 识别编译器	TLS 回调是恶意软件常见藏身点；节名异常（UPX0/.aspack）；导入表极小→加壳；证书表偏移计算
`re-format-elf`	ELF 格式解析：ehdr/phdr/shdr、GOT/PLT、init_array、符号恢复。触发词：ELF、解析so、dynamic section	readelf、objdump、elfutils(eu-*)、patchelf	① readelf -h/-l/-S 三表 ② `.init_array`/`.fini_array`（main 之前执行） ③ GOT/PLT 与动态符号 ④ stripped 二进制符号恢复思路 ⑤ 检查 `--noexecstack`/RELRO/Canary	init_array 藏初始化/反调试；stripped 后靠字符串交叉引用恢复；GOT 覆盖是常见攻击点
`re-format-macho`	Mach-O 格式解析：mach_header、LC_*、segment、dyld 信息。触发词：Mach-O、解析mac程序、dyld	otool、llvm-objdump、jtool2、codesign	① otool -h/-l 头与 load commands ② __TEXT/__DATA 段 ③ LC_MAIN 入口 ④ dyld 环境变量注入点 ⑤ 代码签名(adhoc/Apple)检查	签名验证会拦调试；iOS 上需越狱环境；LC_LOAD_DYLIB 注入检测
`re-imports`	导入导出表与库指纹：IAT/EAT、DLL/so 指纹、FLIRT 思路。触发词：导入表、IAT、库指纹、链接了哪些库	objdump/readelf、pefile、rizin(rz-bin)、Ghidra FLIRT 插件	① 列出导入函数 ② 按导入特征匹配库/编译器（FLIRT 签名、libc 版本指纹） ③ 定位可疑导入（进程注入/网络/加密 API） ④ 导出表分析（插件/服务类样本）	导入表被壳重定向/加密；动态解析（GetProcAddress/dlopen）的 API 不在 IAT 里；字符串比对库版本
`re-ghidra`	Ghidra 工作流：导入→自动分析→反编译→脚本化。触发词：Ghidra、反编译、headless	Ghidra：官方安装（Java 21 要求）、`analyzeHeadless` 无头模式、ghidra-bridge(pip)	① analyzeHeadless 无头导入+分析 ② GUI：导航/交叉引用/反编译 ③ 重命名+类型传播标记 ④ Python 脚本（自动标注、解密循环仿真） ⑤ 导出反编译 C	自动分析漏掉混淆代码→手动标记；Java 版本不匹配启动失败；内存 <4GB 卡顿→radare2
`re-ida`	IDA 工作流：导入→FLIRT→Hex-Rays→idapython。触发词：IDA、Hex-Rays、idapython	IDA（商业/7.x 免费版）、idapython 脚本、FLIRT 签名库	① 导入与 auto-analysis ② FLIRT 识别库函数 ③ 交叉引用与重命名 ④ idapython 批处理（解密循环） ⑤ 免费版限制处理（无 Hex-Rays 时用反汇编+脚本）	免费版无反编译→Ghidra 兜底；反调试检测（IDA 调试器可被检测）；大二进制卡顿
`re-radare2`	rizin/radare2 工作流：命令行分析、pdf、V 模式。触发词：radare2、rizin、rz、r2	rizin：brew(pacman/apt 官方包)、r2 兼容层	① `rizin -A` 分析 ② `pdf @sym.main` 反汇编 ③ `axt` 交叉引用 ④ 可视化 `V` 模式 ⑤ 脚本与 rz-ghidra 反编译插件	未 -A 前信息少；大文件分析慢→限制深度；命令体系 r2/rz 差异
`re-gdb`	GDB/pwndbg/gef 调试：attach、断点、内存读写。触发词：gdb、调试、pwndbg、attach	gdb + pwndbg/gef（pip/官方脚本）、checksec	① attach 前查 ptrace 权限 ② 断点/单步/条件断点 ③ 查看/修改内存寄存器 ④ 反调试绕过（改 EFlags/时间差） ⑤ gcore 转储（见 platform-tips 默认转储优先）	ptrace 被禁→转储兜底；反调试（ptrace 自检、时间差）；Wine 进程 attach（见平台经验）
`re-x64dbg`	x64dbg 调试（Windows）：attach、断点、Scylla。触发词：x64dbg、Windows调试、Scylla	x64dbg（官方 release）、Scylla 插件、OllyDbg(旧)	① 附加/启动目标（管理员权限） ② 断点与条件断点 ③ 内存窗口与搜索 ④ 反调试绕过 ⑤ Scylla 修复 IAT（脱壳后）	需要管理员；反调试/反 attach；PPL 进程无法附加
`re-lldb`	lldb 调试（macOS/iOS）：attach、expr、image。触发词：lldb、macOS调试、iOS调试	lldb（Xcode/CLT）、SIP 关闭或授权	① Developer Tools 权限确认 ② attach/启动 ③ `image lookup` 符号 ④ 内存表达式 `expr` ⑤ 断点脚本	SIP/TCC 拦截 attach；权限弹窗需手动确认；内核调试需额外配置
`re-tracing`	系统调用/函数调用跟踪：strace/ltrace/dtruss。触发词：strace、跟踪系统调用、ltrace、API监控	strace/ltrace（Linux apt/pacman/dnf）、dtruss(macOS)、APIMonitor(Windows)	① strace -f 全进程树跟踪 ② 过滤（-e trace=network,file） ③ ltrace 库调用 ④ 输出保存为证据 ⑤ Windows 用 APIMonitor/ProcMon	不加 -f 漏子进程；输出巨大→先过滤；反调试样本检测 trace 环境
`re-memdump`	内存转储与提取：默认转储优先(gcore)，直读特例。触发词：内存转储、dump内存、找密钥、DEX提取	gdb/gcore、gdb core 分析工具、volatility(pip)、proc(psmisc)	① 默认：等 OEP 解密后 `gcore -o out <pid>`（含寄存器/线程） ② 转储前按 maps 过滤 vsyscall/vdso（见 platform-tips） ③ 导入 Ghidra/IDA 或 Volatility 分析 ④ 定向提取：密钥/DEX/字符串（magic 扫描） ⑤ 特例直读：maps 定址 → SIGSTOP → pread	vsyscall/vdso 读取失败正常；转储时机过早=壳的初始状态；/proc/pid/mem 无脑 open 必报错

Step 1: 写 docs/skill-template.md（内容见上方模板规范代码块）
Step 2: 写 re-binary-core/SKILL.md（内容见上方代码块）
Step 3: 写 13 个原子技能（按模板 + 上表要求；每个技能一个目录，内容可参考上表"必须覆盖"逐项展开；每个技能引用 platform-tips 对应分支；「跨域联合」章节写明被哪些网关/技能引用）
Step 4: 运行 validate

node validate.mjs

Expected: OK: 15 skills validated；死链错误仅剩指向未创建网关的（re-malware/re-firmware/re-protocol/re-mobile/re-anti-analysis/re-cracking/re-ctf）

Step 5: 提交

git add docs/skill-template.md .claude/skills/re-binary-core .claude/skills/re-triage .claude/skills/re-format-pe .claude/skills/re-format-elf .claude/skills/re-format-macho .claude/skills/re-imports .claude/skills/re-ghidra .claude/skills/re-ida .claude/skills/re-radare2 .claude/skills/re-gdb .claude/skills/re-x64dbg .claude/skills/re-lldb .claude/skills/re-tracing .claude/skills/re-memdump
git commit -m "feat: re-binary-core 网关 + 13 原子技能"

Task 8: re-malware 网关 + 3 原子技能

Files:

Create: .claude/skills/re-malware/SKILL.md（网关）
Create: .claude/skills/re-sandbox/SKILL.md、.claude/skills/re-behavior/SKILL.md、.claude/skills/re-ioc/SKILL.md
Test: node validate.mjs

Interfaces:

Consumes: platform-tips.md（默认沙箱最高原则）
Produces: 网关被 re-analyze 引用；被 triage.md "判定恶意行为"路径调用；re-sandbox 被所有动态分析路径引用为强制前置

re-malware 网关内容要求：工作流 = ① 默认沙箱前置（re-sandbox）② 静态初勘（re-triage，可免沙箱）③ 行为分析（re-behavior）④ C2/协议（re-protocol：re-netcap re-proto-rev re-crypto-*）⑤ 加壳样本转 re-anti-analysis ⑥ IOC/报告（re-ioc）。选择树按目标分支（行为判定/配置提取/家族识别）。跨域联合章节写入规格 2.4 的 malware 两行（加壳→anti-analysis、C2→protocol）。

3 个原子技能内容要求：

技能	description（含触发词）	工具准备必须覆盖	操作步骤必须覆盖	坑与陷阱至少含
`re-sandbox`	沙箱环境搭建（动态分析强制前置）。触发词：沙箱、隔离环境、firejail、VM快照、安全运行	firejail、docker、VirtualBox/VMware（快照）、INetSim、Cuckoo/CAPE	① 选隔离级别（VM 快照 > 容器 > firejail） ② 网络隔离（INetSim/fake DNS/断网） ③ 快照建立与恢复 ④ 样本传入/传出（隔离通道） ⑤ 分析完恢复快照	忘恢复快照=环境污染；网络未隔离样本外联；容器共享内核≠完全隔离；样本逃逸检测 VM 环境
`re-behavior`	恶意行为分析：持久化、注入、进程树、文件/注册表、ATT&CK 映射。触发词：行为分析、持久化、注册表、进程注入、它在干什么	沙箱产物（re-sandbox）、procmon(Windows)、sysdig/bpftrace(Linux)、MITRE ATT&CK 导航	① 进程树与注入识别（DLL 注入/进程空洞/APC） ② 持久化清单（Run 键/服务/计划任务/WMI） ③ 文件与注册表操作 ④ 网络连接与 C2 特征 ⑤ ATT&CK 战术映射	行为被沙箱检测绕过（延迟/交互检查）；只看进程树漏注入；持久化藏于计划任务/WMI 常被忽略
`re-ioc`	IOC 提取与 YARA 规则、报告结构。触发词：IOC、YARA、写规则、分析报告、hash列表	yara(pip/apt)、pefile、可选的 VT/grep.app 查询	① 提取 IOC：hash/域名/IP/文件路径/互斥体 ② YARA 规则编写（特征选择+评分） ③ 报告结构：摘要/行为/证据/IOC/结论 ④ 规则验证（yara 扫描样本）	特征选太泛→误报；只写 hash 不写行为特征；报告缺证据路径不可复现

Step 1: 写 re-malware/SKILL.md（按网关模板 + 上述内容要求）
Step 2: 写 3 个原子技能（按模板 + 上表）
Step 3: 运行 validate

node validate.mjs

Expected: OK: 19 skills validated，剩余死链仅指向尚未创建的网关

Step 4: 提交

git add .claude/skills/re-malware .claude/skills/re-sandbox .claude/skills/re-behavior .claude/skills/re-ioc
git commit -m "feat: re-malware 网关 + 3 原子技能"

Task 9: re-firmware 网关 + 4 原子技能

Files:

Create: .claude/skills/re-firmware/SKILL.md
Create: .claude/skills/re-fw-extract/SKILL.md、.claude/skills/re-fw-rootfs/SKILL.md、.claude/skills/re-fw-emulate/SKILL.md、.claude/skills/re-hardware-io/SKILL.md
Test: node validate.mjs

Interfaces:

Consumes: platform-tips.md
Produces: 网关被 re-analyze 引用；固件通信场景联合 re-protocol

网关内容要求：工作流 = ① 提取（re-fw-extract）② rootfs（re-fw-rootfs）③ 仿真（re-fw-emulate）④ 硬件接口（re-hardware-io，需实物时）⑤ 见通信→re-protocol。选择树：有固件文件→extract；有 rootfs→rootfs；需运行→emulate；有板子→hardware-io。

4 个原子技能内容要求：

技能	description（含触发词）	工具准备必须覆盖	操作步骤必须覆盖	坑与陷阱至少含
`re-fw-extract`	固件提取与解包：binwalk/unblob、magic 扫描、字节序。触发词：固件、binwalk、解包固件、firmware、IoT	binwalk（apt/pip）、unblob（pip，更准）、dd、hexdump、sasquatch	① `binwalk`/`unblob` 自动解包 ② magic 手工扫描（`hexdump -C` 找 JPEG/FS/压缩头） ③ 字节序判断（大端 ARM/MIPS 常见） ④ 嵌套容器逐层解 ⑤ 失败时手工切分（dd 按偏移）	自动解包失败≠没东西（自定义头）；字节序错→全错；大端 MIPS 头被 binwalk 漏→手工；解包产物混入垃圾需验证 magic
`re-fw-rootfs`	固件文件系统分析：rootfs、配置、密钥、启动脚本。触发词：rootfs、文件系统分析、squashfs、cramfs、配置文件	解包工具（unblob/binwalk 产物）、7z、grep/ripgrep	① 挂载/解包文件系统 ② 启动脚本（init.d/rcS）找程序入口 ③ 配置文件挖密钥/口令/hardcoded ④ 交叉编译二进制（ARM ELF）定位 ⑤ 弱口令/后门账号搜索	配置里硬编码密钥/口令常见；启动脚本决定分析顺序；交叉架构二进制需对应工具链（readelf -A 确认架构）
`re-fw-emulate`	固件仿真：QEMU 用户态/全系统。触发词：仿真、QEMU、firmadyne、跑固件	qemu-user/qemu-system（apt）、firmadyne 思路、binfmt_misc、gdbserver	① 用户态仿真（`qemu-<arch>` 单程序，最轻） ② 全系统仿真（网卡/外设配置） ③ 外设缺失用 stub/回环 ④ 交叉调试（qemu -g + gdb-multiarch） ⑤ 网络隔离下仿真	外设寄存器访问崩溃→stub；架构选错直接 segfault；无网络设备→初始化卡死；时间戳/时钟函数陷阱
`re-hardware-io`	硬件接口：JTAG/UART/flash 读取。触发词：JTAG、UART、串口、flash芯片、硬件提取、逻辑分析仪	openocd、picocom/minicom、flashrom、逻辑分析仪(pulseview)、JTAGulator	① 板子拆解与接口定位（PCB 丝印/万用表） ② UART 串口调试（波特率枚举） ③ JTAG/SWD 连接（openocd） ④ flash 芯片读取（flashrom/编程器） ⑤ 启动日志抓取	波特率不对→乱码（试 9600/115200 等）；JTAG 被熔断/锁定；5V/3.3V 电平误接烧板；先看启动日志再动手

Step 1: 写 re-firmware/SKILL.md（按网关模板 + 内容要求）
Step 2: 写 4 个原子技能（按模板 + 上表）
Step 3: 运行 validate（Expected: OK: 24 skills validated）
Step 4: 提交

git add .claude/skills/re-firmware .claude/skills/re-fw-extract .claude/skills/re-fw-rootfs .claude/skills/re-fw-emulate .claude/skills/re-hardware-io
git commit -m "feat: re-firmware 网关 + 4 原子技能"

Task 10: re-protocol 网关 + 5 原子技能

Files:

Create: .claude/skills/re-protocol/SKILL.md
Create: .claude/skills/re-netcap/SKILL.md、.claude/skills/re-proto-rev/SKILL.md、.claude/skills/re-crypto-id/SKILL.md、.claude/skills/re-crypto-keys/SKILL.md、.claude/skills/re-crypto-decrypt/SKILL.md
Test: node validate.mjs

Interfaces:

Consumes: platform-tips.md（沙箱网络隔离）
Produces: 网关被 re-analyze、re-malware（C2）、re-firmware（固件通信）引用

网关内容要求：工作流 = ① 捕获（re-netcap）② 加密识别（re-crypto-id）③ 密钥（re-crypto-keys）④ 解密（re-crypto-decrypt）⑤ 状态机重建（re-proto-rev）。选择树：有流量→netcap；流量是密文→crypto-id→keys→decrypt；要理解交互→proto-rev。

5 个原子技能内容要求：

技能	description（含触发词）	工具准备必须覆盖	操作步骤必须覆盖	坑与陷阱至少含
`re-netcap`	网络流量捕获：tcpdump/Wireshark/抓包。触发词：抓包、tcpdump、wireshark、流量分析、pcap	tcpdump、wireshark/tshark（apt/brew）、mitmproxy(pip)、nfqueue	① 选择抓包点（本机/网关/中间人） ② tcpdump 过滤语法 ③ tshark 导出/统计 ④ HTTPS 解密准备（mitmproxy CA） ⑤ 沙箱内隔离抓包（re-sandbox 网络隔离）	沙箱网络不隔离→真外联；TSL/HTTPS 需中间人；过滤写错漏关键流；抓包文件巨大→先过滤再存
`re-proto-rev`	协议状态机重建：Scapy 解析、消息结构。触发词：协议逆向、状态机、scapy、自定义协议	scapy(pip)、tshark、python3、binwalk（已知格式线索）	① 分组统计与聚类（长度/方向/时序） ② 定位固定头（magic/长度字段） ③ 字段推断（类型/长度/CRC） ④ Scapy 写解析器 ⑤ 状态机推演（握手/心跳/结束）	长度字段字节序错误→解析全错；CRC/校验先识别；心跳消息混淆；方向混淆（C2 交互模式）
`re-crypto-id`	加密算法识别：常量表指纹、自定义加密模式。触发词：加密识别、AES、XOR、算法指纹、custom encryption	python3、binutils、hexdump、可选的 Detect It Easy(Windows)	① 常量表指纹（AES S-box/CRC 表/MD5 IV） ② 熵分析定位密文 ③ XOR/ROL/ROR 单字节模式检测 ④ 常见算法流程特征（轮数/分组） ⑤ 动态侧确认（Frida 断在加密函数）	自定义加密先试简单模式（XOR）再升级；表隐藏（动态生成）；算法组合（先 XOR 再 AES）需分层识别
`re-crypto-keys`	密钥与口令提取：硬编码、内存搜索、资源。触发词：找密钥、硬编码、key extraction、口令	转储产物（re-memdump 默认转储）、strings、ghidra/rizin 搜索	① 静态：strings/交叉引用找硬编码 ② 内存：转储后搜密钥模式（16/32 字节熵块、口令可打印串） ③ 资源文件（.rsrc/嵌入 blob） ④ 导入表线索（Crypt* 函数附近） ⑤ 密钥派生函数（PBKDF）还原	密钥分片存储/异或混淆；真随机密钥≠从静态可提取；先查是否硬编码再上动态
`re-crypto-decrypt`	加密数据还原：定位解密函数、写解密脚本。触发词：解密、decrypt、还原数据、解密流量	python3、目标程序转储/反编译产物、可选的 angr（re-angr）	① 定位解密函数（交叉引用密文输入点） ② 反编译还原算法 ③ 重写为独立脚本（python） ④ 用已知明文验证 ⑤ 流量场景：解出明文流量流	还原脚本与样本行为不一致→回查边界条件（长度/填充）；解密在壳内→先脱壳；多轮解密链

Step 1: 写 re-protocol/SKILL.md
Step 2: 写 5 个原子技能
Step 3: 运行 validate（Expected: OK: 30 skills validated）
Step 4: 提交

git add .claude/skills/re-protocol .claude/skills/re-netcap .claude/skills/re-proto-rev .claude/skills/re-crypto-id .claude/skills/re-crypto-keys .claude/skills/re-crypto-decrypt
git commit -m "feat: re-protocol 网关 + 5 原子技能"

Task 11: re-mobile 网关 + 3 原子技能

Files:

Create: .claude/skills/re-mobile/SKILL.md
Create: .claude/skills/re-apk/SKILL.md、.claude/skills/re-ios/SKILL.md、.claude/skills/re-frida/SKILL.md
Test: node validate.mjs

Interfaces:

Consumes: platform-tips.md
Produces: 网关被 re-analyze 引用；原生库场景引用 re-binary-core

网关内容要求：工作流 = ① APK 静态（re-apk）/ iOS（re-ios）② 动态（re-frida）③ 原生库 → re-format-elf/re-ghidra（re-binary-core）。

3 个原子技能内容要求：

技能	description（含触发词）	工具准备必须覆盖	操作步骤必须覆盖	坑与陷阱至少含
`re-apk`	APK 静态分析：jadx/apktool、manifest、smali、加固识别。触发词：apk、android逆向、jadx、smali、dex	jadx、apktool（官方/GitHub release）、aapt2、dex2jar(可选)、JADX GUI	① 解包（apktool d） ② AndroidManifest 入口/权限/组件 ③ jadx 反编译 Java ④ smali 补丁思路 ⑤ 加固/混淆识别（脱壳域 re-anti-analysis）	加固样本 jadx 只看到壳壳（需脱壳/动态）；签名校验；资源混淆需 aapt2 还原；原生 .so 走 re-format-elf
`re-ios`	iOS 应用分析：Mach-O、class-dump、越狱环境。触发词：ios逆向、ipa、class-dump、越狱	ipa 解包工具（unzip）、class-dump、otool、越狱环境（可选）、frida-ios-dump	① ipa 解包与签名检查 ② class-dump 头文件 ③ 二进制走 re-format-macho ④ 越狱环境动态调试 ⑤ 脱壳（frida-ios-dump 思路）	App Store 加密二进制需先脱壳；签名失效无法安装；无越狱→动态分析受限（模拟器/受管设备）
`re-frida`	Frida 动态插桩（桌面+移动统一）。触发词：frida、hook、插桩、绕过、spawn	frida-tools(pip)、frida-server（移动端推送，注意版本与架构匹配）、objection(pip)	① spawn vs attach 选择 ② JS hook 编写（拦截/改参/返回值） ③ 枚举与调用（enumerateModules/Java.perform） ④ 绕过证书校验/检测（常见模板） ⑤ 反检测对抗（隐藏 frida-server、改名）	版本不匹配→协议错误；spawn 时机晚→错过早期逻辑；目标检测 frida（端口/特征）→需要隐藏方案；root 检测

Step 1: 写 re-mobile/SKILL.md
Step 2: 写 3 个原子技能
Step 3: 运行 validate（Expected: OK: 34 skills validated）
Step 4: 提交

git add .claude/skills/re-mobile .claude/skills/re-apk .claude/skills/re-ios .claude/skills/re-frida
git commit -m "feat: re-mobile 网关 + 3 原子技能"

Task 12: re-anti-analysis 网关 + 4 原子技能

Files:

Create: .claude/skills/re-anti-analysis/SKILL.md
Create: .claude/skills/re-packer-id/SKILL.md、.claude/skills/re-unpack-simple/SKILL.md、.claude/skills/re-unpack-advanced/SKILL.md、.claude/skills/re-deobfuscate/SKILL.md
Test: node validate.mjs

Interfaces:

Consumes: platform-tips.md（Wine 直读、转储时机、默认转储）
Produces: 网关被 re-malware（加壳样本）、re-cracking（破解前置）引用

网关内容要求：工作流 = ① 壳识别（re-packer-id）② 简单壳（re-unpack-simple）③ 强壳（re-unpack-advanced）④ 反混淆（re-deobfuscate）。选择树：先识别再选脱壳路径；识别不出→按手动流程。

4 个原子技能内容要求：

技能	description（含触发词）	工具准备必须覆盖	操作步骤必须覆盖	坑与陷阱至少含
`re-packer-id`	壳与混淆器识别：签名/节名/EP/熵。触发词：查壳、加壳识别、packer、壳名、UPX	Detect It Easy（跨平台）、PEiD（Windows）、`file`/`strings`、熵计算	① 签名库扫描（DIE/PEiD） ② 节名异常（UPX0/.aspack/自定义） ③ 入口点指向非首节 ④ 熵 >7 判断 ⑤ 导入表极小特征	签名库不全→漏新壳；伪装节名；壳套壳；先记 OEP 线索（EP 附近 pushad 等）
`re-unpack-simple`	压缩壳脱壳：UPX/ASPack/FSG。触发词：脱壳、unpack、UPX、esp定律、OEP	目标工具（upx -d 官方解包）、调试器（按 OS：re-gdb/re-x64dbg）、Scylla（Windows IAT 修复）	① 优先官方/自动解包（`upx -d`） ② ESP 定律找 OEP（设断在 pushad 后） ③ 内存断点法（VirtualAlloc 断点） ④ 转储 OEP（时机：解密完成后，见 platform-tips） ⑤ IAT 修复（Scylla/ImpREC）	转储过早=壳初始状态；IAT 不修→导入表乱；自校验（CRC）→脱壳后需补丁；Wine 环境用 re-gdb 操作
`re-unpack-advanced`	强壳脱壳：VMProtect/Themida。触发词：VMProtect、Themida、强壳、虚拟化壳、手动脱壳	调试器（按 OS）、Scylla、脚本（idapython/rizin 脚本）、scyllaHide（反反调试，GitHub）	① 反调试对抗（scyllaHide 思路：NtQueryInformationProcess/时间差） ② 找 OEP（堆栈回溯/内存断点组合） ③ 转储（默认转储优先） ④ IAT 修复（Scylla，含重定向处理） ⑤ 虚拟化代码区域标注（不还原则标记绕过）	反调试链多层→先攻最外层；VM 代码还原成本高→标记而非还原；多线程壳（监控线程）需挂起线程；壳检测调试器环境
`re-deobfuscate`	反混淆：花指令、控制流平坦化、字符串加密。触发词：反混淆、花指令、控制流平坦化、字符串解密、obfuscation	反编译产物（re-ghidra 等）、idapython、rizin 脚本、D-810（IDA 插件，可选）、python3	① 花指令清除（patch NOP/跳转修复） ② 控制流平坦化识别与还原（D-810/手动） ③ 字符串解密循环定位与仿真 ④ 批量脚本化（解密所有字符串） ⑤ 还原前后对比验证	删错指令→控制流损坏（先备份）；平坦化状态变量找错→错乱；加密字符串需等运行时（动态解密）

Step 1: 写 re-anti-analysis/SKILL.md
Step 2: 写 4 个原子技能
Step 3: 运行 validate（Expected: OK: 39 skills validated）
Step 4: 提交

git add .claude/skills/re-anti-analysis .claude/skills/re-packer-id .claude/skills/re-unpack-simple .claude/skills/re-unpack-advanced .claude/skills/re-deobfuscate
git commit -m "feat: re-anti-analysis 网关 + 4 原子技能"

Task 13: re-cracking 网关 + 3 原子技能

Files:

Create: .claude/skills/re-cracking/SKILL.md
Create: .claude/skills/re-license/SKILL.md、.claude/skills/re-patching/SKILL.md、.claude/skills/re-keygen/SKILL.md
Test: node validate.mjs

Interfaces:

Consumes: platform-tips.md
Produces: 网关被 re-analyze 引用；联合 re-anti-analysis

网关内容要求：工作流 = ① 若带壳→re-anti-analysis ② 授权定位（re-license）③ 补丁（re-patching）或注册机（re-keygen）。

3 个原子技能内容要求：

技能	description（含触发词）	工具准备必须覆盖	操作步骤必须覆盖	坑与陷阱至少含
`re-license`	授权验证逻辑分析：注册校验定位。触发词：注册码、授权验证、license、序列号校验、破解定位	调试器（按 OS）、反编译器（re-ghidra 等）、strings	① 字符串/API 交叉引用定位校验函数（MessageBox/注册对话框/注册表读取） ② 调用图与校验分支（成功/失败跳转） ③ 算法还原（对比/解密/签名验证） ④ 在线激活 vs 离线校验区分 ⑤ 机器码绑定识别	校验函数可能被混淆/加密（先 re-deobfuscate）；在线激活→需抓包/协议域；校验可能多次（启动+功能点）
`re-patching`	补丁制作：字节级 patch、指令重写。触发词：打补丁、patch、修改跳转、绕过验证、crack	十六进制编辑器（hexedit/hxd）、调试器（按 OS）、rizin（`wx` 写字节）、补丁文件工具	① 定位 patch 点（失败跳转→改 jz/jnz） ② 字节修改（nop/跳转重写） ③ 校验和/自校验处理 ④ 补丁导出（二进制 diff/patch 文件） ⑤ 多架构（ARM 改 B 指令等）	改错分支→功能异常；自校验检测修改；补丁需跨版本适配（版本号检测）；签名（Authenticode）失效提示
`re-keygen`	注册机算法还原。触发词：注册机、keygen、算法还原、序列号生成	反编译产物、z3（re-z3 可选）、python3	① 从 re-license 拿到的校验算法 ② 逆推生成算法（正推/约束求解） ③ python 实现注册机 ④ 边界（校验码/校验位）处理 ⑤ 多平台输出（CLI 脚本）	算法含不可逆部分（哈希/非对称）→补丁替代；用户名绑定→生成逻辑需含输入；大小写/格式校验

Step 1: 写 re-cracking/SKILL.md
Step 2: 写 3 个原子技能
Step 3: 运行 validate（Expected: OK: 43 skills validated）
Step 4: 提交

git add .claude/skills/re-cracking .claude/skills/re-license .claude/skills/re-patching .claude/skills/re-keygen
git commit -m "feat: re-cracking 网关 + 3 原子技能"

Task 14: re-ctf 网关 + 2 原子技能

Files:

Create: .claude/skills/re-ctf/SKILL.md
Create: .claude/skills/re-angr/SKILL.md、.claude/skills/re-z3/SKILL.md
Test: node validate.mjs

Interfaces:

Consumes: platform-tips.md、re-binary-core
Produces: 网关被 re-analyze 引用

网关内容要求：工作流 = ① 题型识别（逆向/加密/算法）② 简单题直接 re-binary-core ③ 需自动化→re-angr/re-z3 ④ 混淆→re-deobfuscate。

2 个原子技能内容要求：

技能	description（含触发词）	工具准备必须覆盖	操作步骤必须覆盖	坑与陷阱至少含
`re-angr`	angr 符号执行：符号化输入、求解。触发词：angr、符号执行、自动解题、constraint	angr(pip)、python3、目标二进制	① 确定符号化点（输入/argv/文件） ② 到达目标地址/避开地址建模 ③ 路径约束与求解（solver） ④ 路径爆炸应对（hook/限制深度/分段） ⑤ 典型模板（find/avoid 模式）	路径爆炸→hook 系统调用/限制；复杂校验慢→结合人工分析；未符号化输入→无解；python 版本兼容（3.9-3.11）
`re-z3`	Z3 约束求解：建模、密钥/flag 推导。触发词：z3、约束求解、solver、SMT	z3-solver(pip)、python3	① 从反编译还原约束（比较链/数学关系） ② BitVec/Int 建模 ③ solver.check/model ④ 边界（长度/字符集）约束 ⑤ 输出 flag/密钥	无界变量→慢（加边界）；位宽不匹配→无解；非线性运算支持差→换思路；约束遗漏→错解

Step 1: 写 re-ctf/SKILL.md
Step 2: 写 2 个原子技能
Step 3: 运行 validate

node validate.mjs

Expected: OK: 46 skills validated，无任何 FAIL（全部网关已创建，死链清零）

Step 4: 提交

git add .claude/skills/re-ctf .claude/skills/re-angr .claude/skills/re-z3
git commit -m "feat: re-ctf 网关 + 2 原子技能，46 技能全部通过 validate"

Phase 4：经验调研补全

Task 15: 调研① —— 平台/格式/恶意行为经验

Files:

Modify: .claude/skills/re-analyze/references/platform-tips.md（追加调研所得）
Modify: re-triage、re-format-pe、re-format-elf、re-format-macho、re-imports、re-memdump、re-behavior、re-ioc 的「常见坑与陷阱」（追加）
Test: node validate.mjs

Interfaces:

Consumes: WebSearch（本任务执行时联网检索）
Produces: 经验库 v2（覆盖 10 类经验中的 1/2/5/9 类）
Step 1: 检索平台与格式经验

WebSearch 查询（至少 3 个）：

malware analysis gotchas TLS callbacks init_array common pitfalls
ELF vs PE reverse engineering common analysis mistakes
process memory forensics pitfalls vsyscall vdso cache poisoning dump

将检索到的、platform-tips.md 尚未覆盖的实战经验追加到对应文件的「常见坑与陷阱」（每条：现象 → 原因 → 对策）。来源链接写入平台经验库的「来源」小节。

Step 2: 检索恶意行为经验

WebSearch 查询（至少 3 个）：

malware persistence mechanisms checklist registry WMI scheduled tasks
process injection techniques detection DLL hollowing APC
IOC extraction YARA rule writing best practices

按上表目标文件追加经验条目。

Step 3: 运行 validate 并提交

node validate.mjs
git add -A
git commit -m "docs: 调研补全平台/格式/恶意行为经验"

Expected: OK: 46 skills validated

Task 16: 调研② —— 脱壳/对抗/协议/加密经验

Files:

Modify: re-packer-id、re-unpack-simple、re-unpack-advanced、re-deobfuscate、re-sandbox、re-proto-rev、re-crypto-id、re-crypto-keys、re-frida、re-angr、re-z3 的「常见坑与陷阱」（追加）
Test: node validate.mjs

Interfaces:

Consumes: WebSearch
Produces: 经验库 v2 剩余部分（3/4/6/7/8/10 类）
Step 1: 检索脱壳/对抗经验

WebSearch 查询（至少 3 个）：

manual unpacking OEP ESP law IAT reconstruction pitfalls
VMProtect Themida unpacking anti-debug bypass techniques
anti-sandbox anti-vm detection techniques malware

Step 2: 检索协议/加密/CTF 经验

WebSearch 查询（至少 3 个）：

custom protocol reverse engineering methodology scapy pitfalls
crypto algorithm identification constants table AES S-box
angr path explosion solutions z3 flag solving tips CTF

Step 3: 运行 validate 并提交

node validate.mjs
git add -A
git commit -m "docs: 调研补全脱壳/对抗/协议/加密经验"

Expected: OK: 46 skills validated

Phase 5：发布基础设施

Task 17: install.mjs 安装器 + 测试（TDD）

Files:

Create: tests/install.test.mjs
Create: bin/convert.mjs（先建，install 依赖其导出——见 Interfaces）
Create: bin/install.mjs

Interfaces:

Consumes: convert.mjs 导出 convertAll(type, destDir)（Task 18 完整实现，本任务先提供可运行的初版）
Produces: CLI re-skills install|uninstall，支持 --global/--project/--target <t|all>/--dry-run/--link/--yes；退出码 0/1

convert.mjs 初版（Step 1，Task 18 会扩展）：

// bin/convert.mjs — SKILL.md → 规则文件转换器
import { readdirSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';

export function skillDirs(skillsRoot) {
  return readdirSync(skillsRoot, { withFileTypes: true })
    .filter(e => e.isDirectory() && e.name.startsWith('re-'))
    .map(e => join(skillsRoot, e.name));
}

export function readSkill(dir) {
  const md = readFileSync(join(dir, 'SKILL.md'), 'utf8');
  const m = md.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
  const fm = {};
  for (const line of (m?.[1] ?? '').split('\n')) {
    const kv = line.match(/^(\w+):\s*(.*)$/);
    if (kv) fm[kv[1]] = kv[2];
  }
  return { name: fm.name, description: fm.description, body: m?.[2] ?? md };
}

const HERE = dirname(fileURLToPath(import.meta.url));

export function convertAll(type, destDir) {
  // 初版：cursor/windsurf 每技能一文件；copilot 聚合单文件
  const skills = skillDirs(join(HERE, '..', '.claude', 'skills'))
    .map(readSkill);
  mkdirSync(destDir, { recursive: true });
  const files = [];
  if (type === 'cursor') {
    for (const s of skills) {
      const p = join(destDir, `${s.name}.mdc`);
      writeFileSync(p, `---\ndescription: ${s.description}\nglobs: **/*\n---\n\n${s.body}`);
      files.push(p);
    }
  } else if (type === 'windsurf') {
    for (const s of skills) {
      const p = join(destDir, `${s.name}.md`);
      writeFileSync(p, `# ${s.name}\n\n${s.description}\n\n${s.body}`);
      files.push(p);
    }
  } else if (type === 'copilot') {
    const p = join(destDir, 'copilot-instructions.md');
    const head = '# 逆向工程技能库（AI 助手指令）\n\n本文件由技能库自动聚合生成，作为分析时的知识参考。\n\n';
    writeFileSync(p, head + skills.map(s =>
      `## ${s.name}\n\n${s.description}\n\n${s.body}`).join('\n\n---\n\n'));
    files.push(p);
  } else {
    throw new Error(`unknown rule type: ${type}`);
  }
  return files;
}

install.mjs 完整实现（Step 2）：

#!/usr/bin/env node
// bin/install.mjs — re-skills 多工具安装器
import { cpSync, rmSync, symlinkSync, existsSync, mkdirSync, readdirSync } from 'node:fs';
import { join, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';
import { createInterface } from 'node:readline';
import { convertAll } from './convert.mjs';

const __dirname = dirname(fileURLToPath(import.meta.url));
export const SKILLS_SRC = join(__dirname, '..', '.claude', 'skills');

const TARGETS = {
  claude:   { mode: 'native', places: { global: '~/.claude/skills', project: '.claude/skills' } },
  gemini:   { mode: 'native', places: { global: '~/.gemini/skills', project: '.gemini/skills' } },
  cline:    { mode: 'native', places: { project: '.claude/skills' } },
  codex:    { mode: 'native', places: { global: '~/.codex/skills', project: '.codex/skills' } },
  cursor:   { mode: 'rule',   places: { project: '.cursor/rules' }, ruleType: 'cursor' },
  copilot:  { mode: 'rule',   places: { project: '.github' }, ruleType: 'copilot' },
  windsurf: { mode: 'rule',   places: { project: '.windsurf/rules' }, ruleType: 'windsurf' },
};

function expandHome(p) { return p.replace(/^~/, process.env.HOME ?? process.env.USERPROFILE ?? '.'); }
function ask(q) {
  const rl = createInterface({ input: process.stdin, output: process.stdout });
  return new Promise(res => rl.question(q, a => { rl.close(); res(a.trim()); }));
}

export function planFor(target, scope, opts) {
  const t = TARGETS[target];
  if (!t) throw new Error(`unknown target: ${target} (valid: ${Object.keys(TARGETS).join(', ')}, all)`);
  if (t.mode === 'native') {
    if (!t.places[scope]) throw new Error(`target ${target} does not support --${scope}`);
    const dest = expandHome(t.places[scope]);
    const names = readdirSync(SKILLS_SRC);
    return { mode: 'native', dest, names, link: opts.link };
  }
  return { mode: 'rule', dest: expandHome(t.places.project), ruleType: t.ruleType };
}

async function installTarget(target, scope, opts) {
  const plan = planFor(target, scope, opts);
  if (plan.mode === 'native') {
    const conflicts = plan.names.filter(n => existsSync(join(plan.dest, n)));
    if (!opts.dryRun) {
      mkdirSync(plan.dest, { recursive: true });
      for (const n of plan.names) {
        const src = join(SKILLS_SRC, n), dst = join(plan.dest, n);
        if (existsSync(dst)) {
          if (opts.force) rmSync(dst, { recursive: true, force: true });
          else { console.log(`SKIP ${n}: exists at ${dst} (use --force to overwrite)`); continue; }
        }
        if (plan.link && !opts.dryRun) {
          try { symlinkSync(src, dst, 'dir'); }
          catch { cpSync(src, dst, { recursive: true }); console.log(`LINK failed for ${n}, copied instead`); }
        } else cpSync(src, dst, { recursive: true });
      }
    }
    console.log(`[${target}] plan: ${plan.names.length} skills → ${plan.dest}${opts.link ? ' (symlink)' : ''}${conflicts.length ? `, ${conflicts.length} conflict(s): ${conflicts.join(', ')}` : ''}`);
    console.log(`[${target}] verify: Claude Code 中运行 /skills 查看，或 ls ${plan.dest}`);
  } else {
    const files = opts.dryRun ? [] : convertAll(plan.ruleType, plan.dest);
    console.log(`[${target}] plan: convert ${readdirSync(SKILLS_SRC).length} skills → ${plan.dest}`);
    if (files.length) console.log(`[${target}] generated: ${files.join(', ')}`);
  }
}

async function main() {
  const args = process.argv.slice(2);
  const opts = {
    target: 'claude', scope: null, dryRun: false, link: false, force: false,
    yes: false, uninstall: args[0] === 'uninstall',
  };
  for (let i = opts.uninstall ? 1 : 0; i < args.length; i++) {
    const a = args[i];
    if (a === '--global') opts.scope = 'global';
    else if (a === '--project') opts.scope = 'project';
    else if (a === '--target') opts.target = args[++i] ?? 'claude';
    else if (a === '--dry-run') opts.dryRun = true;
    else if (a === '--link') opts.link = true;
    else if (a === '--force') opts.force = true;
    else if (a === '--yes') opts.yes = true;
  }
  const targets = opts.target === 'all' ? Object.keys(TARGETS) : [opts.target];
  if (opts.uninstall) {
    for (const t of targets) {
      const scope = opts.scope ?? 'project';
      const plan = planFor(t, scope, opts);
      if (plan.mode === 'rule') { console.log(`[${t}] uninstall: remove ${plan.dest} manually (converted rules are plain files)`); continue; }
      if (!opts.dryRun) { for (const n of readdirSync(SKILLS_SRC)) rmSync(join(plan.dest, n), { recursive: true, force: true }); }
      console.log(`[${t}] removed skills from ${plan.dest}`);
    }
    return;
  }
  for (const t of targets) {
    let scope = opts.scope;
    if (!scope) {
      const tDef = TARGETS[t];
      const hasGlobal = 'global' in tDef.places, hasProject = 'project' in tDef.places;
      scope = hasGlobal && hasProject ? (opts.yes ? 'global' : await ask(`[${t}] 安装到全局还是项目？(global/project) `)) : (hasGlobal ? 'global' : 'project');
    }
    await installTarget(t, scope, opts);
  }
}

if (process.argv[1] && process.argv[1].endsWith('install.mjs')) {
  main().catch(e => { console.error(`ERROR: ${e.message}`); process.exit(1); });
}

Step 1: 写 bin/convert.mjs 初版（上方代码）
Step 2: 写失败测试 tests/install.test.mjs

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, existsSync, readFileSync, readdirSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { planFor, SKILLS_SRC } from '../bin/install.mjs';

test('planFor: claude global 使用 HOME 展开', () => {
  const old = process.env.HOME;
  process.env.HOME = '/tmp/fakehome';
  const plan = planFor('claude', 'global', {});
  assert.equal(plan.dest, '/tmp/fakehome/.claude/skills');
  assert.equal(plan.mode, 'native');
  process.env.HOME = old;
});

test('planFor: cursor 是 rule 模式', () => {
  const plan = planFor('cursor', 'project', {});
  assert.equal(plan.mode, 'rule');
  assert.equal(plan.ruleType, 'cursor');
});

test('planFor: cline 不支持 --global', () => {
  assert.throws(() => planFor('cline', 'global', {}), /does not support/);
});

test('SKILLS_SRC 存在且含 re- 技能', () => {
  const names = readdirSync(SKILLS_SRC);
  assert.ok(names.includes('re-analyze'));
  assert.ok(names.length >= 46);
});

Step 3: 运行测试确认失败

node --test tests/

Expected: FAIL（Cannot find module '../bin/install.mjs' 或 planFor is not exported）

Step 4: 写 bin/install.mjs（上方完整代码；export { planFor, SKILLS_SRC } 导出供测试——在 main() 上方加 export const planFor = ...、export const SKILLS_SRC = ...）
Step 5: 运行测试确认通过

node --test tests/

Expected: 10+ tests PASS（含 Task 2 的 6 个）

Step 6: 手动冒烟测试

node bin/install.mjs --target claude --global --dry-run
node bin/install.mjs --target all --project --dry-run
node bin/install.mjs --target cursor --project --dry-run

Expected: 三条均输出计划不写盘（dry-run）；--target all 覆盖全部 7 个 target 与混合模式

Step 7: 提交

git add bin/convert.mjs bin/install.mjs tests/install.test.mjs
git commit -m "feat: 多工具安装器 install.mjs(TDD)"

Task 18: convert.mjs 完整实现 + 测试（TDD）

Files:

Modify: bin/convert.mjs（扩展：导出 parseSkill(md)、.mdc 模板完善、CLI 入口）
Create: tests/convert.test.mjs
Test: 冒烟生成到 /tmp

Interfaces:

Consumes: 全部技能内容（Task 7-14）
Produces: 三种规则产物的稳定格式；convert.mjs CLI（--target cursor|copilot|windsurf --out <dir>）
Step 1: 写失败测试 tests/convert.test.mjs

import { test } from 'node:test';
import assert from 'node:assert/strict';
import { mkdtempSync, readFileSync, readdirSync, existsSync } from 'node:fs';
import { tmpdir } from 'node:os';
import { join, dirname } from 'node:path';
import { fileURLToPath } from 'node:url';
import { readSkill, convertAll } from '../bin/convert.mjs';

const SKILLS = join(dirname(fileURLToPath(import.meta.url)), '..', '.claude', 'skills');

test('readSkill 解析 frontmatter', () => {
  const s = readSkill(join(SKILLS, 're-analyze'));
  assert.equal(s.name, 're-analyze');
  assert.ok(s.description.length > 10);
  assert.match(s.body, /##/);
});

test('convertAll cursor 生成 .mdc 且带 description 头', () => {
  const out = mkdtempSync(join(tmpdir(), 'rs-cursor-'));
  const files = convertAll('cursor', out);
  const names = readdirSync(out);
  assert.ok(names.includes('re-analyze.mdc'));
  assert.match(readFileSync(join(out, 're-analyze.mdc'), 'utf8'), /^---\ndescription: /);
  assert.ok(files.length >= 46);
});

test('convertAll copilot 聚合为单文件', () => {
  const out = mkdtempSync(join(tmpdir(), 'rs-copilot-'));
  convertAll('copilot', out);
  const p = join(out, 'copilot-instructions.md');
  assert.ok(existsSync(p));
  const txt = readFileSync(p, 'utf8');
  assert.match(txt, /## re-analyze/);
  assert.match(txt, /## re-z3/);
});

test('convertAll windsurf 每技能一文件', () => {
  const out = mkdtempSync(join(tmpdir(), 'rs-ws-'));
  convertAll('windsurf', out);
  assert.ok(existsSync(join(out, 're-triage.md')));
});

Step 2: 运行测试确认失败（Expected: FAIL，convertAll 尚未导出/签名不符——初版 convertAll(type, destDir) 需要 destDir 已建，改签名前先跑）

node --test tests/

Step 3: 扩展 convert.mjs（追加：parseSkill 别名 readSkill 保持兼容；convertAll 内确保 mkdirSync(destDir, {recursive:true}) 幂等；.mdc 模板 YAML 头含 globs: **/*；文件末尾加 CLI 入口）

// —— 追加到 convert.mjs 末尾 ——
function cli() {
  const args = process.argv.slice(2);
  const type = args[args.indexOf('--target') + 1];
  const out = args[args.indexOf('--out') + 1];
  if (!type || !out) { console.error('usage: node bin/convert.mjs --target cursor|copilot|windsurf --out <dir>'); process.exit(1); }
  const files = convertAll(type, out);
  console.log(`generated ${files.length} file(s) in ${out}`);
}
if (process.argv[1] && process.argv[1].endsWith('convert.mjs')) cli();

Step 4: 运行测试确认通过

node --test tests/

Expected: 14+ tests PASS

Step 5: 冒烟生成到 /tmp

node bin/convert.mjs --target cursor --out /tmp/rs-cursor
node bin/convert.mjs --target copilot --out /tmp/rs-copilot
node bin/convert.mjs --target windsurf --out /tmp/rs-windsurf
ls /tmp/rs-cursor | wc -l   # ≥46

Step 6: 提交

git add bin/convert.mjs tests/convert.test.mjs
git commit -m "feat: 规则转换器 convert.mjs 完整实现(TDD)"

Task 19: marketplace.json + AGENTS.md + README.md

Files:

Create: .claude-plugin/marketplace.json
Create: AGENTS.md
Create: README.md

Interfaces:

Consumes: 全部技能 + 安装器 + 转换器
Produces: 发布三件套；README 为发布门面
Step 1: 写 .claude-plugin/marketplace.json

{
  "name": "re-skills",
  "owner": "DslsDZC",
  "version": "0.1.0",
  "schemaVersion": 1,
  "description": "通用逆向工程技能库：46 个技能（恶意软件/固件/协议/移动/脱壳/破解/CTF）",
  "plugins": [
    {
      "name": "re-skills",
      "description": "逆向工程技能库",
      "version": "0.1.0",
      "source": { "type": "github", "repo": "DslsDZC/aihk", "path": "." }
    }
  ]
}

（发布时把 DslsDZC/aihk 替换为实际 GitHub 地址，与 Task 20 同步）

Step 2: 写 AGENTS.md

# AGENTS.md — 逆向工程技能库

本仓库是通用逆向工程 AI 技能库（46 个技能）。任何支持 AGENTS.md 的工具（Claude Code、Codex、Gemini CLI、Cursor、Zed、Qwen Code 等）都可读取本文件。

## 技能索引（三层结构）

- 入口：`re-analyze`（.claude/skills/re-analyze/）——环境探测 → 偏好询问 → 任务识别 → 编排
- 大类网关（8）：re-binary-core / re-malware / re-firmware / re-protocol / re-mobile / re-anti-analysis / re-cracking / re-ctf
- 原子技能（37）：见各网关 SKILL.md 的子技能清单与选择树

## 使用方式

- 本机为 Claude Code/Gemini CLI/Cline/Codex：克隆仓库后 `npx re-skills install --target <工具名>` 或直接引用 .claude/skills/ 目录
- Cursor/Copilot/Windsurf：`npx re-skills install --target cursor` 等生成规则文件
- 完整安装说明见 README.md

## 关键约定

- 技能 frontmatter：name 以 re- 前缀，description 含中英触发词
- 原子技能必含「工具准备」章节（跨 OS 安装指引）
- 动态分析默认沙箱；内存读取默认转储优先（见 re-analyze/references/platform-tips.md）
- 分析流程入口：先读 .claude/skills/re-analyze/SKILL.md 与 references/triage.md

Step 3: 写 README.md（必须覆盖：① 三种安装方式（npx / claude plugin add / 手动拷贝）② 七种工具适配表（含兼容性边界：原生 vs 规则转换）③ 技能目录导航（46 技能一览）④ 工具准备原则说明 ⑤ LICENSE 与免责声明——逆向工程须遵守法律法规，仅用于授权范围内的安全研究）

# re-skills — 通用逆向工程 AI 技能库

[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)

46 个逆向工程技能，覆盖恶意软件分析、软件逆向、固件/嵌入式、协议逆向、移动应用、脱壳/反混淆、软件破解、CTF。**通用、可发布**：不假设用户已装任何工具，每个技能自带跨 OS 安装指引。

>  **免责声明**：本技能库仅用于安全研究与授权范围内的分析。请遵守所在司法辖区的法律法规。

## 安装（三种方式）

### 方式一：npx（推荐，支持 7 种 AI 工具）

```bash
npx re-skills install                     # 交互式，默认 Claude Code
npx re-skills install --target all        # 安装到全部 7 种工具
npx re-skills install --target cursor     # 生成 Cursor 规则
npx re-skills install --target gemini     # Gemini CLI 原生技能
npx re-skills install --global            # 全局安装
npx re-skills install --project           # 仅当前项目
npx re-skills install --dry-run           # 只看计划不安装
npx re-skills uninstall                   # 卸载

方式二：Claude Code 插件市场

claude plugin add DslsDZC/aihk

方式三：手动拷贝

把 .claude/skills/ 下的技能目录复制到 ~/.claude/skills/（Claude Code）或对应工具目录。

多工具适配

工具	安装方式	体验
Claude Code	`--target claude` / plugin	原生技能（按需加载）
Gemini CLI	`--target gemini`	原生技能
Cline	`--target cline`	原生技能（兼容）
Codex CLI	`--target codex`	原生技能
Cursor	`--target cursor` → `.cursor/rules/*.mdc`	规则聚合（知识+流程，无按需加载）
GitHub Copilot	`--target copilot` → `.github/copilot-instructions.md`	规则聚合
Windsurf	`--target windsurf` → `.windsurf/rules/*.md`	规则聚合

技能导航（46）

入口 → 8 大类网关 → 37 原子技能，详见 .claude/skills/ 与 docs/skill-template.md。快速索引：

re-analyze：入口（探测 → 偏好 → 识别 → 编排）
re-binary-core：re-triage、re-format-pe/elf/macho、re-imports、re-ghidra、re-ida、re-radare2、re-gdb、re-x64dbg、re-lldb、re-tracing、re-memdump
re-malware：re-sandbox、re-behavior、re-ioc
re-firmware：re-fw-extract、re-fw-rootfs、re-fw-emulate、re-hardware-io
re-protocol：re-netcap、re-proto-rev、re-crypto-id、re-crypto-keys、re-crypto-decrypt
re-mobile：re-apk、re-ios、re-frida
re-anti-analysis：re-packer-id、re-unpack-simple、re-unpack-advanced、re-deobfuscate
re-cracking：re-license、re-patching、re-keygen
re-ctf：re-angr、re-z3

设计原则

默认空白环境：工具未装 → 技能内「工具准备」引导安装，不中断
默认沙箱：一切动态分析强制前置
默认转储优先：内存读取默认 gcore 转储
平台经验库：.claude/skills/re-analyze/references/platform-tips.md

开发

npm test   # 结构校验（frontmatter/死链/工具准备）

发布流程：npm test 通过 → git tag → npm publish → 同步 marketplace.json 版本。


- [ ] **Step 4: 运行 validate + 全部测试**

```bash
node validate.mjs
node --test tests/

Expected: OK: 46 skills validated + 全部 tests PASS

Step 5: 提交

git add .claude-plugin/ AGENTS.md README.md
git commit -m "feat: 发布三件套(marketplace/AGENTS/README)"

Task 20: 全量验证与发布演练

Files:

Modify: package.json（确认 test script）
Test: 全部验证命令

Interfaces:

Consumes: 全部
Produces: 发布就绪状态
Step 1: 全量测试

npm test
node validate.mjs
sh .claude/skills/re-analyze/references/probe.sh

Expected: 全部 PASS；probe.sh 输出 OS/内存/工具清单

Step 2: 安装器与转换器演练

node bin/install.mjs --target all --project --dry-run
node bin/convert.mjs --target cursor --out /tmp/rs-cursor-final
node bin/convert.mjs --target copilot --out /tmp/rs-copilot-final
node bin/convert.mjs --target windsurf --out /tmp/rs-windsurf-final

Expected: 各 target 输出安装/生成计划；产物文件数 ≥46

Step 3: 死链与交叉引用终检

grep -rno '\[\[[a-z0-9-]*\]\]' .claude/skills/ | sort -u | wc -l

Expected: 列出全部引用；validate.mjs 已保证无死链（46 技能 OK）

Step 4: 发布版本号检查

确认 package.json、marketplace.json、README 中版本一致（0.1.0）。发布时：npm test 通过 → git tag v0.1.0 → npm publish → 更新 marketplace 版本。

Step 5: 最终提交

git add -A
git commit -m "chore: 全量验证通过，发布就绪"

Phase 6：覆盖扩充（46 → 58 技能）

用户确认：先补覆盖。新增 2 网关 + 10 原子 = 12 技能，总数 58（1 入口 + 10 网关 + 47 原子）。全部沿用既有模板/规则/流程（docs/skill-template.md、validate.mjs、type 标记、platform-tips 引用）。

Task 21: re-managed 网关 + 3 原子技能（托管代码域）

Files:

Create: .claude/skills/re-managed/SKILL.md
Create: .claude/skills/re-dotnet/SKILL.md、.claude/skills/re-java/SKILL.md、.claude/skills/re-script-deob/SKILL.md
Test: node validate.mjs

Interfaces:

Consumes: docs/skill-template.md、platform-tips、re-binary-core（底座）
Produces: 网关被 re-analyze triage 调用（.NET/Java/脚本样本路径）；被 re-malware 联合（.NET/Java 恶意样本）

网关内容要求：工作流 = ① 识别运行时（PE 查 .NET 元数据 CLI header / jar manifest / 脚本特征）② 反编译（re-dotnet / re-java / re-script-deob）③ 去混淆 ④ 恶意场景转 re-malware。选择树按运行时分支。跨域联合：被 re-malware 的 .NET/Java 样本路径引用；底座 re-binary-core。

3 个原子技能内容要求：

技能	description（触发词）	工具准备必须覆盖	操作步骤必须覆盖	坑与陷阱至少含
`re-dotnet`	.NET CIL 逆向：dnSpy/ILSpy 反编译、de4dot 去混淆、ConfuserEx。触发词：.NET、dnSpy、ILSpy、de4dot、CIL、ConfuserEx	dnSpy（GitHub release，Windows）、ILSpy（跨平台，dotnet tool）、de4dot（GitHub）、dotnet SDK（装 SDK 才能跑 .NET 工具）	① 识别 .NET 程序集（PE CLI header、`file` 输出）② dnSpy/ILSpy 反编译浏览 ③ 字符串/API 定位关键逻辑 ④ de4dot 去混淆（ConfuserEx/SmartAssembly 等）⑤ 动态侧（可选 Frida/dotnet 调试）	.NET 混淆器（ConfuserEx 字符串加密+控制流）；de4dot 对旧版本混淆器失效；dnSpy 仅 Windows（Linux 用 ILSpy）；.NET 自包含发布（单文件）需先解包
`re-java`	Java 字节码逆向：CFR/JD-GUI、jar 解包、Java 加固。触发词：Java、jar、字节码、JD-GUI、CFR、class文件	JD-GUI（GUI）或 CFR（jar CLI，零依赖）、unzip、javap（JDK）、procyon 备选	① jar/war 解包 ② 类结构识别（javap -c 或反编译器）③ 逻辑还原（CFR/JD-GUI）④ 混淆识别（ProGuard/Allatori/字符串加密）⑤ 动态（JDB 调试或 Frida）	ProGuard 改名后靠字符串交叉引用；Allatori/字符串加密需先解密；反编译不完全正确→对照 javap；Java 加固（如 Virbox）类似壳需脱
`re-script-deob`	脚本/宏去混淆：PowerShell、VBA、JavaScript。触发词：PowerShell混淆、VBA宏、JS去混淆、脚本解密、恶意脚本	python3、可选的 olevba（pip oletools）、pyparsing、美剧 sed/xxd；PowerShell（Windows）/pwsh（Linux）	① 识别脚本类型与混淆风格（编码/字符串拼接/执行链）② 逐层还原（先解码再执行链跟踪）③ PowerShell（-enc 解码、IEX 链）④ VBA（olevba 提取宏 + 还原）⑤ JS（去混淆/解编码）——沙箱内执行（re-sandbox）	混淆层层嵌套需耐心逐层解；VBA 宏用 olevba 提取后仍是混淆的；恶意脚本必须沙箱内运行；正则盲改易破坏脚本结构

Step 1: 写 re-managed/SKILL.md（网关模板 + 内容要求）
Step 2: 写 3 个原子技能（模板 + 上表）
Step 3: 运行 validate（Expected: OK: 50 skills validated，死链仅指向未创建网关 re-forensics）
Step 4: 提交（feat: re-managed 网关 + 3 原子技能，git add 只加 4 个目录）

Task 22: re-forensics 网关 + 2 原子技能（取证/情报域）

Files:

Create: .claude/skills/re-forensics/SKILL.md
Create: .claude/skills/re-mem-forensics/SKILL.md、.claude/skills/re-ti/SKILL.md
Test: node validate.mjs

Interfaces:

Consumes: re-memdump（转储产物）、platform-tips（默认转储优先）
Produces: 网关被 re-analyze triage 调用（内存取证/情报查询路径）；被 re-malware 联合（内存取证、威胁情报关联）

网关内容要求：工作流 = ① 转储来源（re-memdump 默认转储优先，或已有 dump）② 内存取证（re-mem-forensics）③ 线索提取 ④ 情报关联（re-ti）。选择树：有 dump→mem-forensics；要查样本背景→ti。跨域联合：被 re-malware 的深度分析路径引用。

2 个原子技能内容要求：

技能	description（触发词）	工具准备必须覆盖	操作步骤必须覆盖	坑与陷阱至少含
`re-mem-forensics`	Volatility 3 内存取证：进程/内核对象/网络/凭据线索。触发词：内存取证、Volatility、memdump分析、进程列表、mimikatz线索	volatility3（pip，Python 3.8-3.11）、目标 dump（re-memdump 产物或已有 .raw/.mem/.core）	① 确认 dump 来源与架构（win/mac/linux profile）② `vol -f dump windows.pslist` 进程列表 ③ 网络连接（windows.netscan）④ 注入/异常（dlllist/malfind）⑤ 凭据线索（hashdump/lsadump）与可疑对象提取	profile 选错→解析全错（vol3 自动但注意符号文件下载失败）；dump 不完整（vsyscall 段污染）→ 分析偏差；malfind 误报；时间线证据（timeliner）取证要求
`re-ti`	威胁情报查询与关联：VT/Any.run/hybrid-analysis、MISP。触发词：威胁情报、VirusTotal、Any.run、沙箱查询、MISP、样本关联	浏览器/API（VT API key，curl 可用）、Any.run/hybrid-analysis 网站、可选 MISP 实例	① 哈希/域名/IP 查询（VT，注意隐私选项）② 沙箱报告解读（行为/网络/文件操作）③ 家族/团伙关联（VT graph、tag）④ MISP 事件关联（如有）⑤ 情报进报告（re-ioc 衔接）	私有样本 VT 无结果≠干净；沙箱报告不可全信（反沙箱样本）；API 配额/限速；哈希误报需多重确认

Step 1: 写 re-forensics/SKILL.md（网关模板 + 内容要求）
Step 2: 写 2 个原子技能（模板 + 上表）
Step 3: 运行 validate（Expected: OK: 53 skills validated，死链清零——re-forensics 是最后一个新网关）
Step 4: 提交（feat: re-forensics 网关 + 2 原子技能，git add 只加 3 个目录）

Task 23: re-binary-core 域扩充 5 原子技能

Files:

Create: .claude/skills/re-windbg/SKILL.md、.claude/skills/re-binaryninja/SKILL.md、.claude/skills/re-emulation/SKILL.md、.claude/skills/re-kernel/SKILL.md、.claude/skills/re-game/SKILL.md
Modify: .claude/skills/re-binary-core/SKILL.md（子技能清单加 5 个新链接）
Test: node validate.mjs

Interfaces:

Consumes: docs/skill-template.md、platform-tips
Produces: 5 个新原子挂到 re-binary-core 域；被 re-analyze 与各网关按场景引用

5 个原子技能内容要求：

技能	description（触发词）	工具准备必须覆盖	操作步骤必须覆盖	坑与陷阱至少含
`re-windbg`	WinDbg 调试（Windows 用户态+内核）。触发词：WinDbg、windbg、内核调试、kd、!analyze	WinDbg（微软商店版/WDK，Windows）、Windows SDK 符号、虚拟机双机调试（内核需）	① 附加/启动用户态目标 ② 断点/单步/寄存器 ③ `!analyze -v` 异常分析 ④ 内核调试（双机/本地 kd）⑤ 扩展命令（!process !teb lm kv）	符号未配置→无函数名（srv* 路径）；内核调试需双机或 VM 串口/NET；32/64 位命令差异；.exr/.cxr 恢复异常现场
`re-binaryninja`	Binary Ninja 工作流：MLIL、脚本 API。触发词：Binary Ninja、binaryninja、bn、MLIL	Binary Ninja（商业，有个人版）、`binaryninja` python API	① 导入与分析 ② MLIL 中间语言阅读（比裸反汇编可读）③ 重命名/类型 ④ Python 脚本（自动化标注）⑤ 与 Ghidra/IDA 对比选型（价格/插件生态）	MLIL 反编译对混淆代码失真；脚本 API 版本差异；无头模式用法；对比选型按预算/生态
`re-emulation`	模拟执行：Unicorn/Qiling 框架。触发词：Unicorn、Qiling、模拟执行、emulate、无硬件运行	unicorn（pip）、qiling（pip，依赖 unicorn）、capstone（pip）	① 场景判断（脱壳辅助/反调试绕过/无环境运行）② Unicorn 最小框架（映射内存/加载代码/执行）③ Qiling 全系统模拟（rootfs+文件系统）④ 钩子（hook_code/hook_mem）⑤ 结合 re-anti-analysis 脱壳场景	系统调用未处理→崩溃（Qiling 更省心）；自校验/环境检测样本察觉模拟；内存权限错误；模拟≠真实执行（时序/多线程缺失）
`re-kernel`	内核逆向：Windows 驱动/内核模块/rootkit。触发词：内核、驱动、.sys、rootkit、内核模块、IRP	反编译产物（re-ghidra/re-ida，驱动结构插件）、WinDbg 内核调试（re-windbg）、符号	① 驱动入口 DriverEntry 定位 ② IRP 分发表（MajorFunction）③ 设备对象/符号链接 ④ rootkit 特征（SSDT hook/inline hook/隐藏进程）⑤ 与用户态交互（DeviceIoControl）	内核结构随版本变化（结构偏移需符号）；无符号时靠逆向结构；内联 hook 检测需读指令头；内核崩溃=蓝屏（调试机隔离）
`re-game`	游戏逆向：Unity/Unreal、Cheat Engine。触发词：游戏逆向、Unity、Unreal、Cheat Engine、内存修改、反作弊	Cheat Engine（Windows）、Unity 工具（Il2CppDumper 等）、Unreal 工具（UnrealFinder 思路）、调试器（按 OS）	① 运行时/引擎识别（Unity mono/IL2CPP vs Unreal）② Unity：mono DLL 或 IL2CPP 导出（Il2CppDumper）③ 内存搜索（CE：数值/指针扫描）④ 函数定位与修改 ⑤ 反作弊对抗（检测规避，沙箱内）	IL2CPP 无托管 DLL 需 dumper；指针链扫描繁琐；反作弊（EAC/BE）强检测——分析环境隔离；游戏更新频繁补丁失效

Step 1: 更新 re-binary-core/SKILL.md 子技能清单（加 5 个链接）
Step 2: 写 5 个原子技能（模板 + 上表）
Step 3: 运行 validate（Expected: OK: 58 skills validated，零死链）
Step 4: 提交（feat: re-binary-core 扩充 5 原子技能，git add 只加 6 个目录/文件）

Task 24: 全库同步与全量验证（46 → 58）

Files:

Modify: README.md（技能导航 46→58、入口/网关索引、counts）
Modify: AGENTS.md（技能索引加 2 网关 + 10 原子）
Modify: package.json（description 46→58 技能）
Modify: .claude-plugin/marketplace.json（description 46→58）
Modify: .claude/skills/re-analyze/references/triage.md（新增路径：.NET/Java/脚本样本→re-managed；内存取证/情报→re-forensics）
Modify: .claude/skills/re-analyze/SKILL.md（分派列表加 2 新网关）
Test: npm test + node validate.mjs
Step 1: 同步上述 6 个文件（技能计数与导航全部 58；triage 决策表加 re-managed/re-forensics 两行 + 联合场景）
Step 2: 全量验证：npm test（含 validate 门禁，OK: 58 skills validated + 16/16 测试）、node bin/install.mjs --target all --project --dry-run（58 技能）、node bin/convert.mjs --target cursor --out /tmp/rs-final（58 产物）
Step 3: 提交（chore: 覆盖扩充至 58 技能，全库同步，git add -A）

Self-Review 记录

规格覆盖：

2.1 入口四步流程 → Task 3（probe.sh）、Task 5（preferences/triage）、Task 6（SKILL.md）✓
2.2 八个网关 → Task 7-14 ✓
2.3 37 原子技能 → Task 7-14（13+3+4+5+3+4+3+2=37）✓
2.4 跨域联合 → 各网关「跨域联合」章节 + triage.md ✓
2.5 平台经验库（沙箱/vsyscall/转储决策）→ Task 4 + Task 15 ✓
3.1 技能模板 → Task 7（docs/skill-template.md）✓
3.2 多工具兼容约束 → 模板规范 + validate 不检查私有语法（由模板约束）✓
4.1 仓库结构 → Task 1/3/4/5/6/19 ✓
4.2 安装器矩阵 → Task 17 ✓
4.3 兼容性边界 → README（Task 19）✓
4.4 转换器 → Task 18 ✓
5 测试与发布 → Task 2 + Task 20 ✓
6 成功标准 → 全部可验证于 Task 20 ✓

Phase 6 覆盖扩充（追加于 2026-08-07）：

规格更新：网关 8→10、原子 37→47、总数 58；联合场景 +5 行 ✓
Task 21（re-managed + 3）、Task 22（re-forensics + 2）、Task 23（binary-core + 5）、Task 24（全库同步）✓
暂缓项：WASM、Fuzzing、工控/汽车（二期）

Phase 7：深度扩充——经验沉淀（用户口述模式）

用户以工程经验审视种子并标注（对/部分对/错+补充），按最终沉淀建议写入。核心原则：避免绝对化（常见情况≠必然规则）。

Task 25: 平台经验沉淀（A 组 12 条）

Files:

Modify: .claude/skills/re-analyze/references/platform-tips.md
Modify: .claude/skills/re-gdb/SKILL.md、.claude/skills/re-x64dbg/SKILL.md、.claude/skills/re-ghidra/SKILL.md、.claude/skills/re-lldb/SKILL.md、.claude/skills/re-sandbox/SKILL.md
Test: node validate.mjs（OK: 58，零死链）

沉淀内容（用户审定的最终表述）：

A1（修改后，re-x64dbg+platform-tips Windows 分支）：attach 失败先区分权限与 PPL/保护进程；管理员解决普通限制，PPL 取决于 Signer Level 等级（EDR 常见 PPL-Windows TCB/Antimalware），需对应级别调试能力
A2（修改后，re-gdb+platform-tips Linux 分支）：ptrace_scope=1 限制子进程/父子关系/PR_SET_PTRACER；root 也可能受限；CAP_SYS_PTRACE 影响容器
A3（re-gdb+platform-tips）：32 位程序——gdb 架构切换影响 ABI/寄存器集/调用约定；x32dbg；wine32 前缀
A4（修改后，re-ghidra）：大文件卡死诱因=间接调用爆炸/大型 C++ RTTI/混淆控制流/大量数据段——先降低自动分析范围，优先定位入口/字符串/交叉引用再逐步展开
A5（修改后，re-gdb）：时钟对抗分三类——时间倍率检测/单步延迟检测/VM 时间源检测，分别应对
A6（re-gdb/re-fw-emulate）：QEMU 用户态最大问题=syscall ABI/kernel feature/指令扩展（非 libc）
A7（platform-tips）：Windows 读 Linux 样本——静态无平台限制，动态需匹配运行环境
A8（re-sandbox）：容器调试缺 SYS_PTRACE//proc/seccomp/Yama 限制
A9（修改后，re-sandbox）：沙箱隔离≠分析环境伪装（时间/硬件/输入检测是环境指纹；完整 VM 也会被检测）
A10（re-lldb+platform-tips macOS 分支）：task_for_pid entitlement/SIP/Hardened Runtime
A11（新增，platform-tips 原则）：动态分析前先确认目标 ABI、执行环境、权限模型，否则调试失败不代表程序不可分析
A12（新增，platform-tips 原则）：静态与动态不是替代关系，大型样本静态定位先行、动态验证在后
Step 1: 按上表把 12 条写入对应文件（platform-tips 为权威源；技能坑与陷阱各加 1 条"现象→原因→对策"并指向 platform-tips；表述避免绝对化）
Step 2: node validate.mjs（OK: 58，零死链）
Step 3: 提交（docs: 平台经验沉淀(用户审定 12 条)）

Task 26: 脱壳经验沉淀（B 组 11 条）

Files:

Modify: .claude/skills/re-unpack-simple/SKILL.md、.claude/skills/re-unpack-advanced/SKILL.md、.claude/skills/re-packer-id/SKILL.md、.claude/skills/re-triage/SKILL.md
Test: node validate.mjs（OK: 58，零死链）

沉淀内容（用户审定的最终表述）：

B1（re-unpack-simple）：ESP 定律本质=利用入口压栈保护现场找恢复点，不是脱壳公式（TLS 回调壳/多线程壳/VMProtect 不适用）
B2（修改后，re-unpack-simple）：内存断点法——对解密区域设执行监控找解密完成后的真实代码入口；有些壳先跳 loader/多阶段解密/fake OEP，"第一次执行 OEP"不成立
B3（re-unpack-simple）：转储后崩溃≠脱壳失败——除 IAT 外还查 TLS callback/重定位/异常表/Load Config
B4（修改后，re-unpack-advanced）：虚拟化壳入口≠原始程序逻辑入口（Themida 仍有人口，只是进 VM dispatcher）
B5（修改后，re-unpack-advanced）：IAT 异常时从 API 调用链/解析函数/内存写入点恢复导入关系（强壳可能 API hash/动态解析/syscall，跟踪"第一个 API 调用"不是通用法）
B6（re-unpack-advanced）：延迟导入/bound import/API resolver——Scylla 勾选 delayed 选项等
B7（re-unpack-simple）：Wine 脱壳失败原因=API 缺失/驱动/反虚拟化/环境检测——果断转 Windows VM
B8（re-packer-id）：壳套壳逐层检查 PE header/section/entropy/imports
B9（re-triage 或 re-unpack-simple）：脱壳前记录 SHA256/PE timestamp/EP RVA/section hash/import table
B10（新增，re-unpack-advanced）：脱壳=恢复可分析状态（代码/导入/重定位/异常机制完整），不是"找到 OEP"
B11（新增，re-unpack-advanced）：虚拟化保护目标=降低虚拟机解释层复杂度（VM 还原/标注绕过），不是简单还原原始代码
Step 1: 按上表把 11 条写入对应文件（坑与陷阱格式"现象→原因→对策"；表述避免绝对化）
Step 2: node validate.mjs（OK: 58，零死链）
Step 3: 提交（docs: 脱壳经验沉淀(用户审定 11 条)）

Task 27: 逆向基础分析方法论沉淀（R 组 22 条，用户口述）

Files:

Modify: .claude/skills/re-binary-core/SKILL.md（新增「## 分析方法论」章节）
Modify: .claude/skills/re-deobfuscate/SKILL.md、.claude/skills/re-gdb/SKILL.md、.claude/skills/re-memdump/SKILL.md、.claude/skills/re-ghidra/SKILL.md（强相关技能各加 ≤2 条坑）
Test: node validate.mjs（OK: 58，零死链）

沉淀内容（用户口述原话，22 条按 7 组）：

入口分析：R1 入口点≠main（EP 是初始化入口，经 CRT/TLS/loader 才到 main）；R2 字符串交叉引用优先于函数猜测（关键字符串→XREF 回溯）；R3 没有字符串≠没有逻辑（编码/哈希/运行时拼接/解密生成，追踪使用点）；R4 函数边界异常→检查反编译假象（手写汇编/混淆/尾调用/无 frame pointer，不完全相信 decompiler）
调用分析：R5 call 很少≠逻辑简单（函数指针/虚表/回调/切换跳表间接调用）；R6 间接调用异常→查函数指针来源（追踪寄存器/内存中目标地址来源）；R7 虚函数分析→先找 vtable（对象指针→vptr→vtable→函数集合）
内存与数据结构：R8 结构体识别不要只看字段访问（结合初始化位置/生命周期/多处使用）；R9 malloc/free 跟踪对象生命周期（创建点和释放点定含义）；R10 全局变量先找引用不找定义（全局区噪声高）
API/行为：R11 API 调用只是结果不是逻辑（分析参数来源和调用上下文）；R12 异常处理可能是控制流（SEH/C++ exception/signal handler 承担正常跳转）；R13 系统调用层比 API 更可信（hook/封装/替换时向下追到 syscall）
混淆分析：R14 控制流平坦化→看状态变量（调度器+状态变量+情况块）；R15 垃圾代码比例高→不逐条分析（找外部影响/数据流/真实调用）；R16 opaque predicate→验证条件是否恒定（永真/永假判断）
动态调试：R17 断点失效→不一定没执行（自修改代码/内存重映射/异常机制/反调试绕过）；R18 单步异常→查反调试（陷阱旗/时间检测/异常处理）；R19 看见解密数据→立刻保存（下一阶段可能清除）
PE/ELF 深层：R20 内存布局比文件布局重要（loader 后的映射状态才是运行时真相）；R21 section 名称不可信（看权限/熵/内容）；R22 重定位信息影响 dump（地址不一致时先查 relocation）
Step 1: re-binary-core/SKILL.md 新增「## 分析方法论」章节（七组小标题，22 条保留用户表述；插在「完整工作流」之后）
Step 2: 强相关技能加坑（每条"现象→原因→对策"、指向 re-binary-core 方法论章节；与既有条目不重复——重复的只在网关沉淀）：
- re-deobfuscate：R14（平坦化看状态变量）、R16（opaque predicate 恒定性）
- re-gdb：R17（断点失效四机制）、R18（单步异常查反调试）
- re-memdump：R19（看到解密数据立刻 dump）
- re-ghidra：R4（反编译假象——手写汇编/尾调用/无 frame pointer）
Step 3: node validate.mjs（OK: 58，零死链）
Step 4: 提交（docs: 逆向基础分析方法论沉淀(用户口述 22 条)，git add 只加 5 个文件）

Task 28: 反调试方法论沉淀（AD 组 45 条，用户口述）

Files:

Modify: .claude/skills/re-anti-analysis/SKILL.md（新增「## 反调试方法论」章节，45 条 9 组）
Modify: .claude/skills/re-unpack-advanced/SKILL.md、.claude/skills/re-gdb/SKILL.md、.claude/skills/re-x64dbg/SKILL.md（强相关技能各加 ≤2 条坑，查重后）
Test: node validate.mjs（OK: 58，零死链）

沉淀内容（用户口述原话，45 条按 9 组）：

基础检测（AD1-AD6）：启动即退出先查调试检测（EP/TLS/初始化函数）；IsDebuggerPresent 不代表完整反调试（组合检测，别只 patch 一点）；PEB BeingDebugged 用户态快速检测（找 PEB 访问/BeingDebugged/NtGlobalFlag）；NtGlobalFlag 异常→查堆调试标志；CheckRemoteDebuggerPresent 不可靠（可能被 hook/替换/底层）；NtQueryInformationProcess 是重点（ProcessDebugPort/ProcessDebugObjectHandle/ProcessDebugFlags）
异常机制（AD7/AD32-AD34/AD26/AD27）：异常没崩溃→可能反调试（INT3/INT 2D/单步异常）；INT3 不止一种形式（CC vs CD 03 长断点，异常行为不同）；INT 2D 是 Windows 特殊反调试点（调试器下/正常运行行为不同）；ICE 指令检测单步（F1 ICEBP）；异常断点行为异常→查 VEH（AddVectoredExceptionHandler，INT3 被主动处理/单步异常被吞/异常后继续运行）；SEH 链异常→可能反调试控制流（控制跳转/隐藏流程/检测 debugger）
时间检测（AD8-AD11/AD35）：断点后行为变化→查 Trap Flag（EFLAGS/异常次数）；时间突然变慢→查时间反调试（QPC/GetTickCount/timeGetTime/RDTSC）；RDTSC 检测不要只看一次读取（start-end delta、比较阈值、分支位置）；Sleep 检测→查时间加速（Sleep(5000)+检查实际经过时间→调试环境/沙箱加速/时间跳跃）；时间检测不只 RDTSC（RDTSCP/QPC/GetTickCount64/APIC timer）
环境与工具特征（AD12/AD16-AD17/AD38-AD40/AD31）：窗口/鼠标检测→环境真实性（自动化沙箱）；调试器窗口检测低级但常见（OllyDbg/x64dbg/WinDbg/IDA 窗口类或进程名）；进程列表检测→查工具指纹（debugger/monitor/sandbox，易误报）；窗口检测只是低级手段（高级样本更倾向 API 行为/内存特征/异常行为）；父进程检测（explorer→app vs debugger→app 启动链）；命令行检测（debugger/sandbox/分析环境参数）；程序只在 x64dbg 崩→查调试器特征（x64dbg 模块/窗口类/DLL 名称/内存特征）
硬件痕迹（AD29/AD43/AD15）：硬件断点也失效→可能检测 DR 寄存器（DR0-DR3/DR7 或异常行为）；调试寄存器不是唯一硬件痕迹（DR/LBR/性能计数器状态）；硬件断点检测→查 DR 寄存器（DR0-DR3/DR6/DR7）
线程与调试对象（AD25/AD30/AD37）：线程突然消失→查 NtSetInformationThread（ThreadHideFromDebugger：主线程正常/逻辑断点无效/调试器看不到异常）；调试器暂停后逻辑变化→查 Debug Object（ProcessDebugObjectHandle）；调试器导致线程调度变化（线程执行顺序/锁竞争/APC 调度）
自修改与断点（AD13-AD14/AD28）：断点被清除→查硬件断点/自校验（0xCC 检测：校验代码段/比较 hash/扫描 0xCC）；代码执行后恢复原样→可能是自修改（静态内容≠实际执行内容，需内存 dump/执行跟踪）；断点后代码改变→检查 self-modifying code（55 8B EC→CC 8B EC：校验代码/恢复字节/主动检测断点）
深层检测（AD41-AD42/AD44/AD21-AD22）：PEB 检测不仅是 BeingDebugged（NtGlobalFlag/ProcessHeap flags/HeapForceFlags）；内核调试检测（KdDebuggerEnabled/KdDebuggerNotPresent）；反调试可能故意制造假逻辑（返回错误数据/修改算法结果/延迟执行/跳过关键逻辑——比退出更常见）；内核级反调试→用户态 patch 无效（驱动/内核回调/内核对象检查需分析内核路径）；反虚拟化≠反调试（目标不同：观察者 vs 分析环境，不要混为一谈）
方法论（AD18-AD20/AD45）：TLS Callback 比 Entry Point 更早执行（入口断点没触发反调试→查 TLS）；反调试逻辑不要急着 patch（先确认检测结果如何影响控制流：退出/降功能/假数据/延迟）；多点反调试→找汇聚点（多个检测汇聚到一个 flag/状态变量/错误处理函数）；Patch 反调试点可能触发完整性检测（JNZ→JMP/CALL→NOP 触发 CRC/hash/self-check，先找检测链）

Step 1: re-anti-analysis/SKILL.md 新增「## 反调试方法论」章节（9 组 ### 小标题，45 条保留用户口述原话，格式与 re-binary-core 方法论章节一致；插在「完整工作流」之后）
Step 2: 强相关技能加坑（每条"现象→原因→对策"、指向 re-anti-analysis 反调试方法论；先查重——与既有坑重复的只在网关沉淀）：
- re-unpack-advanced：TLS callback 抢先（AD18）、假逻辑返回错误数据（AD44）
- re-gdb：RDTSC 两次读取 delta（AD10）、Trap Flag（AD8，若既有时间差坑已覆盖则跳过）
- re-x64dbg：x64dbg 特征检测（AD31）、DR 寄存器检测（AD15，若既有坑已覆盖则跳过）
Step 3: node validate.mjs（OK: 58，零死链）
Step 4: 提交（docs: 反调试方法论沉淀(用户口述 45 条)，git add 只加本任务文件）

Task 29: 反虚拟化方法论沉淀（AV 组 8 条，用户口述）

Files:

Modify: .claude/skills/re-anti-analysis/SKILL.md（新增「## 反虚拟化方法论」章节，8 条）
Modify: .claude/skills/re-sandbox/SKILL.md、.claude/skills/re-unpack-advanced/SKILL.md（查重后加坑，重复则零改动）
Test: node validate.mjs（OK: 58，零死链）

沉淀内容（用户口述原话，保留 Trigger/Observation/Inference/Action/Constraint 结构化格式）：

AV-001：CPUID leaf 1 ECX bit 31 → hypervisor 存在；继续 CPUID vendor leaf (0x40000000)；约束：hypervisor_present ≠ 一定是恶意分析环境
AV-002：注册表 BIOS/System 信息（Manufacturer/ProductName/BIOS Version）→ 关联 VMware/VirtualBox/Hyper-V 特征字符串；约束：单个字符串命中不能作为 VM 判断依据
AV-003：Sleep 前后时间差（明显短于预期）→ 可能检测沙箱时间加速/虚拟化时间；跟踪 RDTSC/QPC/GetTickCount 来源
AV-004：枚举硬件设备（PCI/Disk model/GPU name）→ VM fingerprinting；建立硬件特征集合而非单点判断
AV-005：多个 VM 检测函数检测结果写入统一变量（is_vm/sandbox_score/env_flag）→ 环境评分机制；追踪汇聚变量避免逐检测点分析
AV-006：检测用户交互（鼠标/键盘/uptime/窗口活动）→ 区分真实用户与自动沙箱；转向行为级分析而非硬件指纹
AV-007：调用 VMware backdoor/Guest Additions/vmtools → 高概率虚拟化检测；确认调用结果如何影响控制流
AV-008：检测结果影响执行路径（VM 环境进入不同分支）→ 反虚拟化不仅用于退出，可能改变样本行为；分析两个分支差异
Step 1: re-anti-analysis/SKILL.md 新增「## 反虚拟化方法论」章节（插在「反调试方法论」之后；8 条保留 Trigger/Observation/Inference/Action/Constraint 结构，用子列表呈现；开头说明同前两章风格）
Step 2: 强相关技能查重加坑（re-sandbox：AV-003/AV-006 相关——既有"沙箱隔离≠环境伪装"与"样本逃逸检测 VM"坑可能覆盖；re-unpack-advanced：AV-007/AV-008 与既有反虚拟化内容；查重后重复的只在网关沉淀）
Step 3: node validate.mjs（OK: 58，零死链）
Step 4: 提交（docs: 反虚拟化方法论沉淀(用户口述 8 条)）

Task 30: 调研③——动态对抗与恶意行为经验（5 查询）

Files:

Modify: re-anti-analysis、re-unpack-advanced、re-sandbox、re-behavior、re-protocol（含 re-netcap/re-proto-rev 视结果）、re-frida 的「常见坑与陷阱」（追加）
Test: node validate.mjs（OK: 58，零死链）

WebSearch 查询（至少 5 个，真实执行）：

anti-debug bypass techniques advanced malware 2024 2025
process injection techniques 2024 syscall callback enumeration APT
sandbox evasion techniques malware detection 2024 2025
malware C2 communication detection DNS over HTTPS encrypted
frida anti-detection bypass malware analysis 2024

沉淀要求（同 Task 15/16 标准）：每条"现象→原因→对策"；与既有条目不重复；宁缺毋滥（每技能 1-3 条）；只追加；来源链接写入对应技能或报告。

Task 31: 调研④——工具与产出经验（5 查询）

Files:

Modify: re-ghidra、re-ida、re-crypto-keys、re-mem-forensics、re-ioc、re-angr、re-z3 的「常见坑与陷阱」（追加）
Test: node validate.mjs（OK: 58，零死链）

WebSearch 查询（至少 5 个，真实执行）：

Ghidra automation scripting tips reverse engineering workflow productivity
IDA Pro tips productivity automation idapython patterns
malware key extraction memory forensics techniques hardcoded
Volatility 3 advanced plugins memory forensics tricks
YARA rule writing advanced techniques false positives

沉淀要求（同 Task 15/16 标准）：每条"现象→原因→对策"；与既有条目不重复；宁缺毋滥；只追加；来源链接写入对应技能或报告。

Phase 8：二期覆盖扩充（58 → 64 技能）

用户确认：二期全做 + Fuzzing 独立网关。新增 1 网关 + 5 原子 = 6 技能，总数 64（1 入口 + 11 网关 + 52 原子）。

Task 32: re-vuln 网关 + 2 原子技能（漏洞挖掘域）

Files:

Create: .claude/skills/re-vuln/SKILL.md、.claude/skills/re-fuzzing/SKILL.md、.claude/skills/re-crash-triage/SKILL.md
Test: node validate.mjs（Expected: OK: 61，死链仅指向未创建网关——本批无其他新网关，创建后即清零）

网关内容要求：工作流 = ① 目标与输入面识别（文件解析/网络服务/库函数）② re-fuzzing 覆盖率引导 ③ re-crash-triage 崩溃分析 ④ 逆向定位（re-binary-core 底座：re-triage/re-ghidra）⑤ 报告。选择树：本地文件解析→AFL++；库函数→libFuzzer；网络服务→网络 fuzz；已有崩溃→triage。跨域联合：底座 re-binary-core；CTF pwn→re-ctf；崩溃 core→re-memdump。

re-fuzzing 内容要求：工具准备 AFL++（apt/源码编译）/clang（-fsanitize=fuzzer,address）/libFuzzer/honggfuzz 跨 OS；步骤 ① 目标与插桩选择 ② 语料初始化 ③ afl-fuzz 运行参数 ④ 覆盖率（afl-cov）⑤ 字典/结构化输入；坑：无插桩无覆盖率、语料大小、崩溃去重（cmin/tmin）、sanitizer 配置、网络目标需 harness。

re-crash-triage 内容要求：工具准备 ASAN/UBSAN（clang/gcc -fsanitize）、gdb（core）、afl-tmin/cmin、rr；步骤 ① 确定性复现 ② ASAN 报告解读（堆溢出/越界/UAF）③ 输入最小化 ④ gdb 回溯定位 ⑤ PoC/报告；坑：非确定性崩溃（多线程→rr）、ASAN 与优化差异、崩溃≠漏洞（可达性）、符号缺失用逆向补。

Task 33: re-wasm 原子技能（re-managed 域 +1）

Files:

Create: .claude/skills/re-wasm/SKILL.md
Modify: .claude/skills/re-managed/SKILL.md（子技能清单/选择树加 re-wasm）
Test: node validate.mjs（OK: 62）

re-wasm 内容要求：description（WASM 逆向：格式解析、wasm2wat、浏览器侧。触发词：WASM、wasm、WebAssembly、wat）；工具准备 WABT（wasm2wat/wasm-decompile/wasm-objdump）、wasmtime/wasm3、Chrome DevTools、binaryen 跨 OS；步骤 ① 识别（magic \0asm）② wasm-objdump/wasm2wat 解析 section ③ wasm-decompile 反编译 ④ 浏览器侧（DevTools Sources/JS 调用面）⑤ 动态（wasmtime + 插桩）；坑：字符串在 data 段、imports 是 JS 边界、wasm 混淆（wasm-obfuscator 等）先反混淆、BigInt 调用约定、WASI 系统调用边界。

Task 34: re-ics + re-automotive 原子技能（协议/固件域各 +1）

Files:

Create: .claude/skills/re-ics/SKILL.md、.claude/skills/re-automotive/SKILL.md
Modify: .claude/skills/re-protocol/SKILL.md（子技能清单加 re-ics）、.claude/skills/re-firmware/SKILL.md（子技能清单加 re-automotive）
Test: node validate.mjs（OK: 64）

re-ics 内容要求：description（工控协议逆向：Modbus/DNP3/OPC UA。触发词：工控、ICS、Modbus、DNP3、OPC UA、SCADA、PLC）；工具准备 Wireshark（ics 解析器）/scapy（modbus/dnp3 层）/tshark 跨 OS；步骤 ① 协议识别（端口 502/20000 等）② Wireshark 解析 ③ 功能码与对象点表 ④ scapy 解析器 ⑤ 授权范围安全测试边界；坑：功能码语义（01 读线圈/03 读寄存器）、大端字节序、协议变体、加密变体（Modbus 明文→加密）、点表映射。

re-automotive 内容要求：description（汽车逆向：CAN 总线、ECU 固件。触发词：汽车、CAN、ECU、车载、OBD、UDS）；工具准备 can-utils（candump/cansend）/socketcan/Wireshark（CAN）/OBD-II 工具跨 OS；步骤 ① CAN 接入（USB-CAN/socketcan）② candump 抓包 ③ 报文 ID/周期/信号解析 ④ UDS/OBD 诊断 ⑤ ECU 固件（走 re-fw-extract）；坑：CAN 无地址（ID 过滤）、信号位打包、总线负载时序、seed-key 安全访问、固件校验。

Task 35: 全库同步与全量验证（58 → 64）

Files:

Modify: README.md、AGENTS.md、package.json、.claude-plugin/marketplace.json、.claude/skills/re-analyze/references/triage.md、.claude/skills/re-analyze/SKILL.md（计数与导航 58→64；triage 加 re-vuln 路径行 + 联合场景）
Test: npm test（含 validate 门禁，OK: 64 + 16/16）、install dry-run、convert
Step 1: 同步 6 文件（README/AGENTS：+re-vuln 网关行 +5 原子；package/marketplace description 64；triage +漏洞挖掘行；re-analyze 分派列表 +re-vuln）
Step 2: 全量验证（npm test OK:64 + 16/16；install all dry-run 64；convert 64）
Step 3: 提交（chore: 二期覆盖至 64 技能，全库同步）

Phase 9：三期覆盖扩充（64 → 76 技能）

用户确认：12 个缺口技能全做（全部挂现有网关，无新网关）。新增 12 原子，总数 76（1 入口 + 11 网关 + 64 原子）。每批内容要求格式：description（触发词）+ 工具准备 + 步骤 + 坑清单。发行版安装命令必须以官方包数据库为准（Task 32-34 教训）。

Task 36: 语言专项 re-go + re-rust（re-binary-core 域 +2）

Files: Create re-go、re-rust；Modify re-binary-core/SKILL.md（子技能清单+选择树最小增量）；Test validate（OK: 66）

re-go 内容要求：description（Go 二进制逆向：符号保留、字符串表、goroutine。触发词：Go、golang、Go二进制、goroutine、go build）；工具准备 Go 工具链（go version/go tool）、ghidra 的 Go 插件（如 go_parser）、redress、bloaty 可选；步骤 ① 识别 Go（buildinfo/.gosymtab/main.main 符号）② go version 指纹（go tool buildid）③ 符号表利用（Go 默认保留符号）④ 字符串表（main.* 函数名/路径）⑤ goroutine/调度器理解（runtime 函数、go 关键字展开）；坑：符号被 strip 的 Go（恢复难）、Go 二进制巨大（runtime 占大头——先过滤 runtime 函数）、goroutine 入口识别、逃逸分析影响栈布局。

re-rust 内容要求：description（Rust 二进制逆向：符号、monomorphization、所有权模式。触发词：Rust、rust、Rust二进制、cargo）；工具准备 rust 工具链（可选）、ghidra/IDA（通用）、rustc --emit 理解、符号表（cargo release 默认保留）；步骤 ① 识别 Rust（_ZN/_RNv 符号前缀、panic 处理函数）② 符号解译（demangle：rustfilt/c++filt）③ monomorphization 识别（泛型展开重复代码）④ 所有权/借用模式（move/drop 调用、drop_in_place）⑤ 常见库模式（tokio/async、serde 序列化）；坑：符号被 strip、monomorphization 大量重复（合并同类）、panic 路径与正常路径交织、async/await 状态机展开。

Task 37: re-uefi + re-ransomware + re-loader（固件/恶意软件域各 +）

Files: Create re-uefi、re-ransomware、re-loader；Modify re-firmware、re-malware 网关清单；Test validate（OK: 69）

re-uefi 内容要求：description（UEFI/BIOS 固件：DXE 驱动、UEFI 模块、bootkit。触发词：UEFI、BIOS、DXE、bootkit、Secure Boot、EFI 固件）；工具准备 UEFITool（固件解析）、UEFIExtract、ida/ghidra（EfiRom 插件可选）、ovmf（仿真）、qemu；步骤 ① 固件镜像解析（UEFITool：Firmware Volume→File→Section）② DXE 驱动提取 ③ 模块分析（入口/Protocol 服务）④ bootkit 定位（SMM/定时器回调/启动路径挂钩）⑤ OVMF 仿真验证；坑：固件镜像多 FV 嵌套、压缩/填充区（UEFITool 已解）、PE 头在 FFS 内偏移、Secure Boot 签名验证绕过分析需合法授权。

re-ransomware 内容要求：description（勒索软件分析：加密识别、勒索信、解密恢复思路。触发词：勒索、ransomware、加密文件、勒索信、解密恢复）；工具准备复用 crypto 域（re-crypto-id/keys/decrypt）、沙箱（re-sandbox）、文件系统快照工具；步骤 ① 初始判断（文件扩展名变化/加密头特征）② 加密算法识别（走 crypto 域）③ 密钥管理还原（本地/网络/C2 分发）④ 勒索信与 C2 交互（走 re-protocol）⑤ 恢复思路（密钥提取→解密脚本；没有密钥→研究社区解密工具）；坑：样本在沙箱内加密所有文件（快照隔离）、双重勒索（数据泄露+加密）、RaaS 变体差异、解密工具时效性。

re-loader 内容要求：description（加载器/投放器分析：多层下载、内存加载、模块拼接。触发词：加载器、loader、dropper、投放器、内存加载、模块拼接）；工具准备动态分析（re-sandbox+re-tracing）、内存转储（re-memdump）、进程注入检测（re-behavior）；步骤 ① 初始样本识别（下载器 vs 完整载荷）② 下载/解压链跟踪 ③ 内存加载分析（反射式加载/进程空洞）④ 模块拼接（多文件合成）⑤ 提取最终载荷分析；坑：多层网络下载（断网导致拿不到后续）、内存载荷转储时机、反沙箱延迟下载、加密载荷需先解密。

Task 38: re-mobile-pack + re-hybrid-app + re-iot-proto（移动/协议域 +）

Files: Create re-mobile-pack、re-hybrid-app、re-iot-proto；Modify re-mobile、re-protocol 网关清单；Test validate（OK: 72）

re-mobile-pack 内容要求：description（Android 加固脱壳专项：乐固/360/梆梆/爱加密、DEX 恢复。触发词：脱壳、Android加固、DEX脱壳、乐固、梆梆、360加固、爱加密）；工具准备 frida（re-frida）、frida-dexdump、BlackDex/Youpk（开源脱壳机）、jadx（re-apk）、内存转储（re-memdump 思路）；步骤 ① 加固识别（类名特征 StubApp/壳 so）② 运行脱壳（frida-dexdump：运行后 dump DEX）③ 静态脱壳（BlackDex 等）④ DEX 修复（方法指令修复/校验）⑤ 脱壳后分析（走 re-apk）；坑：VMP 级加固（抽取+指令虚拟化）脱壳难度大、反 frida 检测、DEX 修复不完整（方法体空壳）、多 DEX 合并。

re-hybrid-app 内容要求：description（Flutter/React Native 混合应用逆向。触发词：Flutter、React Native、混合应用、dart、libapp.so）；工具准备 Flutter：blutter/reFlutter、dart 工具链；RN：react-native 逆向（bundle 提取）、jadx 通用；步骤 ① 引擎识别（libapp.so/libflutter.so vs RN bundle assets）② Flutter：libapp.so 快照分析（blutter 还原 dart 结构）③ RN：bundle.js 提取与还原（Hermes 字节码需 hermes-dec）④ 原生部分走 re-binary-core ⑤ 逻辑定位（dart 函数名保留情况）；坑：Flutter AOT 快照无源码级符号、RN Hermes 字节码难还原、引擎版本差异、JS 与原生桥接边界。

re-iot-proto 内容要求：description（物联网协议：MQTT/CoAP/BLE/Zigbee。触发词：MQTT、CoAP、BLE、Zigbee、物联网协议、IoT协议）；工具准备 Wireshark（MQTT/CoAP 解析）、scapy（可选）、BLE：Wireshark+ubertooth/hci 抓包、Zigbee：Wireshark+zboss；步骤 ① 协议识别（端口 1883/8883 MQTT、5683 CoAP、BLE adv/GATT）② MQTT/CoAP 解析（topic/payload、DTLS 加密）③ BLE 抓包（hci/ubertooth：adv、GATT 服务/特征）④ Zigbee（802.15.4：zboss 解密需网络密钥）⑤ 设备固件联动（走 re-firmware）；坑：MQTT 明文 topic 泄露控制语义、DTLS/PSK 加密需密钥、BLE 白名单/配对绑定、Zigbee 网络密钥获取困难。

Task 39: re-disk-forensics + re-evasion + re-whitebox + re-plugin-dev（四域各 +1）

Files: Create re-disk-forensics、re-evasion、re-whitebox、re-plugin-dev；Modify re-forensics、re-anti-analysis、re-protocol、re-binary-core 网关清单；Test validate（OK: 76）

re-disk-forensics 内容要求：description（磁盘/文件系统取证：删除恢复、时间线、可疑文件定位。触发词：磁盘取证、文件系统、删除恢复、时间线、ext4、NTFS）；工具准备只读挂载（loop/mount -o ro）、photorec/testdisk、sleuthkit（fls/icat/tsk_recover）、autopsy 可选；步骤 ① 只读镜像获取（dd/evtx）② 分区与文件系统识别（ext4/NTFS/APFS）③ 删除文件恢复（testdisk/photorec）④ 时间线重建（fls -m/timeline）⑤ 可疑文件提取（未分配空间/隐藏分区）；坑：必须只读（写操作污染证据）、加密卷（BitLocker/FileVault 需密钥）、文件系统日志干扰、时间戳伪造（timestomp）。

re-evasion 内容要求：description（检测规避/EDR 对抗分析：AMSI/ETW 绕过、无文件、lolbin 链。触发词：规避、evasion、AMSI、ETW、无文件、lolbin、EDR绕过）；工具准备动态（re-sandbox）、内存分析（re-memdump）、AMSI 测试工具（amsi.dll 监控）、ETW 监控（ETWConsumer 等）；步骤 ① 规避手段识别（AMSI patch/ETW 禁用/无文件执行）② AMSI 绕过分析（内存 patch 定位）③ ETW 禁用分析 ④ lolbin 链追踪（rundll32/mshta 等）⑤ 与检测侧对齐（为什么被检测→规避点）；坑：规避手段与反沙箱交织、AMSI patch 触发完整性校验、无文件样本取证难、EDR 版本差异。

re-whitebox 内容要求：description（白盒加密分析：白盒实现识别、密钥提取。触发词：白盒、whitebox、白盒加密、密钥隐藏）；工具准备反编译（re-ghidra 等）、查找表分析工具（脚本）、符号执行（re-angr 可选）；步骤 ① 白盒实现识别（查找表特征、无标准库调用的大段查表代码）② 表提取 ③ 密钥恢复（表逆向→密钥推导，或已知明文攻击）④ 与标准实现对照（同一算法不同实现）⑤ 报告（密钥/算法/影响）；坑：白盒表巨大（内存/时间）、混淆+白盒组合、表加密（二次保护）、算法变体。

re-plugin-dev 内容要求：description（Ghidra/IDA 插件开发：脚本→插件工程化。触发词：插件开发、Ghidra插件、IDA插件、插件工程）；工具准备 Ghidra（Java/Python 插件）、IDA（idapython）、构建工具（gradle 可选）；步骤 ① 场景识别（批处理脚本 vs 交互插件）② Ghidra 插件骨架（Java 扩展/程序脚本）③ IDA 插件骨架（idapython）④ 与现有脚本复用（re-ghidra/re-ida 的脚本）⑤ 测试与分发；坑：API 版本差异（Ghidra/IDA 升级破坏）、Java 环境要求、插件签名（IDA 商业版）、维护成本。

Task 40: 全库同步与全量验证（64 → 76）

Files: Modify README.md、AGENTS.md、package.json、.claude-plugin/marketplace.json、re-analyze/references/triage.md、re-analyze/SKILL.md（64→76：README/AGENTS 各网关行补新原子、计数 76；package/marketplace description 76；triage 可加语言专项/勒索/脱壳路径；re-analyze 分派列表不变——无新网关）；Test npm test（OK: 76 + 16/16）、install dry-run、convert

Step 1: 同步 6 文件（计数与导航 64→76）
Step 2: 全量验证（npm test OK:76 + 16/16；install all dry-run 76；convert 76）
Step 3: 提交（chore: 三期覆盖至 76 技能，全库同步）

Phase 10：四期覆盖扩充（76 → 88 技能）

用户确认：12 个缺口技能全做（全部挂现有网关）。新增 12 原子，总数 88（1 入口 + 11 网关 + 76 原子）。

Task 41: re-shellcode + re-fileless + re-tls（三域各 +1）

Files: Create re-shellcode、re-fileless、re-tls；Modify re-binary-core、re-malware、re-protocol 网关清单；Test validate（OK: 79）

re-shellcode 内容要求：description（Shellcode 分析：提取、解码循环、模拟执行。触发词：shellcode、shell code、位置无关、解码循环、恶意载荷）；工具准备提取工具（binwalk/xxd）、反汇编（re-radare2/re-ghidra）、模拟执行（re-emulation：Unicorn）、scdbg/xxd 可选；步骤 ① 提取（文件/内存/流量中的 shellcode blob）② 定位入口（常见 0xEB 短跳/反汇编扫描）③ 解码循环分析（XOR/ROL 自解码）④ 模拟执行（Unicorn 无环境运行、hook 系统调用）⑤ 与宿主交互面（API 解析：kernel32 遍历、hash 查找）；坑：位置无关地址（无基址概念）、编码器变体（msfvenom 多种编码）、宿主依赖（需先还原调用约定）、模拟执行缺 API（stub）。

re-fileless 内容要求：description（无文件恶意软件：内存执行、持久化、PowerShell 链。触发词：无文件、fileless、内存执行、PowerShell 无文件、注册表持久化）；工具准备动态（re-sandbox+re-tracing）、内存（re-memdump）、PowerShell 分析（re-script-deob 联动）；步骤 ① 识别无文件迹象（无落盘/注册表载荷）② 内存执行链还原（WMI/计划任务/PowerShell 下载执行）③ 注册表/计划任务持久化定位 ④ 内存载荷提取（re-memdump 时机）⑤ 与行为分析交叉（re-behavior）；坑：无落盘导致取证难、内存载荷转储时机（执行完即释放）、PowerShell 混淆链多层、杀软内存扫描对抗。

re-tls 内容要求：description（TLS/加密流量深度：指纹、密钥导出、TLS 1.3。触发词：TLS、SSL、ClientHello、指纹、SSLKEYLOG、证书分析）；工具准备 tshark/wireshark（re-netcap）、openssl、SSLKEYLOG 环境（Chrome/Firefox 导出）；步骤 ① ClientHello 指纹（JA3/JA4）② 证书链分析（openssl x509 解析）③ SSLKEYLOG 解密（TLS 1.2/1.3 密钥导出）④ 加密流量语义还原（应用层协议恢复）⑤ 恶意 TLS 特征（指纹聚类/异常证书）；坑：TLS 1.3 密钥导出与 1.2 不同（client/server traffic secret）、前向保密（无 keylog 解不了）、指纹可伪造、证书固定绕过需中间人配合。

Task 42: re-ai-model + re-blockchain（managed 域 +2）

Files: Create re-ai-model、re-blockchain；Modify re-managed 网关清单；Test validate（OK: 81）

re-ai-model 内容要求：description（AI 模型逆向：格式解析、权重提取、模型水印。触发词：AI模型、模型逆向、ONNX、PyTorch、权重提取、模型窃取）；工具准备 onnx（pip）、netron（模型可视化）、pytorch（torch.load）、python3、protobuf（onnx 是 proto）；步骤 ① 模型格式识别（onnx/safetensors/pytorch pkl）② 结构解析（图/层/算子）③ 权重提取（张量 dump）④ 模型水印/指纹检测（嵌入权重）⑤ 模型窃取判定（架构相似度）；坑：大模型文件巨大（GB 级）、pkl 反序列化风险（不要直接 load 未知文件）、图优化混淆层结构、水印鲁棒性（剪枝后仍存）。

re-blockchain 内容要求：description（EVM 智能合约逆向：字节码反编译、漏洞分析。触发词：智能合约、EVM、Solidity、字节码、合约漏洞、ABI）；工具准备 python3（eth 工具）、cast（foundry）/web3.py、hevm/echidna 可选（形式化）；步骤 ① 合约字节码获取（链上/文件）② ABI 恢复（函数选择器/签名）③ 反编译（panoramix 思路：disasm→流程）④ 逻辑还原（存储布局/状态变量）⑤ 漏洞分析（重入/整数溢出/权限）；坑：选择器碰撞、存储布局 vs 源码映射难、代理合约（delegatecall 逻辑在别处）、反编译工具输出粗糙需手工。

Task 43: re-pwn + re-exploit（ctf/vuln 域各 +1）

Files: Create re-pwn、re-exploit；Modify re-ctf、re-vuln 网关清单；Test validate（OK: 83）

re-pwn 内容要求：description（CTF pwn 入门：栈溢出、格式化字符串、ret2libc。触发词：pwn、栈溢出、格式化字符串、ret2libc、ROP、shellcode 注入）；工具准备 pwntools（pip）、checksec、gdb（re-gdb）、one_gadget 可选；步骤 ① 漏洞识别（checksec 保护/反汇编找危险函数 gets/strcpy）② 栈溢出利用（偏移计算、覆盖返回地址）③ ret2libc（PLT/GOT、libc 版本识别）④ 格式化字符串（泄露/写）⑤ 本地验证（pwntools 脚本）；坑：保护全开（NX/PIE/Canary）需组合利用、libc 版本不匹配（偏移全错）、本地通远程挂（环境差异）、64 位参数传递（rdi）。

re-exploit 内容要求：description（利用开发：ROP 链构造、堆利用。触发词：ROP、堆利用、fastbin、tcache、利用开发、exploit）；工具准备 pwntools、ropper/ROPgadget、gdb+gef/pwndbg、angr 可选（re-angr）；步骤 ① 利用面分析（崩溃点/可控数据）② ROP 链（gadget 搜索、栈布局）③ 堆利用（fastbin/tcache 攻击模式）④ 沙箱/缓解绕过（seccomp）⑤ PoC 验证；坑：gadget 地址受 ASLR/PIE 影响（泄漏为先）、tcache 双链表检查、glibc 版本差异（check 变化）、绕过组合复杂（先规划再写）。

Task 44: re-android-native + re-ios-jb + re-hypervisor + re-anti-cheat + re-drm（五域各 +1）

Files: Create re-android-native、re-ios-jb、re-hypervisor、re-anti-cheat、re-drm；Modify re-mobile（+2）、re-binary-core（+2）、re-cracking（+1）网关清单；Test validate（OK: 88）

re-android-native 内容要求：description（Android 原生库 JNI 逆向。触发词：JNI、.so、Android native、xhook、IDA so）；工具准备 IDA/Ghidra（so 加载）、jni.h 理解、frida（re-frida 联动）、readelf（re-format-elf）；步骤 ① so 提取与架构识别（arm64-v8a 等）② JNI 接口还原（JNIEnv 函数表）③ 注册方式（静态 JNI_OnLoad/动态 RegisterNatives）④ 逻辑分析（re-ghidra 联动）⑤ 与 Java 层交互（native 调用点定位）；坑：JNIEnv 是函数表指针（不是直接调用）、动态注册函数地址不在导出表、混淆 native（OLLVM）、多 ABI 架构差异。

re-ios-jb 内容要求：description（iOS 越狱逆向环境：越狱检测、tweak 开发。触发词：越狱、jailbreak、tweak、Theos、LLDB 远程）；工具准备越狱设备（palera1n 等）、Theos（tweak 构建）、frida（re-frida）、lldb 远程（re-lldb）；步骤 ① 越狱环境搭建（设备/工具链）② 越狱检测识别与绕过（jb 路径/沙箱检查）③ tweak 分析（MobileSubstrate/Substrate hook）④ 动态调试（lldb 远程 attach）⑤ 脱壳与分析（re-ios 联动）；坑：系统完整性（越狱后仍受限）、设备版本匹配（工具链版本）、检测对抗（jb 检测库）、调试器检测。

re-hypervisor 内容要求：description（虚拟化逆向：VT-x/SVM、hypervisor 检测。触发词：hypervisor、VT-x、SVM、虚拟化检测、EPT）；工具准备反编译（re-ghidra/re-ida）、VT-x 理解（VMCS/VMXON）、qemu/kvm（实验）；步骤 ① hypervisor 识别（CPUID 叶子/VMX 标志）② VMCS 结构分析 ③ 虚拟化技术检测对抗（EPT 隐藏内存）④ 嵌套虚拟化（VMM 内调试）⑤ 反虚拟化绕过（re-evasion 联动）；坑：硬件虚拟化调试环境复杂、VMCS 内核对象逆向门槛高、EPT 使内存断点失效、CPU 特性差异。

re-anti-cheat 内容要求：description（反作弊对抗分析：EAC/BE 驱动、内存校验。触发词：反作弊、EAC、BattlEye、内存校验、anti-cheat）；工具准备驱动分析（re-kernel）、调试器（re-windbg/re-x64dbg）、进程保护绕过（PPL）；步骤 ① 反作弊组件识别（驱动/服务）② 驱动校验分析（内存扫描/完整性）③ 检测规避思路（授权范围内研究）④ 内核对抗（re-kernel 联动）⑤ 分析报告（合规边界）；坑：驱动级检测不可 attach（需内核调试）、法律边界（仅研究授权环境）、反作弊更新频繁、绕过技术对抗升级。

re-drm 内容要求：description（DRM 分析：PlayReady/Widevine 实现、许可证流程。触发词：DRM、PlayReady、Widevine、许可证、内容保护）；工具准备浏览器/播放器分析（re-ghidra）、网络（re-netcap）、Widevine L3 设备分析工具；步骤 ① DRM 组件识别（CDM/解密器）② 许可证流程还原（挑战/响应）③ 解密器实现分析（密钥管理）④ 漏洞/弱点定位（授权研究）⑤ 报告（合规）；坑：L1/L3 等级差异（硬件 vs 软件）、密钥分层（设备/内容）、法律与 ToS 边界（仅研究）、DRM 更新频繁。

Task 45: 全库同步与全量验证（76 → 88）

Files: Modify README.md、AGENTS.md、package.json、.claude-plugin/marketplace.json、re-analyze/references/triage.md、re-analyze/SKILL.md（计数 76→88；README/AGENTS 各网关行补新原子；triage 可加 shellcode/合约/模型路径）；Test npm test（OK: 88 + 16/16）、install dry-run、convert

Step 1: 同步 6 文件（计数与导航 76→88）
Step 2: 全量验证（npm test OK:88 + 16/16；install all dry-run 88；convert 88）
Step 3: 提交（chore: 四期覆盖至 88 技能，全库同步）

140 KiB Raw Blame History Unescape Escape

逆向工程技能库（re-skills）实现计划

Global Constraints

Phase 1：基础设施

Task 1: 仓库脚手架

Task 2: validate.mjs 结构校验器 + 测试（TDD）

操作步骤

常见坑与陷阱

跨域联合

Task 3: probe.sh 环境探测脚本

Phase 2：入口 re-analyze

Task 4: platform-tips.md 平台经验知识库

Task 5: preferences.md + triage.md

Task 6: re-analyze 入口 SKILL.md

Phase 3：技能内容（模板 + 8 网关 + 37 原子）

Task 7: 技能模板规范 + re-binary-core 网关 + 13 原子技能

Task 8: re-malware 网关 + 3 原子技能

Task 9: re-firmware 网关 + 4 原子技能

Task 10: re-protocol 网关 + 5 原子技能

Task 11: re-mobile 网关 + 3 原子技能

Task 12: re-anti-analysis 网关 + 4 原子技能

Task 13: re-cracking 网关 + 3 原子技能

Task 14: re-ctf 网关 + 2 原子技能

Phase 4：经验调研补全

Task 15: 调研① —— 平台/格式/恶意行为经验

Task 16: 调研② —— 脱壳/对抗/协议/加密经验

Phase 5：发布基础设施

Task 17: install.mjs 安装器 + 测试（TDD）

Task 18: convert.mjs 完整实现 + 测试（TDD）

Task 19: marketplace.json + AGENTS.md + README.md

方式二：Claude Code 插件市场

方式三：手动拷贝

多工具适配

技能导航（46）

设计原则

开发

Task 20: 全量验证与发布演练

Phase 6：覆盖扩充（46 → 58 技能）

Task 21: re-managed 网关 + 3 原子技能（托管代码域）

Task 22: re-forensics 网关 + 2 原子技能（取证/情报域）

Task 23: re-binary-core 域扩充 5 原子技能

Task 24: 全库同步与全量验证（46 → 58）

Self-Review 记录

Phase 7：深度扩充——经验沉淀（用户口述模式）

Task 25: 平台经验沉淀（A 组 12 条）

Task 26: 脱壳经验沉淀（B 组 11 条）

Task 27: 逆向基础分析方法论沉淀（R 组 22 条，用户口述）

Task 28: 反调试方法论沉淀（AD 组 45 条，用户口述）

Task 29: 反虚拟化方法论沉淀（AV 组 8 条，用户口述）

Task 30: 调研③——动态对抗与恶意行为经验（5 查询）

Task 31: 调研④——工具与产出经验（5 查询）

Phase 8：二期覆盖扩充（58 → 64 技能）

Task 32: re-vuln 网关 + 2 原子技能（漏洞挖掘域）

Task 33: re-wasm 原子技能（re-managed 域 +1）

Task 34: re-ics + re-automotive 原子技能（协议/固件域各 +1）

Task 35: 全库同步与全量验证（58 → 64）

Phase 9：三期覆盖扩充（64 → 76 技能）

Task 36: 语言专项 re-go + re-rust（re-binary-core 域 +2）

Task 37: re-uefi + re-ransomware + re-loader（固件/恶意软件域各 +）

Task 38: re-mobile-pack + re-hybrid-app + re-iot-proto（移动/协议域 +）

Task 39: re-disk-forensics + re-evasion + re-whitebox + re-plugin-dev（四域各 +1）

Task 40: 全库同步与全量验证（64 → 76）

Phase 10：四期覆盖扩充（76 → 88 技能）

Task 41: re-shellcode + re-fileless + re-tls（三域各 +1）

Task 42: re-ai-model + re-blockchain（managed 域 +2）

Task 43: re-pwn + re-exploit（ctf/vuln 域各 +1）

Task 44: re-android-native + re-ios-jb + re-hypervisor + re-anti-cheat + re-drm（五域各 +1）

Task 45: 全库同步与全量验证（76 → 88）

140 KiB

Raw Blame History