F --> G1[Passive scanners]
F --> G2[Active scanners]

I[template-tool] --> H[CVE templates]
H --> G2

G1 --> J[Findings]
G2 --> J
J --> K[Reporter]
K --> L[Auto Reports]
K --> M[CI/CD Controls]

## Warum ApiHunter?

### Hauptvorteile

- **API-First-Architektur**: Speziell für REST/GraphQL-APIs entwickelt, nicht von Web-App-Scannern abgeleitet
- **Intelligente Reduzierung falscher Positiver**:
  - SPA-Catch-all-Erkennung mit Canary-Probing
  - Kontextbewusste Secret-Validierung (Frontend vs. Backend)
  - Body-Content-Validierung und Referer-Prüfung
  - Response-Fingerprinting zur Vermeidung doppelter Funde
- **Produktionssicher von Grund auf**:
  - Adaptive Nebenläufigkeit (AIMD), die bei Fehlern zurückfährt
  - Pro-Host-Ratenbegrenzung mit konfigurierbaren Verzögerungen
  - Höflichkeitskontrollen (Wiederholungen, Timeouts, WAF-Umgehung)
  - Dry-Run-Modus für aktive Prüfungen
- **Tarnung & Umgehung**:
  - User-Agent-Rotation zur Laufzeit aus einer kuratierten Sammlung (assets/user_agents.txt)
  - Zufällige Anforderungsverzögerungen mit Jitter
  - Pro-Host-Verzögerungsdurchsetzung (vermeidet Burst-Muster)
  - Wiederholungslogik mit exponentiellem Backoff
  - Benutzerdefinierte Header-Injektion zur Tarnung als legitimer Traffic
  - Adaptive Zeitsteuerung basierend auf Serverantworten
  - Keine festcodierten Scanner-Fingerabdrücke im Standardmodus

### Tarnungstechniken im Detail

ApiHunter verwendet mehrere Tarnungstechniken, um von WAF (Web Application Firewall) und Bot-Schutzsystemen nicht erkannt zu werden:

#### 1. User-Agent-Rotation
**Was es tut:** Zufälliger Wechsel durch 100+ echte Browser-User-Agent-Strings aus einer Datei (`assets/user_agents.txt`)

**Warum es funktioniert:** Bots verwenden typischerweise denselben User-Agent (z. B. `curl/7.68.0`). Durch Vortäuschung von Chrome, Firefox, Safari usw. tarnt man sich als legitimer Traffic.

**Einfacher Vergleich:** Wie das Tragen verschiedener Verkleidungen, anstatt immer dieselbe Uniform zu tragen.

#### 2. Zufällige Zeitsteuerung & Jitter
**Was es tut:** Fügt zufällige Verzögerungen zwischen Anfragen hinzu (gesteuert durch `--delay-ms`) mit Jitter (kleine zufällige Abweichungen)

**Warum es funktioniert:** Bots senden Anfragen in perfekten Intervallen (genau 100 ms auseinander). Menschen sind unberechenbar. Zufällige Zeitsteuerung lässt Traffic organisch wirken.

**Einfacher Vergleich:** Gehen mit unregelmäßigen Schritten anstatt Marschieren wie ein Roboter.

#### 3. Pro-Host-Verzögerungsdurchsetzung
**Was es tut:** Verfolgt die Verzögerung separat für jede Domain, nicht global.

**Warum es funktioniert:** Verhindert Burst-Muster, bei denen ein Host 50 Mal sofort angegriffen wird. Jeder Host sieht höfliche, zeitlich verteilte Anfragen.

**Einfacher Vergleich:** Abwechselnd in verschiedenen Gesprächen zu Wort kommen, anstatt immer wieder dieselbe Person anzubrüllen.

#### 4. Adaptive Nebenläufigkeit (AIMD)
**Was es tut:** Automatische Verlangsamung bei 429 (Ratenlimit) oder 503 (Server ausgelastet) Fehlern, Beschleunigung bei Erfolg.

**Warum es funktioniert:** Zurückfahren bei Erkennung, Nachahmung des Browser-Wiederholungsverhaltens. WAFs sehen „dieser Client respektiert unsere Grenzen“.

**Einfacher Vergleich:** Langsamer fahren bei Stau, schneller auf freier Strecke.

#### 5. Wiederholung mit exponentiellem Backoff
**Was es tut:** Wenn eine Anfrage fehlschlägt, wird 1s, dann 2s, dann 4s gewartet, bevor erneut versucht wird.

**Warum es funktioniert:** Legitime Clients wiederholen höflich. Bots senden oft sofort erneut oder geben auf.

**Einfacher Vergleich:** An eine Tür klopfen und jedes Mal länger warten, anstatt ununterbrochen zu hämmern.

#### 6. Keine Scanner-Fingerabdrücke
**Was es tut:** Sendet keine Header wie `X-Scanner: ApiHunter` oder vorhersagbare Muster.

**Warum es funktioniert:** Viele Tools hinterlassen Signaturen (Nuclei-Templates, sqlmap-Muster). ApiHunter vermeidet offensichtliche Marker.

**Einfacher Vergleich:** Kein Namensschild mit der Aufschrift „Sicherheitstester“ tragen.

#### 7. Verbindungswiederverwendung & Pooling
**Was es tut:** Verwendet Pro-Host-HTTP-Client-Pools, hält Verbindungen aktiv.

