编程 reverse-skill 深度拆解：当 AI Agent 拥有了「安全直觉」——从路由引擎到自动化渗透的工程全链路

2026-08-10 01:22:21 +0800 CST views 9

reverse-skill 深度拆解：当 AI Agent 拥有了「安全直觉」——从路由引擎到自动化渗透的工程全链路

写在前面

2026年8月4日，一个名为 reverse-skill 的开源项目在 GitHub Trending 上创下了当天的最高日增长记录：一天狂揽 2258 颗 Star，总量突破 17.7k，力压同日的 MiniMax H3、AirLLM、TencentDB-Agent-Memory 等明星项目，登上全榜第一。

这个数字对于安全圈的人来说可能格外刺眼——因为它不是又一个 AI 对话机器人，不是一个新的前端框架，而是一个专门给 AI Agent 用的逆向/渗透/安全技能路由包。

更准确地说：它解决了一个在 2026 年已经开始变得尖锐的问题——当 Claude Code、Cursor、Kiro 这类 AI 编程工具遇到二进制、APK、前端混淆代码、CTF 题目甚至渗透测试任务时，它们根本不知道该用什么工具、该走什么流程。

盲目猜命令。猜错了浪费 token，猜对了靠运气。reverse-skill 就是来解决这个问题的。

本文从工程视角出发，完整拆解这个项目的设计哲学、架构全貌、路由引擎的实现细节，以及它如何与主流 AI Agent 无缝集成。全文超过 8000 字，代码示例超过 20 处，适合想深入理解 AI Agent + 安全工具链融合的开发者阅读。

一、背景：当 AI Coding 撞上安全领域

1.1 AI Coding 的能力边界

2026 年，Claude Code、Cursor、Kiro 这类 AI 编程工具已经在常规软件开发领域展现了惊人的能力：写 CRUD 代码、调试 bug、设计架构——这些事情它们已经做得很好了。

但安全领域是一个完全不同的世界。

当你让 Claude Code 分析一个加壳的 APK 时，它可能会：

先用 strings 命令扫一遍，然后说"这个 APK 看起来是 Flutter 写的"（错了）
尝试用 Python 的 uncompyle6 反编译 Python 代码（APK 里没有 Python）
写了半小时 Frida 脚本，hook 的函数地址根本不对
最后放弃，说"这个任务超出了我的能力范围"

这不是 Claude Code 不够聪明——它只是没有安全领域的知识图谱。它不知道 APK 反编译用 jadx 而非 uncompyle6，不知道 Frida hook 需要先确定基址，不知道二进制逆向的第一步永远是确认架构和编译器。

1.2 安全工具链的碎片化地狱

即使 AI Agent 知道要用什么工具，安全工具链本身也是碎片化的：

IDA Pro 在 ~/tools/ida82/idal64
radare2 在 ~/.local/share/r2/radare2
Ghidra 在 /opt/Ghidra/ghidraRun
Frida 安装在 ~/.npm-global/lib/node_modules/frida
Python 的 frida-tools 又在另一个地方
MCP 服务各有各的配置文件

三台机器三个路径，迁移一次项目要重新踩一遍坑。

1.3 经验的不可复用性

安全分析员最大的资产是什么？是经验。但这些经验往往存在于：

某个分析师的本地笔记里（没有共享）
某次 CTF 比赛的 writeup 里（但只描述结果，没有方法论）
团队内部的 Wiki 里（但维护成本高，容易过时）

每一次遇到同类问题，都要重新踩一遍坑。

reverse-skill 就是在这个问题背景下诞生的。它的核心目标一句话：让 AI Agent 面对安全任务时，能像有经验的安全工程师一样思考——先路由到正确的方法论，再调用正确的工具。

二、核心设计：技能路由的三层架构

2.1 设计哲学：方法论优先于工具

reverse-skill 的核心设计哲学与其他 AI 工具链项目截然不同。大多数 AI 辅助工具的做法是"给 AI 提供更多工具"，而 reverse-skill 的做法是**"先教 AI 选工具的方法论"**。

一个经验丰富的人类安全工程师在面对任务时，脑子里其实有一张决策树：

看到 APK 文件
  → 判断是否加壳
    → 有壳 → 脱壳流程
      → 判断壳类型（某加固厂商）
        → 对应 Frida 脱壳脚本
    → 无壳 → 直接反编译
      → jadx 首选
      → 备选 APKTool + jadx-gui

这张决策树就是 reverse-skill 要编码的东西——不是工具的堆砌，而是方法论的结构化表达。

2.2 三层架构总览

reverse-skill 的架构分为三层，从顶层到底层：

┌─────────────────────────────────────────────────────┐
│ 第一层：AI 任务路由层 (MASTER-ROUTING)               │
│  负责分析用户任务类型，匹配到最合适的方法论 Skill    │
├─────────────────────────────────────────────────────┤
│ 第二层：方法论 Skill 层 (SKILLS/)                    │
│  每个 Skill 是一个完整的方法论包：工具集+脚本+流程   │
├─────────────────────────────────────────────────────┤
│ 第三层：工具链与知识库层 (TOOLS/ + KNOWLEDGE/)       │
│  具体工具的调用封装、MCP 服务、知识沉淀              │
└─────────────────────────────────────────────────────┘

2.3 执行流程：用户任务到完整报告

一个完整任务的执行流程如下：

用户任务
    ↓
RULES.md（全局规则层：授权边界、安全红线）
    ↓
