从脱壳到漏洞挖掘:用 MCP 打造全自动化 Android 应用安全分析流水线

分类: 移动安全

还在手动敲 ADB 命令脱壳、在 JADX 里反复搜索硬编码密钥?本文带你用 MCP 协议将 ADB、一键脱壳技能、Frida 和 JADX 串联成自动化流水线。只需一句话,AI 就能完成从设备连接、脱壳到代码审计的全流程,自动挖掘硬编码凭证、不安全 API 和导出组件风险,最终输出一份专业的安全分析报告。无论你是安全研究员还是逆向新手,都能大幅提升效率,告别重复劳动。

写在前面

在 APK 渗透测试中,经常需要完成这样一套完整流程:拿到一个加固的 APK → 脱壳 → 反编译 → 寻找漏洞。传统的做法是把这些环节拆成孤岛,每个环节都需要手动操作和切换工具,极其耗时。直到我把 MCP(Model Context Protocol)和多个社区技能包组合成一套自动化流水线,才真正实现了“一句话完成从脱壳到漏洞发现”的全流程。

这篇文章是我对这套流水线的完整记录。我会从 ADB 封装开始,一路讲到如何用 AI 驱动 JADX 自动挖掘硬编码凭证和高危漏洞。

一、从“手动挡”到“自动挡”:我们需要什么?

一个完整的 Android 应用安全分析流程通常包括:

  1. 环境准备: 连接设备,确认目标应用。
  2. 拉取 APK: 从设备中提取 APK 文件。
  3. 脱壳: 如果应用加固,需要先从内存中 Dump 出解密后的 DEX。
  4. 反编译: 将 DEX 转换为可读的 Java 代码。
  5. 漏洞挖掘: 在代码中搜索硬编码凭证、不安全 API、导出组件等。
  6. 报告生成: 整理发现,输出结构化的安全报告。

这些步骤中充满了重复性劳动:记 ADB 命令、切终端、复制路径、在 JADX 里手动搜索关键词……能不能把这些工作全部交给 AI 来做?我们只需要说一句“帮我分析这个 App 的安全风险”,剩下的全部自动完成?

答案是肯定的。关键在于 MCP + 技能包组合。

二、MCP 是什么?为什么它能串联整个分析流程?

MCP(Model Context Protocol)是一个开放协议,它标准化了 AI 应用程序如何向外部工具提供上下文。简单说,它允许我们把任何命令行工具或脚本包装成一个“技能”,让大语言模型能够像调用函数一样调用它们。

更关键的是,MCP 支持多个技能协同工作。我把四个核心技能组合在一起,构成了一条完整的分析流水线:

技能

作用

ADB MCP

与 Android 设备交互:连接、拉取 APK、执行 shell 命令

rev-dex-dumper

一键脱壳,从运行中的应用内存中 Dump DEX

rev-frida

生成和调用 Frida 动态插桩脚本

JADX MCP

与 JADX-GUI 反编译引擎交互,提供代码查询和分析能力

把它们组合起来,AI 就能完整执行从“设备连接”到“漏洞发现”的全部步骤。

三、第一步:把 ADB 封装成 MCP 服务器

我本地的 ADB 路径是:

platform-tools\adb.exe

为了让它能被 AI 调用,我写了一个简单的 Python MCP 服务器,定义了几个核心工具。

3.1 定义工具 adb mcp

# adb_mcp_server.py
#!/usr/bin/env python3
"""ADB MCP Server — 通过 MCP 调用本地 adb.exe。"""

from __future__ import annotations

import asyncio
import json
import logging
import subprocess
from pathlib import Path

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import TextContent, Tool

ADB_PATH = Path(__file__).resolve().parent / "adb.exe"

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
)
logger = logging.getLogger("adb-mcp")

app = Server("adb-mcp-server")


def _run_adb(args: list[str], timeout: int = 120) -> dict:
    if not ADB_PATH.exists():
        return {
            "ok": False,
            "command": " ".join([str(ADB_PATH), *args]),
            "stdout": "",
            "stderr": f"adb not found: {ADB_PATH}",
            "returncode": 127,
        }

    cmd = [str(ADB_PATH), *args]
    try:
        proc = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            encoding="utf-8",
            errors="replace",
            timeout=timeout,
        )
        return {
            "ok": proc.returncode == 0,
            "command": " ".join(cmd),
            "stdout": proc.stdout,
            "stderr": proc.stderr,
            "returncode": proc.returncode,
        }
    except subprocess.TimeoutExpired as exc:
        return {
            "ok": False,
            "command": " ".join(cmd),
            "stdout": exc.stdout or "",
            "stderr": (exc.stderr or "") + "\nTimed out",
            "returncode": 124,
        }
    except Exception as exc:
        return {
            "ok": False,
            "command": " ".join(cmd),
            "stdout": "",
            "stderr": str(exc),
            "returncode": 1,
        }


