从脱壳到漏洞挖掘:用 MCP 打造全自动化 Android 应用安全分析流水线
还在手动敲 ADB 命令脱壳、在 JADX 里反复搜索硬编码密钥?本文带你用 MCP 协议将 ADB、一键脱壳技能、Frida 和 JADX 串联成自动化流水线。只需一句话,AI 就能完成从设备连接、脱壳到代码审计的全流程,自动挖掘硬编码凭证、不安全 API 和导出组件风险,最终输出一份专业的安全分析报告。无论你是安全研究员还是逆向新手,都能大幅提升效率,告别重复劳动。
从脱壳到漏洞挖掘:用 MCP 打造全自动化 Android 应用安全分析流水线
分类: 移动安全
还在手动敲 ADB 命令脱壳、在 JADX 里反复搜索硬编码密钥?本文带你用 MCP 协议将 ADB、一键脱壳技能、Frida 和 JADX 串联成自动化流水线。只需一句话,AI 就能完成从设备连接、脱壳到代码审计的全流程,自动挖掘硬编码凭证、不安全 API 和导出组件风险,最终输出一份专业的安全分析报告。无论你是安全研究员还是逆向新手,都能大幅提升效率,告别重复劳动。
写在前面
在 APK 渗透测试中,经常需要完成这样一套完整流程:拿到一个加固的 APK → 脱壳 → 反编译 → 寻找漏洞。传统的做法是把这些环节拆成孤岛,每个环节都需要手动操作和切换工具,极其耗时。直到我把 MCP(Model Context Protocol)和多个社区技能包组合成一套自动化流水线,才真正实现了“一句话完成从脱壳到漏洞发现”的全流程。
这篇文章是我对这套流水线的完整记录。我会从 ADB 封装开始,一路讲到如何用 AI 驱动 JADX 自动挖掘硬编码凭证和高危漏洞。
一、从“手动挡”到“自动挡”:我们需要什么?
一个完整的 Android 应用安全分析流程通常包括:
- 环境准备: 连接设备,确认目标应用。
- 拉取 APK: 从设备中提取 APK 文件。
- 脱壳: 如果应用加固,需要先从内存中 Dump 出解密后的 DEX。
- 反编译: 将 DEX 转换为可读的 Java 代码。
- 漏洞挖掘: 在代码中搜索硬编码凭证、不安全 API、导出组件等。
- 报告生成: 整理发现,输出结构化的安全报告。
这些步骤中充满了重复性劳动:记 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 做了什么
这个工具将脱壳的整个流程自动化了:
- 环境检查: 确认 ADB 可用,设备已连接且已 Root。
- 目标锁定: 自动获取当前顶层 Activity 的包名,或使用用户指定的包名。
- 脱壳执行: 利用 Frida 或定制脚本从内存中 dump 出 DEX。
- 文件拉取: 将 dump 出的 DEX 文件自动 pull 到本地。
- 清理现场: 删除设备上的临时文件,避免残留。
所有这一切,只需要一句话。
脱壳成功
五、第三步:集成 JADX MCP,获得代码分析能力
脱壳只是第一步。拿到 DEX 后,我们还需要反编译和分析代码。为此,我集成了 zinja-coder 开发的 JADX MCP。
5.1 安装与配置
JADX MCP 的发布地址是:
https://github.com/zinja-coder/jadx-ai-mcp/releases
安装步骤:
- 下载对应平台的 Release 包。
- 确保 JADX-GUI 已打开并加载了目标 APK 或 DEX 文件。
- 启动 JADX MCP Server(通常是一个本地 HTTP 服务,默认端口 8080)。
- 在 MCP 客户端中配置该服务。
5.2 JADX MCP 提供的核心能力
JADX MCP 暴露了以下 35+ 个关键工具,让 AI 能够像使用 IDE 一样操作 JADX-GUI。按功能可划分为六类:
类别 | 工具 | 功能 |
获取当前上下文 |
| 获取 JADX-GUI 中当前选中的类 |
| 获取当前选中的文本内容 | |
类/方法/字段查询 |
| 列出所有类名 |
| 获取指定类的 Java 源码 | |
| 获取指定类的 Smali 代码 | |
| 根据方法名获取方法详细信息 | |
| 列出某个类的所有方法 | |
| 按名称在所有类中搜索方法 | |
| 按关键字搜索类名 | |
| 列出某个类的所有字段 | |
资源与清单 |
| 获取解析后的 AndroidManifest.xml |
| 获取 Manifest 中的组件信息 | |
| 获取应用中的所有字符串资源 | |
| 列出所有资源文件名 | |
| 获取指定资源文件的内容 | |
应用结构 |
| 获取启动 Activity 类名 |
| 获取主 Application 类及其引用类名 | |
| 获取主 Application 相关类的源码 | |
| 获取包结构树 | |
交叉引用(Xrefs) |
| 追踪某个类的所有引用 |
| 追踪某个方法的所有调用链 | |
| 追踪某个字段的所有引用 | |
重命名(去混淆) |
| 重命名指定类 |
| 重命名指定方法 | |
| 重命名字段 | |
| 重命名包 | |
| 重命名局部变量 | |
调试辅助 |
| 获取当前调试栈帧(需调试模式) |
| 获取当前线程列表 | |
| 获取当前变量的值 | |
缓存与清理 |
| 获取 JADX 缓存统计信息 |
| 清理 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 将严格按此流程执行:
第一阶段:环境准备与设备连接
- 检查连接: 使用 ADB MCP 的
get_devices工具,确认是否有设备已连接。 - 获取目标: 如果用户未指定包名,使用 ADB MCP 获取当前前台应用的包名;如果用户已指定,则直接使用指定的包名。
- 获取 APK 路径: 使用 ADB MCP 的
list_packages工具,找到目标包名对应的 APK 在设备上的完整路径。 - 拉取 APK: 使用 ADB MCP 的
pull工具,将 APK 文件从设备拉取到本地工作目录。
第二阶段:自动化脱壳(如遇加固)
- 检测加固: 使用 JADX MCP 的
get_android_manifest工具初步检查 APK,或使用 ADB MCP 检查应用进程。若发现加固迹象(如存在libjiagu.so、libsec.so等),进入脱壳流程。 - 启动应用: 使用 ADB MCP 启动目标应用,并等待其进入主界面,确保壳已完成解密。
- 执行脱壳: 调用
rev-dex-dumper技能,通过 AI 对话触发自动脱壳。例如,发送指令:“帮我脱壳 [目标包名]”。 - 拉取 DEX: 脱壳完成后,使用 ADB MCP 将生成的 DEX 文件从设备拉取到本地工作目录。如果未检测到加固,则跳过脱壳阶段,直接使用原始 APK。
第三阶段:智能反编译与分析
- 加载项目: 在 JADX-GUI 中打开脱壳后的 DEX 文件或原始 APK,并确保 JADX MCP Server 已运行。
- 全局敏感信息狩猎: 利用 JADX MCP 的能力,执行以下自动化分析任务:
- 硬编码凭证搜索: 在全部代码中搜索 API Key、Token、密码、密钥等硬编码字符串。参考模式:
sk-*、AKIA*、password =、secret =、Bearer等。 - 不安全 API 检测: 识别并列出不安全的 API 使用,如
SQLiteDatabase.execSQL()、HttpURLConnection、TrustManager的不安全实现等。 - 敏感权限与组件导出分析: 检查
AndroidManifest.xml,识别导出组件和危险权限。
- 深入漏洞分析: 对发现的可疑点,使用 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 技能包实现自动化。