💻 computer science

ClozeMaster: Fuzzing Rust Compiler by Harnessing LLMs for Infilling Masked Real Programs

Il documento introduce ClozeMaster, uno strumento di fuzzing che sfrutta i grandi modelli linguistici per sintetizzare programmi di test Rust validi estraendo e completando frammenti di codice mascherati da rapporti storici di bug, superando di conseguenza i fuzzing esistenti e scoprendo 27 bug del compilatore confermati.

Autori originali: Hongyan Gao, Yibiao Yang, Maolin Sun, Jiangchang Wu, Yuming Zhou, Baowen Xu

Pubblicato 2026-05-04

📖 4 min di lettura☕ Lettura da pausa caffè

CC BY 4.0

Autori originali: Hongyan Gao, Yibiao Yang, Maolin Sun, Jiangchang Wu, Yuming Zhou, Baowen Xu

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 avere uno chef molto severo e di alto livello (il compilatore Rust) famoso per preparare pasti incredibilmente sicuri e veloci. Questo chef ha un insieme di regole molto specifico: se provi a mettere gli ingredienti nel ordine sbagliato, usi una spezia proibita o mescoli consistenze che non appartengono insieme, lo chef non si limita a dire "no". A volte, così confuso dalla tua richiesta strana, lascia cadere l'intero vassoio, urla o si blocca completamente. Questi sono i "bug" di cui parla il documento.

Il problema è che è molto difficile ingannare questo chef. Se gli lanci semplicemente ingredienti a caso (come un "fuzzer" standard o un test automatizzato), di solito ti ignora o ti risponde gentilmente "ordine non valido". Raramente si confonde abbastanza da bloccarsi.

Entra in scena ClozeMaster, il nuovo metodo proposto dai ricercatori. Ecco come funziona, usando una semplice analogia:

La strategia "Mad Libs"

Invece di chiedere allo chef di indovinare cosa vuoi da zero, i ricercatori hanno deciso di guardare ai errori passati. Sono entrati nel registro delle lamentele dello chef (i "bug report") e hanno trovato ricette che in precedenza avevano fatto andare in crash o bloccare lo chef.

Hanno realizzato che queste "ricette di crash" avevano una struttura speciale. Erano come un gioco di Mad Libs (un gioco di parole in cui si riempiono gli spazi vuoti).