def _as_text(result: dict) -> str:
    return json.dumps(result, ensure_ascii=False, indent=2)


@app.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="adb_devices",
            description="列出所有已连接的安卓设备或模拟器",
            inputSchema={"type": "object", "properties": {}},
        ),
        Tool(
            name="adb_shell",
            description="在默认设备上执行 adb shell 命令",
            inputSchema={
                "type": "object",
                "properties": {
                    "command": {
                        "type": "string",
                        "description": "shell 命令,例如 ls /sdcard",
                    },
                    "serial": {
                        "type": "string",
                        "description": "可选,指定设备 serial",
                    },
                },
                "required": ["command"],
            },
        ),
        Tool(
            name="adb_install",
            description="安装 APK 到设备",
            inputSchema={
                "type": "object",
                "properties": {
                    "apk_path": {
                        "type": "string",
                        "description": "本地 APK 完整路径",
                    },
                    "serial": {
                        "type": "string",
                        "description": "可选,指定设备 serial",
                    },
                    "replace": {
                        "type": "boolean",
                        "description": "是否使用 adb install -r",
                        "default": True,
                    },
                },
                "required": ["apk_path"],
            },
        ),
    ]


@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    try:
        if name == "adb_devices":
            result = _run_adb(["devices", "-l"])
            return [TextContent(type="text", text=_as_text(result))]

        if name == "adb_shell":
            command = arguments["command"]
            serial = arguments.get("serial")
            args = ["shell", command]
            if serial:
                args = ["-s", serial, *args]
            result = _run_adb(args)
            return [TextContent(type="text", text=_as_text(result))]

        if name == "adb_install":
            apk_path = Path(arguments["apk_path"])
            if not apk_path.exists():
                return [
                    TextContent(
                        type="text",
                        text=_as_text(
                            {
                                "ok": False,
                                "stdout": "",
                                "stderr": f"APK not found: {apk_path}",
                                "returncode": 1,
                            }
                        ),
                    )
                ]
            serial = arguments.get("serial")
            replace = arguments.get("replace", True)
            args = ["install"]
            if replace:
                args.append("-r")
            args.append(str(apk_path))
            if serial:
                args = ["-s", serial, *args]
            result = _run_adb(args, timeout=300)
            return [TextContent(type="text", text=_as_text(result))]

        return [TextContent(type="text", text=f"Unknown tool: {name}")]
    except Exception as exc:
        logger.exception("tool %s failed: %s", name, exc)
        return [TextContent(type="text", text=f"Error: {exc}")]


async def main() -> None:
    logger.info("Starting ADB MCP Server")
    logger.info("ADB path: %s", ADB_PATH)
    async with stdio_server() as (read_stream, write_stream):
        await app.run(read_stream, write_stream, app.create_initialization_options())


if __name__ == "__main__":
    asyncio.run(main())

3.2 配置 adb_mcp_server

python adb_mcp_server.py

然后在 Claude Desktop 的配置文件中添加这个服务器。重启之后,我就可以用自然语言让 AI 帮我查设备、列包名、拉文件了。



四、第二步:安装 reverse-skills,获得一键脱壳能力

基础 ADB 工具只是“手脚”,真正的“大脑”是社区大佬 P4nda0s 开发的 reverse-skills 技能包。这个包里有两个关键工具:

  • rev-dex-dumper: 专门用于脱壳。
  • rev-frida: 用于生成和调用 Frida 动态插桩脚本。

4.1 安装技能包

在 Claude Code 或支持 MCP 的 AI 编程助手环境中,运行:

npx skills add P4nda0s/reverse-skills

安装完成后,AI 就获得了脱壳和 Frida 插桩的能力。

4.2 了解 rev-dex-dumper 做了什么

这个工具将脱壳的整个流程自动化了:

  1. 环境检查: 确认 ADB 可用,设备已连接且已 Root。
  2. 目标锁定: 自动获取当前顶层 Activity 的包名,或使用用户指定的包名。
  3. 脱壳执行: 利用 Frida 或定制脚本从内存中 dump 出 DEX。
  4. 文件拉取: 将 dump 出的 DEX 文件自动 pull 到本地。
  5. 清理现场: 删除设备上的临时文件,避免残留。

