Automation Challenges and Solutions in Coverage-Guided Fuzzing of Multiprocess Software Systems [Sfide e Soluzioni per l'Automazione del Coverage-Guided Fuzzing di Sistemi Software Multiprocesso]

Modern software systems typically rely on multiprocess architectures to achieve scalability, fault isolation, and enhanced performance. Notable examples are web servers, database systems, and browsers, which handle incoming requests, user sessions, or plugins through separate processes. However, this distributed design introduces significant challenges for automated security testing methodologies. Among the various automated security testing techniques, Coverage-Guided Fuzzing has been widely adopted for software vulnerability discovery. In brief, it leverages runtime code coverage as testcase execution feedback to drive mutation-based input generation with the objective of enhancing system exploration. Despite its effectiveness, current fuzzers are not designed to comprehensively test multiprocess software systems, creating blind spots in vulnerability detection. In fact, existing fuzzers operate under the assumption of single-process execution within clear fuzzing loop boundaries. Multiprocess software systems break these assumptions: processes run concurrently, accept inputs through different inter-process communication mechanisms, code coverage scatters across multiple address spaces, and bugs occur in unmonitored child processes. These limitations stem from a lack of fork-awareness: the capability to detect, trace, and coordinate testing across process boundaries created by fork() system calls. This dissertation addresses the automation challenges of coverage-guided fuzzing for multiprocess software systems. The research identifies four core problems: execution synchronisation across concurrent processes, comprehensive test oracle design for multiprocess bug detection, coverage observation across distributed execution, and multi-input generation and injection through diverse inter-process communication mechanisms. The primary contributions include: (1) empirical evidence demonstrating significantly lower coverage in multiprocess software within OSS-Fuzz projects, (2) the formal definition of fork-awareness and a systematic evaluation framework revealing fundamental limitations across fourteen state-of-the-art fuzzers, and (3) the design and implementation of ForkFuzz, the first fork-aware coverage-guided fuzzer that addresses three of the four core challenges through process tree monitoring, cross-process anomaly detection, and distributed coverage aggregation. Ultimately, this work establishes the foundation for automated coverage-guided fuzzing of multiprocess software systems, with complementary contributions extending to specialised domains including stateful protocol testing and GraphQL API security assessment.

I moderni sistemi software si basano tipicamente su architetture multiprocesso per ottenere scalabilità, isolamento dei guasti e prestazioni migliorate. Esempi notevoli sono i server web, i sistemi di database e i browser, che gestiscono richieste in ingresso, sessioni utente o plugin attraverso processi separati. Tuttavia, questo design distribuito introduce sfide significative per le metodologie di security testing automatizzato. Tra le varie tecniche di security testing automatizzato, il Coverage-Guided Fuzzing è stato ampiamente adottato per la scoperta di vulnerabilità software. In breve, sfrutta la copertura del codice a runtime come feedback sull'esecuzione dei testcase per guidare la generazione di input basata su mutazione con l'obiettivo di migliorare l'esplorazione del sistema. Nonostante la sua efficacia, i fuzzer attuali non sono progettati per testare in modo completo i sistemi software multiprocesso, creando punti ciechi nella rilevazione delle vulnerabilità. Infatti, i fuzzer esistenti operano sotto l'assunzione di esecuzione a singolo processo entro confini chiari del fuzzing loop. I sistemi software multiprocesso infrangono queste assunzioni: i processi vengono eseguiti in modo concorrente, accettano input attraverso diversi meccanismi di comunicazione inter-processo, la copertura del codice si disperde su più spazi di indirizzamento e i bug si verificano in processi figli non monitorati. Queste limitazioni derivano dalla mancanza di fork-awareness: la capacità di rilevare, tracciare e coordinare il testing attraverso i confini dei processi creati dalle system call fork(). Questa tesi affronta le sfide di automazione del coverage-guided fuzzing per sistemi software multiprocesso. La ricerca identifica quattro problemi fondamentali: la sincronizzazione dell'esecuzione tra processi concorrenti, la progettazione di test oracle completi per il rilevamento di bug multiprocesso, l'osservazione della copertura attraverso l'esecuzione distribuita, e la generazione e iniezione di input multipli attraverso diversi meccanismi di comunicazione inter-processo. I contributi principali includono: (1) evidenza empirica che dimostra una copertura significativamente inferiore nel software multiprocesso nei progetti OSS-Fuzz, (2) la definizione formale di fork-awareness e un framework di valutazione sistematica che rivela limitazioni fondamentali in quattordici fuzzer allo stato dell'arte, e (3) la progettazione e implementazione di ForkFuzz, il primo fuzzer coverage-guided fork-aware che affronta tre delle quattro sfide fondamentali attraverso il monitoraggio dell'albero dei processi, il rilevamento di anomalie cross-process e l'aggregazione distribuita della copertura. In definitiva, questo lavoro stabilisce le fondamenta per il coverage-guided fuzzing automatizzato di sistemi software multiprocesso, con contributi complementari che si estendono a domini specializzati tra cui il testing di protocolli stateful e la valutazione della sicurezza delle API GraphQL.