Il mascheramento (Lo spazio vuoto): I ricercatori hanno preso una ricetta che una volta aveva fatto andare in crash lo chef. Hanno esaminato le parti all'interno delle parentesi tonde, quadre e graffe (come ( ), { }, [ ]). Hanno coperto quelle parti specifiche con una "maschera" (uno spazio vuoto), lasciando il resto della ricetta intatto.
- Analogia: Immagina una ricetta che dice: "Mescola la farina con il ______ e inforna". La parte in grassetto è lo spazio vuoto. Il resto della frase (la struttura) è sicuro e grammaticalmente corretto.
Il riempimento AI (L'LLM): Hanno usato un'intelligenza artificiale intelligente (un Large Language Model) per riempire quegli spazi vuoti. Ma non hanno chiesto all'AI di scrivere semplicemente una frase a caso. Hanno prima "addestrato" l'AI su tutte quelle vecchie ricette rotte, in modo che l'AI apprendesse il "sapore" specifico del codice che confonde lo chef Rust.
- Analogia: L'AI è come uno studente che ha studiato ogni volta che lo chef si è arrabbiato. Quando gli viene chiesto di riempire lo spazio vuoto, l'AI non scrive semplicemente "zucchero"; potrebbe scrivere qualcosa di strano come "un polpo vivo" perché sa che lo chef si confonde con combinazioni strane.
Il risultato: Poiché la struttura della ricetta era perfetta (era basata su una ricetta reale e funzionante), lo chef l'ha accettata. Ma poiché la parte riempita era strana e complessa, lo chef si è confuso e ha crashato. Questo ha rivelato un nuovo bug.

Perché questo era necessario

I ricercatori hanno scoperto che Rust è come un linguaggio con regole grammaticali molto complesse.

I vecchi metodi erano come lanciare dardi bendati su una bacheca. Raramente centravano il bersaglio (il bug) perché le regole sono troppo severe.
La generazione diretta con AI era come chiedere a uno studente di scrivere una ricetta da zero senza guardare alcun esempio. Lo studente (l'AI) non conosceva abbastanza le regole severe di Rust e scriveva assurdità che lo chef rifiutava immediatamente.
ClozeMaster era come dare allo studente una ricetta parzialmente scritta e complessa e chiedergli di completare solo una frase difficile. Lo studente conosceva il contesto, quindi scriveva qualcosa che rispettava le regole ma era comunque abbastanza strano da far crashare lo chef.

Cosa hanno scoperto

Il team ha costruito uno strumento prototipo chiamato ClozeMaster e lo ha testato su due versioni dello chef Rust (quello ufficiale e uno realizzato dalla comunità).

Hanno trovato 37 nuovi bug (crash o blocchi) che nessuno aveva mai visto prima.
Gli sviluppatori ne hanno confermati 27 e ne hanno risolti 10.
Il loro strumento era molto migliore nel trovare questi bug ed esplorare la "cucina" dello chef (copertura del codice) rispetto ai migliori strumenti precedenti.

La conclusione

Il documento afferma che prendendo codice vecchio e rotto, nascondendo parti specifiche di esso e usando un'AI per riempire quelle parti, è possibile creare nuovi test insidiosi che mettono in luce debolezze nascoste nel compilatore Rust. È un modo di usare la storia per prevedere dove potrebbero nascondersi i futuri errori.

1. Enunciato del Problema

Il linguaggio di programmazione Rust è sempre più adottato per sistemi critici grazie alle sue garanzie di sicurezza della memoria e dei thread. Tuttavia, il compilatore Rust stesso è complesso, e i bug al suo interno possono portare a comportamenti indefiniti o crash in sistemi di produzione.

Sfida 1: Complessità Sintattica. Rust ha una curva di apprendimento ripida e regole sintattiche rigorose (proprietà, prestito, durate), rendendo difficile generare programmi di test validi utilizzando la generazione casuale tradizionale o il fuzzing basato su mutazione.
Sfida 2: Limiti degli LLM. Sebbene i Modelli Linguistici su Larga Scala (LLM) mostrino promesse nel testing del software, sollecitarli direttamente a generare casi di test in Rust spesso porta a codice non valido o a codice che non riesce a innescare bug del compilatore. Ciò è dovuto al problema della "coda lunga": Rust costituisce una piccola frazione dei dati di addestramento degli LLM, e i modelli esistenti faticano con i casi limite specifici ed evolutivi del compilatore Rust.
Sfida 3: Mancanza di Contesto. I fuzzer basati su LLM esistenti spesso si affidano alla generazione zero-shot o al fine-tuning senza sfruttare le caratteristiche strutturali specifiche del codice storicamente capace di innescare bug.

2. Metodologia: ClozeMaster

Gli autori propongono ClozeMaster, un framework di fuzzing che combina dati storici sui bug con le capacità degli LLM utilizzando una strategia innovativa ClozeMask. Il flusso di lavoro consta di quattro fasi principali:

A. Costruzione e Augmentation del Dataset

Fonte: Il sistema raccoglie frammenti di codice dai report storici sui bug del compilatore Rust (in particolare issue rustc etichettate "C-bug" e "T-compiler"), dalla suite di test ufficiale di Rust e dal repository Glacier (contenente trigger di Internal Compiler Error).
Augmentation: Per aumentare la dimensione del dataset per il fine-tuning, gli autori applicano tecniche di augmentation dei dati:
- Cancellazione Casuale (RD): Rimozione casuale di token di codice (probabilità $p=0.2$ ).
- Scambio Casuale (RS): Scambio delle posizioni di due istruzioni all'interno di un programma.
- Questo ha espanso il dataset da ~25k a 100k frammenti.

B. Fine-Tuning dell'LLM

Modello: Viene selezionato il modello open-source Incoder per la sua capacità di gestire compiti di infilling del codice.
Addestramento: Il modello viene sottoposto a fine-tuning sul dataset curato di codice storicamente capace di innescare bug. Questo insegna all'LLM le specifiche sintattiche e i pattern semantici associati alle vulnerabilità del compilatore Rust.

C. La Strategia ClozeMask (Innovazione Principale)

Invece di generare codice da zero, ClozeMaster utilizza un approccio "completa la frase":

Mascheratura: Viene selezionato un frammento di codice dal dataset. Una ricerca in profondità (DFS) identifica le strutture tra parentesi ((), {}, [], <>). Il contenuto all'interno di queste parentesi viene sostituito con un token [mask].
- Razionale: Le parentesi definiscono la sintassi e la semantica di Rust. Preservare la struttura esterna garantisce che il codice generato rimanga sintatticamente valido, mentre il contenuto interno mascherato permette all'LLM di esplorare casi limite.
Infilling: L'LLM sottoposto a fine-tuning viene sollecitato a riempire le porzioni mascherate.
- Viene applicata una gestione speciale ai blocchi "feature" (ad es. #![feature(...)]) per incoraggiare la generazione di feature sperimentali note per essere instabili.
- Se il codice infillato è identico all'originale, viene scartato per garantire la novità.

D. Oracle e Filtraggio

Oracle: Il sistema compila il codice generato utilizzando rustc e mrustc.
- ICE (Internal Compiler Error): Rilevato tramite crash o messaggi "internal compiler error".
- Hang: Rilevato se la compilazione supera un timeout di 180 secondi.
Deduplicazione: Vengono memorizzati gli stack trace e le informazioni sui time-passes per filtrare i bug duplicati.

3. Contributi Chiave

Strategia ClozeMask: Un approccio innovativo che maschera segmenti di codice racchiusi tra parentesi nei report storici sui bug e utilizza gli LLM per riempirli. Questo preserva l'integrità strutturale necessaria per Rust, sfruttando al contempo gli LLM per generare variazioni nuove e potenzialmente buggate.
Framework CLOZEMASTER: Il primo strumento di fuzzing specificamente progettato per i compilatori Rust che integra dati storici sui bug, augmentation dei dati e fine-tuning degli LLM.
Validazione Empirica: Valutazione estesa su due compilatori (rustc e mrustc) che dimostra prestazioni superiori rispetto alle baseline esistenti.

4. Risultati Sperimentali

Gli autori hanno valutato ClozeMaster contro tre baseline: RustSmith (generativo), Rustlantis (generativo) e SPE (basato su mutazione).

Rilevamento Bug:
- Totale Segnalati: 37 bug.
- Confermati: 27 bug (10 risolti dagli sviluppatori).
- Confronto: ClozeMaster ha trovato 11 bug unici su rustc v1.73, mentre le baseline ne hanno trovati 0–1.
- Novità: Molti bug erano latenti in versioni vecchie fino a v1.56 (oltre 2 anni), sfuggendo al rilevamento da parte di altri strumenti.
Copertura del Codice:
- ClozeMaster ha raggiunto una copertura del codice del 64,34%.
- Ciò rappresenta un aumento relativo del 95,92% rispetto a RustSmith (32,84%) e del 117,73% rispetto a Rustlantis (29,55%).
- Ha anche superato SPE (62,02%).
Copertura dei Componenti: I bug sono stati trovati in diversi componenti del compilatore, inclusi parser, macro, trait, durate e generici costanti. In particolare, la feature "generic const exprs" è stata una fonte maggiore di ICE.

5. Significato e Discussione

Efficacia dei Dati Storici: Lo studio conferma che i frammenti di codice storicamente capaci di innescare bug contengono conoscenze specifiche del dominio preziose. Utilizzarli come base per mascheratura/riempimento è più efficace della generazione casuale o della generazione pura tramite LLM.
Importanza del Contesto: Gli studi di ablazione hanno mostrato che rimuovere i dati storici sui bug o utilizzare un modello non sottoposto a fine-tuning degrada significativamente le prestazioni. Inoltre, l'uso di un LLM senza il contesto "cloze" (generazione da zero) ha portato prevalentemente a sintassi non valida.
Selezione del Modello: Il paper evidenzia che gli LLM generici (come GPT-4o) o i modelli addestrati su codice generico (StarCoder) performano male nell'infilling di Rust a causa di errori sintattici. Incoder, addestrato con strategie di mascheratura casuale, si è rivelato superiore per questo compito specifico.
Impatto: ClozeMaster dimostra che combinare pattern storici di bug con l'infilling tramite LLM è una strategia vitale e potente per testare compilatori complessi e critici per la sicurezza come quello di Rust, scoprendo casi limite profondi che i fuzzer tradizionali mancano.

Disponibilità dell'Artifatto: L'implementazione e l'elenco dei bug sono pubblicamente disponibili all'indirizzo https://github.com/clozeMasterPro/clozeMaster.