Bevorzugen Sie rohes HTTP? Greifen Sie direkt mit curl auf die API zu:```bash
curl -X POST http://localhost:8080/api/v1/execute/async/sec-af.audit \
  -H "Content-Type: application/json" \
  -d '{"input": {"repo_url": "https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application"}}'

Jeder Fund enthält ein **Urteil** (`confirmed` / `likely` / `inconclusive` / `not_exploitable`), ein **Beweisobjekt** mit der vollständigen Taint-Trace und die exakte Codestelle. Kein „könnte ein Problem sein“. SEC-AF verfolgt Daten von der Quelle zur Senke und beweist, ob sie tatsächlich ausnutzbar sind.

> Vollständige Benchmark-Ausgabe (30 Funde): [`exampl/dvga-benchmark-result.json`](https://github.com/agent-field/sec-af/blob/HEAD/exampl/dvga-benchmark-result.json) | Leistungsanalyse: [`exampl/benchmark-analysis.json`](https://github.com/agent-field/sec-af/blob/HEAD/exampl/benchmark-analysis.json)

## Benchmark: DVGA

Wir haben SEC-AF gegen die [Damn Vulnerable GraphQL Application](https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application) ausgeführt, eine absichtlich verwundbare App mit 21 dokumentierten Sicherheitsszenarien.

| Metrik | Wert |
|---|---|
| Rohfunde entdeckt | 106 |
| Nach KI-Deduplizierung | 61 |
| **Nach adversarieller Verifikation** | **28 bestätigt** |
| Unschlüssig (manuelle Prüfung erforderlich) | 1 |
| Nicht ausnutzbar (korrekt abgelehnt) | 1 |
| Rauschreduzierung | 94 % |
| DAG-Kanten (Reasoner-Aufrufe) | 82 |
| Agentenaufrufe | ~166–255 |
| Ausgeführte Strategien | 11 |
| Reale Laufzeit | ~78 Min. |
| Geschätzte Kosten (Kimi K2.5) | ~0,18–0,90 USD |

<details>
<summary><strong>Aufschlüsselung: 30 verifizierte Funde nach Kategorie</strong></summary>

| Kategorie | Anzahl | Beispiele |
|---|---|---|
| Fehlende Authentifizierung | 8 | ImportPaste, delete_all_pastes, system_debug, CreateUser, file upload |
| Befehlseinschleusung | 4 | `os.popen(cmd)` via ImportPaste, system_debug, system_diagnostics |
| SQL-Einschleusung | 3 | Unsanitierter `filter` in `resolve_pastes`, LIKE-Musterinjektion, Login |
| Authentifizierungsumgehung | 3 | JWT-Signatur deaktiviert, JWT-Autorisierungsumgehung, defekte Passwort-Auth |
| Klartext-Zugangsdaten | 3 | Klartext-Passwortspeicherung, Klartextvergleich, Passwort in Diagnosedaten |
| SSRF | 2 | ImportPaste-Mutation folgt benutzerdefinierten URLs serverseitig |
| Geschäftslogik / URL-Bereinigung | 2 | Unzureichende URL-Bereinigung, unauthentifizierte Massenlöschung |
| DoS / Ressourcenerschöpfung | 3 | Fehlende Paginierung bei Benutzer-/Audit-Abfragen, unkontrolliertes simulate_load |
| Konfiguration / Geheimnisse | 2 | Hartcodierte JWT/Flask-Secrets, Debug-Modus in Produktion aktiviert |

</details>

<details>
<summary><strong>Entwurfsmuster: Wie KI-native Sicherheitsanalyse funktioniert</strong></summary>

SEC-AF wendet mehrere architektonische Muster an, die einzigartig dadurch ermöglicht werden, dass viele fokussierte KI-Agenten zusammengesetzt werden, anstatt einen monolithischen Scan auszuführen. Diese Muster adressieren grundlegende Herausforderungen in der KI-gesteuerten Sicherheitsanalyse.

**1. Adversarielle Agentenspannung (HUNT vs. PROVE)**

Die meisten KI-Sicherheitstools fragen ein einzelnes Modell „ist dies verwundbar?“ und akzeptieren die Antwort. SEC-AF trennt strukturell die _Findungs_-Agenten von den _Widerlegungs_-Agenten. Jäger werden angereizt, Verwundbarkeiten zu finden; Beweiser werden angereizt, sie zu widerlegen. Jeder Fund durchläuft eine 4-Agenten-Verifikationskette – ein Tracker rekonstruiert den Datenfluss, ein Bereinigungsanalysator sucht nach Absicherungen, die der Jäger übersehen haben könnte, ein Ausnutzungshypothesierer konstruiert ein konkretes Angriffsszenario, und ein Urteilsagent wägt alle widersprüchlichen Beweise ab. Diese adversarielle Spannung zwischen den Agenten ist es, die die Rauschreduzierung von 94 % antreibt – die Architektur selbst kodiert Skepsis.

**2. Signalkaskade mit progressiver Eingrenzung**

Anstatt alle Funde auf den Benutzer zu werfen, komprimiert die Pipeline das Signal auf jeder Stufe: 106 Rohfunde → 61 nach KI-Deduplizierung → 30 nach adversarieller Verifikation. Jede Phase ist ein Filter. Dies spiegelt wider, wie menschliche Sicherheitsteams triagieren – zuerst breite Entdeckung, dann zunehmend strengere Prüfung. Die entscheidende Erkenntnis ist, dass jeder Filter eine _andere Art_ von KI-Argumentation ist: semantische Ähnlichkeit für Deduplizierung, Taint-Analyse für Verifikation, Konstruktion von Ausnutzung für Bestätigung.

**3. Informationsökonomie durch Kontextbereinigung**

LLMs halluzinieren mehr, wenn sie irrelevanten Kontext erhalten. SEC-AF leitet nur die Informationen weiter, die jeder Agent benötigt: Ein Injektionsjäger erhält den Rekontext, der auf Datenflusskarten und Eingabeeintrittspunkte zugeschnitten ist, während ein Kryptographie-Jäger Abhängigkeitsbäume und Schlüsselverwaltungsmuster erhält. Verifizierer erhalten projizierte Fundansichten mit nur den Feldern, die für ihre spezifische Verifikationsmethode benötigt werden. Diese strategieabhängige Kontextbereinigung reduziert sowohl Halluzinationen als auch Kosten – Agenten können sich nicht mit Informationen verwirren, die sie nie sehen.

**4. Streaming-Phasenüberlappung**

Traditionelle Pipelines laufen sequenziell ab: Recon abschließen, dann mit der Jagd beginnen, dann mit dem Beweisen beginnen. SEC-AF überlappt Phasen via `asyncio.Queue` – Jäger beginnen, Recon-Output zu konsumieren, sobald er eintrifft, und Deduplizierung verarbeitet Funde, sobald jeder Jäger fertig ist. Beweiser beginnen mit der Verifikation der ersten deduplizierten Funde, während spätere Jäger noch laufen. Diese Streaming-Architektur reduziert die Wanduhrzeit, ohne die Signalkaskade zu opfern – jeder Fund durchläuft trotzdem jeden Filter, nur früher.

**5. Dynamisches Routing durch KI-Gates**

Die Pipeline passt sich zur Laufzeit basierend auf dem an, was sie entdeckt. Ein KI-Gate untersucht die Recon-Ausgabe und wählt aus, welche Jagdstrategien aktiviert werden – eine Flask-App mit JWT-Auth löst andere Jäger aus als ein Go-Microservice mit gRPC. Ein separates CWE-Erweiterungs-Gate erweitert dynamisch die Liste der Verwundbarkeitsziele basierend auf dem erkannten Technologie-Stack. Ein Erreichbarkeits-Gate bewertet, ob Abhängigkeitsverwundbarkeiten ausnutzbare Aufrufpfade haben, bevor Verifikationsressourcen für unerreichbaren Code verschwendet werden.

**6. Geführte Autonomie für Code-Agenten**

SEC-AF läuft auf Code-Agenten (Claude Code, OpenCode, Codex) über das AgentField-Steuerungssystem. Anstatt dem Agenten einen einzigen massiven Prompt zu geben, bietet jeder Reasoner phasenbewusste geführte Autonomie: Der Agent erhält eine enge Aufgabenbeschreibung, ein flaches Ausgabeschema (2–4 Felder) und strategieabhängigen Kontext. Der Agent hat innerhalb dieser Grenzen volle Autonomie – er kann Dateien lesen, Code verfolgen und frei argumentieren –, aber das Steuerungssystem beschränkt die _Form_ seiner Ausgabe. Dies verhindert den häufigen Fehlermodus, bei dem autonome Agenten vom Kurs abkommen oder unstrukturierte Ergebnisse liefern.

**7. Komponierbarer Reasoner-DAG mit vollständiger Beobachtbarkeit**

Jeder Agentenaufruf fließt durch die AgentField-Steuerungsebene und erzeugt einen vollständigen gerichteten azyklischen Graphen des Audits. Sie können sehen, welcher Jäger welchen Fund gefunden hat, wie lange jede Verifikation gedauert hat, welche Beweise der Beweiser erzeugt hat und wo die Pipeline ihre Zeit verbracht hat. Das Hinzufügen einer neuen Verwundbarkeitsklasse ist eine Datei – ein neuer Jäger. Der Orchestrator entdeckt ihn, leitet Kontext an ihn weiter und integriert seine Funde in die bestehende Dedup → Prove → Remediation-Pipeline. Der DAG ist die Architektur.

</details>

<details>
<summary><strong>Was es übersehen hat (und warum)</strong></summary>

Die 9 übersehenen Szenarien sind hauptsächlich **GraphQL-Protokollebenen-Angriffe**: Batch-Queries, tiefe Rekursion, Alias-Missbrauch, Feldduplizierung, Introspection-Exposition. Diese erfordern Laufzeit-/DAST-Analyse. SEC-AF ist derzeit SAST-fokussiert. Die Erkennung auf Protokollebene befindet sich auf der Roadmap.

</details>

## So funktioniert es

SEC-AF basiert auf der [Composite Intelligence](https://github.com/Agent-Field/agentfield)-Philosophie: Statt sich auf einen einzigen monolithischen LLM-Aufruf zu verlassen, setzt es viele fokussierte, geführte LLM-Aufrufe zu einem **Reasoner-DAG** zusammen, bei dem die Architektur selbst Intelligenz kodiert (für eine tiefere Betrachtung dieses Musters siehe [The Atomic Unit of Intelligence](https://www.santoshkumarradha.com/writing/atomic-unit-of-intelligence)). Jeder LLM-Aufruf bearbeitet eine kleine, klar definierte Aufgabe mit einem flachen Pydantic-Schema (2–4 Attribute). Der Orchestrator verwaltet Kontextfluss, Parallelität und dynamisches Routing.

### Architektur: Reasoner-Aufrufgraph (DAG)

Jede Phase ist ein `@reasoner`, der Unter-Reasoner durch die AgentField-Steuerungsebene aufruft, insgesamt etwa ~200–300 Agenten, die synchron für eine bestimmte Abfrage arbeiten:

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/7491/d3e99c5c9b7067b17005f71ecb0f7c7abeb9d7fc8843d33938de9f755f416b7b.png" alt="SEC-AF Signalkaskaden-Pipeline — RECON → HUNT → DEDUP → PROVE → OUTPUT" width="100%" />
</p>

### Signalkaskaden-Pipeline

Jede Phase engt das Signal ein. Rohfunde werden durch zunehmend strengere Filter geschleust:

| Phase | Zweck | Parallelität |
|---|---|---|
| **RECON** | Architektur, Abhängigkeiten, Datenflüsse, Sicherheitskontext kartieren | 3-Wege parallel (Arch + Deps + Config), dann 2-Wege (Datenfluss + Sicherheit) |
| **HUNT** | 10+ spezialisierte Strategie-Jäger ausführen | Semaphor-begrenzt parallel (Standard 4 gleichzeitig) mit inkrementeller Deduplizierung |
| **PROVE** | Adversarielle Verifikation: versuchen, jeden Fund zu **widerlegen** | Semaphor-begrenzt parallel (Standard 3 gleichzeitig) |
| **REMEDIATION** | Korrekturvorschläge für bestätigte/wahrscheinliche Funde generieren | Semaphor-begrenzt parallel (Standard 3 gleichzeitig) |

### Warum Multi-Reasoner-Architektur

Die meisten KI-Sicherheitstools führen einen großen Prompt aus und hoffen, dass das LLM es richtig macht. SEC-AF zerlegt das Problem in ~258 fokussierte Agentenaufrufe, jeder mit einem flachen Schema (2–4 Felder) und einer engen Aufgabe. Die Architektur kodiert die Argumentationsstrategie, nicht den Prompt (siehe [The Atomic Unit of Intelligence](https://www.santoshkumarradha.com/writing/atomic-unit-of-intelligence), warum dies wichtig ist).

- **Viele fokussierte Agenten > ein leistungsstarker Agent.** Ein einzelner LLM-Aufruf kann nicht gleichzeitig Architektur kartieren, Datenflüsse verfolgen, nach Injektionen jagen, Ausnutzbarkeit verifizieren und Korrekturen vorschlagen. SEC-AF gibt jede dieser Aufgaben einem separaten Reasoner, der eine Sache gut macht. Der Orchestrator übernimmt Komposition, Parallelität und Kontextlenkung.
- **Adversarielle Verifikation, kein Bestätigungsfehler.** Die PROVE-Phase führt 4 Unter-Agenten pro Fund mit entgegengesetzten Zielen aus: Der Tracker rekonstruiert den Datenfluss, der Bereinigungsanalysator sucht nach Sperren, der Ausnutzungshypothesierer konstruiert einen Angriff, und der Urteilsagent wägt alle Beweise ab. Diese Spannung zwischen den Agenten erzeugt eine höhere Zuverlässigkeit, als ein einzelnes Modell zu fragen: „Ist dies ausnutzbar?“
- **Dynamisches Routing durch KI-Gates.** Das System passt sich zur Laufzeit an. Ein KI-Gate untersucht die Recon-Ausgabe und wählt aus, welche Jagdstrategien aktiviert werden. Ein separates Gate erweitert die CWE-Zielliste basierend auf dem erkannten Stack. Eine Flask-App mit JWT-Auth erhält andere Jäger als ein Go-Microservice mit gRPC.
- **Progressive Signalverengung.** 106 Rohfunde werden zu 61 nach Deduplizierung, dann zu 30 nach adversarieller Verifikation – 94 % Rauschreduzierung. Jede Phase ist ein Filter. Die Pipeline komprimiert Rauschen, sie erkennt nicht nur Verwundbarkeiten und wirft sie aus.
- **Informationsökonomie.** Jeder Agent sieht nur, was er braucht. Jäger erhalten Recon-Kontext, der für ihre Strategie zugeschnitten ist. Verifizierer erhalten projizierte Fundansichten mit minimalen Feldern. Dies reduziert Halluzinationen, senkt Kosten und hält jeden LLM-Aufruf fokussiert.
- **Inkrementelles Streaming.** Deduplizierung läuft als Konsument, während Jäger noch produzieren. Funde werden fingerabdruck-dedupliziert, sobald jeder Jäger fertig ist, dann fängt ein abschließender semantischer Durchlauf strategieübergreifende Duplikate. Die Pipeline streamt, sie batcht nicht.

## Vergleich

> Behauptungen stammen aus offiziellen Dokumentationen und Preisseiten. Falls etwas falsch ist, [öffnen Sie ein Issue](https://github.com/Agent-Field/sec-af/issues).

| | SEC-AF | Nullify | Snyk Code | Semgrep | CodeQL |
|---|---|---|---|---|---|
| **Ansatz** | **KI-native** | **KI-native** | **KI-gestützt** | **Regelbasiert** | **Regelbasiert** |
| | Multi-Reasoner-DAG · LLM argumentiert über Code | Autonome Sicherheitsbelegschaft | DeepCode AI Engine | Muster- + Taint-Abgleich | Semantische Analyse + Datenfluss |
| **Open Source** | ✅ Apache 2.0 | ❌ Proprietär | ❌ Proprietär | Engine: LGPL-2.1 · Pro-Regeln: proprietär | Abfragen: MIT · Engine: proprietär |
| **Verifizierte Funde** | ✅ Adversarielle PROVE-Phase · Urteil + Nachweis pro Fund | ✅ Proof-of-Exploit-Generierung | ❌ Prioritäts-Score (undurchsichtig) · kein Exploit-Nachweis | ❌ Nur Musterübereinstimmungen | ❌ Statische Analyse-Warnungen |
| **Nachweis pro Fund** | Datenfluss-Trace mit Taint-Ausbreitung | Exploit-Pfad + Reproduktionsschritte | Source-to-Sink-Fluss angezeigt | - | Pfadabfragen zeigen Datenfluss |
| **Architektur** | Komponierbarer Reasoner-DAG mit vollständiger Beobachtbarkeit | Monolithischer Agent | Single-Pass-Engine | Regel-Engine | Abfrage-Engine |
| **Parallelität** | ✅ Parallele Jäger, Verifizierer, Remediatoren mit inkrementeller Deduplizierung | Nicht dokumentiert | Nicht dokumentiert | ✅ Regelparallelität | ✅ Abfrageparallelität |
| **Bewertung** | ✅ Veröffentlichte zusammengesetzte Formel | Intern | Undurchsichtiger Prioritäts-Score | Intern | - |
| **SARIF** | ✅ Nativ 2.1.0 | Nicht dokumentiert | ✅ | ✅ | ✅ Nativ |
| **Compliance-Mapping** | PCI-DSS, SOC2, OWASP, HIPAA, ISO27001 | Nicht dokumentiert | Nur Plattform-Compliance | OWASP-Regeln verfügbar | - |
| **Sprachen** | Jede vom LLM unterstützte Sprache | Nicht dokumentiert | 14+ | 35+ (parserbasiert) | 10 |
| **Preis** | **Kostenlos · Open Source** (~0,18–0,90 USD/Audit an LLM-Kosten) | **6.000 USD/Monat** | 25–105 USD/Monat/Entwickler | OSS-Engine: kostenlos nutzbar · Pro: 30 USD/Monat/Contributor | Kostenlos für öffentliche Repos · 49 USD/Monat/Committer (GHAS) |

**Wo SEC-AF am stärksten ist**: Verifizierte Funde mit Beweisobjekten, transparente Bewertung, Compliance-Mapping, komponierbare Multi-Agent-Architektur mit vollständiger DAG-Beobachtbarkeit und vollständig Open Source.

**Wo andere stärker sind**: Semgrep und CodeQL haben jahrelange, kampferprobte Regelabdeckung in 35+ Sprachen. Snyk hat tiefe IDE/SCA-Integration. Nullify fügt Laufzeit-Cloud-Kontext und automatische Behebungskampagnen hinzu. SEC-AF ist neuer und derzeit am stärksten in der KI-gesteuerten Code-Ebene-Analyse.

> **Gleiche Architektur, andere Domäne:** [Contract-AF](https://github.com/Agent-Field/contract-af) wendet adversarielles HUNT→PROVE auf juristische Verträge an – Agenten erzeugen Agenten, um Klauselinteraktionen zu finden, die einzelne LLMs übersehen.

### Warum Multi-Agent-Architektur wichtig ist

Traditionelle Sicherheitsscanner sind monolithisch: eine Engine, ein Durchlauf, ein Satz von Regeln. Die Multi-Reasoner-Architektur von SEC-AF bietet strukturelle Vorteile:

- **Spezialisierung**: Jeder Jäger ist ein geführter LLM-Spezialist – ein Injektionsjäger argumentiert anders als ein Kryptographie-Jäger. Die Architektur kodiert Domänenwissen im Routing, nicht nur in den Prompts.
- **Komponierbarkeit**: Fügen Sie eine neue Verwundbarkeitsklasse hinzu, indem Sie eine Jäger-Datei hinzufügen. Der Orchestrator entdeckt und führt sie automatisch aus. Keine Änderungen an der Pipeline.
- **Adversarielle Verifikation**: Die PROVE-Phase ist strukturell von HUNT getrennt. Jäger versuchen, Verwundbarkeiten zu finden; Beweiser versuchen, sie zu widerlegen. Diese adversarielle Spannung reduziert Fehlalarme.
- **Beobachtbarkeit**: Jeder Reasoner-Aufruf fließt durch die Steuerungsebene und erzeugt einen vollständigen DAG. Sie können genau sehen, welcher Jäger welchen Fund gefunden hat, wie lange jede Phase gedauert hat und was das LLM bei jedem Schritt argumentiert hat.
- **Kosteneffizienz**: Kontextbereinigung und Schema-Ansichten bedeuten, dass jeder LLM-Aufruf nur den benötigten Kontext erhält. Ein vollständiger Standard-Tiefen-Audit mit 30 verifizierten Funden kostet geschätzt ~0,18–0,90 USD in LLM-Aufrufen (Kimi K2.5 via OpenRouter).

## Schnellstart

### Installation in AgentField (`af install`)

Bereits eine [AgentField](https://github.com/Agent-Field/agentfield)-Steuerungsebene am Laufen? Installieren Sie SEC-AF direkt von GitHub – kein Klonen, keine lokale Einrichtung:```bash
af install https://github.com/Agent-Field/sec-af
af run sec-af