所有这一切,只需要一句话。

脱壳成功

五、第三步:集成 JADX MCP,获得代码分析能力

脱壳只是第一步。拿到 DEX 后,我们还需要反编译和分析代码。为此,我集成了 zinja-coder 开发的 JADX MCP。

5.1 安装与配置

JADX MCP 的发布地址是:

https://github.com/zinja-coder/jadx-ai-mcp/releases

安装步骤:

  1. 下载对应平台的 Release 包。
  2. 确保 JADX-GUI 已打开并加载了目标 APK 或 DEX 文件。
  3. 启动 JADX MCP Server(通常是一个本地 HTTP 服务,默认端口 8080)。
  4. 在 MCP 客户端中配置该服务。

5.2 JADX MCP 提供的核心能力

JADX MCP 暴露了以下 35+ 个关键工具,让 AI 能够像使用 IDE 一样操作 JADX-GUI。按功能可划分为六类:

类别

工具

功能

获取当前上下文

fetch_current_class

获取 JADX-GUI 中当前选中的类


get_selected_text

获取当前选中的文本内容

类/方法/字段查询

get_all_classes

列出所有类名


get_class_source

获取指定类的 Java 源码


get_smali_of_class

获取指定类的 Smali 代码


get_method_by_name

根据方法名获取方法详细信息


get_methods_of_class

列出某个类的所有方法


search_method_by_name

按名称在所有类中搜索方法


search_classes_by_keyword

按关键字搜索类名


get_fields_of_class

列出某个类的所有字段

资源与清单

get_android_manifest

获取解析后的 AndroidManifest.xml


get_manifest_component

获取 Manifest 中的组件信息


get_strings

获取应用中的所有字符串资源


get_all_resource_file_names

列出所有资源文件名


get_resource_file

获取指定资源文件的内容

应用结构

get_main_activity_class

获取启动 Activity 类名


get_main_application_classes_names

获取主 Application 类及其引用类名


get_main_application_classes_code

获取主 Application 相关类的源码


get_package_tree

获取包结构树

交叉引用(Xrefs)

get_xrefs_to_class

追踪某个类的所有引用


get_xrefs_to_method

追踪某个方法的所有调用链


get_xrefs_to_field

追踪某个字段的所有引用

重命名(去混淆)

rename_class

重命名指定类


rename_method

重命名指定方法


rename_field

重命名字段


rename_package

重命名包


rename_variable

重命名局部变量

调试辅助

debug_get_stack_frames

获取当前调试栈帧(需调试模式)


debug_get_threads

获取当前线程列表


debug_get_variables

获取当前变量的值

缓存与清理

get_cache_stats

获取 JADX 缓存统计信息


clear_cache

清理 JADX 缓存

有了这组完整的工具,AI 可以:

  • 全量搜索: 通过 search_strings(虽然未在上表,但文档中有)和 search_method_by_name 定位敏感代码;
  • 深度追踪: 利用 get_xrefs_to_* 分析数据流和调用链;
  • 去混淆: 通过 rename_* 工具将混淆符号替换为可读名称;
  • 动态调试: 配合 debug_get_* 实现插桩式动态分析;
  • 结构感知: 通过 get_package_tree 和 get_main_application_classes_code 快速理解应用架构。

在自动化分析工作流中,最常用的是:search_classes_by_keyword、get_xrefs_to_method、get_class_source 和 get_android_manifest,它们能高效完成硬编码凭证搜索、漏洞验证和组件导出检查。

六、定义自动化分析提示词(供参考)

角色与目标

AI 将被设定为一个专业的 Android 安全自动化分析专家,其核心任务是从零开始,对目标 Android 应用进行全自动的逆向分析,最终输出一份聚焦于硬编码凭证、敏感信息泄露和高危漏洞的安全分析报告。

可用工具链

AI 可以调用的工具链包括:

  • ADB MCP: 用于与 Android 设备交互。
  • rev-dex-dumper: 一句话自动化脱壳技能,用于从运行中的应用内存中 Dump DEX 文件。
  • rev-frida: 用于生成和调用 Frida 动态插桩脚本。
  • JADX MCP: 用于与 JADX-GUI 反编译引擎交互,提供实时代码分析能力。

自动化工作流

整个分析过程被划分为四个阶段,AI 将严格按此流程执行:

第一阶段:环境准备与设备连接

  1. 检查连接: 使用 ADB MCP 的 get_devices 工具,确认是否有设备已连接。
  2. 获取目标: 如果用户未指定包名,使用 ADB MCP 获取当前前台应用的包名;如果用户已指定,则直接使用指定的包名。
  3. 获取 APK 路径: 使用 ADB MCP 的 list_packages 工具,找到目标包名对应的 APK 在设备上的完整路径。
  4. 拉取 APK: 使用 ADB MCP 的 pull 工具,将 APK 文件从设备拉取到本地工作目录。

第二阶段:自动化脱壳(如遇加固)

  1. 检测加固: 使用 JADX MCP 的 get_android_manifest 工具初步检查 APK,或使用 ADB MCP 检查应用进程。若发现加固迹象(如存在 libjiagu.so、libsec.so 等),进入脱壳流程。
  2. 启动应用: 使用 ADB MCP 启动目标应用,并等待其进入主界面,确保壳已完成解密。
  3. 执行脱壳: 调用 rev-dex-dumper 技能,通过 AI 对话触发自动脱壳。例如,发送指令:“帮我脱壳 [目标包名]”。
  4. 拉取 DEX: 脱壳完成后,使用 ADB MCP 将生成的 DEX 文件从设备拉取到本地工作目录。如果未检测到加固,则跳过脱壳阶段,直接使用原始 APK。

第三阶段:智能反编译与分析

  1. 加载项目: 在 JADX-GUI 中打开脱壳后的 DEX 文件或原始 APK,并确保 JADX MCP Server 已运行。
  2. 全局敏感信息狩猎: 利用 JADX MCP 的能力,执行以下自动化分析任务:
  • 硬编码凭证搜索: 在全部代码中搜索 API Key、Token、密码、密钥等硬编码字符串。参考模式:sk-*、AKIA*、password =、secret =、Bearer 等。
  • 不安全 API 检测: 识别并列出不安全的 API 使用,如 SQLiteDatabase.execSQL()、HttpURLConnection、TrustManager 的不安全实现等。
  • 敏感权限与组件导出分析: 检查 AndroidManifest.xml,识别导出组件和危险权限。
  1. 深入漏洞分析: 对发现的可疑点,使用 JADX MCP 进行深入分析:
  • 跟踪引用: 使用 xrefs_to_method 和 xrefs_to_field 工具,追踪敏感数据的来源与流向。
  • 代码理解: 对关键方法,使用 AI 能力进行解释和去混淆。

第四阶段:报告生成

根据分析结果,生成一份结构化的 Markdown 安全报告,内容包括:

  • 执行摘要: 整体安全评分和关键发现。
  • 硬编码凭证清单: 列出发现的所有硬编码凭证及其位置。
  • 漏洞详情: 描述每个漏洞的位置、类型、潜在危害和修复建议。
  • 敏感 API 与权限清单: 列出应用使用的不安全 API 和危险权限。

七、实战:从一句话到一份安全报告

7.1 执行过程示例

AI 执行时的日志输出大致如下:

[1/11] 检查 ADB 连接...
[+] 已连接设备: 127.0.0.1:5555
[2/11] 获取当前前台应用包名...
[+] 目标包名: com.example.targetapp
[3/11] 获取 APK 路径...
[+] APK 路径: /data/app/com.example.targetapp/base.apk
[4/11] 拉取 APK 到本地...
[+] APK 已保存至 ./workspace/com.example.targetapp.apk
[5/11] 检测加固...
[*] 发现 libjiagu.so,疑似腾讯加固
[6/11] 启动应用并等待解密...
[+] 应用已启动
[7/11] 执行脱壳 (rev-dex-dumper)...
[+] 脱壳完成,DEX 文件保存至 ./workspace/dump/
[8/11] 加载 DEX 到 JADX-GUI...
[+] JADX MCP 已连接
[9/11] 全局敏感信息搜索...
[*] 搜索硬编码凭证...
[!] 发现 5 处硬编码凭证
[*] 搜索不安全 API...
[!] 发现 3 处不安全 API 使用
[10/11] 深入漏洞分析...
[*] 追踪凭证引用...
[*] 分析导出组件...
[11/11] 生成报告...
[+] 报告已保存至 ./reports/security_report_com.example.targetapp.md

执行结果

八、一张图看懂全流程

整个自动化分析流水线可以清晰地分为四个层次:你(用户)、AI 助手(按角色定义执行工作流)、MCP 技能层和底层工具链。

