MCPwner

Vorsicht vor dem Dachs

Model Context Protocol Server zur Automatisierung von Sicherheitsforschung

Kompatibel mit:

Übersicht

MCPwner ist ein Model Context Protocol (MCP) Server, der Sicherheitstestwerkzeuge in LLM-gesteuerte Workflows integriert. Es bietet eine einheitliche Schnittstelle für Secret-Scanning, statische Analyse (SAST), Software Composition Analysis (SCA), Infrastructure-as-Code (IaC)-Sicherheit, Source-Fuzzing, Reconnaissance, dynamische Anwendungssicherheitstests (DAST) und Schwachstellenforschung einschließlich 0-Day-Entdeckung.

Anstatt Werkzeuge manuell zu verketten und Ausgaben in Ihr LLM einzufügen, standardisiert und streamt MCPwner Ergebnisse direkt in den Arbeitskontext des Modells. Dies ermöglicht kontinuierliches Denken, Korrelation und die Entdeckung von Angriffspfaden über den gesamten Lebenszyklus der Sicherheitsforschung – von der Kartierung von Angriffsflächen und der Identifizierung bekannter Schwachstellen bis hin zur Aufdeckung neuartiger Angriffsvektoren.

Hinweis: Dieses Projekt befindet sich in aktiver Entwicklung. Erfahren Sie mehr über MCPs hier.

Integrierte Werkzeuge

Zukünftige Werkzeuge

Die folgenden Werkzeuge sind für zukünftige Veröffentlichungen geplant.

Unsichere Deserialisierung

Gadget-Chain- und Payload-Generatoren zur Waffenausstattung von Deserialisierungs-Senken, die während SAST identifiziert wurden. Es gibt ausgereifte Gadget-Chain-Ökosysteme für Java, .NET und PHP; Python wird durch bösartige Pickle-Generierung abgedeckt (Ruby/Node-Deserialisierung ist Payload-basiert und befindet sich im Payloads-Korpus unten):

• ysoserial - Java
• ysoserial.net - .NET
• PHPGGC - PHP
• marshalsec - JVM-Marshaller/Unmarshaller
• Fickling - Python (Pickle)

HTTP-Request-Smuggling

• smuggler - HTTP/1.1-Request-Smuggling/Desync (CL.TE, TE.CL, TE.TE)
• h2csmuggler - HTTP/2-Klartext (h2c) Upgrade-Smuggling (unterscheidet sich von HTTP/2-Desync)
• http2smugl - HTTP/2-Request-Smuggling/Desync

Payloads

Zusammengestellte Payload- und Wortlisten-Korpora zur Unterstützung der obigen Werkzeuge:

• SecLists - Aggregate von Fuzzing-Payloads, Anmeldeinformationen und Injectionslisten
• PayloadsAllTheThings - Angriffs-Payloads und Umgehungen, nach Schwachstellenklassen organisiert
• FuzzDB - Fehlerinjektionsprimitive und vorhersagbare Ressourcenmuster

Anwendungsbeispiele

Automatisierte Enumeration-Pipeline```

"Enumerate and scan example.com" → MCPwner chains: Subfinder + Amass → Masscan + Nmap → httpx → Katana + gau → ffuf + Arjun

### Ein GitHub-Repository nach Geheimnissen scannen```
"Scan https://github.com/example/repo for secrets"
→ MCPwner runs Gitleaks, TruffleHog, detect-secrets and correlates findings

Sicherheitsaudit```

"Run a security audit on my Python project" → MCPwner runs Bandit (SAST), OSV-Scanner (SCA), and secrets scanning

### Angriffspfadanalyse```
"Find vulnerabilities in the authentication module"
→ MCPwner runs CodeQL queries, cross-references with secrets and SCA results

Live-Ziel-Exploitation```

"Test for SQLi and XSS on http://localhost:8080" → MCPwner chains: sqlmap + Dalfox and verifies findings

## Installation

### Voraussetzungen

**Systemanforderungen:**

- Docker Engine 20.0+ und Docker Compose 2.0+
- 8 GB RAM mindestens (16 GB empfohlen für gleichzeitigen Betrieb mehrerer Tools)
- 20 GB freier Speicherplatz (Sicherheitstool-Images sind groß)
- Unterstützte Plattformen: Linux, macOS, Windows (mit WSL2)

**MCP-Client:**

- Claude Desktop, Cursor, Kiro oder ein beliebiger MCP-kompatibler Client

### Einrichtung

1. **Repository klonen**:   ```bash
   git clone https://github.com/nedlir/mcpwner.git
   cd mcpwner

