zinja-coder/jadx-ai-mcpPlugin para JADX para integrar el servidor MCP
⚡ Servidor MCP totalmente automatizado + plugin de JADX creado para comunicarse con LLMs a través de MCP para analizar APKs de Android usando LLMs como Claude: descubre vulnerabilidades, analiza APKs y realiza ingeniería inversa sin esfuerzo.
Gracias a estas maravillosas personas por sus contribuciones ⭐
JADX-AI-MCP es un plugin para el descompilador JADX que se integra directamente con Model Context Protocol (MCP) para proporcionar soporte de ingeniería inversa en vivo con LLMs como Claude.
Piensa: "Descompilar → Revisión de código consciente del contexto → Recomendaciones de IA" — todo en tiempo real.
sequenceDiagram LLM CLIENT->>JADX MCP SERVER: INVOKE MCP TOOL JADX MCP SERVER->>JADX AI MCP PLUGIN: INVOKE HTTP REQUEST JADX AI MCP PLUGIN->>REQUEST HANDLERS: INVOKE HTTP REQUEST HANDLER REQUEST HANDLERS->>JADX GUI: PERFORM ACTION/GATHER DATA JADX GUI->>REQUEST HANDLERS: ACTION PERFORMED/DATA GATHERED REQUEST HANDLERS->>JADX AI MCP PLUGIN: CRAFT HTTP RESPONSE JADX AI MCP PLUGIN->>JADX MCP SERVER:HTTP RESPONSE JADX MCP SERVER->>LLM CLIENT: MCP TOOL RESULT
### ¡Mira las demostraciones!
- **Realizar un análisis rápido**
https://github.com/user-attachments/assets/b65c3041-fde3-4803-8d99-45ca77dbe30a
- **Encontrar vulnerabilidades rápidamente**
https://github.com/user-attachments/assets/c184afae-3713-4bc0-a1d0-546c1f4eb57f
- **Soporte para múltiples agentes de IA**
https://github.com/user-attachments/assets/6342ea0f-fa8f-44e6-9b3a-4ceb8919a5b0
- **Ejecuta con tu cliente LLM favorito**
https://github.com/user-attachments/assets/b4a6b280-5aa9-4e76-ac72-a0abec73b809
- **Analizar los recursos del APK**
https://github.com/user-attachments/assets/f42d8072-0e3e-4f03-93ea-121af4e66eb1
- **Tu asistente de IA durante la depuración de APK usando JADX**
https://github.com/user-attachments/assets/2b0bd9b1-95c1-4f32-9b0c-38b864dd6aec
Es una combinación de dos herramientas:
1. JADX-AI-MCP
2. [JADX MCP SERVER](https://github.com/zinja-coder/jadx-mcp-server)
## 🤖 ¿Qué es JADX-MCP-SERVER?
**JADX MCP Server** es un servidor Python independiente que interactúa con un plugin `JADX-AI-MCP` (ver: [jadx-ai-mcp](https://github.com/zinja-coder/jadx-ai-mcp)) a través de MCP (Model Context Protocol). Permite que los LLM se comuniquen en tiempo real con el contexto de la aplicación Android decompilada.
---
## Otros proyectos en Zin MCP Suite
- **[APKTool-MCP-Server](https://github.com/zinja-coder/apktool-mcp-server)**
- **[JADX-MCP-Server](https://github.com/zinja-coder/jadx-mcp-server)**
- **[ZIN-MCP-Client](https://github.com/zinja-coder/zin-mcp-client)**
## Herramientas MCP actuales
Las siguientes herramientas MCP están disponibles:
- `fetch_current_class()` — Obtener el nombre de la clase y el código fuente completo de la clase seleccionada
- `get_selected_text()` — Obtener el texto actualmente seleccionado
- `get_all_classes()` — Listar todas las clases del proyecto
- `get_class_source()` — Obtener el código fuente completo de una clase determinada
- `get_method_by_name()` — Obtener el código fuente de un método
- `search_method_by_name()` — Buscar un método en todas las clases
- `search_classes_by_keyword()` — Buscar clases cuyo código fuente contenga una palabra clave específica (admite paginación)
- `get_methods_of_class()` — Listar los métodos de una clase
- `get_fields_of_class()` — Listar los campos de una clase
- `get_smali_of_class()` — Obtener el smali de la clase
- `get_main_activity_class()` — Obtener la actividad principal de jadx mencionada en el archivo AndroidManifest.xml.
- `get_main_application_classes_code()` — Obtener el código de todas las clases principales de la aplicación según el nombre del paquete definido en AndroidManifest.xml.
- `get_main_application_classes_names()` — Obtener los nombres de todas las clases principales de la aplicación según el nombre del paquete definido en AndroidManifest.xml.
- `get_android_manifest()` — Recuperar y devolver el contenido de AndroidManifest.xml.
- `get_manifest_component` - Recuperar un componente específico del manifiesto en lugar de todo el archivo de manifiesto
- `get_strings()` : Obtiene el archivo strings.xml
- `get_all_resource_file_names()` : Recupera todos los nombres de archivos de recursos existentes en la aplicación
- `get_resource_file()` : Recupera el contenido del archivo de recursos
- `rename_class()` : Cambia el nombre de la clase
- `rename_method()` : Cambia el nombre del método
- `rename_field()` : Cambia el nombre del campo
- `rename_package()` : Cambia el nombre de todo el paquete
- `rename_variable()` : Cambia el nombre de la variable dentro de un método
- `debug_get_stack_frames()` : Obtener los marcos de pila del depurador de jadx
- `debug_get_threads()` : Obtener información sobre los hilos del depurador de jadx
- `debug_get_variables()` : Obtener las variables del depurador de jadx
- `xrefs_to_class()` : Encuentra todas las referencias a una clase (devuelve referencias a nivel de método y de clase, admite paginación)
- `xrefs_to_method()` : Encuentra todas las referencias a un método (incluye métodos relacionados con override, admite paginación)
- `xrefs_to_field()` : Encuentra todas las referencias a un campo (devuelve métodos que acceden al campo, admite paginación)
---
## 🗒️ Ejemplos de Prompts
🔍 Comprensión básica del código
"Explica qué hace esta clase en un párrafo."
"Resume las responsabilidades de este método."
"¿Hay alguna ofuscación en esta clase?"
"Enumera todos los permisos de Android que esta clase podría requerir."
🛡️ Detección de vulnerabilidades
"¿Hay algún uso inseguro de API en este método?"
"Revisa esta clase en busca de secretos o credenciales hardcodeados."
"¿Este método sanea la entrada del usuario antes de usarla?"
"¿Qué vulnerabilidades de seguridad podría introducir este código?"
🛠️ Asistentes de ingeniería inversa
"Desofusca y renombra las clases y métodos a algo legible."
"¿Puedes inferir el propósito original de este método smali?"
"¿De qué librerías o SDK parece formar parte esta clase?"
"Dime qué clases contienen código relacionado con 'cifrado'?"
📦 Análisis estático
"Enumera todas las llamadas API relacionadas con la red en esta clase."
"Identifica las operaciones de E/S de archivos y sus riesgos potenciales."
"¿Este método filtra información del dispositivo o PII?"
🤖 Modificación de código con IA
"Refactoriza este método para mejorar la legibilidad."
"Añade comentarios a este código explicando cada paso."
"Reescribe este método Java en Python para analizarlo."
📄 Documentación y metadatos
"Genera comentarios de estilo Javadoc para todos los métodos."
"¿A qué paquete o componente de la aplicación probablemente pertenece esta clase?"
"¿Puedes identificar el tipo de componente de Android (Activity, Service, etc.)?"
🐞 Asistente del depurador```
"Fetch stack frames, varirables and threads from debugger and provide summary"
"Based the stack frames from debugger, explain the execution flow of the application"
"Based on the state of variables, is there security threat?"
[!NOTE]
Descarga tanto el archivo
jadx-ai-mcp-<version>.jarcomo el archivojadx-mcp-server-<version>.zip.```bash
https://github.com/zinja-coder/jadx-ai-mcp/releases
unzip jadx-ai-mcp-.zip
├jadx-mcp-server/ ├── jadx_mcp.py ├── requirements.txt ├── README.md ├── LICENSE
├jadx-ai-mcp-.jar
jadx plugins --install "github:zinja-coder:jadx-ai-mcp"
<div align="center">
<img alt="banner" height="480px" widht="620px" src="https://assets.kitploit.com/production/public/readmes/6657/1c2660639daf7352d2bdeafeb7b5e0846e3c0bed45846ee52256b7bf3d316386.png">
</div>
<div align="center">
<img alt="banner" height="480px" widht="620px" src="https://assets.kitploit.com/production/public/readmes/6657/ccc2cc3566566517abad1097711afad3c668a999dc105d82686c4ffb791eba3b.png">
</div>
<div align="center">
<img alt="banner" height="480px" widht="620px" src="https://assets.kitploit.com/production/public/readmes/6657/0f9770bc38f4234826a661e6d37bc205a801ad38380363fd4394a903bd35ff94.png">
</div>```bash
## 3. GUI method, download the .jar file and follow below steps shown in images
```bash
cd jadx-mcp-server
## a. Install uv (if you dont have it yet)
curl -LsSf https://astral.sh/uv/install.sh | sh ## b. OPTIONAL, if for any reasons, you get dependecy errors in jadx-mcp-server, Set up the environment uv venv source .venv/bin/activate # or .venv\Scripts\activate on Windows ## c. OPTIONAL Install dependencies uv pip install httpx fastmcp
## 🤖 2. Usar Claude Desktop
Asegúrate de que Claude Desktop esté ejecutándose con MCP habilitado.
Por ejemplo, he utilizado lo siguiente para Kali Linux: https://github.com/aaddrick/claude-desktop-debian
Configura y añade el servidor MCP al archivo LLM:```bash
nano ~/.config/Claude/claude_desktop_config.json
Para:
%APPDATA%\Claude\claude_desktop_config.json~/Library/Application Support/Claude/claude_desktop_config.jsonY el siguiente contenido en él:```json { "mcpServers": { "jadx-mcp-server": { "command": "///uv", "args": [ "--directory", "</PATH/TO/>jadx-mcp-server/", "run", "jadx_mcp_server.py" ] } } }
Reemplaza:
- `path/to/uv` con la ruta real a tu ejecutable `uv`
- `path/to/jadx-mcp-server` con la ruta absoluta donde clonaste este
repositorio
Luego, navega por el código e interactúa mediante indicaciones de revisión de código en tiempo real usando la integración incorporada.
**O**
o puedes instalar jadx_mcp_server directamente como ejecutable usando el siguiente comando:```
uv tool install git+https://github.com/zinja-coder/jadx-mcp-server
y luego puedes simplemente proporcionar jadx_mcp_server en la sección command de la configuración de mcp.
Si quieres configurar la herramienta MCP en Cherry Studio, puedes consultar la siguiente configuración.
- `path/to/jadx-mcp-server` con la ruta absoluta a donde clonaste este
repositorio
## 4. Usando LMStudio
También puedes usar JADX AI MCP Server con LM Studio configurando su archivo mcp.json. Aquí está la guía en video.
https://github.com/user-attachments/assets/b4a6b280-5aa9-4e76-ac72-a0abec73b809
## 5. Ejecutando en modo de flujo HTTP
También puedes usar Jadx en modo de flujo HTTP usando la opción `--http` con `jadx_mcp_server.py` como se muestra a continuación:```bash
uv run jadx_mcp_server.py --http
OR
uv run jadx_mcp_server.py --http --port 9999
Hay dos conexiones separadas y cada una tiene su propio host/puerto:``` ┌─────────────┐ --host / --port ┌──────────────────┐ --jadx-host / --jadx-port ┌──────────────────┐ │ LLM Client │ ◄──────────────────► │ jadx-mcp-server │ ──────────────────────────► │ JADX-GUI Plugin │ │ (Claude, │ Where the MCP server │ │ Where the MCP server looks │ (jadx-ai-mcp) │ │ Codex..) │ LISTENS for clients │ │ for the JADX plugin │ │ └─────────────┘ └──────────────────┘ └──────────────────┘
| Flag | Default | Controls |
|------|---------|----------|
| `--http` | off | Usa transporte HTTP en lugar de stdio |
| `--host` | `127.0.0.1` | **Dónde escucha el servidor MCP** (dirección de enlace para clientes LLM) |
| `--port` | `8651` | **En qué puerto escucha el servidor MCP** |
| `--jadx-host` | `127.0.0.1` | **Dónde encontrar el plugin de JADX** (la máquina objetivo con JADX-GUI) |
| `--jadx-port` | `8650` | **En qué puerto está el plugin de JADX** |
### Ejemplos de uso
**Escenario 1 — Todo en la misma máquina (el más común):**```bash
# Default: MCP server on localhost:8651, connects to JADX plugin on localhost:8650
uv run jadx_mcp_server.py --http
Escenario 2 — Contenedor Docker o WSL (servidor MCP accesible desde la red del host):```bash
uv run jadx_mcp_server.py --http --host 0.0.0.0
**Escenario 3 — JADX-GUI ejecutándose en una máquina diferente (por ejemplo, VM remota):**```bash
# MCP server runs locally, but connects to JADX plugin on a remote machine
uv run jadx_mcp_server.py --http --jadx-host 192.168.1.100
Escenario 4 — Configuración totalmente remota (todo en máquinas diferentes):```bash
uv run jadx_mcp_server.py --http --host 0.0.0.0 --port 9999 --jadx-host 192.168.1.100 --jadx-port 8652
> [!CAUTION]
> ### ⚠️ Advertencia de seguridad — Vinculación remota
>
> Cuando se usa `--host 0.0.0.0` (o cualquier dirección que no sea localhost), el servidor MCP se vincula a **todas las interfaces de red** mediante **HTTP plano sin autenticación**. Esto significa:
>
> - **Cualquier persona en la red** puede conectarse e invocar todas las herramientas MCP
> - **No hay cifrado TLS** — el tráfico puede ser interceptado
> - Un atacante puede usar el servidor para **leer código decompilado**, **renombrar clases/métodos** y **acceder a información de depuración**
>
> **Mitigaciones:**
> - Vincula solo a `0.0.0.0` en **redes confiables y aisladas** (p. ej., puente de Docker, VM local)
> - Usa un **firewall** para restringir el acceso al puerto MCP
> - Considera un **túnel SSH** en su lugar: `ssh -L 8651:127.0.0.1:8651 remote-host`
### Compatibilidad con el modo Stdio
> [!NOTE]
> Cuando se ejecuta en modo **stdio** (el predeterminado, sin `--http`), toda la salida legible para humanos (banner, comprobación de salud) se escribe en **stderr** para mantener **stdout** reservado para el flujo JSON-RPC de MCP. Esto garantiza compatibilidad con Codex, Claude Desktop y otros clientes MCP basados en stdio.
## 6. Configuración personalizada de puerto y host para JADX AI MCP Plugin
<img width="800" height="335" alt="image" src="https://assets.kitploit.com/production/public/readmes/6657/34e13964afba1fa722733838892491b2ec9ea2d11f2dfd4e8612aa62817dfa41.png" />
1. Configurar puerto: Configura el puerto en el que escuchará el plugin JADX AI MCP.
2. Puerto predeterminado: Revierte los cambios y escucha en el puerto predeterminado.
3. Reiniciar servidor: Fuerza el reinicio del servidor del plugin JADX AI MCP.
4. Estado del servidor: Comprueba el estado del servidor del plugin JADX AI MCP.
Para conectarse con JADX AI MCP Plugin ejecutándose en un puerto personalizado, se usará la opción `--jadx-port` como se muestra a continuación:```
uv run jadx_mcp_server.py --jadx-port 8652
Si el JADX AI MCP Plugin se ejecuta en una máquina diferente (p. ej., JADX en una VM remota, servidor MCP en tu host local), usa la opción --jadx-host:```bash
uv run jadx_mcp_server.py --jadx-host 192.168.1.100 --jadx-port 8650
### Referencia de la CLI — Comprender las banderas
Hay **dos conexiones separadas** y cada una tiene su propio host/puerto:```
┌─────────────┐ --host / --port ┌──────────────────┐ --jadx-host / --jadx-port ┌──────────────────┐
│ LLM Client │ ◄──────────────────► │ jadx-mcp-server │ ──────────────────────────► │ JADX-GUI Plugin │
│ (Claude, │ Where the MCP server │ │ Where the MCP server looks │ (jadx-ai-mcp) │
│ Codex..) │ LISTENS for clients │ │ for the JADX plugin │ │
└─────────────┘ └──────────────────┘ └──────────────────┘
Escenario 1 — Todo en la misma máquina (lo más común):```bash
uv run jadx_mcp_server.py --http
**Escenario 2 — Contenedor Docker o WSL (servidor MCP accesible desde la red del host):**```bash
# MCP server listens on ALL interfaces so the host can reach it
# JADX plugin is still on the same machine
uv run jadx_mcp_server.py --http --host 0.0.0.0
Escenario 3 — JADX-GUI ejecutándose en una máquina diferente (p. ej., VM remota):```bash
uv run jadx_mcp_server.py --http --jadx-host 192.168.1.100
**Escenario 4 — Configuración totalmente remota (todo en máquinas diferentes):**```bash
# MCP server listens on all interfaces on port 9999
# JADX plugin is on a different machine at 192.168.1.100:8652
uv run jadx_mcp_server.py --http --host 0.0.0.0 --port 9999 --jadx-host 192.168.1.100 --jadx-port 8652
La configuración MCP para el puerto jadx personalizado será la siguiente para claude:``` { "mcpServers": { "jadx-mcp-server": { "command": "/path/to/uv", "args": [ "--directory", "/path/to/jadx-mcp-server/", "run", "jadx_mcp_server.py", "--jadx-port", "8652" ] } } }
## Pruébalo
1. Ejecuta jadx-gui y carga cualquier archivo .apk
2. Inicia claude - Debes ver el símbolo del martillo
3. Haz clic en el símbolo del `martillo` y deberías ver algo como lo siguiente:
4. Ejecuta el siguiente prompt:```text
fetch currently selected class and perform quick sast on it
Este plugin permite un control total sobre la GUI y el modelo interno del proyecto para soportar una integración más profunda con LLM, incluyendo:
Los archivos relacionados con JADX-AI-MCP se encuentran en este repositorio.
Los archivos relacionados con jadx-mcp-server se pueden encontrar aquí.
Abre un issue con la plantilla correspondiente.
Probado en Claude Desktop Client, ¡el soporte para otras IA se probará pronto!
Este proyecto es un plugin para JADX, un increíble descompilador de Android de código abierto creado y mantenido por @skylot. Toda la lógica principal de descompilación les pertenece. Yo solo lo he extendido para soportar mi servidor MCP con capacidades de IA.
El README.md original de JADX se incluye aquí en este repositorio como referencia y crédito.
Este servidor MCP es posible gracias a la extensibilidad de JADX-GUI y a la increíble comunidad de ingeniería inversa de Android.
También un enorme agradecimiento a @aaddrick por desarrollar Claude Desktop para Linux basado en Debian.
Y por último, gracias a @anthropics por desarrollar el Model Context Protocol y al equipo de @FastMCP.
Además de esto, un enorme agradecimiento a todos los proyectos de código abierto que sirven como dependencias para este proyecto y que lo han hecho posible.
Este proyecto utiliza las siguientes librerías increíbles.
Plugin - Java
Servidor MCP - Python
JADX-AI-MCP y todos los proyectos relacionados heredan la Licencia Apache 2.0 del repositorio original de JADX.
Descargo de responsabilidad
Las herramientas jadx-ai-mcp y jadx_mcp_server están destinadas estrictamente a fines educativos, de investigación y de evaluación ética de la seguridad. Se proporcionan "tal cual", sin garantías de ningún tipo, ya sean expresas o implícitas. Los usuarios son los únicos responsables de asegurarse de que su uso de estas herramientas cumpla con todas las leyes, regulaciones y pautas éticas aplicables.
Al usar jadx-ai-mcp o jadx_mcp_server, aceptas utilizarlas únicamente en entornos que estés autorizado a probar, como aplicaciones que poseas o para las que tengas permiso explícito de análisis. Cualquier uso indebido de estas herramientas para ingeniería inversa no autorizada, infracción de derechos de propiedad intelectual o actividades maliciosas está estrictamente prohibido.
Los desarrolladores de jadx-ai-mcp y jadx_mcp_server no serán responsables de ningún daño, pérdida de datos, consecuencias legales u otras consecuencias derivadas del uso o mal uso de estas herramientas. Los usuarios asumen toda la responsabilidad por sus acciones y cualquier impacto causado por su uso.
Usa con responsabilidad. Respeta la propiedad intelectual. Sigue las prácticas éticas de hacking.
Hecho con ❤️ para las comunidades de ingeniería inversa e IA.
| Flag | Default | Controles |
|---|
--http | off | Usa transporte HTTP en lugar de stdio |
--host | 127.0.0.1 | Dónde escucha el servidor MCP (dirección de enlace para clientes LLM) |
--port | 8651 | En qué puerto escucha el servidor MCP |
--jadx-host | 127.0.0.1 | Dónde encontrar el plugin de JADX (la máquina JADX-GUI de destino) |
--jadx-port | 8650 | En qué puerto está el plugin de JADX |
