pentest-ai

Das Pentest-Tool, das seine Befunde beweist. Kein Orakel, kein Badge.

Website · Installation · Warum Verifikation? · Dokumentation · Benchmarks · Agenten · Discord

⚠️ Offensive Tools, nur für autorisierte Tests. Mit der Installation akzeptierst du die AUP und die Nutzungsbedingungen. Volltext in Verantwortungsvolle Nutzung ↓

ptai ist ein KI-gesteuertes Pentest-Tool, das jeden Exploit erneut ausführt, um ihn zu bestätigen. Es führt Aufklärung durch, meldet sich an und verknüpft Befunde zu mehrstufigen Angriffspfaden, aber es verlangt nicht, dass du den Ergebnissen vertraust. So wie TruffleHog ein geleaktes Geheimnis bestätigt, indem es sich damit anmeldet, bestätigt ptai einen Web-Befund, indem es den Exploit erneut ausführt: Ein Befund bleibt ein Kandidat, bis ein maschinelles Orakel ihn in N von N Fällen reproduziert, und erst dann erhält er ein VERIFIED-Badge. Die Ausgabe von Drittanbieter-Scannern (nuclei, nikto, zap) wird zurückgehalten, bis ein Orakel sie erneut beweist. Scanner-Rauschen ist es, das Teams lehrt, ihre Tools zu ignorieren. Der Bericht enthält daher nur das, was ptai beweisen konnte – jeder VERIFIED-Befund mit einer portablen Beweiskapsel, die du selbst erneut ausführen kannst.

Heute sind 14 Schwachstellenklassen per Orakel verifiziert. In einem absichtlich verwundbaren Test-Honeypot werden 23 Befunde über diese Klassen hinweg mit 100 % Präzision und null Fehlalarmen verifiziert. Bei einem unveränderten OWASP Juice Shop werden 12 in einem einzigen Scan verifiziert. Läuft auf deinem Laptop. Keine Cloud, keine Telemetrie.

Sieh es in Aktion

ptai scannt OWASP Juice Shop: Befunde wechseln von Kandidat zu Orakel-VERIFIED, 12 in einem Scan verifiziert

Scan eines unveränderten OWASP Juice Shop: 12 Befunde per Orakel in einem einzigen Scan verifiziert. Die Befunde sind real; das Timing ist für die Betrachtung angepasst.

Reproduziere die Kernidee selbst in zwei Minuten, ohne eigenes Ziel:```bash pip install ptai && ptai demo

`ptai demo` scannt eine gebündelte verwundbare App und meldet `4 findings, 4 oracle-VERIFIED`, spielt einen Fund live aus einer Beweiskapsel ab (`replay 3/3`), führt dann dieselben Routen gehärtet aus und meldet `0 findings`. Das Einzige, was sich zwischen den beiden Läufen ändert, ist der Fix, daher erscheinen und verschwinden die Funde mit der Schwachstelle – nicht, weil das Tool verstummt. Zwei Minuten, kein API-Schlüssel, kein eigenes Ziel. Jede Kapsel können Sie selbst mit `ptai replay` erneut beweisen.

> **Ehrliche Zahlen.** Der Honeypot-Lauf (23 verifizierte über 14 Klassen, 100 % Präzision, null Fehlalarme) und der Juice-Shop-Lauf (12 in einem Scan verifiziert) sind einzelne reproduzierbare Benchmarks, keine Feld-Fehlalarmraten. Das Orakel-Gate erkauft Präzision, nicht Erkennungsrate: Es entfernt Fehlalarme, es erhöht nicht die Erkennung. Juice Shop ist die am besten untersuchte verwundbare App im Internet; lesen Sie also die schiere Anzahl als Breite und die verifizierte Zahl als die Präzisionsgeschichte. Der Honeypot – mit Bugs, die wir selbst geschrieben haben – ist das ehrliche Signal. Die Honeypot-Harness (`tests/honeypot/`) und ein Clean-App-Gate mit null Fehlalarmen (`tests/cleanapp/`) werden im Repo mitgeliefert, sodass die Behauptungen reproduzierbar sind und nicht nur Screenshots.

## Was ist neu in 1.1.0

Die Verifizierungsabdeckung hat sich ungefähr verdoppelt, und ein Scan meldet nicht mehr null für ein Ziel, das er mitten im Lauf umgeworfen hat. Jeder VERIFIED-Fund stammt von einem benannten Maschinen-Orakel, niemals von einer LLM-Behauptung – im Code erzwungen: Ein Urteil, das sein Orakel nicht benennen kann, wird abgelehnt. Dieses Release fügt hinzu:

- **Zehn neue Orakelklassen (insgesamt 14).** Trusted-Header-Bypass, JWT `alg:none`, Host-Header-Poisoning, XXE, Type Confusion, Stored XSS, sequenzielles IDOR, Mass Assignment, nicht-blinder SSRF und SQLi-Login-Bypass – zusammen mit SQLi (boolean/blind), BOLA/IDOR, Reflected XSS, Open Redirect und Path Traversal. Jedes Orakel besitzt eine Kontrolle, die auf einem sicheren Ziel fehlschlagen muss, sodass eine nicht verwundbare App sich enthält, anstatt ein Abzeichen zu erhalten.
- **Robuste Verifizierung.** Ein aggressiver Sweep konnte ein fragiles Single-Container-Ziel umwerfen; danach schlug die Verifizierungsphase bei jedem Orakel fehl und meldete 0, obwohl gültige, wiederholbare Rezepte vorlagen. Der Scan wartet jetzt, bis das Ziel wieder antwortet, bevor er erneut beweist – das brachte einen OWASP-Juice-Shop-Scan von 0 auf 12 orakel-verifizierte Funde.
- **Scope-Sicherheit.** Aktive Tools (sqlmap, dalfox) sind an den Host des Engagement-Ziels gebunden; der Scan führt Angriffstools nicht länger Drittanbieter-URLs zu, die aus dem Inhalt einer Seite extrahiert wurden.
- **Tragbare Beweiskapseln** mit `ptai replay`, einer Live-TUI, die Befunde auf dem Bildschirm zu VERIFIED umschaltet, und einem CI-Gate (`--fail-on verified`), das einen Build nur bei bewiesenen Funden unterbricht.

## Auf einem echten Ziel: OWASP Juice Shop

Auf einen Standard-OWASP-Juice-Shop gerichtet, **orakel-verifiziert ptai 12 Funde in einem einzigen Scan**: JWT `alg:none` wird auf geschützten Endpunkten akzeptiert, BOLA-Cross-User-Lesezugriffe, sequenzielles IDOR und Type Confusion – jeder erneut von einem Maschinen-Orakel bewiesen, nicht behauptet. Es erkennt mehr, als es verifiziert (SQLi-Auth-Bypass auf `/rest/user/login`, UNION-SQLi auf `/rest/products/search`, XXE, das `/etc/passwd` offenlegt, Mass Assignment, Passwort-Reset-Bypass); nur die verifizierte Teilmenge erreicht den Bericht. Steuern Sie es über Claude Code per MCP ohne API-Schlüssel oder eigenständig.

> **Ehrlichkeitsvorbehalt.** Juice Shop ist die am besten dokumentierte verwundbare App im Internet, daher haben sowohl das LLM als auch die Autoren der Probes einen Vorsprung. Bei einem neuartigen Ziel entspricht die Erkennungsrate genau dem, was die kuratierte Probe-Bibliothek abdeckt (heute 60+ Web-Probes, mit jedem Release wachsend); das LLM koordiniert den Prozess und wertet Ergebnisse aus, es ersetzt die Probes nicht. Eine private Honeypot-Harness in `tests/honeypot/` misst die Abdeckung gegen von uns selbst geschriebene Bugs und wird in CI geprüft (`tests/honeypot/test_mcp_honeypot_e2e.py`); ihre Zahlen sind niedriger als bei Juice Shop, und genau das ist der Punkt. Wir veröffentlichen beide. Siehe den vollständigen [Juice-Shop-Benchmark vs. ZAP / Nuclei / HexStrike](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/benchmarks/juice-shop.md).

## Installation```bash
pip install ptai

