Jadx MCP+Trae结合分析思路
通过将经典apk反编译工具jadx与MCP、trae等工具结合,提升安全人员的分析效率。
前言
通过将经典apk反编译工具jadx与MCP、trae等工具结合,提升安全人员的分析效率。环境搭建
1、jadx工具
下载jadx1.5版本的
下载地址:https://github.com/skylot/jadx/releases/tag/v1.5.3

2、jadx mcp
访问jadx mcp地址下载jadx-ai-mcp-6.0.0.jar与jadx-mcp-server-v6.0.0.zip
下载地址:https://github.com/zinja-coder/jadx-ai-mcp/releases

下载地址:https://github.com/zinja-coder/jadx-ai-mcp/releases

进入插件功能

点击安装插件,选择jadx-ai-mcp-6.0.0.jar的路径安装即可

安装成功之后,如下所示

安装失败则是如下的错误。出现这个错误的原因有可能是java版本过低

建议下载使用自带jre环境的jadx

执行以下命令,安装mcp
pip install -r requirements.txt
速度多慢可使用以下命令
pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/
启动mcp

3、Trae
访问下载Trae并安装好
下载地址:https://www.trae.cn/
点击手动添加

复制下面的内容,填入到MCP配置中。
注意: command 后面跟的是python.exe的路径 args后面是jadx-mcp-server.py的路径,记得替换为自己的路径
{
"mcpServers": {
"jadx-mcp-server": {
"command": "D:\\Python311\\python.exe",
"args": [
"D:\\security\\app\\jadx-gui-1.5.3-with-jre-win\\jadx-mcp-server\\jadx_mcp_server.py"
]
}
}
}
创建智能体

打开一个apk验证一下mcp查看是否成功

如果没有成功连接,Trae则是如下的样子,没有直接读取Jadx反编译过的代码,而是要手动去执行命令来读取

实例
小试牛刀-CTF-easyEZbaby_app
https://adworld.xctf.org.cn/challenges/list

打开Trae连接MCP。
输入提示词:搜索apk当中是否存在与flag相关的代码
得到如下结果:
输出了flag的验证机制以及计算后的flag结果:flag{7afc4fcefd6feb1onmlkjihgfedcba}


但是给出的flag并不对。于是让其直接输出Toast.makeText对应的函数

