Execution-guided LLM reasoning for automated harnessing in coverage-guided fuzzing

Coverage-guided fuzzing is one of the most effective techniques for vulnerability discovery, yet its practical efficiency often depends on manual configuration decisions. In AFL++, advanced execution modes, such as deferred forkserver initialization, can significantly reduce per-iteration overhead by executing heavy setup code only once, and then fuzzing the steady-state input-processing logic. However, selecting a correct and effective deferred initialization point in real-world executables remains a manual, error-prone task that requires a deep understanding of program structure and runtime behavior. This thesis proposes an automated approach for identifying deferred initialization points in source-available standalone binaries. The proposed method combines debugger-driven runtime observation with Large Language Model (LLM) reasoning. The target program is executed under GDB control with breakpoints placed on input-related functions. When input is consumed, the system captures backtraces and extracts focused source code context from the project’s repository. This execution-grounded information is provided to a Large Language Model, which evaluates candidate boundaries between initialization and steady-state logic. Then, actionable artifacts are produced, including a ranked report and a ready-to-apply patch that inserts AFL++ deferred initialization macros. The approach is implemented as an end-to-end pipeline, integrating repository indexing, debugger automation, structured prompt construction, candidate ranking, and artifact generation. Experimental validation is conducted on three common Linux tools: SQLite, Redis Server, and XMLLint. Each target is fuzzed for 24 hours using AFL++ in deferred mode. In all cases, the system successfully identifies valid insertion points aligned with the core input-processing logic, enabling stable campaigns with progressive coverage growth. The results demonstrate that runtime-guided LLM reasoning can automate a critical configuration step in fuzzing workflows, while preserving practical effectiveness across different architectural paradigms, including command-line tools, event-driven servers, and parser-based executables.

La tecnica del coverage-guided fuzzing è una delle tecniche più efficaci per la scoperta di vulnerabilità; tuttavia, la sua efficacia dipende fortemente da decisioni configurazionali. In AFL++, modalità di esecuzioni avanzate, come la deferred forkserver initialization, consentono di ridurre significativamente l’overhead per iterazione, eseguendo il codice di inizializzazione una sola volta, concentrando la campagna di fuzzing sulla logica di elaborazione dell’input in fase steady-state. Tuttavia, selezionare il punto di inizializzazione corretto ed efficace in eseguibili rimane un’attività manuale e soggetta ad errori, che richiede una profonda conoscenza della struttura del programma. Questa tesi propone un approccio automatizzato per l’identificazione dei punti di inizializzazione differita in eseguibili standalone, avendo a disposizione il codice sorgente. Il metodo proposto combina l’osservazione dinamica guidata da un debugger con capacità di ragionamento di un Large Language Model (LLM). Il programma target viene eseguito sotto il controllo di un debugger, con breakpoint impostati sulle funzioni che gestiscono l’input. Queste informazioni vengono fornite ad un Large Language Model, che valuta i possibili punti di confine tra la componente di inizializzazione e la logica steady-state. Il sistema produce artefatti, tra cui un report ordinato per ranking, e una patch applicabile al codice sorgente che inserisce le macro di deferred initialization di AFL++. L’approccio è implementato secondo una pipeline end-to-end. La validazione sperimentale è stata condotta su tre utility Linux comuni: SQLite, Redis Server e XMLLint. Ogni target è stato sottoposto a una campagna di fuzzing per 24 ore, utilizzando AFL++ in modalità deferred. Per ogni test, il sistema ha identificato con successo punti di inserimento delle macro validi, relativi alla logica centrale di elaborazione dell’input, consentendo campagne stabili con una crescita progressiva della copertura del codice. I risultati dimostrano che un approccio basato sul ragionamento degli LLM, guidati da informazioni relative all’esecuzione, può automatizzare una fase critica della configurazione delle campagne di fuzzing, preservando l’efficacia pratica su diversi paradigmi architetturali.