Weg 1: Nutzung über Claude Code (kein API-Schlüssel)

Wenn du bereits für Claude Pro / Max / Team zahlst, ist dein Abonnement das LLM. Binde ptai als MCP-Server ein:```bash claude mcp add pentest-ai -- ptai mcp

Starte Claude Code neu und frage dann:

> *"Führe einen authentifizierten Pentest gegen staging.acme.com durch. Der Login befindet sich unter /login, das Passwort steht in $APP_PASS."*

> **Was ins Netzwerk geht**: Die Tools und Probes von ptai werden lokal gegen dein Ziel ausgeführt. Deine Prompts und die Tool-Ausgabe, die Claude Code liest, laufen über die Anthropic-API, genau wie bei jeder Claude-Code-Sitzung. Falls du einen netzwerkisolierten Pfad benötigst, siehe Pfad 3 (Ollama / On-Prem-LLM).

Claude Code steuert ptai über diese MCP-Tools (derzeit 47):

- `list_tools` / `run_tool`: Tools auflisten und beliebige der über 200 eingebundenen Sicherheitstools aufrufen
- `plan_tools` / `ensure_tools_installed`: die kanonische Tool-Liste für ein Engagement abrufen, Batch-Installation
- `list_probes` / `run_probe`: 60 SPA-bewusste Probes für OWASP-Top-10-Schwachstellenklassen
- `http_request`: rohes HTTP unter strengem Scope-Schutz für neuartige Angriffsketten
- `start_engagement` / `get_findings` / `get_attack_chains`: die Engagement-Aufzeichnung
- sowie `test_web_app`, `test_active_directory`, `test_cloud`, `test_api_security` und die restlichen

### Pfad 2: Andere MCP-Clients (Cursor, VS Code Copilot, Codex, Claude Desktop)```bash
ptai setup --mcp

Erkennt automatisch jeden MCP-kompatiblen Client, den du installiert hast, und schreibt seine Konfigurationsdateien. Starte den Client neu und dieselben 47 Tools sind vorhanden.

Pfad 3: Eigenständige CLI, wenn du KEINEN MCP-Client hast

Wenn du Claude Code, Cursor, Codex oder Claude Desktop verwendest, nutze Pfad 1 oder 2 oben und überspringe diesen Abschnitt. Dort ist kein API-Schlüssel erforderlich.