onClick函数主要是并且还在注释里给出了新的结果flag{7afc4fcefd6feb1onmlkjihgfedcba},可惜结果依旧不对。
@Override // android.view.View.OnClickListener
public void onClick(View view) {
// 从用户名输入框获取用户输入的文本并转换为字符串
String string = this.username.getText().toString();
// 从密码输入框获取用户输入的文本并转换为字符串
String string2 = this.password.getText().toString();
// 验证用户名和密码是否正确
// checkUsername: 验证用户名是否为 "zhishixuebao" 的MD5哈希的偶数位
// checkPass: 验证密码是否为经过字符变换算法计算出的正确密码
if (checkUsername(string) && checkPass(string2)) {
// 登录成功,显示"登录成功"提示
Toast.makeText(this, "登录成功", 0).show();
// 显示flag,格式为 flag{用户名+密码}
// 例如:flag{7afc4fcefd6feb1onmlkjihgfedcba}
Toast.makeText(this, "flag{" + string + string2 + "}", 0).show();
return;
}
// 登录失败,显示"登录失败"提示
Toast.makeText(this, "登录失败", 0).show();
}继续让其输出checkUsername函数注释
checkUsername函数的主要作用是使用MD5算法对固定字符串 "zhishixuebao" 进行哈希,提取哈希的偶数位字符
完整注释如下:
public boolean checkUsername(String str) throws NoSuchAlgorithmException {
if (str != null) {
try {
if (str.length() != 0 && str != null) {
// 创建MD5哈希实例
MessageDigest messageDigest = MessageDigest.getInstance("MD5");
messageDigest.reset();
// 对固定字符串"zhishixuebao"进行MD5哈希
messageDigest.update("zhishixuebao".getBytes());
// 将哈希结果转换为十六进制字符串
String hexString = toHexString(messageDigest.digest(), "");
// 提取MD5结果的偶数位字符(第0, 2, 4, 6...位)
StringBuilder sb = new StringBuilder();
for (int i = 0; i < hexString.length(); i += 2) {
sb.append(hexString.charAt(i));
}
// 将提取的偶数位字符串与用户输入进行比较
return (sb.toString()).equals(str);
}
return false;
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
return false;
}继续让其输出checkPass函数

checkPass函数主要用于验证用户输入的密码是否正确。它通过字符变换算法来验证密码,只有经过特定变换后所有字符都变成 '0' 的密码才能通过验证。
完整的代码注释如下:
public boolean checkPass(String str) {
// 检查输入是否为null
if (str == null) {
return false;
}
// 将字符串转换为字符数组
char[] charArray = str.toCharArray();
// 检查密码长度是否为15个字符
if (charArray.length != 15) {
return false;
}
// 遍历每个字符进行变换验证
for (int i = 0; i < charArray.length; i++) {
// 对每个字符进行变换:charArray[i] = (char) ((((255 - i) + 2) - 98) - charArray[i])
// 简化后:charArray[i] = (char) ((159 - i) - charArray[i])
charArray[i] = (char) ((((255 - i) + 2) - 98) - charArray[i]);
// 检查变换后的字符是否为'0'
if (charArray[i] != '0' || i >= 15) {
return false;
}
}
// 所有字符变换后都是'0',验证通过
return true;
}此时MCP给出的flag依旧不对,于是直接返回Jadx查看代码,验证是否是因为mcp读取的apk反编译代码不准确所导致。验证之后,发现MCP读取的代码并无任何问题。

既然MCP读取的代码没有,那么应该是提示词表述存在问题。
存在两种可能性:
1、在中文语境下,有时“偶数位”指的是自然顺序的偶数位,即第2、4、6...位
2、在计算机编程当中,字符串索引从0开始,那么偶数索引(即索引为偶数)通常被称为“偶数位置”
返回trae中,输入提示词:如何得到7afc4fcefd6feb1的,提供计算代码

最终验证结果成功,使用的如下代码:
import hashlib
# 计算用户名
md5_hash = hashlib.md5('zhishixuebao'.encode()).hexdigest()
username = md5_hash[::2]
# 计算密码
password = ""
for i in range(15):
password += chr(111 - i)
# 生成flag
flag = f"flag{{{username}{password}}}"
print(f"MD5哈希: {md5_hash}")
print(f"用户名: {username}")
print(f"密码: {password}")
print(f"Flag: {flag}")
同时让其输出了计算出错的原因

那么现在经过人工的排查,得到了正确的结果:flag{7afc4fcefc616ebdonmlkjihgfedcba}

提交正确的flag,成功获取到了CTF题目的积分。

在实例APP当中的分析思路
打开app进行查看,发现是数字壳。

代码无法正常反编译查看

通过相关手段脱壳后,再打开已经可以看见反编译代码了。

丢给MCP分析功能,得到apk的主要功能。
- 位置选择 : 集成百度地图,支持地图选点、地址搜索、POI搜索
- 应用选择 : 可选择单个或多个应用进行虚拟定位
- 位置控制 : 支持摇杆控制、路线模拟、自动移动
- 精确定位 : 集成气压传感器获取真实海拔高度
- 多定位源 : 支持GPS、网络、fused等多种定位方式
该app存在强制性的条款验证,需要手动输入相关许可,才能使用。

让MCP找到所需的代码以及函数信息

通过MCP分析到使用条款的验证原理以及对应的位置

继续下去,得到了与SharedPreference有关的验证代码。

同时提供了对应的代码位置以及绕过思路,那么通过MCP可以得知其使用条款的强制性同意存在被绕过的可能性,极大的提升了相关安全工作者的效率,减轻工作强度。大佬们可自行探索更加具体的分析及利用思路。

Jadx MCP源码分析
使用vs code打开源码,发现其主要拥有1个入口文件:jadx_mcp_server.py;6个功能工具模块:class_tools.py、debug_tools.py、refactor_tools.py、resource_tools.py、search_tools.py、xrefs_tools.py;1个配置文件:config.py
主要结构如下:
JADX-MCP-SERVER/
├── banner.py
├── PaginationUtils.py
├── jadx_mcp_server.py
├── src/
│ └── __pycache__/
├── server/
│ └── __pycache__/
└── tools/
├── __init__.py
├── config.py
├── class_tools.py
├── debug_tools.py
├── refactor_tools.py
├── resource_tools.py
├── search_tools.py
└── xrefs_tools.py
config.py
首先查看以下配置文件

查看后得知其作用主要是:
通过set_jadx_port()函数动态修改JADX插件的连接端口;

health_ping()函数执行JADX插件的健康检查,打印连接尝试信息;

get_from_jadx()函数用于从JADX插件获取数据。

执行流程图如下:

class_tools.py
class_tools.py主要是通过JADX反编译,分析Android应用类结构的工具模块。
首先是通过fetch_current_class()获取JADX-GUI中当前打开的类与get_selected_text()获取代码编辑器中选中的文本

然后通过get_class_source()获取指定类的完整Java源代码。例如com.example.MainActivity
以及get_methods_of_class()列出类中的所有方法与get_fields_of_class()列出类中的所有字段

再使用get_smali_of_class()获取类的Smali

再分别通过get_all_classes()获取项目中所有类;get_main_application_classes_names()获取主应用包中的所有类名;get_main_activity_class()获取主活动类

流程图如下:

debug_tools.py
debug_tools.py主要是通过与JADX调试器集成,提供了对执行状态、线程和变量的实时检查功能。

refactor_tools.py
refactor_tools.py主要是提高代码可读性。通过重命名类、方法、字段和包,帮助分析人员更好地理解混淆后的代码结构。

假设我们有一些字段信息,或许可以尝试添加一些适合自己的重命名习惯 。例如:
async def rename_fields_based_on_type():
"""
基于字段类型重命名
"""
fields_to_rename = [
{
"class_name": "com.example.UserManager",
"field_name": "a",
"field_type": "String",
"new_name": "userName"
},
{
"class_name": "com.example.UserManager",
"field_name": "b",
"field_type": "int",
"new_name": "userId"
},
{
"class_name": "com.example.Config",
"field_name": "c",
"field_type": "boolean",
"new_name": "isEnabled"
}
]
operations = []
for field_info in fields_to_rename:
print(f"重命名字段: {field_info['class_name']}.{field_info['field_name']} -> {field_info['new_name']}")
result = await rename_field(
field_info["class_name"],
field_info["field_name"],
field_info["new_name"]
)
operations.append({
"class": field_info["class_name"],
"field": {
"old": field_info["field_name"],
"new": field_info["new_name"],
"type": field_info["field_type"]
},
"result": "成功" if "error" not in result else "失败"
})
return {
"field_renames": operations,
"summary": f"共重命名 {len(operations)} 个字段"
}resource_tools.py
用于分析Android应用的资源文件,包括AndroidManifest.xml、字符串资源以及其他各类资源文件

search_tools.py
search_tools文件提供在反编译的Android代码中进行搜索的能力,支持跨整个APK搜索类、方法和关键字。

xrefs_tools.py
xrefs_tools.py主要提供在Android代码的交叉引用分析功能,用于追踪类、方法和字段的引用关系。与IDA Pro中按X键交叉引用查看相关调用的函数功能类似。

jadx_mcp_server.py
jadx_mcp_server.py的主要作用如下:
【启动类函数】(程序运行必备,无则服务无法启动)
main() → 程序唯一入口,解析命令行参数、配置端口、健康检查、启动服务
mcp = FastMCP(...) → 初始化 MCP 服务核心实例,服务的「心脏」
【注册类函数】(6 大模块)
所有注册的异步函数都是「空壳转发」,作用是:将工具模块的业务能力注册为 MCP 服务的可调用接口,供外部调用。
按模块分类的核心作用如下:
类分析工具 → 查类 / 方法 / 字段的源码、Smali、主入口类,逆向基础
搜索工具 → 精准查方法、全局搜方法名、全局搜关键词,线索落地核心
资源工具 → 查 Manifest、字符串、资源文件,逆向线索源头
重构工具 → 重命名类 / 方法 / 字段 / 包名,提升代码可读性,唯一写操作
调试工具 → 查栈帧、线程、变量,获取运行时明文数据,进阶逆向
交叉引用工具 → 查类 / 方法 / 字段的引用关系,梳理业务链路,高阶逆向
【依赖类函数】(底层支撑,无则注册 / 启动逻辑无法执行)
argparse.ArgumentParser() → 解析命令行参数
config.set_jadx_port() → 配置 JADX 插件端口
config.health_ping() → 测试与 JADX 的连通性
mcp.run() → 启动 MCP 服务,监听请求
该文件的流程图如下:

完整代码如下:
#!/usr/bin/env python3
# /// script
# requires-python = ">=3.10" # 声明项目运行的Python版本要求:必须3.10及以上
# dependencies = [ "fastmcp", "httpx" ] # 声明项目的核心第三方依赖包
# ///
"""
Copyright (c) 2025 jadx mcp server developer(s) (https://github.com/zinja-coder/jadx-ai-mcp)
See the file 'LICENSE' for copying permission
"""
# ====================== 导入项目核心依赖模块 ======================
# 导入python内置命令行参数解析库,用于解析启动服务时的命令行参数
import argparse
# 导入python内置系统库,预留扩展使用,当前未实际调用
import sys
# 从fastmcp框架导入核心的FastMCP服务类,所有MCP服务能力的基石
from fastmcp import FastMCP
# 导入服务启动时打印的ASCII艺术横幅,纯美化展示作用
from src.banner import jadx_mcp_server_banner
# 导入项目内部核心模块:config=配置/通信模块,tools=所有业务工具的总入口
from src.server import config, tools
# ====================== 初始化MCP服务核心实例 ======================
# 创建FastMCP服务实例,传入服务名称标识,后续所有工具注册/服务启动都基于此实例
mcp = FastMCP("JADX-AI-MCP Plugin Reverse Engineering Server")
# ====================== 批量导入所有业务工具的实现方法 ======================
# 遵循FastMCP标准规范,导入src/server/tools下6大工具模块的全部业务实现方法
# 所有导入的方法都是真正的业务逻辑实现,下方注册的函数仅做转发
from src.server.tools.class_tools import (
fetch_current_class, get_selected_text, get_class_source,
get_all_classes, get_methods_of_class, get_fields_of_class, get_smali_of_class,
get_main_application_classes_names, get_main_application_classes_code, get_main_activity_class
)
from src.server.tools.search_tools import (
get_method_by_name, search_method_by_name, search_classes_by_keyword
)
from src.server.tools.resource_tools import (
get_android_manifest, get_strings, get_all_resource_file_names,
get_resource_file
)
from src.server.tools.refactor_tools import (
rename_class, rename_method, rename_field, rename_package
)
from src.server.tools.debug_tools import (
debug_get_stack_frames, debug_get_threads, debug_get_variables
)
from src.server.tools.xrefs_tools import (
get_xrefs_to_class, get_xrefs_to_method, get_xrefs_to_field
)
# ====================== 核心:所有工具方法的注册【对外暴露的MCP接口】 ======================
# @mcp.tool() 是FastMCP的核心注册装饰器:将下方的异步函数注册为MCP服务的可调用工具
# 所有注册的函数均为【空壳转发函数】:无业务逻辑,仅将请求转发到对应工具模块的实现方法
# 所有函数统一返回dict结构化数据,入参与工具模块的实现方法完全一致,纯透传无修改
# --------------------- 【类分析工具 class_tools 注册】 ---------------------
@mcp.tool()
async def fetch_current_class() -> dict:
"""Fetch the currently selected class and its code from the JADX-GUI plugin."""
return await tools.class_tools.fetch_current_class()
@mcp.tool()
async def get_selected_text() -> dict:
"""Returns the currently selected text in the decompiled code view."""
return await tools.class_tools.get_selected_text()
@mcp.tool()
async def get_all_classes(offset: int = 0, count: int = 0) -> dict:
"""Returns a list of all classes in the project with pagination support."""
return await tools.class_tools.get_all_classes(offset, count)
@mcp.tool()
async def get_class_source(class_name: str) -> dict:
"""Fetch the Java source of a specific class."""
return await tools.class_tools.get_class_source(class_name)
@mcp.tool()
async def get_methods_of_class(class_name: str) -> dict:
"""List all method names in a class."""
return await tools.class_tools.get_methods_of_class(class_name)
@mcp.tool()
async def get_fields_of_class(class_name: str) -> dict:
"""List all field names in a class."""
return await tools.class_tools.get_fields_of_class(class_name)
@mcp.tool()
async def get_smali_of_class(class_name: str) -> dict:
"""Fetch the smali representation of a class."""
return await tools.class_tools.get_smali_of_class(class_name)
@mcp.tool()
async def get_main_application_classes_names() -> dict:
"""Fetch main application classes' names from Manifest package."""
return await tools.class_tools.get_main_application_classes_names()
@mcp.tool()
async def get_main_application_classes_code(offset: int = 0, count: int = 0) -> dict:
"""Fetch main application classes' code with pagination."""
return await tools.class_tools.get_main_application_classes_code(offset, count)
@mcp.tool()
async def get_main_activity_class() -> dict:
"""Fetch the main activity class from AndroidManifest.xml."""
return await tools.class_tools.get_main_activity_class()
# --------------------- 【全局搜索工具 search_tools 注册】 ---------------------
@mcp.tool()
async def get_method_by_name(class_name: str, method_name: str) -> dict:
"""Fetch the source code of a method from a specific class."""
return await tools.search_tools.get_method_by_name(class_name, method_name)
@mcp.tool()
async def search_method_by_name(method_name: str) -> dict:
"""Search for a method name across all classes."""
return await tools.search_tools.search_method_by_name(method_name)
@mcp.tool()
async def search_classes_by_keyword(search_term: str, offset: int = 0, count: int = 20) -> dict:
"""Search for classes whose source code contains a specific keyword."""
return await tools.search_tools.search_classes_by_keyword(search_term, offset, count)
# --------------------- 【资源分析工具 resource_tools 注册】 ---------------------
@mcp.tool()
async def get_android_manifest() -> dict:
"""Retrieve and return the AndroidManifest.xml content."""
return await tools.resource_tools.get_android_manifest()
@mcp.tool()
async def get_strings(offset: int = 0, count: int = 0) -> dict:
"""Retrieve contents of strings.xml files."""
return await tools.resource_tools.get_strings(offset, count)
@mcp.tool()
async def get_all_resource_file_names(offset: int = 0, count: int = 0) -> dict:
"""Retrieve all resource files names."""
return await tools.resource_tools.get_all_resource_file_names(offset, count)
@mcp.tool()
async def get_resource_file(resource_name: str) -> dict:
"""Retrieve resource file content."""
return await tools.resource_tools.get_resource_file(resource_name)
# --------------------- 【代码重构工具 refactor_tools 注册 - 唯一写操作】 ---------------------
@mcp.tool()
async def rename_class(class_name: str, new_name: str) -> dict:
"""Renames a specific class."""
return await tools.refactor_tools.rename_class(class_name, new_name)
@mcp.tool()
async def rename_method(method_name: str, new_name: str) -> dict:
"""Renames a specific method."""
return await tools.refactor_tools.rename_method(method_name, new_name)
@mcp.tool()
async def rename_field(class_name: str, field_name: str, new_name: str) -> dict:
"""Renames a specific field."""
return await tools.refactor_tools.rename_field(class_name, field_name, new_name)
@mcp.tool()
async def rename_package(old_package_name: str, new_package_name: str) -> dict:
"""Renames a package and all its classes."""
return await tools.refactor_tools.rename_package(old_package_name, new_package_name)
# --------------------- 【调试工具 debug_tools 注册 - 运行时动态数据】 ---------------------
@mcp.tool()
async def debug_get_stack_frames() -> dict:
"""Get current stack frames (call stack)."""
return await tools.debug_tools.debug_get_stack_frames()
@mcp.tool()
async def debug_get_threads() -> dict:
"""Get all threads in the debugged process."""
return await tools.debug_tools.debug_get_threads()
@mcp.tool()
async def debug_get_variables() -> dict:
"""Get current variables when process is suspended."""
return await tools.debug_tools.debug_get_variables()
# --------------------- 【交叉引用工具 xrefs_tools 注册 - 高阶链路分析】 ---------------------
@mcp.tool()
async def get_xrefs_to_class(class_name: str, offset: int = 0, count: int = 20) -> dict:
"""Find all references to a class."""
return await tools.xrefs_tools.get_xrefs_to_class(class_name, offset, count)
@mcp.tool()
async def get_xrefs_to_method(class_name: str, method_name: str, offset: int = 0, count: int = 20) -> dict:
"""Find all references to a method."""
return await tools.xrefs_tools.get_xrefs_to_method(class_name, method_name, offset, count)
@mcp.tool()
async def get_xrefs_to_field(class_name: str, field_name: str, offset: int = 0, count: int = 20) -> dict:
"""Find all references to a field."""
return await tools.xrefs_tools.get_xrefs_to_field(class_name, field_name, offset, count)
# ====================== 程序主入口函数 ======================
# Python程序的核心入口,执行 python3 main.py 时自动调用该函数
# 负责:解析命令行参数、配置服务、健康检查、启动MCP服务
def main():
# 创建命令行参数解析器对象,指定程序名称
parser = argparse.ArgumentParser("MCP Server for Jadx")
# 添加命令行参数:--http 开启HTTP流传输模式,默认关闭
parser.add_argument("--http", help="Serve MCP Server over HTTP stream.", action="store_true", default=False)
# 添加命令行参数:--port 指定HTTP模式的端口号,默认8651,强制为整数类型
parser.add_argument("--port", help="Port for --http (default:8651)", default=8651, type=int)
# 添加命令行参数:--jadx-port 指定JADX插件的通信端口,默认8650,强制为整数类型
parser.add_argument("--jadx-port", help="JADX AI MCP Plugin port (default:8650)", default=8650, type=int)
# 解析用户传入的所有命令行参数,生成参数对象
args = parser.parse_args()
# 将解析到的JADX端口号配置到全局config模块,供底层通信使用
config.set_jadx_port(args.jadx_port)
# 打印服务启动横幅,添加异常捕获:防止横幅加载失败导致服务启动中断,提升健壮性
try:
print(jadx_mcp_server_banner())
except:
# 横幅加载失败时,打印极简的服务信息,保证服务正常启动
print("[JADX AI MCP Server] v3.3.5 | MCP Port:", args.port, "| JADX Port:", args.jadx_port)
# 执行JADX插件连通性健康检查,提前发现端口配置错误/JADX未启动等问题
print("Testing JADX AI MCP Plugin connectivity...")
result = config.health_ping()
print(f"Health check result: {result}")
# 根据命令行参数,选择对应的模式启动MCP服务
if args.http:
# 开启HTTP流传输模式启动服务,指定运行端口
mcp.run(transport="streamable-http", port=args.port)
else:
# 默认模式:原生MCP协议启动服务,本地通信性能最优
mcp.run()
# ====================== Python程序启动固定入口 ======================
# 固定语法:当该文件被直接执行时,调用main()函数启动服务
# 当该文件被作为模块导入时,不执行任何代码,避免服务被误启动
if __name__ == "__main__":
main()整个工具的调用流程如下:

经过对源码的简单分析,安全人员或许可以加入一些自己的想法。
结合jadx、MCP及Trae实现高效APK逆向分析,提升安全研究效率。
由 AI 根据全文自动生成,仅供参考,以原文为准