MASTER-ROUTING / master-route.ps1（路由决策引擎）
    ↓
case-init / scope.md（任务初始化：确认授权范围 + 网络拓扑）
    ↓
目标 Skill（APK 逆向 Skill / 二进制分析 Skill / JS 逆向 Skill ...）
    ↓
工具 / MCP / 脚本（jadx, Frida, IDA, radare2, Wireshark ...）
    ↓
timeline + Evidence → Finding → Path（结构化发现）
    ↓
报告 + field-journal（可复盘的完整记录）

注意这个流程中有一个强制性的 scope.md 步骤：

未就绪禁止对目标 ACT

这是整个系统最重要的安全护栏。在执行任何实际分析之前，必须先确认：

授权边界：目标是否在授权范围内？（授权渗透测试 vs 非法入侵）
网络拓扑 profile：目标的网络环境如何？（内网 / 外网 / 云环境）

没有这两个信息，系统不会执行任何对目标有实际影响的操作。

三、AI 智能路由引擎详解

3.1 为什么 AI 需要路由？

传统 CLI 工具是给人用的——人调用工具，人负责决策。但 AI Agent 调用工具时，面临的是两层不确定性：

任务类型不确定：AI 看到的用户输入是自然语言，它需要推断这是什么类型的任务
工具选择不确定：即使推断出任务类型，对应的工具和方法论也有多个选择

reverse-skill 的路由引擎解决的就是这两个问题。

3.2 master-route.ps1 的路由逻辑

master-route.ps1（PowerShell 版本，主路由脚本）是整个系统的决策中枢。它的路由逻辑本质上是基于关键词匹配 + 上下文推理的决策树：

# reverse-skill/MASTER-ROUTING/master-route.ps1 (伪代码实现逻辑)

param(
    [string]$UserInput,
    [string]$FilePath
)

function Get-TaskType {
    param([string]$Input, [string]$Path)

    # Step 1: 文件类型识别（优先级最高）
    if ($Path -match '\.apk$|\.dex$') {
        return "APK_REVERSE"
    }
    if ($Path -match '\.elf$|\.exe$|\.dll$|\.so$') {
        return "BINARY_ANALYSIS"
    }
    if ($Path -match '\.pcap$|\.pcapng$|\.cap$') {
        return "NETWORK_FORENSICS"
    }
    if ($Path -match '\.js$|\.wasm$|\.bundle\.js$') {
        return "JS_REVERSE"
    }
    if ($Path -match '\.bin$|\.rom$|\.img$') {
        return "FIRMWARE_ANALYSIS"
    }

    # Step 2: 自然语言意图识别
    $lowerInput = $Input.ToLower()
    if ($lowerInput -match "ctf|pwn|crypto|web|misc|reverse") {
        return "CTF_SANDBOX"
    }
    if ($lowerInput -match "penetrat|exploit|vuln|scan") {
        return "PEN_TEST"
    }
    if ($lowerInput -match "脱壳|逆向|反编译") {
        return "APK_REVERSE"
    }

    return "UNKNOWN"
}

function Get-RoutingDecision {
    param([string]$TaskType)

    $routingTable = @{
        "APK_REVERSE"      = @{
            Skill      = "apk-decompilation-skill"
            Priority   = 1
            Tools      = @("jadx", "frida", "apktool")
            EnvCheck   = "check-java-android-sdk.ps1"
        }
        "BINARY_ANALYSIS" = @{
            Skill      = "binary-analysis-skill"
            Priority   = 1
            Tools      = @("ghidra", "ida", "radare2", "objdump")
            EnvCheck   = "check-binary-toolchain.ps1"
        }
        "JS_REVERSE"      = @{
            Skill      = "js-reverse-skill"
            Priority   = 1
            Tools      = @("node", "bun", "webpack-decode")
            EnvCheck   = "check-js-toolchain.ps1"
        }
        "NETWORK_FORENSICS" = @{
            Skill      = "network-forensics-skill"
            Priority   = 1
            Tools      = @("wireshark", "tshark", "mitmproxy")
            EnvCheck   = "check-network-tools.ps1"
        }
        "CTF_SANDBOX"     = @{
            Skill      = "ctf-sandbox-skill"
            Priority   = 1
            Tools      = @("docker", "pwntools", "angr")
            EnvCheck   = "check-ctf-docker.ps1"
        }
        "FIRMWARE_ANALYSIS" = @{
            Skill      = "firmware-analysis-skill"
            Priority   = 1
            Tools      = @("binwalk", "firmwalker", "qemu")
            EnvCheck   = "check-firmware-toolchain.ps1"
        }
        "PEN_TEST"        = @{
            Skill      = "penetration-testing-skill"
            Priority   = 1
            Tools      = @("nmap", "nuclei", "ffuf", "metasploit")
            EnvCheck   = "check-pentest-toolchain.ps1"
        }
        "SUPPLY_CHAIN"    = @{
            Skill      = "supply-chain-skill"
            Priority   = 1
            Tools      = @("syft", "grype", "sbom-gen")
            EnvCheck   = "check-supply-chain-tools.ps1"
        }
    }

    return $routingTable[$TaskType]
}

# 实际路由执行
$taskType = Get-TaskType -Input $UserInput -Path $FilePath
$decision = Get-RoutingDecision -TaskType $taskType

Write-Host "🎯 Task Type: $taskType"
Write-Host "📦 Skill: $($decision.Skill)"
Write-Host "🛠️  Tools: $($decision.Tools -join ', ')"

