💻 computer science

RustGo: Fairly Directed Greybox Fuzzing for Enforcing Rust Memory Safety

RustGo è un nuovo fuzzer greybox diretto che sfrutta l'analisi statica specifica di Rust per identificare automaticamente potenziali target di bug di memoria e scartare percorsi di esecuzione irrilevanti, migliorando così significativamente l'efficienza del fuzzing e scoprendo vulnerabilità sconosciute nel codice Rust unsafe rispetto agli approcci esistenti.

Autori originali: Dongyeon Yu (Korea University), Jiun Min (Korea University), Yewan Na (Ulsan National Institute of Science and Technology), Mijung Kim (Ulsan National Institute of Science and Technology), Taegyu Kim

Pubblicato 2026-08-07

📖 7 min di lettura🧠 Approfondimento

CC BY 4.0

Autori originali: Dongyeon Yu (Korea University), Jiun Min (Korea University), Yewan Na (Ulsan National Institute of Science and Technology), Mijung Kim (Ulsan National Institute of Science and Technology), Taegyu Kim (The Pennsylvania State University), Yuseok Jeon (Korea University)

Articolo originale sotto licenza CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Questa è una spiegazione generata dall'IA dell'articolo qui sotto. Non è stata scritta né approvata dagli autori. Per precisione tecnica, consulta l'articolo originale. Leggi il disclaimer completo

Immagina di essere un detective che cerca un singolo, minuscolo difetto in una città enorme e frenetica. Nel mondo del software, questa città è un programma, e il difetto è un "bug di memoria": un errore in cui il programma cerca di prendere, usare o scartare dati che non dovrebbe, causando un crash o una vulnerabilità. Per decenni, il modo più popolare per trovare questi bug è stato il "fuzzing". Pensa al fuzzing come al lanciare milioni di palle di neve casuali e caotiche contro le mura della città per vedere se qualche una rompe una finestra. Di solito, questo funziona bene per i linguaggi più vecchi, ma c'è un problema: è incredibilmente inefficiente. Potresti lanciare 99 palle di neve contro la porta principale, robusta e indistruttibile, solo per trovare l'unica finestra debole in un vicolo sul retro.

Entra Rust, un linguaggio di programmazione moderno che agisce come un guardiano della sicurezza super severo. Le regole di Rust sono così buone che il 90% della città che costruisce è praticamente a prova di proiettile; il guardiano assicura che la maggior parte delle "finestre" (aree di memoria) sia chiusa ermeticamente per impostazione predefinita. Tuttavia, per costruire certe cose complesse, Rust permette agli sviluppatori di aprire un piccolo cancello speciale chiamato "codice unsafe". Questo è l'unico posto in cui le regole rigide vengono allentate, ed è l'unico posto in cui un bug di memoria può nascondersi. Il problema è che gli strumenti di "lancio di palle di neve" esistenti non lo sanno. Continuano a lanciare palle di neve nel 90% della città che è già sicura, sprecando tempo ed energia, mentre mancano i pochi punti pericolosi dietro il cancello speciale. Questo articolo presenta un nuovo strumento investigativo chiamato RustGo che cambia le regole del gioco, sapendo esattamente dove lanciare le palle di neve.

Il Detective Intelligente: RustGo

I ricercatori dietro questo articolo, un team della Korea University e di altre istituzioni, hanno capito che lanciare palle di neve casualmente contro un programma Rust è come cercare un ago in un pagliaio bruciando l'intero pagliaio. Poiché Rust garantisce la sicurezza per la maggior parte del suo codice, si sono chiesti: Perché testare le parti sicure? Hanno costruito RustGo, un "greybox fuzzer direzionato" che agisce come un detective con una mappa e una lente d'ingrandimento, piuttosto che come una persona bendata che lancia sassi.

RustGo funziona in tre fasi intelligenti per dare la caccia ai bug in modo efficiente:

1. Trovare i Target Giusti (La Mappa)
Per prima cosa, RustGo scansiona il codice per trovare le zone "unsafe" dove i bug potrebbero nascondersi. Ma non va a tentoni. Utilizza un tipo speciale di analisi per osservare come i dati fluiscono attraverso il programma. Immagina che la città abbia molti vicoli, ma alcuni portano a vicoli ciechi o loop che non accadono mai nella realtà. RustGo li filtra. Identifica i punti specifici in cui un bug di memoria potrebbe attivarsi e poi unisce i punti simili tra loro. Se due diversi percorsi nel codice portano esattamente allo stesso esito pericoloso, RustGo li tratta come un unico target, così da non perdere tempo a controllare la stessa cosa due volte. Nei loro test, questo passaggio li ha aiutati a ridurre il numero di target da controllare di circa l'84%, concentrandosi solo sulle aree veramente sospette.