**Warum es funktioniert:** Browser nutzen Verbindungen wieder. Jede Anfrage eine neue Verbindung zu öffnen/schließen wirkt verdächtig.

**Einfacher Vergleich:** Die Tür offen lassen, anstatt sie zuzuschlagen und erneut zu klingeln.

#### 8. Benutzerdefinierte Header-Injektion
**Was es tut:** Kann Header wie `Referer`, `X-Forwarded-For`, benutzerdefinierte Cookies hinzufügen.

**Warum es funktioniert:** Lässt Anfragen aussehen, als kämen sie aus einem legitimen Anwendungsfluss (Link geklickt, Sitzungscookies vorhanden).

**Einfacher Vergleich:** Beim Eintritt in eine Veranstaltung eine Eintrittskarte vorzeigen, anstatt über den Zaun zu springen.

#### Erkennungsvergleich

| Technik | Ohne Umgehung | Mit Umgehung |
|---------|---------------|--------------|
| **User-Agent** | `python-requests/2.28.0` (offensichtlicher Bot) | `Mozilla/5.0 (Windows NT 10.0; Win64; x64)...` (sieht aus wie Chrome) |
| **Zeitsteuerung** | Perfekte 100-ms-Intervalle → WAF blockiert | 120 ms, 95 ms, 180 ms → sieht menschlich aus |
| **Wiederholungen** | Sofortiger erneuter Versuch → Sperre | Warte 1s→2s→4s → „geduldiger Client“ |
| **Nebenläufigkeit** | 100 parallele Treffer → Alarm | Adaptiv 5→10→3 basierend auf Antwort → „höflicher Browser“ |

#### Wann `--waf-evasion` verwenden

- Testen von Produktions-APIs mit Cloudflare/Akamai/AWS WAF
- Vermeidung von IP-Sperren bei großen Scans
- Penetrationstests, bei denen Sie unter dem Radar bleiben müssen

- **CI/CD-nativ**:
  - Baseline-Diffing (nur neue Befunde melden)
  - Streaming-NDJSON-Ausgabe für Echtzeit-Überwachung
  - SARIF 2.1.0 für GitHub/GitLab Code Scanning
  - Exit-Code-Bitmaske für Pipeline-Steuerung
  - Schweregrad-basierte Filterung und Fehlerschwellen
- **Leistung im großen Maßstab**:
  - Rust-async-Laufzeit (tokio) mit Zero-Cost-Abstraktionen
  - Gleichzeitiges Scannen mit Semaphor-begrenzter Parallelität
  - Pro-Host-HTTP-Client-Pools zur Vermeidung von Verbindungsengpässen
  - Effiziente Speichernutzung (keine GC-Pausen)
- **Umfassende Authentifizierungsunterstützung**:
  - JSON-basierte Authentifizierungsabläufe mit Cookie/Header-Extraktion
  - Dual-Identity-IDOR/BOLA-Tests
  - Sitzungsdatei-Import (Excalibur-Integration)
  - Bearer-, Basic- und benutzerdefinierte Header-Authentifizierung
  - Automatischer nicht authentifizierter Client für Privilege-Escalation-Prüfungen

## Scanner-Module

