### Sehen Sie sich die Demos an!

- **Schnelle Analyse durchführen**
  
https://github.com/user-attachments/assets/b65c3041-fde3-4803-8d99-45ca77dbe30a

- **Schnell Schwachstellen finden**

https://github.com/user-attachments/assets/c184afae-3713-4bc0-a1d0-546c1f4eb57f

- **Unterstützung mehrerer KI-Agenten**

https://github.com/user-attachments/assets/6342ea0f-fa8f-44e6-9b3a-4ceb8919a5b0

- **Mit Ihrem bevorzugten LLM-Client ausführen**

https://github.com/user-attachments/assets/b4a6b280-5aa9-4e76-ac72-a0abec73b809

- **Die APK-Ressourcen analysieren**

https://github.com/user-attachments/assets/f42d8072-0e3e-4f03-93ea-121af4e66eb1

- **Ihr KI-Assistent beim Debuggen der APK mit JADX**

https://github.com/user-attachments/assets/2b0bd9b1-95c1-4f32-9b0c-38b864dd6aec

Es ist eine Kombination aus zwei Tools:
1. JADX-AI-MCP
2. [JADX MCP SERVER](https://github.com/zinja-coder/jadx-mcp-server)

## 🤖 Was ist JADX-MCP-SERVER?

**JADX MCP Server** ist ein eigenständiger Python-Server, der über MCP (Model Context Protocol) mit einem `JADX-AI-MCP`-Plugin interagiert (siehe: [jadx-ai-mcp](https://github.com/zinja-coder/jadx-ai-mcp)). Er ermöglicht es LLMs, live mit dem dekompilierten Kontext der Android-App zu kommunizieren.

---

## Weitere Projekte in der 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)**

## Aktuelle MCP-Tools

Die folgenden MCP-Tools sind verfügbar:

- `fetch_current_class()` — Ruft den Klassennamen und den vollständigen Quellcode der ausgewählten Klasse ab.
- `get_selected_text()` — Ruft den aktuell ausgewählten Text ab.
- `get_all_classes()` — Listet alle Klassen im Projekt auf.
- `get_class_source()` — Ruft den vollständigen Quellcode einer bestimmten Klasse ab.
- `get_method_by_name()` — Ruft den Quellcode einer Methode ab.
- `search_method_by_name()` — Durchsucht alle Klassen nach einer Methode.
- `search_classes_by_keyword()` — Durchsucht Klassen, deren Quellcode ein bestimmtes Schlüsselwort enthält (unterstützt Pagination).
- `get_methods_of_class()` — Listet die Methoden einer Klasse auf.
- `get_fields_of_class()` — Listet die Felder einer Klasse auf.
- `get_smali_of_class()` — Ruft den Smali-Code der Klasse ab.
- `get_main_activity_class()` — Ruft die Haupt-Activity aus jadx ab, die in der Datei AndroidManifest.xml erwähnt wird.
- `get_main_application_classes_code()` — Ruft den Code aller Hauptanwendungsklassen basierend auf dem in der AndroidManifest.xml definierten Paketnamen ab.
- `get_main_application_classes_names()` — Ruft die Namen aller Hauptanwendungsklassen basierend auf dem in der AndroidManifest.xml definierten Paketnamen ab.
- `get_android_manifest()` — Ruft den Inhalt der AndroidManifest.xml ab und gibt ihn zurück.
- `get_manifest_component` - Ruft eine bestimmte Manifest-Komponente ab, anstatt der gesamten Manifest-Datei.
- `get_strings()` : Ruft die Datei strings.xml ab.
- `get_all_resource_file_names()` : Ruft alle in der Anwendung vorhandenen Ressourcendateinamen ab.
- `get_resource_file()` : Ruft den Inhalt einer Ressourcendatei ab.
- `rename_class()` : Benennt den Klassennamen um.
- `rename_method()` : Benennt die Methode um.
- `rename_field()` : Benennt das Feld um.
- `rename_package()` : Benennt das gesamte Paket um.
- `rename_variable()` : Benennt die Variable innerhalb einer Methode um.
- `debug_get_stack_frames()` : Ruft die Stack-Frames vom jadx-Debugger ab.
- `debug_get_threads()` : Ruft Einblicke in die Threads vom jadx-Debugger ab.
- `debug_get_variables()` : Ruft die Variablen vom jadx-Debugger ab.
- `xrefs_to_class()` : Findet alle Referenzen auf eine Klasse (liefert Referenzen auf Methoden- und Klassenebene, unterstützt Pagination).
- `xrefs_to_method()` : Findet alle Referenzen auf eine Methode (einschließlich überschreibungsbezogener Methoden, unterstützt Pagination).
- `xrefs_to_field()` : Findet alle Referenzen auf ein Feld (gibt Methoden zurück, die auf das Feld zugreifen, unterstützt Pagination).
  
---

## 🗒️ Beispiel-Prompts

🔍 Grundlegendes Codeverständnis

    "Erkläre, was diese Klasse in einem Absatz tut."

    "Fasse die Verantwortlichkeiten dieser Methode zusammen."

    "Gibt es in dieser Klasse eine Verschleierung?"

    "Liste alle Android-Berechtigungen auf, die diese Klasse möglicherweise benötigt."

🛡️ Erkennung von Schwachstellen

    "Gibt es in dieser Methode unsichere API-Nutzungen?"

    "Prüfe diese Klasse auf hartkodierte Geheimnisse oder Anmeldeinformationen."

    "Bereinigt diese Methode Benutzereingaben, bevor sie verwendet werden?"

    "Welche Sicherheitsschwachstellen könnte dieser Code einführen?"

🛠️ Hilfsmittel für Reverse Engineering

    "Entschleiere und benenne die Klassen und Methoden so um, dass sie lesbar sind."

    "Kannst du den ursprünglichen Zweck dieser Smali-Methode ableiten?"

    "Zu welchen Bibliotheken oder SDKs scheint diese Klasse zu gehören?"

    "Sag mir, welche Klassen Code enthalten, der mit 'Verschlüsselung' zu tun hat."

📦 Statische Analyse

    "Liste alle netzwerkbezogenen API-Aufrufe in dieser Klasse auf."

    "Identifiziere Datei-I/O-Operationen und ihre potenziellen Risiken."

    "Leakt diese Methode Geräteinformationen oder personenbezogene Daten (PII)?"

🤖 KI-Codemodifikation

    "Refaktoriere diese Methode, um die Lesbarkeit zu verbessern."

    "Füge diesem Code Kommentare hinzu, die jeden Schritt erklären."

    "Schreibe diese Java-Methode zur Analyse in Python um."

📄 Dokumentation & Metadaten

    "Generiere Javadoc-Kommentare für alle Methoden."

    "Zu welchem Paket oder welcher App-Komponente gehört diese Klasse wahrscheinlich?"

    "Kannst du den Android-Komponententyp identifizieren (Activity, Service, usw.)?"

🐞 Debugger-Assistent```
   "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?"

<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

## a. Install uv (if you dont have it yet)

## 🤖 2. Claude Desktop verwenden

Stellen Sie sicher, dass Claude Desktop mit aktiviertem MCP ausgeführt wird.

Zum Beispiel habe ich Folgendes für Kali Linux verwendet: https://github.com/aaddrick/claude-desktop-debian

Konfigurieren Sie den MCP-Server und fügen Sie ihn zur LLM-Datei hinzu:```bash
nano ~/.config/Claude/claude_desktop_config.json

Replace:

- `path/to/uv` durch den tatsächlichen Pfad zu Ihrer `uv`-ausführbaren Datei
- `path/to/jadx-mcp-server` durch den absoluten Pfad zu dem Verzeichnis, in das Sie dieses
Repository geklont haben

Navigieren Sie dann durch den Code und interagieren Sie über Echtzeit-Code-Review-Prompts mit der integrierten Integration.

**ODER**

oder Sie können den jadx_mcp_server direkt als ausführbare Datei direkt mit dem folgenden Befehl installieren:```
uv tool install git+https://github.com/zinja-coder/jadx-mcp-server

- `path/to/jadx-mcp-server` mit dem absoluten Pfad zu dem Verzeichnis, in das du dieses Repository geklont hast

## 4. Verwenden von LMStudio

Du kannst den JADX AI MCP Server auch mit LM Studio verwenden, indem du die `mcp.json`-Datei konfigurierst. Hier ist die Videoanleitung.

https://github.com/user-attachments/assets/b4a6b280-5aa9-4e76-ac72-a0abec73b809

## 5. Ausführen im HTTP-Stream-Modus

Du kannst Jadx auch im HTTP-Stream-Modus ausführen, indem du die Option `--http` mit `jadx_mcp_server.py` verwendest, wie im Folgenden gezeigt:```bash
uv run jadx_mcp_server.py --http

OR

uv run jadx_mcp_server.py --http --port 9999

| Flag | Default | Controls |
|------|---------|----------|
| `--http` | off | HTTP-Transport statt stdio verwenden |
| `--host` | `127.0.0.1` | **Wo der MCP-Server lauscht** (Bind-Adresse für LLM-Clients) |
| `--port` | `8651` | **Auf welchem Port der MCP-Server lauscht** |
| `--jadx-host` | `127.0.0.1` | **Wo das JADX-Plugin zu finden ist** (die Ziel-JADX-GUI-Maschine) |
| `--jadx-port` | `8650` | **Auf welchem Port das JADX-Plugin läuft** |

### Anwendungsbeispiele

**Szenario 1 — Alles auf derselben Maschine (am häufigsten):**```bash
# Default: MCP server on localhost:8651, connects to JADX plugin on localhost:8650
uv run jadx_mcp_server.py --http

**Szenario 3 — JADX-GUI auf einem anderen Rechner (z. B. Remote-VM):**```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

> [!CAUTION]
> ### ⚠️ Sicherheitswarnung — Remote-Bindung
>
> Bei Verwendung von `--host 0.0.0.0` (oder einer beliebigen Nicht-Localhost-Adresse) bindet der MCP-Server an **alle Netzwerkschnittstellen** über **einfaches HTTP ohne Authentifizierung**. Das bedeutet:
>
> - **Jeder im Netzwerk** kann sich verbinden und alle MCP-Tools aufrufen
> - Es gibt **keine TLS-Verschlüsselung** — der Datenverkehr kann abgefangen werden
> - Ein Angreifer kann den Server nutzen, um **dekompilierten Code zu lesen**, **Klassen/Methoden umzubenennen** und **Debug-Informationen abzurufen**
>
> **Gegenmaßnahmen:**
> - Binden Sie `0.0.0.0` nur in **vertrauenswürdigen, isolierten Netzwerken** (z. B. Docker-Brücke, lokale VM)
> - Verwenden Sie eine **Firewall**, um den Zugriff auf den MCP-Port einzuschränken
> - Ziehen Sie stattdessen einen **SSH-Tunnel** in Betracht: `ssh -L 8651:127.0.0.1:8651 remote-host`

### Stdio-Modus-Kompatibilität

> [!NOTE]
> Bei Ausführung im **Stdio**-Modus (Standard, ohne `--http`) werden alle menschenlesbaren Ausgaben (Banner, Health Check) nach **stderr** geschrieben, um **stdout** für den MCP-JSON-RPC-Stream reserviert zu halten. Dies gewährleistet Kompatibilität mit Codex, Claude Desktop und anderen stdio-basierten MCP-Clients.

## 6. Benutzerdefinierte Port- und Host-Konfiguration für JADX AI MCP Plugin

<img width="800" height="335" alt="image" src="https://assets.kitploit.com/production/public/readmes/6657/34e13964afba1fa722733838892491b2ec9ea2d11f2dfd4e8612aa62817dfa41.png" />

1. Port konfigurieren: Konfigurieren Sie den Port, auf dem das JADX AI MCP Plugin lauschen soll.
2. Standardport: Änderungen rückgängig machen und auf dem Standardport lauschen.
3. Server neu starten: Starten Sie den JADX AI MCP Plugin-Server neu.
4. Serverstatus: Status des JADX AI MCP Plugin-Servers prüfen.

Um eine Verbindung zum JADX AI MCP Plugin herzustellen, das auf einem benutzerdefinierten Port läuft, wird die Option `--jadx-port` wie im Folgenden gezeigt verwendet:```
uv run jadx_mcp_server.py --jadx-port 8652

### CLI-Referenz — Die Flags verstehen

Es gibt **zwei getrennte Verbindungen** und jede hat ihren eigenen Host/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         │                  │
└─────────────┘                        └──────────────────┘                               └──────────────────┘

**Szenario 2 — Docker-Container oder WSL (MCP-Server vom Host-Netzwerk aus erreichbar):**```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

**Szenario 4 — Komplettes Remote-Setup (alles auf verschiedenen Rechnern):**```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

## Probier es aus

1. Starte jadx-gui und lade eine beliebige .apk-Datei

![img_1.png](https://assets.kitploit.com/production/public/readmes/6657/57512ca023da5fdca0cc3fac791a68e1c76c9ff4e97d9391ca6fdcf8b6e34bff.png)

2. Starte claude - Du musst das Hammersymbol sehen

![img2.png](https://assets.kitploit.com/production/public/readmes/6657/18d5936ea3d66f3667e827f2b757926f56230f5b0a150eb0077414cca550009e.png)

3. Klicke auf das `hammer`-Symbol und du solltest etwa Folgendes sehen:

![img3.png](https://assets.kitploit.com/production/public/readmes/6657/ce4c8a048d32bb1f5a16fed73153b83ec78c3253a0109fb7aa064f064b34fc34.png)

4. Führe den folgenden Prompt aus:```text
fetch currently selected class and perform quick sast on it