┌─────────────────────────────────────────────────────────────────┐
│ 1. 你(用户)说一句话                                           │
│    “帮我分析 [目标应用],生成安全报告”                          │
└─────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────┐
│ 2. AI 助手(角色:Android 安全自动化分析专家)                   │
│    按照四阶段工作流执行任务                                      │
└─────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────────┐
│ 3. MCP 技能层(多个技能协同工作)                                        │
├─────────────────────────────────────────────────────────────────────────┤
│  ADB MCP                          JADX MCP                               │
│  ├── adb_devices                 ├── get_android_manifest                 │
│  ├── adb_list_packages           ├── search_strings                       │
│  ├── adb_pull                    ├── get_class_source                     │
│  └── adb_shell                   ├── xrefs_to_method                      │
│                                  └── xrefs_to_field                       │
│  rev-dex-dumper                   rev-frida                               │
│  └── 一键脱壳                      └── 动态插桩脚本生成                    │
└─────────────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────────┐
│ 4. 底层工具链                                                           │
├─────────────────────────────────────────────────────────────────────────┤
│  Android 设备 / 模拟器  ←→  ADB  ←→  Frida  ←→  JADX-GUI                 │
└─────────────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────────┐
│ 5. 结果返回给你                                                         │
│    ✅ 安全报告已生成:                                                    │
│       - 执行摘要:安全评分 4.2/10                                         │
│       - 硬编码凭证:5 处                                                  │
│       - 高危漏洞:2 个                                                    │
│       - 导出组件风险:3 个                                                │
└─────────────────────────────────────────────────────────────────────────┘

九、这样做到底有什么意义?

可能你会想:“我自己也能一步步操作,为什么非要让 AI 来做?”下面我从几个角度说明这套流水线的核心价值。

1. 从“记住命令”到“表达意图”

传统分析你需要记住:

  • adb shell dumpsys window | grep mCurrentFocus(找包名)
  • adb shell pm path com.example.target(找 APK 路径)
  • 不同加固对应的不同 Frida 脚本
  • 在 JADX 中手动搜索几十个关键词

而现在,你只需要说一句 “帮我分析这个 App”。AI 替你记住所有细节。你的大脑被解放出来,去关注真正的漏洞挖掘逻辑。

2. 从“脚本散落一地”到“统一技能市场”

过去每个人都会积累一堆自己写的 .bat / .sh / Frida 脚本,但难以分享和复用。MCP 技能包(如 reverse-skills)相当于一个逆向工具的 App Store。你只需要 npx skills add xxx,就获得了别人封装好的最佳实践。而且这些技能可以被 AI 自主组合调用——先脱壳、再反编译、再找字符串、再追踪引用,一句话完成一整条分析流水线。

3. 真正消灭“上下文切换”的心流打断

逆向分析时最怕打断。当你盯着反汇编代码思考,突然需要 dump 一下内存——

  • 传统方式: 切到终端 → 找包名 → 执行脚本 → 等 DEX 拉回来 → 导入 JADX → 重新搜索。
  • AI 自动化: 直接在聊天框里说一句话,几秒钟后安全报告就在你眼前。

你始终保持在分析思维里,再也没有“我去敲个命令”的中断。

4. 降低门槛,让更多人能参与 Android 安全

对于刚入门安全研究的新手,最劝退的不是漏洞原理,而是环境配置和工具链壁垒。有了这套自动化流水线后,新人可以这样说:“我想分析一下那个 App 有没有硬编码密钥。”AI 自动完成设备连接、脱壳、反编译、代码搜索的全过程。技术民主化——这才是最大的意义。

5. 未来可无限扩展

今天这套流水线能帮你脱壳和找硬编码凭证,明天就能:

  • 自动分析 DEX 中可疑字符串,标记恶意行为
  • 用自然语言编写 Frida Hook 脚本:“帮我 Hook 这个 App 的 AES 加密函数并打印密钥”
  • 自动比对不同版本的加固变化
  • 集成更多静态分析规则,覆盖 OWASP Mobile Top 10

所有这一切,都是因为有了 MCP 这座桥梁:AI 不再是一个只能聊天的玩具,而是可以直接操纵整个安全分析工具链的智能体。

十、总结与展望

通过将 ADB MCP、rev-dex-dumper、rev-frida 和 JADX MCP 组合成一套自动化流水线,并为其设定明确的角色定义和四阶段工作流,我真正实现了“用一句话完成从脱壳到漏洞挖掘的全过程”。整个过程无需手动输入一条 ADB 命令,无需记忆复杂的 Frida 脚本语法,也无需在 JADX 中反复搜索关键词——AI 充当了智能调度中心,理解我的意图并按照预设的工作流调用最合适的工具。

这套流水线的潜力远不止于此。任何重复性的安全分析任务——静态分析、Hook 编写、日志分析、报告生成——都可以通过 MCP 技能包实现自动化。