前言

通过将经典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()

整个工具的调用流程如下:

经过对源码的简单分析,安全人员或许可以加入一些自己的想法。