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..5ed44df0f --- /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}} + +## Panoramica +I modelli di linguaggio di grandi dimensioni (LLM) possono potenziare i tradizionali pipeline di ricerca delle vulnerabilità generando input semanticamente ricchi, evolvendo grammatiche, ragionando sui dati di crash e persino proponendo patch multi-bug. Questa pagina raccoglie i modelli più efficaci osservati durante le finali della sfida AI Cyber Challenge (AIxCC) della DARPA e altre ricerche pubbliche. + +Ciò che segue non è una descrizione di un sistema di competizione specifico, ma un'astrazione delle tecniche in modo che tu possa riprodurle nei tuoi flussi di lavoro. + +--- + +## 1. Input Seed Generati da LLM + +I fuzzers tradizionali guidati dalla copertura (AFL++, libFuzzer, Honggfuzz…) iniziano con un piccolo corpus di semi e mutano i byte alla cieca. Quando il formato di input target è complesso (SQL, URL, protocolli binari personalizzati), le mutazioni casuali di solito rompono la sintassi prima che si raggiungano rami interessanti. + +Gli LLM possono risolvere questo problema di avvio emettendo *generatori di semi* – brevi script che producono **input sintatticamente corretti ma rilevanti per la sicurezza**. Ad esempio: +```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) +``` +Esegui una volta e alimenta l'output direttamente nel corpus iniziale del fuzzer: +```bash +python3 gen_sqli_seeds.py > seeds.txt +afl-fuzz -i seeds.txt -o findings/ -- ./target @@ +``` +Benefici: +1. Validità semantica → copertura più profonda all'inizio. +2. Rigenerabile: modifica il prompt per concentrarti su XSS, traversamento di percorso, blob binari, ecc. +3. Economico (< 1 ¢ con GPT-3.5). + +### Suggerimenti +* Istruisci il modello a *diversificare* la lunghezza e la codifica del payload (UTF-8, URL-encoded, UTF-16-LE) per bypassare filtri superficiali. +* Richiedi un *singolo script autonomo* – evita problemi di formattazione JSON. + +--- + +## 2. Fuzzing dell'Evoluzione della Grammatica + +Una variante più potente è lasciare che il LLM **evolva una grammatica** invece di semi concreti. Il flusso di lavoro (“Grammar Guy” pattern) è: + +1. Genera una grammatica ANTLR/Peach/LibFuzzer iniziale tramite prompt. +2. Fuzz per N minuti e raccogli metriche di copertura (edge / blocchi colpiti). +3. Riassumi le aree del programma non coperte e reinserisci il riassunto nel modello: +```prompt +La grammatica precedente ha attivato il 12 % degli edge del programma. Funzioni non raggiunte: parse_auth, handle_upload. Aggiungi / modifica regole per coprire questi. +``` +4. Unisci le nuove regole, ri-fuzz, ripeti. + +Scheletro di pseudo-codice: +```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) +``` +Punti chiave: +* Mantieni un *budget* – ogni affinamento utilizza token. +* Usa istruzioni `diff` + `patch` in modo che il modello modifichi piuttosto che riscrivere. +* Fermati quando Δcoverage < ε. + +--- + +## 3. Generazione di PoV (Exploit) Basata su Agenti + +Dopo aver trovato un crash, hai ancora bisogno di una **proof-of-vulnerability (PoV)** che lo attivi in modo deterministico. + +Un approccio scalabile è generare *migliaia* di agenti leggeri (), ciascuno in esecuzione con un diverso LLM (GPT-4, Claude, Mixtral) o impostazione di temperatura. + +Pipeline: +1. L'analisi statica/dinamica produce *candidati bug* (struttura con crash PC, input slice, messaggio del sanitizzatore). +2. L'orchestratore distribuisce i candidati agli agenti. +3. Passaggi di ragionamento dell'agente: +a. Riproduci il bug localmente con `gdb` + input. +b. Suggerisci un payload di exploit minimo. +c. Valida l'exploit in sandbox. Se ha successo → invia. +4. I tentativi falliti vengono **ri-inseriti come nuovi semi** per il fuzzing di copertura (feedback loop). + +Vantaggi: +* La parallelizzazione nasconde l'affidabilità di un singolo agente. +* Auto-tuning della temperatura / dimensione del modello basato sul tasso di successo osservato. + +--- + +## 4. Fuzzing Diretto con Modelli di Codice Affinati + +Affina un modello a peso aperto (ad es. Llama-7B) su sorgente C/C++ etichettato con schemi di vulnerabilità (overflow intero, copia di buffer, stringa di formato). Poi: + +1. Esegui un'analisi statica per ottenere l'elenco delle funzioni + AST. +2. Invia un prompt al modello: *“Fornisci voci del dizionario di mutazione che probabilmente romperanno la sicurezza della memoria nella funzione X”*. +3. Inserisci quei token in un `AFL_CUSTOM_MUTATOR` personalizzato. + +Esempio di output per un wrapper `sprintf`: +``` +{"pattern":"%99999999s"} +{"pattern":"AAAAAAAA....<1024>....%n"} +``` +Empiricamente, questo riduce il tempo fino al crash di oltre 2× su obiettivi reali. + +--- + +## 5. Strategie di Patching Guidate dall'AI + +### 5.1 Super Patches +Chiedi al modello di *raggruppare* le firme di crash e proporre una **singola patch** che rimuova la causa radice comune. Invia una volta, risolvi diversi bug → meno penalità di accuratezza in ambienti in cui ogni patch errata costa punti. + +Schema del prompt: +``` +Here are 10 stack traces + file snippets. Identify the shared mistake and generate a unified diff fixing all occurrences. +``` +### 5.2 Rapporto di Patch Speculativi +Implementa una coda in cui le patch convalidate da PoV confermate e le patch *speculative* (senza PoV) sono alternate in un rapporto 1:​N regolato dalle regole di punteggio (ad es. 2 speculative : 1 confermata). Un modello di costo monitora le penalità rispetto ai punti e si auto-regola su N. + +--- + +## Mettere Tutto Insieme +Un CRS (Cyber Reasoning System) end-to-end può collegare i componenti in questo modo: +```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] +``` +--- + +## Riferimenti +* [Trail of Bits – AIxCC finals: Tale of the tape](https://blog.trailofbits.com/2025/08/07/aixcc-finals-tale-of-the-tape/) +* [CTF Radiooo AIxCC finalist interviews](https://www.youtube.com/@ctfradiooo) +{{#include ../banners/hacktricks-training.md}} diff --git a/src/AI/README.md b/src/AI/README.md index bf86f77dd..66645e447 100644 --- a/src/AI/README.md +++ b/src/AI/README.md @@ -30,7 +30,7 @@ Nella pagina seguente troverai le basi di ciascun componente per costruire un LL AI-llm-architecture/README.md {{#endref}} -## Sicurezza AI +## Sicurezza dell'AI ### Framework di Rischio AI @@ -58,10 +58,16 @@ AI-Models-RCE.md ### Protocollo di Contesto del Modello AI -MCP (Model Context Protocol) è un protocollo che consente ai client agenti AI di connettersi con strumenti esterni e fonti di dati in modo plug-and-play. Questo abilita flussi di lavoro complessi e interazioni tra modelli AI e sistemi esterni: +MCP (Model Context Protocol) è un protocollo che consente ai client agenti AI di connettersi a strumenti esterni e fonti di dati in modo plug-and-play. Questo abilita flussi di lavoro complessi e interazioni tra modelli AI e sistemi esterni: {{#ref}} AI-MCP-Servers.md {{#endref}} +### Fuzzing Assistito da AI e Scoperta Automatica di Vulnerabilità + +{{#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)