2. Tagliare i Vicoli Ciechi (La Lente d'Ingrandimento)
Una volta che RustGo sa dove guardare, deve ignorare il resto della città. Negli strumenti di fuzzing più vecchi, la "mappa" della città includeva spesso la libreria standard (gli strumenti pre-costruiti che Rust usa), che è enorme e piena di percorsi che sembrano raggiungibili ma che in realtà non lo sono. Questo confondeva gli strumenti, portandoli a esplorare aree inutili. RustGo ha introdotto un nuovo trucco chiamato "target-specific path pruning" (potatura dei percorsi specifica per il target). È come avere una staccionata magica che fa scomparire istantaneamente qualsiasi percorso che non conduca al target specifico che si sta indagando in quel momento. Se il detective sta cercando un bug in una panetteria, la staccionata blocca i percorsi verso la biblioteca o il parco, anche se quei percorsi tecnicamente esistono nella città. Questo ha permesso a RustGo di tagliare via il 78,49% dei percorsi irrilevanti che altri strumenti avrebbero esplorato perdendo tempo.

3. Giocare Lealmente (La Strategia Round-Robin)
Ecco l'ultimo, cruciale colpo di scena. Quando un detective ha più sospetti (target) da controllare, gli strumenti più vecchi spesso si ossessionano con quello più facile da raggiungere, ignorando quelli più difficili. RustGo utilizza un sistema di "dynamic fair toggling" (commutazione equa dinamica). Immaginate un arbitro che sposta l'attenzione del detective tra i sospetti in una rotazione perfetta. Se il detective passa troppo tempo sul Sospetto A, l'arbitro lo sposta immediatamente sul S sospetto B, assicurando che ogni sospetto riceva la giusta attenzione. RustGo fa questo assegnando a ogni target la propria "coda" di palle di neve e il proprio "tabellone dei punteggi" per monitorare i progressi. Ciò garantisce che nessun punto pericoloso venga lasciato non testato solo perché è leggermente più difficile da raggiungere.

I Risultati: Più Veloci e Più Intelligenti

Il team ha testato RustGo su 13 applicazioni Rust reali, che spaziano dai server web agli strumenti di elaborazione dati. Hanno confrontato RustGo con i migliori strumenti esistenti, inclusi il famoso AFL++ e diversi fuzzer "direzionati". I risultati sono stati sorprendenti.

Poiché RustGo ha smesso di sprecare tempo sul 90% sicuro del codice per concentrarsi puramente sul 10% pericoloso, ha trovato vulnerabilità da 2,09 a 5,08 volte più velocemente rispetto agli altri strumenti. In alcuni casi, come l'applicazione gimli, è stato più di 10 volte più veloce. Per dare un termine di paragone, se un vecchio strumento impiegava 10 ore per trovare un bug, RustGo lo ha trovato in meno di un'ora.

Ma la velocità non è l'unica vittoria. Il team ha usato RustGo per dare la caccia ai bug "nel mondo reale", non solo nel loro laboratorio di test. Hanno scoperto 13 bug di memoria precedentemente sconosciuti in applicazioni software reali. Di questi, 10 sono stati confermati dagli sviluppatori del software e 8 sono già stati corretti. Ancora più impressionante, 6 di questi bug sono stati assegnati a ID di sicurezza ufficiali (RUSTSEC), e uno ha ricevuto un ID CVE, che è lo standard globale per il tracciamento delle gravi falle di sicurezza. Questo dimostra che RustGo non è solo un'idea teorica; è uno strumento pratico che sta già rendendo il software più sicuro.

Perché Questo È Importante

Questo articolo non si limita a suggerire che RustGo sia una buona idea; ne misura l'efficacia, ne prova il funzionamento e mostra come trovi bug reali che altri hanno mancato. Argomenta esplicitamente contro il vecchio modo di pensare: che dobbiamo testare ogni singola riga di codice per essere sicuri. Al contrario, dimostra che comprendendo le regole uniche di Rust, possiamo essere più intelligenti, più veloci ed efficaci.

I ricercatori hanno anche affrontato una preoccupazione comune: "E se manchiamo un bug ignorando le parti sicure?". Spiegano che le regole di sicurezza di Rust sono così rigide che i bug di memoria spaziale (come l'accesso a un indirizzo di memoria errato) semplicemente non possono accadere nelle parti sicure del codice. Pertanto, ignorarli non crea un punto cieco; rimuove solo il rumore. Per i bug temporali (usare la memoria dopo che è stata liberata), RustGo è attento a non eliminare accidentalmente un percorso che potrebbe portare a un bug, utilizzando un approccio "conservativo" che mantiene la rete di sicurezza abbastanza ampia da catturare tutto.

In definitiva, RustGo è una testimonianza della potenza della specializzazione. Proprio come uno chef esperto non usa un martello per rompere una noce, un fuzzer moderno non dovrebbe usare uno strumento rozzo su un linguaggio sofisticato come Rust. Adattando l'approccio ai punti di forza e di debolezza unici del linguaggio, gli autori hanno creato uno strumento che non è solo più veloce, ma anche più equo, assicurando che ogni potenziale pericolo nel codice riceva l'attenzione che merita.

Riepilogo Tecnico: RustGo

Problematica

Rust garantisce la sicurezza della memoria attraverso rigorose policy di tempo di compilazione (ownership, borrowing, lifetime), eppure i bug di memoria persistono nelle regioni unsafe dove queste policy vengono eluse. Sebbene il codice unsafe costituisca una piccola frazione dei tipici programmi Rust (circa il 10%), gli approcci di fuzzing esistenti trattano l'intero codice sorgente come una potenziale fonte di bug. Ciò risulta in un'allocazione inefficiente delle risorse, poiché i fuzzer sprecano sforzi su regioni di memoria sicure che il compilatore Rust garantisce già essere sicure.

Inoltre, le soluzioni di Directed Greybox Fuzzing (DGF) esistenti, originariamente progettate per C/C++, affrontano sfide significative quando applicate a Rust:

Identificazione del Target: I metodi tradizionali si affidano alla selezione manuale o a criteri semplici (ad esempio, la posizione dei sanitizer) e non riescono a identificare automaticamente i target inclini ai bug di memoria specifici dell'architettura unica di Rust, come il dereferenziazione di puntatori grezzi in codice sicuro che è aliasato a puntatori unsafe.
Pruning dei Percorsi: La libreria standard di Rust è collegata staticamente e monomorfizzata, creando un binario unificato complesso. Le analisi di raggiungibilità esistenti sovrastimano spesso, fallendo nel rimuovere (pruning) i percorsi irrilevanti perché non riescono a distinguere efficacemente tra il codice utente e la logica della libreria standard.
Equità nel Multi-Target Fuzzing: I DGF multi-target esistenti spesso danno priorità ai target più "vicini", portando alla fame (starvation) di target distanti ma vulnerabili. Gli stati di fuzzing condivisi (singola coda di input, singolo bitmap di copertura) rendono difficile allocare l'energia in modo equo tra più target distinti.

Metodologia

Il paper propone RustGo, un fuzzer directed greybox per Rust progettato per identificare, ottimizzare e fuzzare automaticamente le regioni inclini ai bug di memoria. RustGo opera attraverso tre componenti principali:

1. Identificazione e Ottimizzazione del Target

RustGo impiega un'analisi statica multi-stadio per identificare i target vulnerabili:

Analisi MIR e LLVM IR: Esegue un'analisi di type-matching a livello di Mid-level Intermediate Representation (MIR) per identificare le operazioni sui puntatori grezzi, che non vengono preservate in LLVM IR. Successivamente, utilizza un'analisi di taint basata su Value Flow Graph (VFG) a livello di LLVM IR per tracciare la propagazione dei puntatori e identificare i siti di aliasing.
Filtraggio della Libreria Standard: Per evitare falsi positivi causati dall'analisi non contestuale della libreria standard monomorfizzata, RustGo annota le funzioni della libreria standard. Utilizza gli archi dell'Inter-procedural Control Flow Graph (ICFG) per propagare il taint attraverso i confini della libreria senza attraversare la logica interna della libreria, filtrando efficacemente i percorsi irraggiungibili.
Ottimizzazione Post-Dominance: Per ridurre il numero di target e prevenire il degrado del fuzzer in un generico fuzzer guidato dalla copertura, RustGo esegue un'analisi di post-dominanza inter-procedurale. Se un target $t_i$ è post-dominato da $t_j$ (ovvero tutti i percorsi verso $t_i$ devono passare per $t_j$ ), $t_i$ viene unito a $t_j$ . Ciò riduce i target ridondanti consolidandoli in posizioni rappresentative.

2. Pruning dei Percorsi Specifici per il Target

Una volta identificati i target, RustGo elimina i percorsi irrilevanti per massimizzare l'efficienza del fuzzing:

Remapping dei Call-Site: I target situati all'interno della libreria standard vengono rimappati ai rispettivi siti di invocazione nel codice utente per garantire un'analisi di raggiungibilità precisa.
Pruning Consapevole delle Precondizioni:
- Per i bug spaziali (dereferenziazione di puntatori grezzi), non viene applicato alcun pruning poiché possono verificarsi senza precondizioni specifiche.
- Per i bug temporali (es. Use-After-Free), RustGo sfrutta i risultati dell'analisi di taint per verificare se un percorso contiene la sequenza necessaria di operazioni di memoria (es. alloc $\to$ free $\to$ dereference). I percorsi privi di tali sequenze vengono sottoposti a pruning.
- Gestione Async/Await: Per evitare falsi negativi nel codice concorrente, RustGo disabilita conservativamente il pruning per le funzioni che coinvolgono async/await e l'aliasing di puntatori grezzi.

3. Dynamic Fair Toggling Fuzzing

Per garantire un test equo tra più target senza interferenze, RustGo introduce un meccanismo di toggling dinamico:

Multi-Queue e Multi-Coverage: A differenza dei fuzzer tradizionali che utilizzano una singola coda di input e un singolo bitmap di copertura globale, RustGo mantiene code di input e bitmap di copertura indipendenti per ogni target.
Dynamic Toggle: Il fuzzer passa da un target all'altro in modalità round-robin. Quando un target è attivo, il sistema aggiorna una "Toggle Shared Memory" (TSM) condivisa per abilitare dinamicamente solo i blocchi di base rilevanti per quel target specifico. Ciò consente al fuzzer di eseguire il pruning dei percorsi irrivoli in tempo reale per il target corrente mantenendo stati di fuzzing indipendenti, assicurando che nessun target sia affamato di risorse.

Contributi Chiave

Framework RustGo: Un nuovo fuzzer directed greybox su misura per Rust, capace di identificare e ottimizzare automaticamente i target inclini ai bug di memoria utilizzando l'analisi specifica per Rust (analisi incrociata MIR/LLVM IR, tracciamento del taint e post-dominanza).
Pruning Specifico per il Target: Una nuova strategia di pruning che gestisce la complessa struttura della libreria standard di Rust e la monomorfizzazione, ottenendo un'alta precisione nell'eliminare i percorsi irrilevanti.
Fair Multi-Target Fuzzing: Un approccio di toggling dinamico con schemi multi-queue e multi-coverage che garantisce un'allocazione equa dell'energia tra più target, prevenendo il bias verso i target facilmente raggiungibili comune nei DGF esistenti.
Valutazione e Scoperta: Valutazione completa su applicazioni Rust reali, dimostrando miglioramenti significativi delle prestazioni rispetto ai fuzzer allo stato dell'arte e la scoperta di 13 bug di memoria precedentemente sconosciuti.

Risultati

Gli autori hanno valutato RustGo su un benchmark personalizzato di 13 applicazioni Rust reali e sul benchmark deepSURF (26 bug reali).

Ottimizzazione del Target: RustGo ha ridotto il numero di target iniziali in media dell'84,13% attraverso la consolidazione della post-dominanza.
Pruning dei Percorsi: RustGo ha rimosso in media il 78,49% dei percorsi irrilevanti per target, superando significativamente gli approcci di base (ad esempio, RG-base al 51,11%).
Velocità (Speedup): RustGo ha raggiunto i target da 2,09x a 5,08x più velocemente rispetto ai DGF esistenti (inclusi AFLGo, WindRanger, FishFuzz e PanicKiller) e da 2,85x a 3,45x più velocemente rispetto ai fuzzer guidati dalla copertura (AFL, AFL++).
Scoperta di Vulnerabilità: RustGo ha identificato 13 bug di memoria precedentemente sconosciuti in progetti Rust reali. Di questi, 10 sono stati confermati, 8 sono stati patchati, 6 hanno ricevuto ID RUSTSEC e 1 ha ricevuto un ID CVE.
Confronto con i Fuzz Driver: Rispetto ai generatori di fuzz driver (RPG, RUG, deepSURF), RustGo ha rilevato con successo tutti i 13 nuovi bug, mentre i generatori hanno fallito nel rilevarne la maggior parte a causa delle difficoltà nel costruire tipi di argomenti complessi e contesti di esecuzione.

Significato

Il paper afferma che RustGo affronta l'inefficienza critica dell'applicazione di strategie di fuzzing centrate su C/C++ a Rust. Sfruttando le caratteristiche uniche del linguaggio Rust (ownership, monomorfizzazione e la distinzione tra codice safe e unsafe), RustGo ottiene un processo di fuzzing "equo" e "diretto" che evita di sprecare risorse su codice memory-safe. I risultati dimostrano che un fuzzing mirato e consapevole di Rust non è solo più efficiente, ma anche più efficace nel scoprire vulnerabilità profonde di sicurezza della memoria rispetto sia al fuzzing generico guidato dalla copertura che agli approcci diretti esistenti. La scoperta di 13 nuovi bug, inclusi quelli assegnati a ID CVE e RUSTSEC, valida l'utilità pratica del framework nel potenziare la sicurezza dell'ecosistema Rust.