Pfad 3 ist für CI/CD-Pipelines, geplante Cron-Jobs, abgeschottete Terminals und Benutzer ohne MCP-Client gedacht. Die eigenständige CLI hat kein eigenes LLM, du bringst also eines über eine Umgebungsvariable mit:```bash export ANTHROPIC_API_KEY=sk-ant-... # Claude (best results)

or

export OPENAI_API_KEY=sk-... # OpenAI

or, fully local, no cloud

export PENTEST_AI_LLM_PROVIDER=ollama # Ollama (default localhost:11434)

or, any of 300+ models via LiteLLM (OpenRouter, Azure, DeepSeek, Groq, Mistral, ...)

pip install litellm

ptai start https://your-target.com

Nutzt du einen OpenAI-kompatiblen Endpunkt (DeepSeek cloud, Groq, Together AI, vLLM usw.)? Setze `OPENAI_BASE_URL` + `PENTEST_AI_MODEL` und verwende den openai-Provider. Vollständige Rezepte für jeden Provider - einschließlich benutzerdefinierter Modellnamen, Fehlerbehebung und der LiteLLM-300+-Liste - findest du in [`docs/llm-providers.md`](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/llm-providers.md).

#### Ausgabenlimit (nur Path 3)

Die eigenständige Agentenschleife steuert ihr eigenes LLM, daher kosten außer Kontrolle geratene Schleifen echtes Geld. ptai begrenzt die Ausgaben pro Engagement standardmäßig auf **$10 USD**. Ein normaler Web-App-Sweep mit Sonnet 4.6 und Prompt-Caching bleibt deutlich darunter; ein tiefer Lauf mit Opus 4.7 kann es weit überschreiten.

Ändere es über die Umgebungsvariable (kein CLI-Flag - die Umgebungsvariable ist der einzige Stellhebel):```bash
export PTAI_PRICE_LIMIT=25        # raise to $25
export PTAI_PRICE_LIMIT=0         # unlimited (logs a warning)
unset PTAI_PRICE_LIMIT            # back to the $10 default

Wenn das Limit mitten im Engagement auslöst, wird das Engagement als aborted_cost_limit markiert und sein Checkpoint bleibt erhalten. Erhöhen Sie das Limit und setzen Sie dort fort, wo es gestoppt wurde:```bash export PTAI_PRICE_LIMIT=25 ptai resume <engagement_id>

Pfade 1 und 2 (MCP) nutzen dieses Limit nicht - Ihr KI-Client (Claude Code, Cursor usw.) übernimmt die eigene LLM-Abrechnung.

### Sicherheitswerkzeuge installieren

ptai kapselt 200+ externe Tools. Es gibt drei Möglichkeiten, sie auf das System zu bringen:```bash
# 1. Zero-config (recommended). At engagement start, the planner predicts
#    which tools the LLM will need and asks ONCE to install the missing
#    ones. Decline once and the answer persists in
#    ~/.pentest-ai/install-preferences.json.
ptai start https://target.example.com

# 2. Batch install upfront. Skips the engagement-time prompt entirely.
ptai setup --tier core            # ~6 essentials, ~30s
ptai setup --tier recommended     # + fuzzers, crawlers, password tools, ~5m
ptai setup --tier full            # everything, ~30m

# 3. Install specific tools by name.
ptai setup --per-tool wpscan,dalfox,paramspider
ptai setup --wizard               # interactive picker

In nicht-interaktiven Kontexten (PTAI_NON_INTERACTIVE=1 oder kein TTY) nutzt ptai das, was im PATH liegt, und protokolliert (statt abzufragen), was fehlt.

Andere Wege: REST API, MCP-Komposition, HITL-Teleoperation, Cloud-Workspace, öffentliche Benchmarks

HTTP REST API (für Dashboards und Integrationen)```bash

pip install ptai[api] ptai serve --port 8888

Endpunkte: `/health`, `/version`, `/agents`, `/tools`, `/engagements` (Liste, Detail, Findings, Chains, Erkennungsregeln, SARIF-Export). Schreib-Endpunkte (`POST /engagements`, `POST /engagements/{id}/abort`) erfordern `Authorization: Bearer $PENTEST_AI_API_TOKEN`. Live-Ereignisstream unter `WS /engagements/{id}/stream`.

### Andere MCP-Server als Toolquellen laden

Kombinieren Sie mit hexstrike oder einem anderen MCP-kompatiblen Sicherheitsserver. Bearbeiten Sie `~/.pentest-ai/mcp_servers.json`:```json
{
  "servers": [
    {"name": "hexstrike", "command": "python3 hexstrike_mcp.py", "transport": "stdio"}
  ]
}

Übernahme mitten im Lauf (HITL-Teleoperation)

Während ein Engagement läuft, drücke Ctrl+C zweimal innerhalb von 600 ms, um den Orchestrator anzuhalten und in eine REPL zu wechseln: step, inspect findings, inject <instruction>, skip, resume, abort. Aktuelle LLMs sind nicht vollständig autonom. Der Operator trifft die Entscheidung, wenn es darauf ankommt.

Öffentliche Benchmarks