# 输出路由结果，供 AI Agent 消费
@{
    task_type = $taskType
    skill      = $decision.Skill
    tools      = $decision.Tools
    env_check  = $decision.EnvCheck
} | ConvertTo-Json

这个 PowerShell 脚本被设计为AI Agent 可以调用并解析输出的。它既可以被人执行，也可以被 Claude Code 这类 Agent 通过 exec 工具调用。

3.3 AI 客户端适配层

reverse-skill 支持多个 AI 客户端，每个客户端有不同的调用方式：

# Claude Code 调用示例
# 用户: "帮我分析这个 APK，文件在 /tmp/target.apk"
# AI Agent 自动执行:

# 1. 调用路由引擎
$ task_router="/path/to/reverse-skill/MASTER-ROUTING/master-route.ps1"
$ routing_result=$(pwsh "$task_router" -UserInput "分析APK" -FilePath "/tmp/target.apk")
# routing_result = {"task_type":"APK_REVERSE","skill":"apk-decompilation-skill",...}

# 2. 加载对应的 Skill
$ skill_dir="/path/to/reverse-skill/SKILLS/apk-decompilation-skill"
$ cat "$skill_dir/SKILL.md"

# 3. 按 Skill 定义执行

四、核心 Skill 模块深度解析

4.1 APK 逆向 Skill：完整的脱壳与反编译链路

APK 逆向是 reverse-skill 支持的最成熟的场景之一。以 APK 逆向 Skill 为例，其结构如下：

SKILLS/apk-decompilation-skill/
├── SKILL.md              # 方法论定义（供 AI 读取）
├── decompilation/
│   ├── basic-decomp.sh   # 无壳 APK 直接反编译
│   └── assisted-decomp.sh # 辅助反编译（有混淆）
├── unpack/
│   ├── frida-unpack.js   # Frida 通用脱壳脚本
│   ├── detect-shell.py    # 壳类型检测
│   └──壳定制脚本/         # 各大厂商加固定制脱壳
├── analysis/
│   ├── manifest-parser.sh
│   ├── class-graph.py    # 类关系图生成
│   └── string-search.sh
└── hooks/
    └── frida-scripts/    # 常用 Hook 脚本集

4.1.1 壳检测与自动路由

APK 脱壳的第一步永远是判断壳类型。reverse-skill 提供了一个智能壳检测脚本：

# SKILLS/apk-decompilation-skill/unpack/detect-shell.py

import zipfile
import os
import subprocess
import json

def detect_shell(apk_path: str) -> dict:
    """
    检测 APK 加壳情况，返回壳类型和建议的工具链
    """
    result = {
        "is_shelled": False,
        "shell_type": None,
        "confidence": 0.0,
        "suggested_tools": [],
        "detection_details": []
    }

    # 方法1: 检查特征文件
    with zipfile.ZipFile(apk_path, 'r') as zf:
        file_list = zf.namelist()

        # 常见壳特征
        shell_signatures = {
            "DexGuard": ["libDexHelper.so", "libDexHelper-arm64.so", "libDexHelper-x86.so"],
            "Bangcle": ["libsecexe.so", "libsecmain.so", "bangcle"],
            "Ali": ["aliprobe", "libsgsecuritybody.so"],
            "Tencent": ["libtup.so", "libshell.so", "dex-jump"],
            "NAGA": ["libnaga.so", "naga"],
            "Jiagu": ["libjiagu.so", "jiagu"],
            "Ijiagu": ["ijiami", "libegoale.so"],
        }

        for shell_type, signatures in shell_signatures.items():
            matches = sum(1 for sig in signatures if any(sig in f for f in file_list))
            if matches > 0:
                result["is_shelled"] = True
                result["shell_type"] = shell_type
                result["confidence"] = min(matches / len(signatures), 1.0)
                result["detection_details"].append(f"Found {matches} signatures for {shell_type}")

        # 检查入口 Activity 是否在原始 dex 中
        manifest_content = zf.read("AndroidManifest.xml").hex()
        if "7885c4c79a8f" in manifest_content:  # 某加固方案的入口特征
            result["shell_type"] = "Unknown_Custom_Shell"
            result["is_shelled"] = True
            result["confidence"] = 0.6
            result["suggested_tools"] = ["frida-unpack.js"]

    # 方法2: 检查 classes.dex 数量
    dex_files = [f for f in file_list if f.startswith("classes") and f.endswith(".dex")]
    if len(dex_files) > 5:
        result["detection_details"].append(f"Found {len(dex_files)} dex files (may indicate multi-dex or shell)")

    # 方法3: 调用 strings + grep 快速扫描
    if not result["is_shelled"]:
        try:
            strings_out = subprocess.check_output(
                ["strings", apk_path],
                stderr=subprocess.DEVNULL,
                timeout=10
            ).decode("utf-8", errors="ignore")

            shell_keywords = ["hook", "hookZz", "substrate", "frida", "xhook"]
            for keyword in shell_keywords:
                if keyword in strings_out.lower():
                    result["detection_details"].append(f"Found keyword: {keyword}")
        except:
            pass

    # 工具推荐
    if result["is_shelled"]:
        tool_map = {
            "DexGuard": ["frida-unpack-dx.js", "objection"],
            "Bangcle": ["frida-unpack-bc.js", "BangcleUnpacker.py"],
            "Ali": ["frida-unpack-ali.js"],
            "Tencent": ["frida-unpack-tencent.js", "dump Dex"],
            "NAGA": ["frida-unpack-naga.js"],
            "Jiagu": ["frida-unpack-jiagu.js", "android-unpacker"],
        }
        result["suggested_tools"] = tool_map.get(result["shell_type"], ["frida-unpack.js"])

    return result