2. Server konfigurieren: ```bash cp config/config.yaml.example config/config.yaml

   Edit config/config.yaml as needed

   root@kitploit:~

3. Starten Sie die Dienste: ```bash docker-compose up -d --build
   root@kitploit:~

4. Überprüfen Sie, ob die Dienste ausgeführt werden: ```bash docker-compose ps
   root@kitploit:~

Verbinde deine IDE

Sobald die Docker-Container laufen, füge MCPwner zu deinem MCP-Client hinzu:

Wichtig: Dynamische Tool-Registrierung MCPwner verwendet eine modulare, opt-in Architektur. Sicherheitswerkzeuge werden durch Docker Compose profiles gesteuert.

1. Die .env-Datei (COMPOSE_PROFILES=sast,secrets,reconnaissance,dast,etc) legt fest, welche Container gestartet werden. Alternativ kannst du dies überschreiben und bestimmte Profile über die CLI starten: docker compose --profile sast --profile dast up -d.
2. Der MCP-Server überprüft beim Start dynamisch die laufenden Container und registriert nur die gesunden Tools bei deinem LLM.
3. Wenn du bestimmte Tools (z. B. semgrep) auslassen möchtest, entferne seine Kategorie (sast) aus der .env-Datei und liste die anderen gewünschten Tools manuell auf (bandit,gosec,codeql).
4. Hinweis: Tools in der Kategorie utilities (z. B. Linguist, WireMock, Chromium) werden als dauerhafte Kernabhängigkeiten behandelt. Sie werden bedingungslos mit docker compose up -d gestartet, um sicherzustellen, dass kritische toolübergreifende Abhängigkeiten (wie Spracherkennung) immer funktionieren.

Standorte der Konfigurationsdateien:

• Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)
• Cursor/Kiro: mcp.json in deinem Projekt- oder Einstellungsverzeichnis

Ein-Klick-Installation (erfordert laufenden Docker):

Manuelle Konfiguration:

Füge Folgendes zu deiner MCP-Konfigurationsdatei hinzu:```json { "mcpServers": { "mcpwner": { "command": "docker", "args": ["exec", "-i", "mcpwner-server", "python", "src/server.py"], "env": {} } } }

Starten Sie Ihren MCP-Client neu, um die neue Serverkonfiguration zu laden.

### Lokale Projekte scannen

Um Projekte von Ihrem Host-Rechner zu scannen, mounten Sie diese in den Container, indem Sie ein Volume in `docker-compose.yaml` hinzufügen:```yaml
services:
  mcpwner:
    volumes:
      - /path/to/your/projects:/mnt/projects:ro

Dann verwende das Tool create_workspace mit:

• source_type="local"
• source="/mnt/projects/my-project"

Datenpersistenz

MCPwner persistiert automatisch Workspace- und CodeQL-Datenbank-Metadaten über Container-Neustarts hinweg mithilfe dateibasierter Speicherung im gemeinsamen Docker-Volume (/workspaces/.metadata/). Keine Konfiguration erforderlich – das System lädt vorhandene Daten beim Start und speichert nach jedem Vorgang mittels atomarer Schreibvorgänge, um Korruption zu verhindern.

Workspace-Bereinigungssteuerung:

Das Tool cleanup_workspace bietet granulare Kontrolle:

• delete_files=True, delete_metadata=False – Speicherplatz freigeben, aber Workspace-Verlauf bewahren (empfohlen)
• delete_files=True, delete_metadata=True – Vollständige Entfernung von Workspace und Metadaten
• delete_files=False, delete_metadata=True – Aus der Liste entfernen, aber Dateien auf der Festplatte behalten

Backup:```bash

Backup entire workspaces volume

docker run --rm -v mcpwner_workspaces:/data -v $(pwd):/backup
alpine tar czf /backup/workspaces-backup.tar.gz /data

Restore volume

docker run --rm -v mcpwner_workspaces:/data -v $(pwd):/backup
alpine tar xzf /backup/workspaces-backup.tar.gz -C /

## Architektur

MCPwner nutzt HTTP-basierte Kommunikation zwischen Containern, um zukünftige Fernbereitstellungen zu unterstützen. Obwohl derzeit für lokale Nutzung optimiert, kann die Architektur mit minimalen Änderungen für entfernte Serverbereitstellungen angepasst werden.

**Designprinzipien:**

- Containerisolierung für die Ausführung von Sicherheitstools
- Standardisierte Ausgabeformate für den LLM-Konsum (SARIF/JSON)
- Erweiterbare Plugin-Architektur für neue Tools
- Zustandslose API (Erinnerungen werden vom Benutzer verwaltet)