Reproduzierbare Messungen der Lösungsrate befinden sich in benchmarks/:```bash ./benchmarks/scripts/run_all.sh # writes JSON per run + RESULTS.md

Spezifikation, Test-Harness und Ergebnisse – alles in Git. Der vollständige Juice-Shop-Vergleich mit ZAP / Nuclei / HexStrike befindet sich unter [`docs/benchmarks/juice-shop.md`](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/benchmarks/juice-shop.md). Keine „98,7 % Erkennungsrate“-Behauptungen, die du nicht überprüfen kannst.

### Cloud-Arbeitsbereich (Pro / Team / Enterprise)

Die CLI ist für immer kostenlos und speichert alles lokal. Wenn du Engagement-Verlauf, kundenfertige PDF-Berichte mit Branding und Team-Zusammenarbeit möchtest, verbinde die CLI mit einem [app.pentestai.xyz](https://app.pentestai.xyz)-Workspace:```bash
# Sign up, then Dashboard -> API Keys -> Generate -> copy ptai_...
ptai auth login        # paste the key (hidden prompt)
ptai auth status       # confirm link
# or use an env var for CI:
export PENTESTAI_API_KEY=ptai_...

ptai start synchronisiert Ergebnisse automatisch in deinen Cloud-Arbeitsbereich, wenn du angemeldet bist. Keine Cloud = keine Aufrufe; die Integration bleibt stillschweigend deaktiviert, bis du dich anmeldest.

Ganz ohne LLM (interaktiver Launcher)```bash

ptai menu

Numeric category navigation, Suche (`/term`), Tag-Filterung (`t web`), schlüsselwortbasierte Empfehlung. Echte Engagements laufen weiterhin über `ptai start` mit vollständiger Scope-Bestätigung.

</details>

## Warum es anders ist

|  |  |
|---|---|
| 🤖 **LLM-koordiniert, nicht LLM-abhängig** | Siebzehn Agenten decken Recon, Web, API, AD, Cloud, Mobile, Wireless, Browser, Credentials, Privesc, Vuln-Scan, Chaining, PoC, Detection, Report, Social Engineering und LLM Red Team ab. Die LLM führt die Phasenschleife aus und bewertet Ergebnisse; die Fehlererkennung liegt in der kuratierten deterministischen Probe-Bibliothek. Ohne API-Schlüssel laufen dieselben Probes trotzdem. Die LLM koordiniert; sie scannt nicht. |
| 🔓 **Kein API-Schlüssel auf dem MCP-Pfad** | Claude Code / Cursor / Codex-Nutzer steuern ptai über MCP mit ihrem bestehenden Abonnement. Über 200 Tool-Wrapper und 60 Probes sind ohne Anthropic-Schlüssel LLM-aufrufbar. Das eigenständige CLI (`ptai start --agent-mode`) ist der Punkt, an dem der API-Schlüssel wichtig wird; das sind die Codex-ohne-MCP-, CI- und Air-Gapped-Pfade. |
| 🔐 **Es loggt sich ein** | Die meisten Scanner scheitern an der Login-Seite. Dieser hält eine Sitzung, aktualisiert Anmeldedaten, wenn sie ablaufen, und jedes nachgelagerte Tool erbt das Cookie. Auth-Profile speichern *Referenzen* (Env-Vars, `op://`, Vault-Pfade, AWS-Secrets-Manager-ARNs), nie den Wert. |
| 🧪 **Jeder Befund ist belegt** | Ein nicht-destruktiver Proof of Concept läuft gegen das Ziel. Keine Triage von 40 Vielleichts mehr von einem verrauschten Scanner. |
| ⚡ **CI-nativ** | GitHub Action, Severity-Gates, SARIF-Ausgabe, PR-Kommentare. Wirf es in deine Workflow-Datei und es läuft beim nächsten PR. |
| 💾 **Läuft auf deinem Laptop** | MIT-lizenziert, keine Cloud-Aufrufe. Läuft offline mit Ollama. Befunde bleiben auf deiner Festplatte. |

## Wie es funktioniert```
┌─────────────────────────────────────────────────────────────┐
│                    ptai start <target>                      │
└─────────────────────────────────────────────────────────────┘
                             │
          ┌──────────────────┼──────────────────┐
          ▼                  ▼                  ▼
      ┌────────┐        ┌────────┐        ┌─────────┐
      │ recon  │   ->    │  auth  │   ->    │   web   │
      └────────┘        └────────┘        └─────────┘
                                               │
          ┌────────────────────────────────────┤
          ▼                                    ▼
      ┌────────┐                          ┌─────────┐
      │   ad   │   ┌──────────────────┐   │ cloud   │
      └────────┘   │  Findings DB     │   └─────────┘
          │        │  (sqlite + evidence)│       │
          └───────▶│  scope-guarded     │◀──────┘
                   │  deduplicated      │
                   └──────────────────┘
                             │
                ┌────────────┼────────────┐
                ▼            ▼            ▼
           ┌──────┐    ┌─────────┐  ┌──────────┐
           │chain │    │validate │  │ detect   │
           └──────┘    └─────────┘  └──────────┘
                             │
                             ▼
                       ┌──────────┐
                       │  report  │   md · html · pdf · SARIF · JUnit
                       └──────────┘

Jeder Agent läuft mit einem LLM, wenn ein Schlüssel gesetzt ist, oder andernfalls als deterministische Tool-Schleife. In beiden Fällen bleibt die Phasenreihenfolge gleich.

Agenten