if __name__ == "__main__":
    import sys
    apk = sys.argv[1] if len(sys.argv) > 1 else "sample.apk"
    detection = detect_shell(apk)
    print(json.dumps(detection, indent=2, ensure_ascii=False))

4.1.2 通用 Frida 脱壳脚本

// SKILLS/apk-decompilation-skill/unpack/frida-unpack.js
// 通用内存Dump脱壳脚本，支持主流加固方案

// 使用方法: frida -U -f com.example.app -l frida-unpack.js --no-pause

if (Java.available) {
    Java.perform(function () {
        console.log("[*] reverse-skill: Frida memory dumper loaded");

        // 1. Hook所有重载的DexFile.loadDex方法
        var DexFile = Java.use("dalvik.system.DexFile");
        DexFile.loadDex.overload('java.lang.String', 'int').implementation = function (dexPath, flags) {
            console.log("[+] DexFile.loadDex called with: " + dexPath);
            var result = this.loadDex(dexPath, flags);

            // 2. 在内存中定位DEX
            Java.perform(function () {
                var dumpDexFile = "/data/local/tmp/dumped_" +
                    dexPath.replace(/.*\//, "").replace(".dex", "") + ".dex";

                // 3. 获取mCookie（包含真实DEX数据的指针）
                var mCookie = result.getClass().getDeclaredField("mCookie");
                mCookie.setAccessible(true);
                var cookie = mCookie.get(result);

                console.log("[+] Dumped DEX via mCookie: " + dumpDexFile);
            });

            return result;
        };

        // 4. Hook BaseDexClassLoader获取完整路径
        var BaseDexClassLoader = Java.use("dalvik.system.BaseDexClassLoader");
        BaseDexClassLoader.$init.implementation = function (dexPath, libraryPath, parent, optDirectory) {
            console.log("[+] BaseDexClassLoader init: " + dexPath);
            return this.$init(dexPath, libraryPath, parent, optDirectory);
        };

        // 5. 高级方案：Hook libdexfile.so中的OpenCommon（读取真实DEX数据）
        var openCommon = Module.findExportByName("libdexfile.so", "OpenCommon");
        if (openCommon) {
            Interceptor.attach(Module.findBaseAddress("libdexfile.so").add(openCommon), {
                onEnter: function (args) {
                    // args[1] = dex_data pointer
                    // args[2] = dex_size
                    console.log("[+] OpenCommon: dex_size=" + args[2].toInt32());
                }
            });
        }

        console.log("[*] reverse-skill: All hooks attached. Dumping in progress...");
    });
}

4.1.3 从检测到执行的完整链路

当 AI Agent 遇到一个 APK 任务时，完整的执行链路如下：

# AI Agent 端到端执行示例

# Step 1: 路由识别
$ ./master-route.ps1 -FilePath "/tmp/app-release.apk"
{
  "task_type": "APK_REVERSE",
  "skill": "apk-decompilation-skill",
  "tools": ["jadx", "frida", "apktool"]
}

# Step 2: 壳检测
$ python3 detect-shell.py /tmp/app-release.apk
{
  "is_shelled": true,
  "shell_type": "Tencent",
  "confidence": 0.85,
  "suggested_tools": ["frida-unpack-tencent.js", "dump Dex"]
}

# Step 3: 自动环境检测
$ ./check-java-android-sdk.ps1
[OK] Java 17 installed
[OK] Android SDK found at /Users/tools/android-sdk
[OK] jadx available: /Users/tools/jadx/build/dist/jadx/bin/jadx
[OK] Frida server running (Android device connected)

# Step 4: 执行脱壳
$ frida -U -f com.tencent.app -l frida-unpack-tencent.js --no-pause &
$ sleep 5 && ./dump-dex.sh  # 等待脱壳完成后Dump

# Step 5: 反编译分析
$ jadx -d /tmp/app-decompiled /tmp/app-release.apk
$ jadx --output-dir /tmp/decoded_dex/ /tmp/dumped_dex/*.dex

# Step 6: 关键信息提取
$ python3 manifest-parser.py /tmp/decoded_dex/AndroidManifest.xml
{
  "activities": ["com.tencent.app.MainActivity", "com.tencent.app.LoginActivity"],
  "services": ["com.tencent.app.PushService"],
  "receivers": ["com.tencent.app.BootReceiver"],
  "permissions": ["android.permission.INTERNET", "android.permission.READ_SMS"]
}

# Step 7: 生成分析报告（AI自动完成）

4.2 二进制分析 Skill：Ghidra + IDA + radare2 协同工作流

二进制逆向是安全分析中最复杂的场景之一。reverse-skill 的二进制分析 Skill 提供了跨平台的工具链封装：

# SKILLS/binary-analysis-skill/SKILL.md (核心流程)

# 二进制分析的标准工作流：

# Phase 1: 基础信息收集（所有工具通用）
file <binary>              # 确认架构、文件类型
readelf -h <binary>        # ELF 文件头
objdump -d <binary>        # 反汇编（快速浏览）
strings <binary> | grep   # 字符串搜索

# Phase 2: 自动化分析
ghidra (headless mode)    # Ghidra 自动化反编译
radare2 -c "aaa; afl"     # radare2 函数列表

# Phase 3: IDA Pro 深度分析（如果有License）
ida64 <binary>            # 交互式逆向

# Phase 4: 动态分析
gdb <binary>              # 调试
strace <binary>           # 系统调用追踪
ltrace <binary>           # 库函数调用追踪

# 二进制分析 Skill 提供的便捷封装
# SKILLS/binary-analysis-skill/analyze.sh

#!/bin/bash
BINARY=$1
OUTPUT_DIR="./analysis/$(basename $BINARY)"

mkdir -p "$OUTPUT_DIR"

echo "[*] reverse-skill: Binary Analysis Workflow"
echo "[*] Target: $BINARY"

# Step 1: 文件格式识别
echo "[1/7] Identifying binary format..."
file "$BINARY" > "$OUTPUT_DIR/01_format.txt"

# Step 2: 架构和编译器检测
echo "[2/7] Architecture and compiler detection..."
readelf -h "$BINARY" > "$OUTPUT_DIR/02_elf_header.txt" 2>/dev/null
if [ $? -eq 0 ]; then
    ARCH=$(readelf -h "$BINARY" | grep Machine | awk '{print $2}')
    echo "Architecture: $ARCH"
fi

# Step 3: 导入/导出表分析
echo "[3/7] Import/Export analysis..."
readelf -d "$BINARY" > "$OUTPUT_DIR/03_dynamic.txt" 2>/dev/null
nm "$BINARY" > "$OUTPUT_DIR/04_symbols.txt" 2>/dev/null

# Step 4: 字符串提取
echo "[4/7] String extraction..."
strings "$BINARY" > "$OUTPUT_DIR/05_strings.txt"
strings -n 8 "$BINARY" > "$OUTPUT_DIR/05_strings_filtered.txt"

# Step 5: Ghidra 自动化反编译（headless）
if command -v analyzeHeadless &> /dev/null; then
    echo "[5/7] Ghidra headless decompilation..."
    analyzeHeadless "$OUTPUT_DIR/ghidra_project" "Project" \
        -import "$BINARY" \
        -processor x86:LE:64:default \
        -scriptPath "$SKILL_DIR/scripts/" \
        -postScript AutoDecompile.java \
        -deleteProject \
        > "$OUTPUT_DIR/06_ghidra_output.txt" 2>&1
fi

# Step 6: radare2 函数分析
if command -v r2 &> /dev/null; then
    echo "[6/7] radare2 function analysis..."
    r2 -q -c "aaa; afl; afl~main" "$BINARY" > "$OUTPUT_DIR/07_radare2.txt" 2>/dev/null
fi

# Step 7: 生成综合报告
echo "[7/7] Generating summary report..."
{
    echo "=== Binary Analysis Summary ==="
    echo "File: $BINARY"
    echo "Date: $(date)"
    echo ""
    cat "$OUTPUT_DIR/01_format.txt"
    echo ""
    echo "=== Key Strings ==="
    grep -E "(http|key|token|password|secret|api)" "$OUTPUT_DIR/05_strings_filtered.txt" || echo "No obvious secrets found"
} > "$OUTPUT_DIR/00_summary.md"

echo "[✓] Analysis complete. Results in $OUTPUT_DIR/"

4.3 JS 逆向 Skill：混淆代码的自动化解析

前端 JavaScript 混淆是 App 安全分析中非常常见的场景。reverse-skill 的 JS 逆向 Skill 覆盖了多种场景：

// SKILLS/js-reverse-skill/analyze-obfuscated.js
// JS 逆向 Skill 的核心脚本之一

/**
 * 典型混淆 JS 的识别与处理流程：
 *
 * 1. 识别混淆类型（eval, obfuscator, webpack, jsfuck, aaencode...）
 * 2. 尝试自动化解混淆
 * 3. 提取关键逻辑（加密函数、网络请求）
 */

// 识别混淆类型
function detectObfuscation(jsCode) {
    const patterns = {
        "eval": /eval\s*\(/,
        "obfuscator": /[_0-9a-z]{6}\(_0x[0-9a-f]{4,}\)/,
        "webpack": /\+\s*"\d+"\s*\+\s*"\d+"/,
        "jsfuck": /\[\]\[\"\\"+"\]\+/,
        "aaencode": /\(\s*\[\s*\]\s*\+\s*'\+"\//,
    };

    const result = { type: "clean", confidence: 1.0 };
    for (const [type, pattern] of Object.entries(patterns)) {
        if (pattern.test(jsCode)) {
            result.type = type;
            result.confidence = 0.9;
            break;
        }
    }
    return result;
}

// 自动化解混淆核心逻辑
function deobfuscateObfuscator(code) {
    // 提取所有字符串常量
    const stringPool = [];
    const poolPattern = /var\s+[_0-9a-z]+\s*=\s*\["([^"]+)"(?:,\s*"([^"]+)")*\]/g;
    let match;
    while ((match = poolPattern.exec(code)) !== null) {
        stringPool.push(...match.slice(1).filter(Boolean));
    }

    // 找到主加密函数并重命名
    const mainFuncPattern = /function\s+([_0-9a-z]+)\s*\([^)]*\)\s*\{[\s\S]*?return\s+[^\}]+\}/;
    const funcMatch = code.match(mainFuncPattern);

    if (funcMatch) {
        const funcBody = funcMatch[0];
        const funcName = funcMatch[1];

        // 替换混淆函数调用为可读形式
        let deobfuscated = code
            .replace(new RegExp(funcName + '\\(([^)]+)\\)', 'g'),
                (match, args) => {
                    const argArray = args.split(',').map(s => s.trim());
                    return `"DECRYPTED:${argArray.join('|')}"`;
                });

        return deobfuscated;
    }

    return code;
}

// 使用 Node.js 环境运行
const fs = require('fs');
const code = fs.readFileSync(process.argv[2], 'utf-8');
const detection = detectObfuscation(code);
console.log(JSON.stringify(detection, null, 2));

if (detection.type !== "clean") {
    const deobfuscated = deobfuscateObfuscator(code);
    fs.writeFileSync(process.argv[2].replace('.js', '_deobfuscated.js'), deobfuscated);
    console.log("[✓] Saved deobfuscated version");
}

4.4 CTF 沙箱编排 Skill

CTF 是安全学习的重要场景。reverse-skill 的 CTF Skill 提供了完整的 Docker 沙箱环境一键初始化：

# SKILLS/ctf-sandbox-skill/init-ctf-env.sh

#!/bin/bash
# CTF 竞赛环境一键初始化脚本

set -e

CTF_DIR="${1:-./ctf-workspace}"
mkdir -p "$CTF_DIR"

echo "[reverse-skill] Initializing CTF sandbox environment..."

# 拉取预配置的 CTF Docker 镜像
docker pull reverse-skill/ctf-sandbox:latest 2>/dev/null || \
    docker pull registry.docker.io/library/ubuntu:22.04

# Docker Compose 配置
cat > "$CTF_DIR/docker-compose.yml" << 'EOF'
services:
  pwn:
    image: reverse-skill/pwn-tools:latest
    container_name: ctf-pwn
    security_opt:
      - seccomp:unconfined
    cap_add:
      - SYS_PTRACE
    volumes:
      - ./pwn:/workspace
    network_mode: host
    working_dir: /workspace

  web:
    image: reverse-skill/web-tools:latest
    container_name: ctf-web
    ports:
      - "8080:80"
      - "8443:443"
    volumes:
      - ./web:/var/www/html
    environment:
      - FLAG=test_flag_do_not_submit

  crypto:
    image: reverse-skill/crypto-tools:latest
    container_name: ctf-crypto
    volumes:
      - ./crypto:/workspace
    working_dir: /workspace

  misc:
    image: reverse-skill/misc-tools:latest
    container_name: ctf-misc
    volumes:
      - ./misc:/workspace
    working_dir: /workspace

  rev:
    image: reverse-skill/rev-tools:latest
    container_name: ctf-rev
    volumes:
      - ./rev:/workspace
    working_dir: /workspace
EOF

# 启动所有容器
docker-compose -f "$CTF_DIR/docker-compose.yml" up -d

echo "[✓] CTF environment ready!"
echo "    Pwn:    docker exec -it ctf-pwn bash"
echo "    Web:    docker exec -it ctf-web bash"
echo "    Crypto: docker exec -it ctf-crypto bash"
echo "    Rev:    docker exec -it ctf-rev bash"

五、环境自举：跨平台一键初始化

5.1 为什么环境自举如此重要

传统的安全工具安装有多痛苦，做过逆向的朋友都知道：

IDA Pro 需要手动下载、安装、配置插件路径
Ghidra 需要 JDK 17+
Frida 需要 npm 安装 + Android/iOS 设备配置
Python 的各种安全库（pwntools、angr）依赖管理混乱

reverse-skill 的环境自举机制解决了这个问题：一个命令，在 Windows/Linux/macOS 上全自动安装所有依赖。

5.2 bootstrap.ps1 的实现

# reverse-skill/bootstrap.ps1 (Windows PowerShell 核心逻辑)

$ErrorActionPreference = "Stop"
$REVERSE_SKILL_ROOT = $PSScriptRoot

Write-Host "[reverse-skill] Environment Bootstrap" -ForegroundColor Cyan
Write-Host "Platform: $($PSVersionTable.Platform)" -ForegroundColor Gray

# 检测包管理器
function Get-PackageManager {
    if (Test-Command "winget") { return "winget" }
    if (Test-Command "choco")  { return "choco" }
    if (Test-Command "brew")   { return "brew" }
    if (Test-Command "apt")   { return "apt" }
    return $null
}

# 安装 Java（jadx 必需）
function Install-Java {
    Write-Host "[*] Installing Java..." -ForegroundColor Yellow
    switch ($pkgMgr) {
        "winget" { winget install --id Oracle.JDK.17 -e --accept-package-agreements --accept-source-agreements }
        "brew"   { brew install openjdk@17 }
        "apt"    { sudo apt install openjdk-17-jdk -y }
    }
    $env:JAVA_HOME = Find-JavaHome
    Write-Host "[✓] Java installed: $env:JAVA_HOME" -ForegroundColor Green
}

# 安装 Python 安全工具
function Install-PythonSecurityTools {
    Write-Host "[*] Installing Python security tools..." -ForegroundColor Yellow
    pip install frida-tools pwntools angr bochs unicorn capstone ropper z3-solver
    Write-Host "[✓] Python security tools installed" -ForegroundColor Green
}

# 安装 Frida（核心工具）
function Install-Frida {
    Write-Host "[*] Installing Frida..." -ForegroundColor Yellow
    if (Test-Command "pip") {
        pip install frida frida-tools
    } else {
        npm install -g frida-tools
    }
    # 验证
    frida --version
    Write-Host "[✓] Frida installed" -ForegroundColor Green
}

# 安装 APK 逆向工具集
function Install-APKTools {
    Write-Host "[*] Installing APK tools..." -ForegroundColor Yellow

    $TOOLS_DIR = "$REVERSE_SKILL_ROOT/tools"
    mkdir -p "$TOOLS_DIR"

    # jadx (最新 release)
    $JADX_VERSION = "1.4.7"
    $JADX_URL = "https://github.com/skylot/jadx/releases/download/v$JADX_VERSION/jadx-$JADX_VERSION.zip"
    if (!(Test-Path "$TOOLS_DIR/jadx")) {
        Invoke-WebRequest $JADX_URL -OutFile "$TOOLS_DIR/jadx.zip"
        Expand-Archive "$TOOLS_DIR/jadx.zip" -DestinationPath "$TOOLS_DIR"
        Rename-Item "$TOOLS_DIR/jadx-$JADX_VERSION" "$TOOLS_DIR/jadx"
    }

    # APKTool
    $APKTOOL_URL = "https://github.com/iBotPeaches/Apktool/releases/download/v2.9.3/apktool_2.9.3.jar"
    if (!(Test-Path "$TOOLS_DIR/apktool.jar")) {
        Invoke-WebRequest $APKTOOL_URL -OutFile "$TOOLS_DIR/apktool.jar"
    }

    # android-platform-tools (adb for emulator access)
    if (!(Test-Command "adb")) {
        Write-Host "[!] ADB not found. Install Android SDK platform-tools manually." -ForegroundColor Red
    }

    Write-Host "[✓] APK tools installed" -ForegroundColor Green
}

# 一键完整安装
function Invoke-FullBootstrap {
    $pkgMgr = Get-PackageManager
    Write-Host "[*] Package manager: $pkgMgr" -ForegroundColor Cyan

    Install-Java
    Install-PythonSecurityTools
    Install-Frida
    Install-APKTools

    # 写入环境配置文件（供 Skill 读取）
    $envConfig = @{
        JAVA_HOME    = $env:JAVA_HOME
        JADX_PATH    = "$REVERSE_SKILL_ROOT/tools/jadx/bin/jadx"
        APKTOOL_JAR  = "$REVERSE_SKILL_ROOT/tools/apktool.jar"
        FRIDA_VERSION = (frida --version 2>$null) -replace '`n', ''
    } | ConvertTo-Json

    $envConfig | Out-File "$REVERSE_SKILL_ROOT/.env.json" -Encoding UTF8

    Write-Host ""
    Write-Host "[✓] reverse-skill bootstrap complete!" -ForegroundColor Green
    Write-Host "    Run 'pwsh master-route.ps1' to start." -ForegroundColor Cyan
}

Invoke-FullBootstrap

六、知识库进化：从踩坑到资产

6.1 经验资产的自动化沉淀

reverse-skill 最有价值的设计之一是其知识库的自动化沉淀机制。

每一次成功的分析任务结束后，系统会自动提取并归档：

技术发现（脱壳方法、关键函数、加密算法）
踩坑记录（某壳的某个版本需要特殊处理）
工具配置（特定环境下某工具的版本兼容问题）
脚本片段（可以复用的 Frida 脚本、Python 工具）

这些内容以结构化格式存入 field-journal/ 目录，供未来的任务复用：

# field-journal/YYYY-MM-DD/[task_id].md

## 任务概述
- 目标: 分析某加固 APK
- 日期: 2026-08-05
- AI Client: Claude Code
- Skill Used: APK_REVERSE

## 关键发现
### 发现1: 某加固厂商 v3.2.1 特殊处理
**现象**: 标准 Frida 脱壳脚本失效
**原因**: 该版本使用了内存完整性校验，直接 Dump 的 DEX 在加载时会触发校验失败
**解决方案**: 需要先 Hook 校验函数 `com.shell.integrity.Checker` 禁用校验，再 Dump
**代码**:
```frida
Java.perform(function() {
    var Checker = Java.use("com.shell.integrity.Checker");
    Checker.check.implementation = function() {
        console.log("[ bypass ] integrity check disabled");
        return;  // 不执行校验
    };
});

标签: #APK #DexGuard #bypass #frida

经验教训

该壳的 dex2oat 编译产物路径与标准路径不同，需要额外搜索
Hook 时机很重要，需要在 Application.attachBaseContext 中提前注入

可复用资产

frida-bypass-integrity-v3.2.1.js → 归档到 hooks/integrity-bypass/


### 6.2 场景全覆盖：从 APK 到固件到供应链

reverse-skill 的 Skill 列表持续扩展，目前已覆盖：

| Skill 名称 | 场景 | 核心工具链 |
|-----------|------|-----------|
| `apk-decompilation-skill` | Android APK 逆向 | jadx, apktool, Frida |
| `binary-analysis-skill` | 通用二进制分析 | Ghidra, IDA, radare2 |
| `js-reverse-skill` | JS/前端逆向 | Node.js, webpack decoder |
| `network-forensics-skill` | 流量分析与取证 | Wireshark, tshark, mitmproxy |
| `ctf-sandbox-skill` | CTF 竞赛沙箱 | Docker, pwntools, angr |
| `firmware-analysis-skill` | 固件逆向与安全分析 | binwalk, firmwarealker, QEMU |
| `penetration-testing-skill` | 授权渗透测试 | nmap, nuclei, ffuf, metasploit |
| `supply-chain-skill` | 供应链安全分析 | syft, grype, sbom-gen |
| `wasm-reverse-skill` | WebAssembly 逆向 | wasm-dis, wasm-decompile, wabt |
| `pcap-analysis-skill` | PCAP 流量取证 | tshark, NetworkMiner |

---

## 七、AI Agent 集成实战：让 Claude Code 具备安全能力

### 7.1 集成到 Claude Code

reverse-skill 设计之初就考虑了 AI Agent 的使用场景。最简单的集成方式是通过 `.claude/` 配置：

```bash
# 项目根目录下的 .claude/commands/reverse.sh
# 供 Claude Code 调用的逆向分析命令

#!/bin/bash
COMMAND=$1
TARGET=$2
SKILL_ROOT="$HOME/.reverse-skill"

case "$COMMAND" in
    "apk")
        echo "[reverse-skill] Running APK reverse analysis on $TARGET"
        pwsh "$SKILL_ROOT/MASTER-ROUTING/master-route.ps1" \
            -FilePath "$TARGET"
        ;;
    "binary")
        echo "[reverse-skill] Running binary analysis on $TARGET"
        "$SKILL_ROOT/SKILLS/binary-analysis-skill/analyze.sh" "$TARGET"
        ;;
    "js")
        echo "[reverse-skill] Running JS reverse analysis on $TARGET"
        node "$SKILL_ROOT/SKILLS/js-reverse-skill/analyze-obfuscated.js" "$TARGET"
        ;;
    *)
        echo "Usage: reverse <apk|binary|js|pcap> <target_file>"
        ;;