**Architekturübersicht:**```mermaid
graph LR
    subgraph IDE[" "]
        LLM[🤖<br/>LLM]
        Client[MCP Client]
        LLM -.-> Client
    end

    Server[MCPwner Server]

    SAST[SAST Tools]
    Secrets[Secrets Scanning]
    SCA[SCA Tools]
    Recon[Reconnaissance]
    CodeQL[CodeQL Service]
    Linguist[Language Detection]
    Utilities[Utilities]
    IaC[IaC Security]
    Fuzzing[Source Fuzzing]
    DAST[DAST Tools]

    Client -->|JSON-RPC 2.0| Server
    Server -->|HTTP| SAST
    Server -->|HTTP| Secrets
    Server -->|HTTP| SCA
    Server -->|HTTP| Recon
    Server -->|HTTP| CodeQL
    Server -->|HTTP| Linguist
    Server -->|HTTP| Utilities
    Server -->|HTTP| IaC
    Server -->|HTTP| Fuzzing
    Server -->|HTTP| DAST

    style LLM fill:#7C3AED,stroke:#5B21B6,stroke-width:3px,color:#fff
    style Client fill:#4A90E2,stroke:#2E5C8A,stroke-width:3px,color:#fff
    style Server fill:#F5A623,stroke:#C17D11,stroke-width:3px,color:#fff
    style SAST fill:#E74C3C,stroke:#C0392B,stroke-width:2px,color:#fff
    style Secrets fill:#9B59B6,stroke:#7D3C98,stroke-width:2px,color:#fff
    style SCA fill:#1ABC9C,stroke:#16A085,stroke-width:2px,color:#fff
    style Recon fill:#00BCD4,stroke:#0097A7,stroke-width:2px,color:#fff
    style CodeQL fill:#E67E22,stroke:#CA6F1E,stroke-width:2px,color:#fff
    style Linguist fill:#3498DB,stroke:#2874A6,stroke-width:2px,color:#fff
    style Utilities fill:#6D28D9,stroke:#4C1D95,stroke-width:2px,color:#fff
    style IaC fill:#059669,stroke:#047857,stroke-width:2px,color:#fff
    style Fuzzing fill:#B91C1C,stroke:#7F1D1D,stroke-width:2px,color:#fff
    style DAST fill:#D35400,stroke:#A04000,stroke-width:2px,color:#fff
    style IDE fill:none,stroke:#ddd,stroke-width:2px,stroke-dasharray: 5 5

Verfügbare MCP-Tools

MCPwner stellt die folgenden Tools über die MCP-Schnittstelle bereit:

Arbeitsbereichsverwaltung:

• create_workspace - Arbeitsbereich initialisieren von lokalem Pfad, Git-URL oder GitHub-Repo
• list_workspaces - Alle verfügbaren Arbeitsbereiche auflisten
• cleanup_workspace - Arbeitsbereich und zugehörige Daten entfernen

Findings-Ledger:

Auf den Arbeitsbereich bezogen, auf Disk gespeichert (<workspace>/findings/<id>.json) und immer verfügbar — kein Container oder Health-Check erforderlich. Dies ist die Quelle der Wahrheit für die Multi-Agenten-Tiefenrecherche-Pipeline: jede Hypothese, jedes PoC-Ergebnis und jedes Prüfurteil ist ein Eintrag im Findings-Ledger, nicht als Fließtext.

• upsert_finding - Erstellen oder Aktualisieren eines Findings. Standardmäßig wird tief in einen vorhandenen Eintrag eingefügt, sodass ein Agent sein eigenes Unterobjekt schreiben kann (z. B. poc), ohne die Felder eines anderen Agents zu überschreiben (z. B. review).
• list_findings - Alle Findings in einem Arbeitsbereich auflisten, optional gefiltert nach status (z. B. poc-confirmed, review-approved).
• get_finding - Ein einzelnes Finding anhand der ID abrufen

SAST (Statische Analyse):

• run_sast_scan - Statische Analysetools ausführen (Semgrep, Bandit, Gosec, Brakeman, PMD, Psalm, NodeJsScan, Joern, YASA)
• get_sast_report - SAST-Scanergebnisse abrufen
• sast_list_tools - Verfügbare SAST-Tools auflisten

Geheimniserkennung:

• run_secrets_scan - Tools zur Geheimnissuche ausführen (Gitleaks, TruffleHog, Whispers, detect-secrets, Hawk-Eye)
• get_secrets_report - Ergebnisse der Geheimnissuche abrufen
• secrets_list_tools - Verfügbare Tools zur Geheimnissuche auflisten

SCA (Softwarezusammensetzungsanalyse):

• run_sca_scan - Abhängigkeiten auf Schwachstellen analysieren (Grype, Syft, OSV-Scanner, Retire.js)
• get_sca_report - SCA-Scanergebnisse abrufen
• sca_list_tools - Verfügbare SCA-Tools auflisten

Aufklärung:

• run_reconnaissance_scan - Ein einzelnes Aufklärungstool ausführen (Subfinder, Amass, Nmap, Masscan, httpx, Katana, ffuf, bbot, gau, Arjun, wafw00f, Kiterunner)
• run_reconnaissance_chain - Mehrere Aufklärungstools nacheinander verketten
• get_reconnaissance_report - Ergebnisse des Aufklärungsscans abrufen
• reconnaissance_list_tools - Verfügbare Aufklärungstools auflisten

CodeQL:

• detect_languages - Sprachen im Codebestand via Linguist erkennen
• create_codeql_database - CodeQL-Datenbank zur Analyse erstellen
• list_databases - Verfügbare CodeQL-Datenbanken auflisten
• list_query_packs - Verfügbare Abfragepakete auflisten
• execute_query - Bestimmte CodeQL-Abfragen ausführen

Infrastruktur- & IaC-Sicherheit:

• run_iac_scan - Infrastruktur-als-Code auf Fehlkonfigurationen scannen (Checkov, KICS, Terrascan, TFSec, Hadolint)
• get_iac_report - IaC-Scanergebnisse abrufen
• iac_list_tools - Verfügbare IaC-Scanning-Tools auflisten

Quellcode-Fuzzing:

• run_fuzzing_scan - Eine White-Box-, Coverage-gesteuerte Fuzzing-Kampagne gegen ein pro-Ziel-Harness ausführen (Atheris, Jazzer, Jazzer.js, PHP-Fuzzer)
• get_fuzzing_report - Fuzzing-Absturzergebnisse abrufen (abstürzende Eingabe + Stack Trace)
• fuzzing_list_tools - Verfügbare Fuzzing-Engines auflisten, gefiltert nach erkannter Sprache

DAST (Dynamische Anwendungssicherheitstests):

• run_dast_scan - Dynamische Anwendungssicherheitstest-Tools ausführen (sqlmap, NoSQLMap, Commix, Dalfox, SSTImap, SSRFmap, jwt_tool, interactsh)
• get_dast_report - DAST-Scanergebnisse abrufen
• dast_list_tools - Verfügbare DAST-Tools auflisten

Hilfsprogramme:

• run_utilities_scan - Ein Hilfsprogramm gegen ein Live-Ziel ausführen (Linguist, WireMock, Mitmproxy, aiohttp, Headless Chromium)
• get_utilities_report - Ergebnisse des Hilfsprogrammscans abrufen
• utilities_list_tools - Verfügbare Hilfsprogramme und deren Konfigurationsoptionen auflisten

Gesundheit & Überwachung:

• health_check - Server- und Toolverfügbarkeit prüfen
• list_tools - Alle verfügbaren Tools und deren Status auflisten

Sicherheitsaspekte

MCPwner führt Sicherheitstools aus, die invasive Operationen durchführen können. Verwenden Sie es nur auf Systemen und Codebasen, die Ihnen gehören oder für die Sie ausdrücklich die Erlaubnis zum Testen haben – unbefugter Zugriff ist illegal. Beschränken Sie den Zugriff auf den MCP-Server auf autorisierte Benutzer und erwägen Sie eine Netzwerkisolation für Produktionsumgebungen. Überprüfen Sie die Tool-Konfigurationen, bevor Sie Scans ausführen, da einige Tools erheblichen Netzwerkverkehr oder Systemlast verursachen können. Protokollieren Sie die Tool-Ausführung und -Ergebnisse, aber denken Sie daran, dass Sicherheitsscans Warnungen in Überwachungssystemen auslösen können. Befolgen Sie die Grundsätze der verantwortungsvollen Offenlegung, wenn Sie mit MCPwner entdeckte Schwachstellen melden. Halten Sie Docker-Images aktuell und scannen Sie Container regelmäßig auf Schwachstellen. Committen Sie niemals API-Schlüssel, Tokens oder Anmeldeinformationen in Konfigurationsdateien – verwenden Sie stattdessen Umgebungsvariablen oder Secret-Management-Systeme.

Außerdem sollten Sie selbst für Ihre Sicherheit verantwortlich sein, wenn Sie diese Tools ausführen und auf Bibliotheken von Drittanbietern zugreifen. Es wird empfohlen, alles in einer Sandbox und ohne spezielle Authentifizierung auszuführen (minimiert und gehärtet, wo möglich).