Agent	Phase	Funktion
`recon`	1	Portscan, DNS- und Subdomain-Enumeration, Service-Fingerprinting
`web`	2	Authentifizierter Durchlauf nach OWASP Testing Guide v4
`api_security`	2	OpenAPI/GraphQL/REST-Oberflächenanalyse, OWASP API Top 10
`browser`	2	Playwright-gesteuerte DOM-Analyse, XHR-Erfassung, Security-Header-Bewertung
`ad`	3	AD-Enumeration, Kerberoasting, BloodHound-Pfadsuche, Delegationsmissbrauch
`cloud`	4	AWS-, Azure-, GCP-IAM, Fehlkonfiguration, K8s-RBAC, Serverless
`credential_tester`	4	Password-Spraying, Credential-Stuffing, MFA-Bypass-Prüfungen
`privesc`	5	Hinweise zur lokalen und lateralen Privilegienausweitung auf Basis des gesammelten Kontexts
`vuln_scanner`	5	Querschnittliche Schwachstellenaggregation auf Basis der Findings-DB
`exploit_chain`	6	Korreliert Findings zu mehrstufigen Angriffspfaden
`poc_validator`	7	Nicht-destruktiver Proof of Concept pro Finding
`detection`	8	Sigma-, SPL- und KQL-Regeln für das Blue Team
`report`	9	Markdown, HTML, PDF, SARIF, JUnit, Compliance-Mappings
`llm_redteam`	opt	OWASP-LLM-Top-10-Sonden
`social_engineer`	opt	Phishing-Korpus und Pretext-Generierung
`mobile`	opt	Android/iOS statische + dynamische Prüfungen
`wireless`	opt	Wireless-Aufklärung und Handshake-Erfassung

Playbooks

Deine Methodik als Datei. In Git eingecheckt. Mit deinem Team geteilt.```yaml name: internal-ad-pentest inputs: domain: { required: true, prompt: "AD domain" } dc_ip: { required: true, prompt: "DC IP" }

phases:

id: recon tools: [nmap, masscan]
id: ad-enum depends_on: [recon] condition: "any_finding(type='open_port', port=445)" tools: [enum4linux, ldapsearch, bloodhound-python]
id: kerberoast requires_finding: { type: ad_user_enumerated } tools: [impacket-getuserspns] llm_decide: true # let the LLM skip if context says useless

# Gophish - Open-Source-Phishing-Toolkit

Gophish ist ein leistungsstarkes Open-Source-Phishing-Framework, mit dem Sie die Anfälligkeit Ihres Unternehmens für Phishing-Angriffe einfach testen können.

## Funktionen

- Phishing-Kampagnen
- E-Mail-Status verfolgen
- Web-Traffic-Verfolgung
- Kampagnenplanung
- Landingpages
- HTML-E-Mail-Vorlagen
- Gruppen und Ziele
- API-Zugriff
- Audit-Protokollierung

## Erste Schritte

[Installation](https://docs.getgophish.com/user-guide/installation)

## Dokumentation

Die vollständige Dokumentation, einschließlich Installationsanleitungen und Beispiele für den Einstieg, finden Sie [hier](https://docs.getgophish.com).```bash
ptai playbook list                  # show installed playbooks
ptai playbook show web-app-quick    # preview before running
ptai playbook run ./my-ad.yaml      # execute

Fünf Playbooks werden standardmäßig mitgeliefert. Ein Community-Katalog ist in Vorbereitung.

