diff --git a/src/AI/AI-Assisted-Fuzzing-and-Vulnerability-Discovery.md b/src/AI/AI-Assisted-Fuzzing-and-Vulnerability-Discovery.md new file mode 100644 index 000000000..8c41b17ca --- /dev/null +++ b/src/AI/AI-Assisted-Fuzzing-and-Vulnerability-Discovery.md @@ -0,0 +1,147 @@ +# AI-Assisted Fuzzing & Automated Vulnerability Discovery + +{{#include ../banners/hacktricks-training.md}} + +## Übersicht +Große Sprachmodelle (LLMs) können traditionelle Schwachstellenforschungs-Pipelines durch die Generierung semantisch reicher Eingaben, die Entwicklung von Grammatiken, das Nachdenken über Absturzdaten und sogar das Vorschlagen von Multi-Bug-Patches erheblich verbessern. Diese Seite sammelt die effektivsten Muster, die während der AI Cyber Challenge (AIxCC) Finals von DARPA und anderer öffentlicher Forschung beobachtet wurden. + +Was folgt, ist keine Beschreibung eines spezifischen Wettbewerbssystems, sondern eine Abstraktion der Techniken, damit Sie diese in Ihren eigenen Workflows reproduzieren können. + +--- + +## 1. LLM-generierte Seed-Eingaben + +Traditionelle coverage-gesteuerte Fuzzer (AFL++, libFuzzer, Honggfuzz…) beginnen mit einem kleinen Korpus von Seeds und mutieren Bytes blind. Wenn das Ziel-Eingabeformat komplex ist (SQL, URLs, benutzerdefinierte binäre Protokolle), brechen zufällige Mutationen normalerweise die Syntax, bevor interessante Verzweigungen erreicht werden. + +LLMs können dieses Bootstrap-Problem lösen, indem sie *Seed-Generatoren* ausgeben – kurze Skripte, die **syntaxkorrekte, aber sicherheitsrelevante Eingaben** erzeugen. Zum Beispiel: +```prompt +SYSTEM: You are a helpful security engineer. +USER: +Write a Python3 program that prints 200 unique SQL injection strings targeting common anti-pattern mistakes (missing quotes, numeric context, stacked queries). Ensure length ≤ 256 bytes / string so they survive common length limits. +``` + +```python +# gen_sqli_seeds.py (truncated) +PAYLOADS = [ +"1 OR 1=1 -- ", +"' UNION SELECT NULL,NULL--", +"0; DROP TABLE users;--", +... +] +for p in PAYLOADS: +print(p) +``` +Führen Sie es einmal aus und speisen Sie die Ausgabe direkt in das anfängliche Corpus des Fuzzers ein: +```bash +python3 gen_sqli_seeds.py > seeds.txt +afl-fuzz -i seeds.txt -o findings/ -- ./target @@ +``` +Benefits: +1. Semantische Gültigkeit → tiefere Abdeckung frühzeitig. +2. Wiederherstellbar: passe den Prompt an, um sich auf XSS, Pfadüberquerung, binäre Blobs usw. zu konzentrieren. +3. Günstig (< 1 ¢ mit GPT-3.5). + +### Tipps +* Weisen Sie das Modell an, die *Länge und Kodierung* der Payloads (UTF-8, URL-kodiert, UTF-16-LE) zu *diversifizieren*, um oberflächliche Filter zu umgehen. +* Fordern Sie ein *einzelnes, eigenständiges Skript* an – vermeidet JSON-Formatierungsprobleme. + +--- + +## 2. Grammatik-Evolution Fuzzing + +Eine leistungsfähigere Variante besteht darin, das LLM eine **Grammatik zu entwickeln** anstelle von konkreten Seeds. Der Workflow („Grammar Guy“-Muster) ist: + +1. Generiere eine initiale ANTLR/Peach/LibFuzzer-Grammatik über den Prompt. +2. Fuzz für N Minuten und sammle Abdeckungsmetriken (getroffene Kanten / Blöcke). +3. Fasse nicht abgedeckte Programmgebiete zusammen und speise die Zusammenfassung zurück in das Modell: +```prompt +Die vorherige Grammatik hat 12 % der Programmkanten ausgelöst. Nicht erreichte Funktionen: parse_auth, handle_upload. Füge Regeln hinzu / ändere sie, um diese abzudecken. +``` +4. Füge die neuen Regeln zusammen, führe erneut Fuzzing durch, wiederhole. + +Pseudo-Code-Skelett: +```python +for epoch in range(MAX_EPOCHS): +grammar = llm.refine(grammar, feedback=coverage_stats) +save(grammar, f"grammar_{epoch}.txt") +coverage_stats = run_fuzzer(grammar) +``` +Wichtige Punkte: +* Halte ein *Budget* – jede Verfeinerung verwendet Tokens. +* Verwende `diff` + `patch` Anweisungen, damit das Modell bearbeitet und nicht neu schreibt. +* Stoppe, wenn Δcoverage < ε. + +--- + +## 3. Agentenbasierte PoV (Exploit) Generierung + +Nachdem ein Absturz gefunden wurde, benötigst du immer noch einen **Proof-of-Vulnerability (PoV)**, der ihn deterministisch auslöst. + +Ein skalierbarer Ansatz ist es, *tausende* von leichten Agenten () zu starten, die jeweils ein anderes LLM (GPT-4, Claude, Mixtral) oder Temperatureinstellung ausführen. + +Pipeline: +1. Statische/dynamische Analyse produziert *Fehlerkandidaten* (Struktur mit Absturz-PC, Eingabeslice, Sanitizer-Nachricht). +2. Orchestrator verteilt Kandidaten an Agenten. +3. Agenten-Überlegungs-Schritte: +a. Reproduziere den Fehler lokal mit `gdb` + Eingabe. +b. Schlage minimale Exploit-Nutzlast vor. +c. Validiere den Exploit in einer Sandbox. Wenn erfolgreich → einreichen. +4. Fehlgeschlagene Versuche werden **als neue Seeds für Coverage-Fuzzing erneut eingereiht** (Feedback-Schleife). + +Vorteile: +* Parallelisierung verbirgt die Unzuverlässigkeit einzelner Agenten. +* Automatische Anpassung von Temperatur / Modellgröße basierend auf der beobachteten Erfolgsquote. + +--- + +## 4. Gezieltes Fuzzing mit feinabgestimmten Code-Modellen + +Feinabstimmung eines offenen Modells (z.B. Llama-7B) auf C/C++-Quellcode, der mit Schwachstellenmustern (Integerüberlauf, Pufferkopie, Formatzeichenfolge) gekennzeichnet ist. Dann: + +1. Führe eine statische Analyse durch, um die Funktionsliste + AST zu erhalten. +2. Fordere das Modell auf: *„Gib Mutationswörterbucheinträge an, die wahrscheinlich die Speichersicherheit in Funktion X brechen“*. +3. Füge diese Tokens in einen benutzerdefinierten `AFL_CUSTOM_MUTATOR` ein. + +Beispielausgabe für einen `sprintf` Wrapper: +``` +{"pattern":"%99999999s"} +{"pattern":"AAAAAAAA....<1024>....%n"} +``` +Empirisch verkürzt dies die Zeit bis zum Absturz um >2× bei realen Zielen. + +--- + +## 5. KI-gestützte Patch-Strategien + +### 5.1 Super-Patches +Fordern Sie das Modell auf, Absturzsignaturen zu *clustern* und einen **einzelnen Patch** vorzuschlagen, der die gemeinsame Grundursache entfernt. Einmal einreichen, mehrere Fehler beheben → weniger Genauigkeitsstrafen in Umgebungen, in denen jeder falsche Patch Punkte kostet. + +Prompt-Umriss: +``` +Here are 10 stack traces + file snippets. Identify the shared mistake and generate a unified diff fixing all occurrences. +``` +### 5.2 Spekulatives Patch-Verhältnis +Implementieren Sie eine Warteschlange, in der bestätigte PoV-validierte Patches und *spekulative* Patches (kein PoV) im Verhältnis 1:​N angeordnet sind, das an die Bewertungsregeln angepasst ist (z. B. 2 spekulative : 1 bestätigter). Ein Kostenmodell überwacht Strafen im Vergleich zu Punkten und passt N automatisch an. + +--- + +## Alles Zusammenfügen +Ein End-to-End CRS (Cyber Reasoning System) kann die Komponenten wie folgt verbinden: +```mermaid +graph TD +subgraph Discovery +A[LLM Seed/Grammar Gen] --> B[Fuzzer] +C[Fine-Tuned Model Dicts] --> B +end +B --> D[Crash DB] +D --> E[Agent PoV Gen] +E -->|valid PoV| PatchQueue +D -->|cluster| F[LLM Super-Patch] +PatchQueue --> G[Patch Submitter] +``` +--- + +## Referenzen +* [Trail of Bits – AIxCC-Finale: Die Bilanz](https://blog.trailofbits.com/2025/08/07/aixcc-finals-tale-of-the-tape/) +* [CTF Radiooo AIxCC Finalisteninterviews](https://www.youtube.com/@ctfradiooo) +{{#include ../banners/hacktricks-training.md}} diff --git a/src/AI/README.md b/src/AI/README.md index 70949dba3..a4d9f11a4 100644 --- a/src/AI/README.md +++ b/src/AI/README.md @@ -58,10 +58,16 @@ AI-Models-RCE.md ### Protokoll für den Kontext von KI-Modellen -MCP (Model Context Protocol) ist ein Protokoll, das es KI-Agenten-Clients ermöglicht, sich auf eine Plug-and-Play-Art und Weise mit externen Tools und Datenquellen zu verbinden. Dies ermöglicht komplexe Arbeitsabläufe und Interaktionen zwischen KI-Modellen und externen Systemen: +MCP (Model Context Protocol) ist ein Protokoll, das es KI-Agenten-Clients ermöglicht, sich mit externen Tools und Datenquellen auf eine Plug-and-Play-Art und Weise zu verbinden. Dies ermöglicht komplexe Workflows und Interaktionen zwischen KI-Modellen und externen Systemen: {{#ref}} AI-MCP-Servers.md {{#endref}} +### KI-unterstütztes Fuzzing & automatisierte Schwachstellenerkennung + +{{#ref}} +AI-Assisted-Fuzzing-and-Vulnerability-Discovery.md +{{#endref}} + {{#include ../banners/hacktricks-training.md}} diff --git a/src/SUMMARY.md b/src/SUMMARY.md index adb5b37c0..68cf84961 100644 --- a/src/SUMMARY.md +++ b/src/SUMMARY.md @@ -825,6 +825,7 @@ # 🤖 AI - [AI Security](AI/README.md) + - [Ai Assisted Fuzzing And Vulnerability Discovery](AI/AI-Assisted-Fuzzing-and-Vulnerability-Discovery.md) - [AI Security Methodology](AI/AI-Deep-Learning.md) - [AI MCP Security](AI/AI-MCP-Servers.md) - [AI Model Data Preparation](AI/AI-Model-Data-Preparation-and-Evaluation.md)