Neu bei AgentField? Installieren Sie zuerst die Control Plane mit `curl -fsSL https://agentfield.ai/install.sh | bash`, oder nutzen Sie die Docker-/Railway-Optionen unten.

### Ein-Klick-Deployment (Railway)

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/sec-af)

Stellt die AgentField Control Plane + den SEC-AF-Agenten bereit. Sie benötigen einen `OPENROUTER_API_KEY`.

### Lokal (Docker Compose)```bash
git clone https://github.com/Agent-Field/sec-af.git && cd sec-af
cp .env.example .env          # Add OPENROUTER_API_KEY
docker compose up --build

Ergebnisse abfragen:```bash
curl http://localhost:8080/api/v1/executions/<execution_id>

**Schritt 2 — Eine virtuelle Umgebung erstellen und aktivieren**```bash
python3 -m venv .venv
source .venv/bin/activate

**Schritt 4 — Konfigurieren der Umgebungsvariablen**```bash
cp .env.example .env

Optional — legen Sie ein benutzerdefiniertes Arbeitsverzeichnis fest, um Berechtigungsprobleme zu vermeiden:```
SEC_AF_WORKSPACES_DIR=~/.sec-af/workspaces

This runs on `http://localhost:8080` by default.

**Schritt 6 — Starte den SEC-AF-Agenten** (in einem anderen Terminal, mit aktiviertem venv)```bash
python3 main.py

## API

<details>
<summary><strong>Vollständige Anfrageoptionen</strong></summary>```bash
curl -X POST http://localhost:8080/api/v1/execute/async/sec-af.audit \
  -H "Content-Type: application/json" \
  -d '{
    "input": {
      "repo_url": "https://github.com/org/repo",
      "branch": "main",
      "depth": "thorough",
      "severity_threshold": "high",
      "scan_types": ["sast", "sca", "secrets", "config"],
      "output_formats": ["sarif", "json", "markdown"],
      "compliance_frameworks": ["pci-dss", "soc2", "owasp", "hipaa"],
      "max_cost_usd": 15.0,
      "max_provers": 30,
      "max_duration_seconds": 1800,
      "include_paths": ["src/"],
      "exclude_paths": ["tests/", "vendor/"]
    }
  }'