Lege es in deine CI```yaml

.github/workflows/security.yml

name: Security scan on: [pull_request]

jobs: ptai: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - run: pip install ptai - run: | ptai start ${{ vars.STAGING_URL }}
--ci
--fail-on high
--sarif pentest.sarif env: ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }} - uses: github/codeql-action/upload-sarif@v3 if: always() with: sarif_file: pentest.sarif

Ergebnisse werden als PR-Kommentar gepostet, SARIF-Uploads an GitHub Code Scanning, und der Build schlägt beim Überschreiten der Schweregrad-Schwelle fehl. **GitLab-CI- und Jenkins**-Vorlagen plus erweiterte Optionen (Auth-Profile in der CI, Kostenschwellen, Scope-Dateien) -> [docs/ci-cd.md](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/ci-cd.md).

## Benchmarks

Das Design von ptai ist gezielt für SPA-Pentesting mit kuratierter Sonden-Abdeckung ausgelegt. Beim OWASP Juice Shop zeigte die veröffentlichte [4-Tool-Matrix](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/benchmarks/juice-shop.md):

| Tool | Ergebnisse | Kritisch+Hoch | OWASP-Top-10-Kategorien | FP-Rate |
|---|---:|---:|---:|---:|
| **ptai 0.13.0** | **88** | **46** | **5** | **0%** |
| ZAP 2.17.0 | 593 | 0 | 1 | 47% |
| Nuclei 3.8.0 | 1 | 0 | 1 | 0% |
| HexStrike v6.0 | 11 | 0 | 1 | - |

n=1, einzelner Bewerter, einmaliger Durchlauf. Methodik + Roh-Artefakte in [`benchmarks/results/2026-05-12/juice-shop/`](https://github.com/0xsteph/pentest-ai/blob/HEAD/benchmarks/results/2026-05-12/juice-shop/). Die ehrliche Einschätzung: ptai ist besser bei SPA-Web-Pentests mit kuratierter Sonden-Abdeckung. HexStrike ist breiter aufgestellt (Cloud, Binärdateien, CTF) und schlägt ptai wahrscheinlich auf traditionellen crawlbaren Oberflächen wie WordPress. Zukünftige Releases werden den Vergleich erweitern.

Aktueller Forschungskontext: Vollautonome LLM-Pentest-Agenten schließen **21-31 %** der Aufgaben Ende-zu-Ende ab; menschlich unterstützte Setups erreichen **64 %** (ARTEMIS, DARPA AICC Atlantis, xOffense). ptai ist für das menschlich unterstützte Regime gebaut: Das LLM bewertet Ergebnisse, die kuratierten Sonden erkennen, und zweimaliges Ctrl+C ermöglicht dem Bediener die Übernahme.

## Vergleich mit der Konkurrenz

|  | `ptai` | Hexstrike | ZAP | Nuclei | Burp Pro | PentestGPT |
|---|:-:|:-:|:-:|:-:|:-:|:-:|
| LLM-gesteuert über MCP (ohne API-Schlüssel) | ✓ | ✓ | | | | |
| LLM-synthetisiertes HTTP unter Scope-Kontrolle | ✓ | teilweise | | | | |
| Authentifiziertes Scannen über MCP | ✓ | teilweise | teilweise | rohes HTTP | ✓ | |
| Exploit-Verkettung | ✓ | teilweise | | | | teilweise |
| Nicht-destruktive PoC-Validierung | ✓ | | | | teilweise | |
| Gespeicherte Injection-Ketten (POST -> GET-Verifizierung) | ✓ | manuell | teilweise | | manuell | |
| Kuratierte Sonden (spezialisiert, nicht template-getrieben) | 60 | Tool-Wrapper-gesteuert | regelbasiert | 8000+ Templates | manuell + Scan | - |
| Gekapselte CLI-Sicherheitstools | 200+ | 150+ | - | - | - | - |
| Tool-Installationsassistent | core/recommended/full + per-tool | - | n/a | n/a | n/a | - |
| Intelligente Installation zu Beginn des Engagements | ✓ | | | | | |
| CI-nativ (SARIF + Schweregrad-Gates) | ✓ | | teilweise | teilweise | teilweise | |
| LLM-Red-Team-Sonden | ✓ | | | | | |
| YAML-Playbooks | ✓ | | | Vorlagen | | |
| Lizenz | MIT | MIT | Apache-2.0 | MIT | kommerziell | MIT |

## Was enthalten ist

- **17 Agenten** für Recon, Web, API-Sicherheit, AD, Cloud, Mobil, Wireless, Browser, Credential-Tests, Privilege Escalation, Schwachstellen-Scanning, Exploit-Verkettung, PoC-Validierung, Erkennung, Reporting, LLM Red Team, Social Engineering
- **60 kuratierte Web-Sonden**, die OWASP Top 10 + API Top 10 abdecken
- **200+ Tool-Wrapper** mit Auto-Installation: nmap, masscan, nuclei, ffuf, sqlmap, gobuster, wapiti, nikto, dalfox, xsstrike, wpscan, hydra, hashcat, enum4linux, bloodhound-python, die impacket-Suite, trufflehog, gitleaks, kube-hunter, trivy, prowler, scout-suite und mehr
- **4000+ Nuclei-Templates** für die atomare Schwachstellenerkennung integriert
- **47 MCP-Tools** für LLM-gesteuerte Engagements, einschließlich `plan_tools` / `ensure_tools_installed`, die es dem äußeren LLM ermöglichen, Tools ohne Anthropic-API-Schlüssel stapelweise zu installieren
- **300+ LLM-Modelle** über den LiteLLM-Anbieter (Anthropic, OpenAI, Ollama direkt; Azure, OpenRouter, DeepSeek, Groq, Mistral, Together AI, Bedrock, Vertex AI, Cohere über LiteLLM)
- **HTTP-REST-API + WebSocket**-Oberfläche (`ptai serve`) für Nicht-MCP-Integrationen
- **Lokales Web-Dashboard** mit Live-Engagement-Ansicht, Befundtabelle, Visualisierung der Angriffskette, SARIF-Export
- **Browser-Automatisierungsagent** mit Screenshot-Erfassung, DOM-Analyse, Netzwerk-Mitschnitt, Bewertung der Security-Header (Playwright-gesteuert)
- **Human-in-the-Loop-Teleoperation** (zweimal Ctrl+C, um ein laufendes Engagement zu übernehmen)
- **MCP-Client**-Fähigkeit, externe MCP-Server als Tool-Quellen zu laden
- **Öffentlich reproduzierbare Benchmark-Umgebung** in `benchmarks/`. Zahlen, Code, Roh-Artefakte – alles in Git.
- **6 Ausgabeformate**: Markdown, HTML, PDF, SARIF 2.1.0, JUnit-XML, Compliance-Mappings (OWASP, CWE, CVE, CVSS v3.1)
- **2,400+ Tests** mit CI auf Python 3.10, 3.11, 3.12, 3.13
- **MIT-lizenziert**, 100 % deins

## Wer nutzt es wofür

**AppSec-Teams.** Binde `ptai` in eure CI ein. Jeder PR gegen Staging erhält einen authentifizierten Scan. Der Build schlägt bei Befunden mit hoher Schwere fehl. Der Ablauf Fix -> Retest -> Bestätigen läuft von selbst.

**Berater.** Richte ein einwöchiges Engagement ein, richte `ptai` auf die Zielliste aus und verbringe deine Zeit mit den Teilen, die einen Menschen brauchen: Befunde analysieren, Ketten zur Demonstration auswählen, mit dem Kunden sprechen. Der Bericht schreibt sich von selbst.

**Bug-Bounty-Jäger.** Lass es beim Frühstück laufen. Komm zurück zu einer Liste validierter Befunde mit PoCs, die du direkt in HackerOne einfügen kannst.

**Red-Teamer.** Kodiere deine AD-Methodik als YAML-Playbook. Jedes neue Engagement führt es aus. Gleiche Methodik, teamweit geteilt.

**Claude Code / Cursor / Codex-Nutzer.** Füge ptai als MCP-Server hinzu. Bitte deinen Assistenten, einen Scan in einfachem Englisch auszuführen. Dein bestehendes Abonnement bezahlt das LLM; ptai liefert die Tools.

**Entwickler, die KI-Funktionen ausliefern.** Aktiviere `--enable-llm-redteam` gegen deinen Chatbot. Erhalte in Minuten einen OWASP-LLM-Top-10-Bericht.

## Verantwortungsvolle Nutzung

`pentest-ai` ist offensive Security-Software. Sie führt echte Netzwerk- und Host-Operationen gegen die von dir angegebenen Ziele aus. **Du bist allein dafür verantwortlich, dass du eine ausdrückliche, schriftliche Genehmigung zum Testen jedes Ziels hast.**

Mit der Installation oder Ausführung von `ptai` stimmst du der [Acceptable Use Policy](https://pentestai.xyz/aup) und den [Terms of Service](https://pentestai.xyz/terms) zu. Das Testen von Systemen, die dir nicht gehören, ohne schriftliche Genehmigung kann gegen den Computer Fraud and Abuse Act, den Computer Misuse Act 1990, Artikel 32 der DSGVO und entsprechende Gesetze in deiner Rechtsordnung verstoßen. Missbrauch liegt in deiner alleinigen Verantwortung.

Beim ersten Start wirst du aufgefordert, die AUP-Zustimmung zu bestätigen; die Auswahl wird in `~/.pentest-ai/aup-consent.txt` gespeichert. Setze `PENTEST_AI_AUP_ACCEPTED=1` in CI, um die Eingabeaufforderung nicht-interaktiv zu umgehen.

Beim Start lädt `ptai` eine Scope-Datei. Hosts außerhalb des Scopes werden beim Tool-Aufruf abgelehnt. PoCs sind standardmäßig nicht destruktiv. Rate-Limits greifen im Stealth-Modus automatisch. Sei nicht diese Person.

### Out-of-band-Callbacks (OAST) – Datenschutz

`ptai` erkennt blinde Schwachstellenklassen (blindes SSRF, blindes SQLi, blindes XXE, blindes gespeichertes XSS, SSTI, Log4Shell), indem es Payloads aussendet, die, wenn sie serverseitig ausgelöst werden, einen Out-of-Band-Collaborator anrufen. Standardmäßig werden Callbacks an ProjectDiscoverys öffentliche `oast.fun`-Infrastruktur weitergeleitet.

**Was auf dem Collaborator landet und wer es lesen kann.** Jedes Engagement erzeugt ein frisches RSA-2048-Schlüsselpaar in deinem lokalen `ptai`-Prozess. Interaktions-Payloads (rohe HTTP-Anfragen, DNS-Abfragen, SMTP-Envelopes, die der Collaborator empfängt) werden serverseitig mit AES-CTR-256 im Ruhezustand verschlüsselt, wobei der AES-Schlüssel mit RSA-OAEP-SHA256 unter Verwendung des öffentlichen Schlüssels deines Engagements verpackt ist. **Nur der Inhaber des passenden privaten Schlüssels – dein lokaler `ptai`-Prozess – kann sie entschlüsseln.** ProjectDiscovery (oder wer auch immer den Collaborator betreibt) kann den Inhalt der Interaktionen nicht lesen. Allerdings ist **Metadaten serverseitig sichtbar**: die Tatsache, dass eine Interaktion stattfand, die Quell-IP des aufrufenden Ziels, der Zeitstempel und das Protokoll.

**Wann selbst hosten.** PortSwigger verbietet ausdrücklich die Nutzung des öffentlichen Burp-Collaborators in ihren Bug-Bounty-Regeln für Engagements, und große Unternehmensprogramme (Meta, Apple, Finanzsektor) verlangen zunehmend, dass die Callback-Infrastruktur auf vom Tester kontrollierten Hosts endet. Für bezahlte Engagements betreibe deinen eigenen Interactsh-Server (Apache-2.0, einzelne Go-Binary) und richte ptai darauf aus:```bash
ptai start http://target --oast-server https://oast.example.com --oast-token <T>