esac

7.2 实际使用效果对比

集成前（AI 盲目操作）：

User: "分析这个 APK，提取其中的 API 密钥"
Claude Code:
  1. strings target.apk | grep -i api  → 找到一些字符串，但大量混淆
  2. 尝试 pip install uncompyle6 (错误工具)
  3. 失败
  4. 尝试直接读取 smali 文件（读不懂格式）
  5. 输出: "无法分析，文件已混淆"

集成后（reverse-skill 路由）：

User: "分析这个 APK，提取其中的 API 密钥"
Claude Code:
  1. pwsh master-route.ps1 -FilePath target.apk
     → {"task_type": "APK_REVERSE", "skill": "apk-decompilation-skill"}
  2. python3 detect-shell.py target.apk
     → {"shell_type": "Tencent", "confidence": 0.9}
  3. frida -U -f com.app -l frida-unpack-tencent.js --no-pause
  4. jadx -d decoded/ dumped_dex/*.dex
  5. grep -r "api.*key\|secret\|token" decoded/
     → 找到硬编码密钥
  6. 生成完整报告

八、局限性与安全红线

8.1 使用边界

reverse-skill 的 RULES.md 和 scope.md 机制明确了其使用边界：

仅限授权测试：系统强制要求 scope.md 确认授权范围后才能执行
禁止自动攻击：路由引擎的渗透测试 Skill 包含多重确认步骤，不会自动对外网目标发起攻击
知识库脱敏：所有归档到 field-journal 的内容必须脱敏，不得包含目标系统的真实敏感信息

8.2 当前局限性

IDA Pro 依赖：高级二进制分析 Skill 依赖 IDA Pro（商业软件），无 License 时功能受限
路由规则更新滞后：新壳、新混淆方案的识别规则需要手动更新到知识库
Android 优先：iOS 相关的 Skill 覆盖度不如 Android 场景完善
AI 路由准确率：当前基于关键词匹配的路由在复杂场景下仍有误判可能

九、总结：AI Agent 的安全能力扩展之路

reverse-skill 不是一个普通的开源工具——它是 2026 年 AI Agent 能力扩展趋势的一个标志性样本。

回顾一下本文的核心观点：

1. AI Coding 的下一个瓶颈是专业领域知识
当 AI Agent 开始处理越来越复杂的任务时，它们的短板不再是"写代码"的能力，而是"特定领域的决策能力"。reverse-skill 用方法论路由的方式，给 AI Agent 注入了一个可以快速获取的"安全专家经验层"。

2. Skill 路由是比工具封装更高级的设计
大多数 AI 工具链项目在做的事情是"封装更多工具"。reverse-skill 的设计更聪明：先教 AI 什么时候用什么工具。方法论优先，工具其次。

3. 知识库的持续进化是关键护城河
reverse-skill 的 field-journal 机制将每一次踩坑转化为可复用资产。随着用户社区的贡献，这个知识库会越来越完善，最终成为一个真正的"安全知识图谱"。

4. 安全场景是 AI Agent 能力验证的绝佳场景
安全分析的特点是：需要精确的工具选择、严格的流程规范、复杂的上下文判断。这恰好是当前 AI Agent 最欠缺的能力。reverse-skill 在这个领域的实践，对整个 AI Agent 生态都有借鉴意义。

项目地址: https://github.com/zhaoxuya520/reverse-skill
Star: 17.7k+ (2026-08-04)
日增长: 2258⭐
支持的 AI 客户端: Claude Code, Kiro, Cursor, Cline
平台支持: Windows (PowerShell), Linux, macOS
许可: 开源（具体见 GitHub）

本文所有代码示例均基于 reverse-skill 项目公开文档和结构分析，实际使用时请以官方仓库最新版本为准。

复制全文生成海报 reverse-skill AI Agent 安全工具逆向工程 Claude Code Frida 渗透测试 Skill Router