zinja-coder/jadx-ai-mcpPlugin pour JADX afin d'intégrer le serveur MCP
⚡ Serveur MCP entièrement automatisé + plugin JADX conçu pour communiquer avec les LLM via MCP afin d'analyser des APK Android avec des LLM comme Claude — découvrez des vulnérabilités, analysez des APK et faites de la rétro-ingénierie sans effort.
Merci à ces merveilleuses personnes pour leurs contributions ⭐
JADX-AI-MCP est un plugin pour le décompilateur JADX qui s'intègre directement avec le Model Context Protocol (MCP) pour fournir un support de rétro-ingénierie en direct avec des LLM comme Claude.
Pensez : "Décompiler → Revue de code contextuelle → Recommandations IA" — le tout en temps réel.
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
### Regardez les démos !
- **Effectuer une analyse rapide**
https://github.com/user-attachments/assets/b65c3041-fde3-4803-8d99-45ca77dbe30a
- **Trouver rapidement des vulnérabilités**
https://github.com/user-attachments/assets/c184afae-3713-4bc0-a1d0-546c1f4eb57f
- **Prise en charge de plusieurs agents IA**
https://github.com/user-attachments/assets/6342ea0f-fa8f-44e6-9b3a-4ceb8919a5b0
- **Exécutez avec votre client LLM préféré**
https://github.com/user-attachments/assets/b4a6b280-5aa9-4e76-ac72-a0abec73b809
- **Analyser les ressources APK**
https://github.com/user-attachments/assets/f42d8072-0e3e-4f03-93ea-121af4e66eb1
- **Votre assistant IA lors du débogage d'APK avec JADX**
https://github.com/user-attachments/assets/2b0bd9b1-95c1-4f32-9b0c-38b864dd6aec
C'est une combinaison de deux outils :
1. JADX-AI-MCP
2. [JADX MCP SERVER](https://github.com/zinja-coder/jadx-mcp-server)
---
## 🤖 Qu'est-ce que JADX-MCP-SERVER ?
**JADX MCP Server** est un serveur Python autonome qui interagit avec un plugin `JADX-AI-MCP` (voir : [jadx-ai-mcp](https://github.com/zinja-coder/jadx-ai-mcp)) via MCP (Model Context Protocol). Il permet aux LLM de communiquer en direct avec le contexte de l'application Android décompilée.
---
## Autres projets de la suite Zin MCP
- **[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)**
## Outils MCP actuels
Les outils MCP suivants sont disponibles :
- `fetch_current_class()` — Obtient le nom de la classe et le code source complet de la classe sélectionnée
- `get_selected_text()` — Obtient le texte actuellement sélectionné
- `get_all_classes()` — Liste toutes les classes du projet
- `get_class_source()` — Obtient le code source complet d'une classe donnée
- `get_method_by_name()` — Récupère le code source d'une méthode
- `search_method_by_name()` — Recherche une méthode dans toutes les classes
- `search_classes_by_keyword()` — Recherche des classes dont le code source contient un mot-clé spécifique (prend en charge la pagination)
- `get_methods_of_class()` — Liste les méthodes d'une classe
- `get_fields_of_class()` — Liste les champs d'une classe
- `get_smali_of_class()` — Récupère le smali de la classe
- `get_main_activity_class()` — Récupère l'activité principale depuis jadx mentionnée dans le fichier AndroidManifest.xml.
- `get_main_application_classes_code()` — Récupère le code de toutes les classes principales de l'application en fonction du nom de package défini dans AndroidManifest.xml.
- `get_main_application_classes_names()` — Récupère les noms de toutes les classes principales de l'application en fonction du nom de package défini dans AndroidManifest.xml.
- `get_android_manifest()` — Récupère et renvoie le contenu du fichier AndroidManifest.xml.
- `get_manifest_component` - Récupère un composant spécifique du manifeste au lieu du fichier manifeste entier
- `get_strings()` : Récupère le fichier strings.xml
- `get_all_resource_file_names()` : Récupère tous les noms de fichiers de ressources présents dans l'application
- `get_resource_file()` : Récupère le contenu du fichier de ressources
- `rename_class()` : Renomme le nom de la classe
- `rename_method()` : Renomme la méthode
- `rename_field()` : Renomme le champ
- `rename_package()` : Renomme tout le package
- `rename_variable()` : Renomme la variable dans une méthode
- `debug_get_stack_frames()` : Obtient les stack frames du débogueur jadx
- `debug_get_threads()` : Obtient les informations sur les threads du débogueur jadx
- `debug_get_variables()` : Obtient les variables du débogueur jadx
- `xrefs_to_class()` : Recherche toutes les références vers une classe (renvoie les références au niveau de la méthode et de la classe, prend en charge la pagination)
- `xrefs_to_method()` : Recherche toutes les références vers une méthode (inclut les méthodes liées à l'override, prend en charge la pagination)
- `xrefs_to_field()` : Recherche toutes les références vers un champ (renvoie les méthodes qui accèdent au champ, prend en charge la pagination)
---
## 🗒️ Exemples de prompts
🔍 Compréhension de base du code
"Explain what this class does in one paragraph."
"Summarize the responsibilities of this method."
"Is there any obfuscation in this class?"
"List all Android permissions this class might require."
🛡️ Détection des vulnérabilités
"Are there any insecure API usages in this method?"
"Check this class for hardcoded secrets or credentials."
"Does this method sanitize user input before using it?"
"What security vulnerabilities might be introduced by this code?"
🛠️ Assistants de rétro-ingénierie
"Deobfuscate and rename the classes and methods to something readable."
"Can you infer the original purpose of this smali method?"
"What libraries or SDKs does this class appear to be part of?"
"Tell me which classes contains code related to 'encryption'?"
📦 Analyse statique
"List all network-related API calls in this class."
"Identify file I/O operations and their potential risks."
"Does this method leak device info or PII?"
🤖 Modification de code IA
"Refactor this method to improve readability."
"Add comments to this code explaining each step."
"Rewrite this Java method in Python for analysis."
📄 Documentation et métadonnées
"Generate Javadoc-style comments for all methods."
"What package or app component does this class likely belong to?"
"Can you identify the Android component type (Activity, Service, etc.)?"
🐞 Assistant de débogage```
"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]
Téléchargez les deux fichiers
jadx-ai-mcp-<version>.jaretjadx-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="bannière" height="480px" widht="620px" src="https://assets.kitploit.com/production/public/readmes/6657/1c2660639daf7352d2bdeafeb7b5e0846e3c0bed45846ee52256b7bf3d316386.png">
</div>
<div align="center">
<img alt="bannière" height="480px" widht="620px" src="https://assets.kitploit.com/production/public/readmes/6657/ccc2cc3566566517abad1097711afad3c668a999dc105d82686c4ffb791eba3b.png">
</div>
<div align="center">
<img alt="bannière" 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. Utiliser Claude Desktop
Assurez-vous que Claude Desktop est en cours d'exécution avec MCP activé.
Par exemple, j'ai utilisé ceci pour Kali Linux : https://github.com/aaddrick/claude-desktop-debian
Configurez et ajoutez le serveur MCP au fichier LLM :```bash
nano ~/.config/Claude/claude_desktop_config.json
Pour :
%APPDATA%\Claude\claude_desktop_config.json~/Library/Application Support/Claude/claude_desktop_config.jsonEt le contenu suivant à l'intérieur :```json { "mcpServers": { "jadx-mcp-server": { "command": "///uv", "args": [ "--directory", "</PATH/TO/>jadx-mcp-server/", "run", "jadx_mcp_server.py" ] } } }
Remplacez :
- `path/to/uv` par le chemin réel vers votre exécutable `uv`
- `path/to/jadx-mcp-server` par le chemin absolu vers le dossier où vous avez cloné ce
dépôt
Ensuite, naviguez dans le code et interagissez via des invites de revue de code en temps réel à l'aide de l'intégration intégrée.
**OU**
ou vous pouvez installer le jadx_mcp_server directement comme exécutable en utilisant la commande ci-dessous :```
uv tool install git+https://github.com/zinja-coder/jadx-mcp-server
et ensuite vous pouvez simplement fournir jadx_mcp_server dans la section command de la configuration mcp.
Si vous souhaitez configurer l'outil MCP dans Cherry Studio, vous pouvez vous référer à la configuration suivante.
- `path/to/jadx-mcp-server` avec le chemin absolu vers l'endroit où vous avez cloné ce
dépôt
## 4. Utilisation de LMStudio
Vous pouvez également utiliser JADX AI MCP Server avec LM Studio en configurant son fichier mcp.json. Voici le guide vidéo.
https://github.com/user-attachments/assets/b4a6b280-5aa9-4e76-ac72-a0abec73b809
## 5. Exécution en mode flux HTTP
Vous pouvez également utiliser Jadx en mode flux HTTP à l'aide de l'option `--http` avec `jadx_mcp_server.py`, comme indiqué ci-dessous :```bash
uv run jadx_mcp_server.py --http
OR
uv run jadx_mcp_server.py --http --port 9999
Il existe deux connexions distinctes et chacune possède son propre hôte/port:``` ┌─────────────┐ --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 │ │ └─────────────┘ └──────────────────┘ └──────────────────┘
| Option | Défaut | Contrôle |
|------|---------|----------|
| `--http` | off | Utilise le transport HTTP au lieu de stdio |
| `--host` | `127.0.0.1` | **Où le serveur MCP écoute** (adresse d'écoute pour les clients LLM) |
| `--port` | `8651` | **Sur quel port le serveur MCP écoute** |
| `--jadx-host` | `127.0.0.1` | **Où trouver le plugin JADX** (la machine JADX-GUI cible) |
| `--jadx-port` | `8650` | **Sur quel port se trouve le plugin JADX** |
### Exemples d'utilisation
**Scénario 1 — Tout sur la même machine (le plus courant) :**```bash
# Default: MCP server on localhost:8651, connects to JADX plugin on localhost:8650
uv run jadx_mcp_server.py --http
Scénario 2 — Conteneur Docker ou WSL (serveur MCP accessible depuis le réseau hôte) :```bash
uv run jadx_mcp_server.py --http --host 0.0.0.0
**Scénario 3 — JADX-GUI exécuté sur une machine différente (par exemple, VM distante):**```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
Scénario 4 — Configuration entièrement à distance (tout sur des machines différentes) :```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]
> ### ⚠️ Avertissement de sécurité — Liaison à distance
>
> Lors de l'utilisation de `--host 0.0.0.0` (ou de toute adresse autre que localhost), le serveur MCP se lie à **toutes les interfaces réseau** via **HTTP en clair sans authentification**. Cela signifie :
>
> - **Toute personne sur le réseau** peut se connecter et invoquer tous les outils MCP
> - Il n'y a **aucun chiffrement TLS** — le trafic peut être intercepté
> - Un attaquant peut utiliser le serveur pour **lire le code décompilé**, **renommer des classes/méthodes** et **accéder aux informations de débogage**
>
> **Mesures d'atténuation :**
> - Ne vous liez à `0.0.0.0` que sur des **réseaux de confiance et isolés** (par exemple, pont Docker, machine virtuelle locale)
> - Utilisez un **pare-feu** pour restreindre l'accès au port MCP
> - Envisagez plutôt un **tunnel SSH** : `ssh -L 8651:127.0.0.1:8651 remote-host`
### Compatibilité du mode Stdio
> [!NOTE]
> Lors de l'exécution en mode **stdio** (le mode par défaut, sans `--http`), toutes les sorties lisibles par l'humain (bannière, vérification d'état) sont écrites sur **stderr** afin de réserver **stdout** au flux JSON-RPC MCP. Cela garantit la compatibilité avec Codex, Claude Desktop et d'autres clients MCP basés sur stdio.
## 6. Configuration personnalisée du port et de l'hôte pour le plugin MCP JADX AI
<img width="800" height="335" alt="image" src="https://assets.kitploit.com/production/public/readmes/6657/34e13964afba1fa722733838892491b2ec9ea2d11f2dfd4e8612aa62817dfa41.png" />
1. Configurer le port : configurez le port sur lequel le plugin MCP JADX AI écoutera.
2. Port par défaut : annulez les modifications et écoutez sur le port par défaut.
3. Redémarrer le serveur : forcez le redémarrage du serveur du plugin MCP JADX AI.
4. État du serveur : vérifiez l'état du serveur du plugin MCP JADX AI.
Pour se connecter au plugin MCP JADX AI exécuté sur un port personnalisé, l'option `--jadx-port` sera utilisée comme indiqué ci-dessous :```
uv run jadx_mcp_server.py --jadx-port 8652
Si le plugin JADX AI MCP s'exécute sur une machine différente (par exemple, JADX sur une VM distante, serveur MCP sur votre hôte local), utilisez l'option --jadx-host :```bash
uv run jadx_mcp_server.py --jadx-host 192.168.1.100 --jadx-port 8650
### Référence CLI — Comprendre les options
Il existe **deux connexions distinctes** et chacune possède son propre hôte/port :```
┌─────────────┐ --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 │ │
└─────────────┘ └──────────────────┘ └──────────────────┘
Scénario 1 — Tout sur la même machine (le plus courant) :```bash
uv run jadx_mcp_server.py --http
**Scénario 2 — Conteneur Docker ou WSL (serveur MCP accessible depuis le réseau hôte) :**```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
Scénario 3 — JADX-GUI exécuté sur une autre machine (par exemple, VM distante) :```bash
uv run jadx_mcp_server.py --http --jadx-host 192.168.1.100
**Scénario 4 — Configuration entièrement distante (tout sur des machines différentes):**```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 configuration MCP pour le port jadx personnalisé sera la suivante pour claude :``` { "mcpServers": { "jadx-mcp-server": { "command": "/path/to/uv", "args": [ "--directory", "/path/to/jadx-mcp-server/", "run", "jadx_mcp_server.py", "--jadx-port", "8652" ] } } }
## Essayez
1. Exécutez jadx-gui et chargez n'importe quel fichier .apk
2. Démarrez claude - Vous devez voir le symbole du marteau
3. Cliquez sur le symbole `hammer` et vous devriez voir quelque chose comme ceci :
4. Exécutez l'invite suivante :```text
fetch currently selected class and perform quick sast on it
Ce plugin permet un contrôle total sur l'interface graphique et le modèle de projet interne afin de prendre en charge une intégration plus poussée des LLM, notamment :
Les fichiers liés à JADX-AI-MCP se trouvent dans ce dépôt.
Les fichiers liés à jadx-mcp-server se trouvent ici.
Veuillez ouvrir une issue avec le modèle correspondant.
Testé sur Claude Desktop Client, la prise en charge d'autres IA sera bientôt testée !
Ce projet est un plugin pour JADX, un incroyable décompilateur Android open-source créé et maintenu par @skylot. Toute la logique de décompilation appartient à son auteur. Je l'ai uniquement étendu pour prendre en charge mon serveur MCP avec des capacités IA.
Le README.md d'origine de jadx est inclus ici dans ce dépôt à titre de référence et de crédit.
Ce serveur MCP est rendu possible grâce à l'extensibilité de JADX-GUI et à l'incroyable communauté de rétro-ingénierie Android.
Merci également à @aaddrick pour le développement de Claude Desktop pour Linux basé sur Debian.
Et enfin, merci à @anthropics pour le développement du Model Context Protocol et à l'équipe @FastMCP
Par ailleurs, un immense merci à tous les projets open source qui servent de dépendances à ce projet et qui ont rendu cela possible.
Ce projet utilise les excellentes bibliothèques suivantes.
Plugin - Java
Serveur MCP - Python
JADX-AI-MCP et tous les projets associés héritent de la licence Apache 2.0 du dépôt JADX d'origine.
Clause de non-responsabilité
Les outils jadx-ai-mcp et jadx_mcp_server sont strictement destinés à des fins éducatives, de recherche et d'évaluation éthique de la sécurité. Ils sont fournis « tels quels », sans aucune garantie, expresse ou implicite. Les utilisateurs sont seuls responsables de veiller à ce que leur utilisation de ces outils soit conforme à toutes les lois, réglementations et directives éthiques applicables.
En utilisant jadx-ai-mcp ou jadx_mcp_server, vous acceptez de les utiliser uniquement dans des environnements que vous êtes autorisé à tester, comme des applications que vous possédez ou pour lesquelles vous avez l'autorisation explicite d'analyser. Toute utilisation abusive de ces outils pour de la rétro-ingénierie non autorisée, une violation des droits de propriété intellectuelle ou une activité malveillante est strictement interdite.
Les développeurs de jadx-ai-mcp et jadx_mcp_server ne pourront être tenus responsables de tout dommage, perte de données, conséquences juridiques ou autres conséquences résultant de l'utilisation ou de la mauvaise utilisation de ces outils. Les utilisateurs assument l'entière responsabilité de leurs actions et de tout impact causé par leur utilisation.
Utilisez de manière responsable. Respectez la propriété intellectuelle. Suivez les pratiques de hacking éthique.
Construit avec ❤️ pour les communautés de rétro-ingénierie et d'IA.
| Flag | Default | Controls |
|---|
--http | off | Utiliser le transport HTTP au lieu de stdio |
--host | 127.0.0.1 | Adresse d'écoute du serveur MCP (adresse de liaison pour les clients LLM) |
--port | 8651 | Port d'écoute du serveur MCP |
--jadx-host | 127.0.0.1 | Où trouver le plugin JADX (la machine cible JADX-GUI) |
--jadx-port | 8650 | Port d'écoute du plugin JADX |