Um OAST vollständig zu deaktivieren:```bash ptai start http://target --no-oast

Blind-Schwachstellenklassen werden bei deaktiviertem OAST nicht erkannt; In-Band-Erkennungspfade (Größendelta / SQL-Fehlermarkierungen / Metadaten-Signaturen / zeitbasiert) laufen weiterhin.

## Ökosystem

| Repo | Was |
|---|---|
| [**pentest-ai**](https://github.com/0xSteph/pentest-ai) | Dieses Repo. Der CLI- und MCP-Server. Python-Produkt. |
| [**pentest-ai-agents**](https://github.com/0xSteph/pentest-ai-agents) | Eigenständige Markdown-Dateien für Claude-Code-Subagenten. Optional, läuft ohne diese CLI. |

Brauchst du gemeinsame Arbeitsbereiche, gebrandete PDF-Berichte, SSO oder ein gemanagtes Engagement? Die [Website](https://pentestai.xyz) bietet Pro-/Team-/Enterprise-Dashboards und eine One-Shot-Option für Launch Engagements. Das OSS-Tool bleibt OSS, für immer kostenlos.

## Community

- **Discord:** [dem Server beitreten](https://discord.gg/6weeTAubJw). Chatten, Hilfe bekommen, Findings teilen, mitlesen.
- **Fragen, Ideen, Feedback:** [GitHub Discussions](https://github.com/0xSteph/pentest-ai/discussions)
- **Bugmeldungen:** [GitHub Issues](https://github.com/0xSteph/pentest-ai/issues)
- **Show and tell:** poste das verrückteste Finding, das dir `ptai` geliefert hat, in [Show and tell](https://github.com/0xSteph/pentest-ai/discussions/categories/show-and-tell)

## FAQ

**Brauche ich einen API-Schlüssel?** Nein auf dem MCP-Pfad. Wenn du ptai über Claude Code, Cursor, Codex oder Claude Desktop steuerst, fungiert dein bestehendes Abonnement als LLM. Einen Schlüssel brauchst du nur bei der eigenständigen CLI (Pfad 3), und selbst dort kannst du vollständig lokal mit Ollama arbeiten. Siehe [Installation](#install).

**Ist es wirklich autonom, oder muss ich es babysitten?** Du bleibst im Loop. ptai ist LLM-koordiniert, nicht autonom - die kuratierten Probes übernehmen die Erkennung, das LLM analysiert die Ergebnisse, und du triffst die Entscheidung. Drücke während des Laufs zweimal Ctrl+C, um die Kontrolle zu übernehmen. Vollautonome LLM-Agenten schließen 21-31 % der Pentest-Aufgaben Ende-zu-Ende ab; menschlich unterstützte Setups erreichen 64 %, und ptai ist für dieses zweite Regime gebaut.

**Ist es sicher, es auf die Produktion zu richten?** Nur mit schriftlicher Autorisierung und nur mit eingeschalteten Guardrails: `intensity=safe` überspringt zustandsverändernde Probes, `respect_rate_limits` respektiert 429 / Retry-After, und `strict_scope` lehnt Off-Host-Anfragen ab und folgt keinen Weiterleitungen mehr. Alle drei sind standardmäßig deaktiviert, also schalte sie ein. Siehe [Verantwortungsvolle Nutzung](#responsible-use).

**Warum ist die Juice-Shop-Zahl hoch, aber die des Honeypots niedriger?** Juice Shop ist die am besten dokumentierte verwundbare App im Internet, daher haben sowohl das LLM als auch die Probe-Autoren einen Vorsprung. Der private Honeypot misst Bugs, die wir selbst geschrieben haben, daher ist seine Zahl niedriger - und diese niedrigere Zahl ist das ehrliche Signal. Wir veröffentlichen beide. Siehe [Benchmarks](#benchmarks).

**Meldet es sich nach Hause?** Keine Telemetrie, und Findings bleiben auf deiner Festplatte. Auf dem MCP-Pfad laufen deine Prompts und die Tool-Ausgabe, die dein KI-Client liest, über die API dieses Clients, wie bei jeder Sitzung. Die Blind-Schwachstellenerkennung (OAST) sendet standardmäßig Callbacks an das öffentliche oast.fun - die Inhalte sind mit einem lokalen Schlüsselpaar verschlüsselt, aber die Tatsache, dass ein Callback stattgefunden hat, plus Quell-IP und Zeitstempel sind für jeden sichtbar, der den Collaborator betreibt. Hoste Interactsh selbst oder führe es mit `--no-oast` aus, um das zu vermeiden. Siehe [Verantwortungsvolle Nutzung](#responsible-use).

**Was kostet der Betrieb?** Auf dem MCP-Pfad nichts außer deinem KI-Abonnement, das seine eigene Abrechnung übernimmt. In der eigenständigen CLI deckelt ptai die Ausgaben standardmäßig bei 10 $ pro Engagement; ändere das mit `PTAI_PRICE_LIMIT`. Siehe [Installation](#install).

**Wie unterscheidet sich das von der bloßen Verwendung von Claude oder PentestGPT?** Eine kuratierte deterministische Probe-Bibliothek findet die Bugs; das LLM führt die Phasenschleife aus und analysiert die Ergebnisse, es scannt nicht. Deshalb sind Findings reproduzierbar und werden mit einem funktionierenden PoC geliefert, statt mit einer LLM-Vermutung. Siehe [Warum es anders ist](#why-its-different) und [vs. den Rest](#vs-the-field).

## Sternenverlauf

<a href="https://star-history.com/#0xSteph/pentest-ai&Date">
  <img src="https://assets.kitploit.com/production/public/readmes/placeholders/f0fc86cfe65f76d40e15aaec61704ec8220a56dc89d4be03c46f67cb31b9fa8c.svg" alt="Star history chart" width="600">
</a>

## Lizenz

MIT. Mach damit, was du willst.

<div align="center">

**Wenn dir `ptai` einen Sonntag erspart hat, [gib dem Repo einen Stern](https://github.com/0xSteph/pentest-ai). Es ist die einzige Zahlung, um die ich bitte.**

</div>