ApiHunter enthält 13 integrierte Scanner-Module. Siehe [docs/scanners.md](https://github.com/teycir/apihunter/blob/main/docs/scanners.md) für detaillierte Erkennungslogik.

| Scanner | Typ | Was wird erkannt |
|---------|-----|------------------|
| **CORS** | Passiv | Wildcard-Origins, reflektierte Origins mit Credentials, Null-Origin-Akzeptanz, Regex-ByPass-Schwachstellen (Suffix/Präfix-Angriffe), fehlender Vary: Origin, unsichere Preflight-Methoden |
| **CSP** | Passiv | Fehlende Content-Security-Policy, unsafe-inline/unsafe-eval-Direktiven, Wildcard-Quellen, umgehbare CDN-Hosts (JSONP-Gadgets), fehlende frame-ancestors |
| **GraphQL** | Passiv | Introspection aktiviert, sensible Schema-Felder (user/password/token-Typen), Feld-Vorschläge (Schema-Leak), Query-Batching, Alias-Amplification (DoS), GraphiQL/Playground-Exposition |
| **JWT** | Passiv | alg=none-Token, schwache HS256-Geheimnisse (Wortlisten-basiert), fehlende/übermäßige Ablaufzeit, sensible Claims in der Payload, Algorithm Confusion-Schwachstellen |
| **OpenAPI** | Passiv | Fehlende Security Schemes, Operationen ohne Auth-Anforderungen, Datei-Upload-Endpunkte, veraltete Operationen, ungesicherte sensible Endpunkte |
| **API-Versionierung** | Passiv | Versions-Header-Offenlegung, gleichzeitige Legacy-/neue API-Versionen, Deprecation-Header und Antwortdriften über harmlose Abfrage-/Versionsvarianten (plus Tiefenmodus über `--response-diff-deep`) |
| **gRPC/Protobuf** | Passiv + Aktiv | gRPC-Transport/Content-Type-Signale, Protobuf-Oberflächenhinweise sowie optionale Reflexion/Health-Probe-Signale |
| **API-Sicherheit** | Passiv + Aktiv | Fehlende Sicherheits-Header (X-Content-Type-Options, X-Frame-Options), Server-Versions-Offenlegung, nicht authentifizierter Zugriff auf sensible Pfade, HTTP-Methoden-Enumeration, Debug-Endpunkte, Secret-Exposure-Muster, aktive IDOR/BOLA-Prüfungen (Body + ausgewählter Header-Vergleich), blinde SSRF-Callback-Probes sowie Gateway/ByPass-Probe-Signale |
| **Mass Assignment** | Aktiv | Reflektierte sensible Felder (is_admin, role, permissions), persistierte Zustandsänderungen, Privilege Escalation durch Feldinjektion |
| **OAuth/OIDC** | Aktiv | Redirect-URI-Validierungs-ByPass, fehlender State-Parameter, PKCE-Unterstützungsprobleme (fehlendes S256, Plain erlaubt), impliziter Flow aktiviert, Password-Grant aktiviert |
| **Rate Limit** | Aktiv | Fehlendes Ratenlimit (Burst-Probes), fehlende Retry-After-Header, IP-Header-Spoofing-ByPass (X-Forwarded-For) |
| **WebSocket** | Aktiv | WebSocket-Upgrade-Akzeptanz auf häufigen Pfaden, fehlende Origin-Validierung, nicht authentifizierte WebSocket-Verbindungen |
| **CVE-Vorlagen** | Aktiv | Vorlagengetriebene CVE-Erkennung aus `assets/cve_templates/*.toml` (derzeit 168 Vorlagen), Baseline-vs-ByPass-differentieller Abgleich |

**Passiv-Scanner** laufen standardmäßig und analysieren Antworten ohne maßgeschneiderte Anfragen zu senden.  
**Aktiv-Scanner/Prüfungen** erfordern `--active-checks` und senden potenziell invasive Sonden (IDOR/BOLA, Mutation, ByPass-Tests).  
IDOR/BOLA lebt unter dem `API-Sicherheit`-Scanner (es gibt kein dediziertes `--no-idor`-Flag; verwenden Sie `--no-api-security`, um es zu deaktivieren).

### Modulausgabe & Signalhinweise

Diese Hinweise fassen zusammen, wie Befunde ausgegeben werden und was typischerweise Rauschen verursacht:

| Modul | Befund-Präfix / Form | Häufige falsch Positive | Häufige falsch Negative |
|-------|-----------------------|-------------------------|-------------------------|
| CORS | `cors/*` mit Origin/Evidence-Feldern | Reflexion auf nicht sensiblen Routen | Origin-Prüfungen nur auf authentifizierten Routen angewendet |
| CSP | `csp/*` mit Directive-Evidence | Legacy-CSP, absichtlich während Migration angewendet | CSP wird nur auf Produktions-CDN-Edge-Pfad ausgeliefert |
| GraphQL | `graphql/*` mit Endpunkt + Capability-Signal | Öffentliche Playgrounds, für interne/Test-Mandanten bestimmt | Schema-Kontrollen erst nach Auth aktiviert |
| JWT | `jwt/*` mit Token-Claim/Header-Evidence | Test-/Demo-Token in synthetischen Antworten | Token erscheint nie in gescannten Antworten |
| OpenAPI | `openapi/*` mit Operation/Security-Kontext | Spezifikation enthält absichtlich veraltete, aber blockierte Endpunkte | Spezifikation nicht verfügbar oder auf private Dokumente verteilt |
| API-Versionierung | `api_versioning/*` + `response_diff/*` | Mehrere unterstützte Versionen während kontrollierter Migrationen | Versionierte Pfade nicht aus aktueller Seed-Menge entdeckbar |
| gRPC/Protobuf | `grpc_protobuf/*` mit Transport/Reflexion-Evidence | gRPC-ähnliche Metadaten auf Edge-Proxys ohne offengelegte RPC-Oberfläche | gRPC-Endpunkte hinter separatem Host/Pfad von Seed-Menge nicht erreicht |
| API-Sicherheit | `api_security/*` mit Header/Pfad/Methoden-Evidence | Debug/Test-Endpunkte absichtlich in Nicht-Prod exponiert | Kontrollen hinter Auth/Session-Kontext erzwungen |
| Mass Assignment | `mass_assignment/*` mit reflektierten/persistierten Deltas | Echo-Verhalten, das nicht den Backend-Zustand persistiert | Mutationen durch versteckte Validierungsregeln abgelehnt |
| OAuth/OIDC | `oauth/*` mit Redirect/Metadaten-Evidence | Nicht-Produktions-IdP-Konfiguration mit gelockerten Richtlinien | Dynamische Richtliniendurchsetzung nicht in Metadaten sichtbar |
| Rate Limit | `rate_limit/*` mit Burst/429-Verhalten | Globales Traffic-Shaping überlagert App-Ebene-Limiter-Verhalten | Langzeit-Limiter nicht durch kurzes Sondenfenster ausgelöst |
| WebSocket | `websocket/*` mit Upgrade/Origin-Prüfungen | Öffentliche WS-Endpunkte absichtlich anonym | Auth über Handshake-Header erforderlich, nicht in Sonde bereitgestellt |
| CVE-Vorlagen | `cve/<id>/<check>` mit Template-Evidence | Fingerprint-Kollision auf generischen Endpunkten | Verwundbarer Pfad/Kontext nicht von Seed-URLs erreicht |

Für detaillierte Informationen und Anleitungen zur Behebung siehe [docs/scanners.md](https://github.com/teycir/apihunter/blob/main/docs/scanners.md) und [docs/findings.md](https://github.com/teycir/apihunter/blob/main/docs/findings.md).  
Die Scanner-Dokumentation enthält jetzt einen quellalinierten [Modulprüfkatalog](https://github.com/teycir/apihunter/blob/main/docs/scanners.md#module-check-catalog) und ein [Erwartungsmodell für falsch Positive](https://github.com/teycir/apihunter/blob/main/docs/scanners.md#false-positive-expectation-model).

## Funktionen

### Passive Sicherheitsanalyse
- **CORS-Fehlkonfigurationserkennung**:
  - Dynamische Origin-Generierung basierend auf der Ziel-Domain
  - Regex-ByPass-Tests (Suffix/Präfix-Angriffe)
  - Credential-bewusste Schweregradeinstufung
  - Wildcard- und Null-Origin-Erkennung
- **CSP-Richtlinienanalyse**:
  - Erkennung fehlender/schwacher Content Security Policy
  - Unsichere Inline/Eval-Direktiven
  - Wildcard-Quellenerkennung
  - Richtlinien-ByPass-Muster
- **GraphQL-Sicherheit**:
  - Introspection-Abfrageerkennung
  - Analyse sensibler Typen/Feldnamen
  - Query-Batching-Unterstützungserkennung
  - Alias-Amplification (DoS) Sondierung
  - Aktives Mutations-Fuzzing (`--active-checks`, unterstützt `--dry-run`)
  - GraphiQL/Playground-Exposition
- **JWT-Tokenanalyse**:
  - Algorithm Confusion (alg=none, HS256→RS256)
  - Schwache Secret-Erkennung (kuratierte Wortliste)
  - Erkennung langlebiger Token (fehlende/übermäßige exp)
  - Offenlegung sensibler Claims
  - Tokenextraktion aus Headern und Cookies
- **OpenAPI/Swagger-Analyse**:
  - Security-Scheme-Validierung
  - Datei-Upload-Endpunkt-Erkennung
  - Kennzeichnung veralteter Operationen
  - Fehlende Sicherheitsdefinitionen
  - Spec-Caching für Leistung
- **gRPC/Protobuf-Abdeckung**:
  - gRPC-Antwortmetadaten/Content-Type-Erkennung
  - Protobuf-Oberflächenhinweis-Erkennung aus Endpunkt-Metadaten/Pfadform
  - Optionale Reflexion/Health-Aktiv-Probe-Signale auf bekannten gRPC-Pfaden
- **Secret-Exposure-Erkennung**:
  - AWS-Schlüssel (AKIA*, Secret Keys)
  - Google-API-Schlüssel (AIza*)
  - GitHub-Token (ghp_*, github_pat_*)
  - Slack-Token (xox*)
  - Stripe-Schlüssel (sk_live_*, pk_live_*)
  - Datenbank-URLs, private Schlüssel, Bearer-Token
  - Kontextbewusste Validierung (reduziert falsch Positive)
- **API-Sicherheitsprüfungen**:
  - HTTP-Methoden-Enumeration
  - Debug-Endpunkt-Erkennung
  - Directory-Listing-Exposition
  - Sicherheit.txt-Vorhandensein
  - Antwort-Header-Analyse (HSTS, X-Frame-Options usw.)
  - Offenlegung von Fehlermeldungen

### Aktive Sicherheitstests (--active-checks)
- **API-Sicherheit-IDOR/BOLA-Prüfungen** (3-Stufen-Ansatz):
  - Test nicht authentifizierten Zugriffs
  - Antwortvergleich über Body-Fingerabdrücke plus stabile Header-Snapshots
  - ID-Enumeration (±2 Bereichsdurchlauf)
  - Benutzerübergreifende Autorisierungsbypässe (Dual-Identity)
  - Blinde SSRF-Callback-Sondierung über Callback-artige Query-Parameter (`APIHUNTER_OAST_BASE`, unterstützt `--dry-run`)
  - Gateway-Fingerprint- und ByPass-Sondierung (`api_security/gateway-*`)
- **Mass Assignment-Schwachstellen**:
  - Reflektierte Injektion sensibler Felder
  - Erkennung persistierter Zustandsänderungen
  - Baseline→Mutate→Confirm-Verifikation
  - Privilege Escalation durch Feldinjektion
- **OAuth/OIDC-Sicherheit**:
  - Redirect-URI-Validierungs-ByPass
  - State-Parameter-Handling
  - PKCE-Unterstützungserkennung
  - Härtung der Metadatenkonfiguration
  - Erkennung von Implizitem Flow und Password Grant
- **Ratenbegrenzung**:
  - Burst-Anforderungssondierung
  - Erkennung fehlender Ratenbegrenzung
  - Retry-After-Header-Validierung
  - IP-Header-Spoofing-ByPass-Tests
- **WebSocket-Sicherheit**:
  - Upgrade-Akzeptanz auf häufigen Pfaden
  - Origin-Validierungstests
  - Fehlende Authentifizierungsprüfungen
- **CVE-Vorlagen-Engine**:
  - TOML-basierter Vorlagenkatalog
  - Nuclei YAML-Importunterstützung
  - Baseline-vs-ByPass-differentieller Abgleich
  - Host+Template-Deduplizierung
  - Lader-Qualitätsgates überspringen ungültige/unsichere Anforderungsvorlagen (z. B. nicht aufgelöste Anforderungs-Platzhalter)
  - Segmentbewusster Kontextabgleich reduziert breites Pfad-Substring-Überauslösen
  - Aktueller lokaler Katalog: 168 Vorlagen (enthält kuratierte gehärtete Prüfungen wie CVE-2022-22947, CVE-2021-29442, CVE-2021-29441, CVE-2020-13945, CVE-2021-45232, CVE-2022-24288)

### Entdeckung & Enumeration
- **Endpunkt-Entdeckung**:
  - robots.txt-Parsing
  - sitemap.xml-Parsing
  - OpenAPI/Swagger-Spec-Import
  - HAR-Datei-Import (Excalibur-Integration)
  - Postman/Insomnia-Sammlungsimport (`--collection`)
  - JavaScript-Endpunkt-Extraktion
  - Gleich-Host-Filterung
- **URL-Zugänglichkeits-Vorfilterung**:
  - Schnelle Vorkontrolle zur Überspringung toter Endpunkte
  - Konfigurierbares Timeout
  - Optionale Umgehung mit --no-filter

### Leistung & Zuverlässigkeit
- **Adaptive Nebenläufigkeit (AIMD)**:
  - Automatische Ratenanpassung basierend auf Fehlern
  - Additive Erhöhung (alle 5s)
  - Multiplikatives Verringern bei 429/503/Timeouts
- **Tarnung & WAF-Umgehung**:
  - User-Agent-Rotation aus Laufzeit-Pool (assets/user_agents.txt mit 100+ echten UAs)
  - Eingebettete Fallback-UAs, falls Datei nicht verfügbar
  - Zufällige Verzögerungs-Jitter zur Vermeidung von Erkennungsmustern
  - Pro-Host-Zeitsteuerungsdurchsetzung (nicht global)
  - Wiederholungslogik mit exponentiellem Backoff
  - Benutzerdefinierte Header-Injektion (X-Forwarded-For, Referer usw.)
  - Adaptive Zeitsteuerung basierend auf 429/503-Antworten
  - Höflichkeitsmodus für kooperatives Testen
  - Keine Scanner-Fingerabdrücke in User-Agent oder Headern standardmäßig
- **Ressourcenmanagement**:
  - Semaphor-begrenzte Parallelität
  - Pro-Host-HTTP-Client-Pools
  - Verbindungswiederverwendung und Pooling
  - Konfigurierbare Timeouts und Wiederholungen
- **Fehlerbehandlung**:
  - Panik-Wiederherstellung über JoinSet
  - Erfasste Fehler separat gemeldet
  - Graceful Degradation bei Scanner-Fehlern

### Ausgabe & Berichterstattung
- **Mehrere Ausgabeformate**:
  - Pretty JSON (lesbar)
  - NDJSON (Streaming, analysierbar)
  - SARIF 2.1.0 (GitHub/GitLab Code Scanning)
- **Baseline-Diffing**:
  - Baseline-Snapshots generieren
  - Scans vergleichen, um nur neue Befunde zu melden
  - Perfekt für Regressionstests
- **Auto-Save Reports** (standardmäßig aktiviert, mit `--no-auto-report` deaktivierbar):
  - Gespeichert in ~/Documents/ApiHunterReports/<timestamp>/
  - findings.json (strukturierte Befunde)
  - summary.md (Markdown-Bericht)
  - scan.log (Ausführungsprotokoll)
- **Echtzeit-Streaming**:
  - Befunde streamen, sobald sie entdeckt werden
  - NDJSON-Format zur Live-Analyse
  - Fortschrittsverfolgung
- **Schweregrad-Filterung**:
  - Nach minimalem Schweregrad filtern (info/low/medium/high/critical)
  - Fail-on-Schwelle für CI/CD
  - Exit-Code-Bitmaske (0x01 Befunde, 0x02 Fehler)

### Integration & Erweiterbarkeit
- **Steckbare Scanner-Architektur**:
  - Scanner-Trait implementieren, um Module hinzuzufügen
  - Async-first-Design
  - Unabhängige Scanner-Ausführung
  - Panik-Isolation pro Scanner
- **TOML-basierte Erweiterbarkeit**:
  - CVE-Vorlagenkatalog in assets/cve_templates/*.toml
  - Keine Codeänderungen erforderlich, um neue Prüfungen hinzuzufügen
  - Vorlagengetriebene Schwachstellenerkennung
  - Von der Community teilbares Vorlagenformat
- **Nuclei-Vorlagen-Import**:
  - template-tool-Binärprogramm zur YAML→TOML-Konvertierung
  - Automatische Matcher-Übersetzung (status, word, regex, dsl)
  - Sichere Preflight-Request-Chain-Extraktion
  - Bewahrt Erkennungslogik von Upstream-Vorlagen
- **Duales Erweiterungsmodell**:
  - **Codebasiert**: Rust-Scanner schreiben, die Scanner-Trait für komplexe Logik implementieren
  - **Vorlagenbasiert**: TOML-Vorlagen für signaturbasierte Prüfungen (CVEs, Fehlkonfigurationen) schreiben
  - Beste aus beiden Welten: Leistung + Flexibilität
- **Ergänzende Tools**:
  - Excalibur-Browsererweiterung (HAR-Erfassung)
  - BurpAPIsecuritysuite (manuelles Testen)
  - Workflow: Erfassen → Automatisieren → Tiefentest

### Konfiguration & Steuerung
- **Flexibler Input**:
  - Dateibasierte URL-Listen
  - stdin (Pipe von anderen Tools)
  - HAR-Datei-Import
  - Postman/Insomnia-Sammlungsimport
  - OpenAPI-Spec-Import
- **Granulare Scanner-Steuerung**:
  - Einzelne Scanner aktivieren/deaktivieren
  - Aktiver vs. passiver Modus
  - Dry-Run für aktive Prüfungen
  - Pro-Scanner-Konfiguration
- **Netzwerkkonfiguration**:
  - HTTP/HTTPS-Proxy-Unterstützung
  - TLS-Zertifikatsvalidierungskontrolle
  - Benutzerdefinierte Header und Cookies
  - Konfigurierbare Timeouts und Wiederholungen
- **Scan-Profile**:
  - quickscan.sh (schnell, geringe Auswirkungen)
  - deepscan.sh (umfassend, aktive Prüfungen)
  - inaccessiblescan.sh (erneute Prüfung zuvor unzugänglicher Ziele mit langsameren Einstellungen)
  - baselinescan.sh (Baseline generieren)
  - diffscan.sh (gegen Baseline vergleichen)
  - authscan.sh (authentifiziertes Scannen)
  - sarifscan.sh (CI/CD-Integration)
  - scan-and-report.sh (Scan ausführen + letzten Berichtspfad ausgeben)
  - split-by-host.sh (Ziele nach Host aufteilen und optional Scans verteilen)

## Vergleich mit anderen Tools| Funktion | ApiHunter | Nuclei | ZAP | Burp Suite | ffuf |
|---------|-----------|--------|-----|------------|------|
| **Sprache** | Rust | Go | Java | Java | Go |
| **Leistung** | ⚡⚡⚡ Asynchron, adaptive Nebenläufigkeit | ⚡⚡ Schnell parallel | ⚡ Mäßig | ⚡ Mäßig | ⚡⚡⚡ Sehr schnell |
| **API-First-Design** | ✅ Für APIs entwickelt | ❌ Allgemeines Web | ⚠️ Hybrid | ⚠️ Hybrid | ❌ Fuzzing-Fokus |
| **False-Positive-Filterung** | ✅ SPA-Erkennung, Body-Validierung, Referer-Prüfungen | ⚠️ Template-abhängig | ⚠️ Viele FPs | ✅ Gut | N/A |
| **CORS/CSP-Analyse** | ✅ Tiefgehende Policy-Analyse | ⚠️ Basis-Templates | ✅ Gut | ✅ Gut | ❌ |
| **GraphQL-Introspection** | ✅ Schema-Exposition + Prüfung sensibler Felder | ⚠️ Basis-Erkennung | ⚠️ Eingeschränkt | ✅ Über Erweiterungen | ❌ |
| **OpenAPI/Swagger** | ✅ Sicherheitsschema-Analyse | ❌ | ✅ Nur Import | ✅ Import + Scan | ❌ |
| **JWT-Analyse** | ✅ alg=none, schwache Geheimnisse, Ablauf | ⚠️ Über Templates | ⚠️ Eingeschränkt | ✅ Über Erweiterungen | ❌ |
| **IDOR/BOLA-Erkennung** | ✅ 3-stufig (unauth/range/benutzerübergreifend) | ⚠️ Manuelle Templates | ⚠️ Eingeschränkt | ✅ Manuelles Testen | ❌ |
| **Geheimnis-Erkennung** | ✅ Kontextbewusst (Frontend vs. Backend) | ⚠️ Regex-basiert | ⚠️ Basis | ⚠️ Basis | ❌ |
| **Aktive Prüfungen** | ✅ Opt-in (IDOR, Massenzuweisung, OAuth/OIDC, Websocket, Ratenbegrenzung, CVE-Templates) | ✅ Template-basiert | ✅ Aktiver Scan | ✅ Aktiver Scan | ✅ Fuzzing |
| **WAF-Umgehung** | ✅ UA-Rotation, Verzögerungen, Wiederholungen, adaptives Timing | ⚠️ Basis | ⚠️ Eingeschränkt | ✅ Gut | ⚠️ Basis |
| **CI/CD-Integration** | ✅ NDJSON, SARIF, Exit-Codes | ✅ JSON, SARIF | ⚠️ XML-Berichte | ⚠️ XML/JSON | ✅ JSON |
| **Baseline-Diffing** | ✅ Eingebaut | ❌ Externe Werkzeuge | ❌ | ❌ | ❌ |
| **Auth-Flows** | ✅ JSON-basierter Pre-Scan-Login | ⚠️ Header-Injektion | ✅ Sitzungsverwaltung | ✅ Sitzungsverwaltung | ⚠️ Header-Injektion |
| **Streaming-Ausgabe** | ✅ Echtzeit-NDJSON | ❌ Nur Stapelverarbeitung | ❌ | ❌ | ✅ |
| **Ressourcennutzung** | 🟢 Niedrig (Rust) | 🟢 Niedrig (Go) | 🟡 Hoch (Java) | 🟡 Hoch (Java) | 🟢 Niedrig (Go) |
| **Lernkurve** | 🟢 Einfache CLI | 🟢 Template-Syntax | 🟡 GUI-Komplexität | 🔴 Steil | 🟢 Einfach |
| **Erweiterbarkeit** | ✅ Rust-Trait-System | ✅ YAML-Templates | ✅ Add-ons | ✅ Erweiterungen | ⚠️ Eingeschränkt |
| **Lizenz** | MIT (Kostenlos) | MIT (Kostenlos) | Apache 2.0 (Kostenlos) | Kommerziell | MIT (Kostenlos) |
| **Am besten geeignet für** | API-Sicherheit in CI/CD, Regressionstests, CORS/GraphQL/JWT-Analyse | Allgemeines Schwachstellen-Scanning, CVE-Erkennung | Komplettes Web-App-Pentesting | Manuelles Pentesting, komplexe Arbeitsabläufe | Verzeichnis-/Parameter-Fuzzing |

### Hauptunterschiede

**ApiHunter:** API-First-Design, SPA-Erkennung, Baseline-Diffing, 3-stufige IDOR/BOLA, kontextbewusste Geheimnisse, AIMD-Nebenläufigkeit, **Stealth/WAF-Umgehung (UA-Rotation, Jitter, adaptives Timing)**, **duale Erweiterbarkeit (TOML-Templates + Rust-Module)**  
**Nuclei:** Breitere CVE-Abdeckung, nur YAML-Templates, grundlegende Umgehung  
**ZAP/Burp:** Manuelles Testen, Proxy-Workflows, GUI-basierte Erweiterungen, eingeschränkte Stealth  
**ffuf:** Reines Fuzzing, Inhaltserkennung, eingeschränkte Erweiterbarkeit, grundlegende Umgehung

## Schnellstart```bash
cargo build --release

# Scan URLs from a file (newline-delimited)
./target/release/apihunter --urls ./targets/cve-regression-real-public.txt --format ndjson --output ./results.ndjson

# Or scan URLs from stdin
cat ./targets/cve-regression-real-public.txt | ./target/release/apihunter --stdin --min-severity medium

Desktop-Scan-Eingabe unterstützt:
- Manuelle Multi-Ziel-Eingabe (eine URL pro Zeile oder kommagetrennt)
- CSV-Import über `Load CSV` (maximal 307.200 Bytes / 300 KiB)
- Geführte Scan-Voreinstellungen: `Quick Passive` und `Deep Active`
- Hartes Limit: bis zu 3.000 Ziele pro Durchlauf (dedupliziert und als absolute `http/https`-URLs validiert)
- Bereichssteuerungen: Discovery ein/aus, Zugänglichkeitsfilter + Timeout, maximale Endpunkte pro Seite
- API-Versionskontrollen: optionaler tiefer Response-Diff-Probing-Umschalter
- Erweiterte Steuerungen: Proxy, Header, Cookies, Bearer/Basic-Auth, TLS ungültiges Zertifikat umschalten
- Blind-SSRF-Callback-Korrelationseingabe (`OAST callback base`) für aktive Prüfungen
- Leistungssteuerungen: Clients pro Host, adaptive Parallelität, WAF-Umgehung mit benutzerdefiniertem User-Agent-Pool
- Vollständige Scanner-Umschaltabdeckung einschließlich `API Versioning` und `gRPC/Protobuf`
- Zusammenklappbare Scan-Abschnitte mit rechtsbündigen Carets; `Safety and Scan Behavior`, `Runtime Limits` und `Scanner toggles` sind standardmäßig zugeklappt
- Parallel-Lauf-Fortschrittskarten mit Abschluss-/Ergebnis-Snapshots pro Ziel
- Ergebnisanalyse-Dashboard: Schweregrad-Wärmekarte, schlechtestes Ziel-Karte, Scan-Effizienz, Scanner-Abdeckung, häufigste angreifbare Pfade, Aufschlüsselung der Prüfschweregrade
- Sitzungspersistenz: letzte Scan-Ergebnisse werden beim nächsten Start automatisch wiederhergestellt
- Enrich-Mode-Panel: NDJSON-Ergebnisse laden, Threat-Intelligence-Anreicherung ausführen, Hosts mit hoher Bewertung direkt in Vollscan mit Deep Active-Voreinstellung überführen
- Export-UI: Größenangaben + `Save All Reports` + pro Durchlauf Zeitstempel-Dateinamen; Exporte enthalten JSON-Bündel pro Ziel, NDJSON, SARIF, Insomnia-Sammlung und Insomnia-Runner-Daten

Siehe [HOWTO.md](https://github.com/teycir/apihunter/blob/main/HOWTO.md) für detaillierte Nutzung, [docs/lab-setup.md](https://github.com/teycir/apihunter/blob/main/docs/lab-setup.md) für Vulhub-basierte CVE-Validierungslabore und [docs/](https://github.com/teycir/apihunter/blob/main/docs) für interne Details.

Wenn Sie ein Desktop-Binärpaket für die Veröffentlichung möchten:```bash
cd apps/desktop
npm run tauri build
./src-tauri/target/release/apihunter-desktop

Hinweis: Der Desktop-Entwicklungsstart verwendet jetzt direkt die erstellten Frontend-Assets und benötigt keinen separaten `localhost:1420`-Server.

Siehe [HOWTO.md](https://github.com/teycir/apihunter/blob/main/HOWTO.md) für detaillierte Nutzung, [docs/lab-setup.md](https://github.com/teycir/apihunter/blob/main/docs/lab-setup.md) für Vulhub-basierte CVE-Validierungslabore und [docs/](https://github.com/teycir/apihunter/blob/main/docs) für Interna.

### Beispiel-NDJSON-Fund```json
{
  "url": "https://api.example.com/graphql",
  "check": "graphql/introspection-enabled",
  "title": "GraphQL introspection is enabled",
  "severity": "MEDIUM",
  "detail": "Introspection query returned schema metadata from a public endpoint.",
  "evidence": "POST /graphql -> HTTP 200 with __schema fields in response body",
  "scanner": "graphql",
  "timestamp": "2026-03-19T14:02:11.824Z"
}

**Flow:** CLI args → Config → Runner orchestriert Discovery + Scanners → HTTP Client (mit Auth/WAF) → Reports

## Vorlagen-Tooling

ApiHunter unterstützt **duale Erweiterbarkeit**: fügen Sie Prüfungen über **TOML-Vorlagen** (kein Code) oder **Rust-Module** (volle Kontrolle) hinzu.

### TOML-Vorlagenformat
Erstellen Sie benutzerdefinierte Prüfungen in `assets/cve_templates/*.toml`:```toml
id = "custom-api-check"
name = "Custom API Vulnerability"
severity = "high"

[[requests]]
method = "GET"
path = "/api/vulnerable"

[[requests.matchers]]
type = "status"
values = [200]

[[requests.matchers]]
type = "word"
part = "body"
words = ["sensitive_data", "exposed"]

### Eigene Rust-Scanner hinzufügen
Implementieren Sie das `Scanner`-Trait für komplexe Logik:```rust
#[async_trait]
impl Scanner for MyCustomScanner {
    async fn scan(
        &self,
        url: &str,
        client: &HttpClient,
        config: &Config,
    ) -> (Vec<Finding>, Vec<CapturedError>) {
        // Your custom scanning logic
    }
}

Alle Wrapper-Skripte außer `split-by-host.sh` unterstützen `--stdin` und nachgestellte ApiHunter-Flags.

## Teststrategie

ApiHunter-Tests sind nach Absicht unterteilt:

- **Unit-Tests** (`tests/*_scanner.rs`, Parser-/Konfigurationstests): Scannerlogik und Randfälle.
- **Integrationstests** (`tests/integration_runner.rs`, Start-/CLI-Verhalten): Orchestrierung und Laufzeitverdrahtung.
- **Fixture-Regressionstests** (`tests/cve_templates_real_data.rs`, `tests/cve_templates_upstream_parity.rs`): Reale Payloads abspielen und mit festgelegten Upstream-Vorlagen vergleichen.
- **Mock-Server-Tests** (mehrere Scanner-Suiten): Deterministisches Verhalten ohne Abhängigkeit von Internet-Zielen.
- **Live-Ziel-Überprüfungen**: Optional/manuell (nicht Teil des standardmäßigen `cargo test`).

Siehe den dedizierten [Testleitfaden](https://github.com/teycir/apihunter/blob/main/docs/testing.md) für die vollständige Testmatrix und Coverage-Karte.

Fokussierte Suiten ausführen:```bash
cargo test --test cors_scanner
cargo test --test graphql_scanner
cargo test --test cve_templates_runtime_ext
cargo test --test integration_runner

Führen Sie das real-data integration gate aus (Fixtures + live ignored suites):```bash
# Fixture-backed real payload regression suites
cargo test --test cve_templates_real_data --test cve_templates_upstream_parity --test cve_templates_runtime_ext

# Manual live internet integration suites (ignored by default)
cargo test --test live_vulnerable_apis --test live_real_world_targets -- --ignored

### Vorgefertigte Release-Artefakte

Getaggte Releases (`v*`) veröffentlichen vorgefertigte `apihunter`-Binärdateien für:

- Linux (`x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`)
- macOS (`x86_64-apple-darwin`)
- Windows (`x86_64-pc-windows-msvc`)

Jedes Release veröffentlicht auch Lieferketten-Artefakte:

- SHA256-Prüfsummendateien (`*.sha256`)
- Sigstore schlüsselloses Signaturmaterial (`*.sig`, `*.pem`, `*.sigstore.json`)
- SPDX JSON SBOM (`apihunter-release-assets-sbom.spdx.json`)
- GitHub-Artefaktbescheinigungen (Herkunfts- und SBOM-Bescheinigungsmetadaten)

Herunterladen von [GitHub Releases](https://github.com/Teycir/ApiHunter/releases).

### Desktop-Installation (Tauri + React)

Der Quellcode der Desktop-App befindet sich in `apps/desktop`.

Erstellen und Ausführen einer Produktions-Desktop-Binärdatei:```bash
cd apps/desktop
npm install
npm run tauri build
./src-tauri/target/release/apihunter-desktop

Installiere ein klickbares Linux-Startersymbol:```bash
cd apps/desktop
npm run desktop:install-icon

Führen Sie einen Scan von Dateien in Ihrem aktuellen Verzeichnis aus:```bash
docker run --rm -v "$PWD:/work" apihunter:local \
  --urls /work/targets/cve-regression-real-public.txt \
  --format ndjson \
  --output /work/results.ndjson

**F: Baseline-Diffing?**```bash
./target/release/apihunter --urls targets/cve-regression-real-public.txt --format ndjson --output baseline.ndjson
./target/release/apihunter --urls targets/cve-regression-real-public.txt --baseline baseline.ndjson --format ndjson