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

1. Probleemstelling

De programmeertaal Rust wordt steeds vaker toegepast voor kritieke systemen vanwege zijn garanties op het gebied van geheugen- en threadveiligheid. De Rust-compiler zelf is echter complex, en bugs hierin kunnen leiden tot ongedefinieerd gedrag of crashes in productiesystemen.

• Uitdaging 1: Syntaxiscomplexiteit. Rust heeft een steile leercurve en strikte syntaxisregels (ownership, borrowing, lifetimes), wat het moeilijk maakt om geldige testprogramma's te genereren met traditionele willekeurige generatie of mutatie-gebaseerde fuzzing.
• Uitdaging 2: Beperkingen van LLM's. Hoewel Large Language Models (LLM's) veelbelovend zijn voor softwaretesten, leidt het rechtstreeks opwekken van deze modellen om Rust-testgevallen te genereren vaak tot ongeldige code of code die geen compilerbugs activeert. Dit komt door het "long-tail"-probleem: Rust vormt een klein deel van de trainingsdata van LLM's, en bestaande modellen worstelen met de specifieke, evoluerende edge cases van de Rust-compiler.
• Uitdaging 3: Gebrek aan context. Bestaande op LLM's gebaseerde fuzzers vertrouwen vaak op zero-shot-generatie of fine-tuning zonder gebruik te maken van de specifieke structurele kenmerken van historische bug-activerende code.

2. Methodologie: ClozeMaster

De auteurs stellen ClozeMaster voor, een fuzzing-framework dat historische bugdata combineert met LLM-capaciteiten via een nieuwe ClozeMask-strategie. De werkwijze bestaat uit vier hoofdstappen:

A. Datasetconstructie en Augmentatie

• Bron: Het systeem verzamelt codefragmenten uit historische Rust-compilerbugrapporten (specifiek rustc-issues gelabeld als "C-bug" en "T-compiler"), de officiële Rust-testsuite en de Glacier-repository (bevat Internal Compiler Error-triggers).
• Augmentatie: Om de datasetgrootte voor fine-tuning te vergroten, passen de auteurs data-augmentatietechnieken toe:
  • Willekeurige Verwijdering (RD): Willekeurig verwijderen van code-tokens (kans $p=0.2$).
  • Willekeurig Wisselen (RS): Het verwisselen van de posities van twee statements binnen een programma.
  • Hierdoor werd de dataset uitgebreid van ongeveer 25.000 naar 100.000 fragmenten.

B. Fine-tuning van de LLM

• Model: Het open-source Incoder-model is geselecteerd vanwege zijn vermogen om code-infilling-taken te verwerken.
• Training: Het model wordt gefine-tuned op de samengestelde dataset van historische bug-activerende code. Dit leert de LLM de specifieke syntaxis en semantische patronen die geassocieerd zijn met Rust-compilerkwetsbaarheden.

C. De ClozeMask-strategie (Kerninnovatie)

In plaats van code van scratch te genereren, gebruikt ClozeMaster een "invul-de-leegte"-benadering:

1. Maskeren: Een codefragment uit de dataset wordt geselecteerd. Een Depth-First Search (DFS) identificeert haakjesstructuren ((), {}, [], <>). De inhoud binnen deze haakjes wordt vervangen door een [mask]-token.
   • Redenering: Haakjes definiëren de syntaxis en semantiek van Rust. Het behoud van de buitenste structuur zorgt ervoor dat de gegenereerde code syntactisch geldig blijft, terwijl de gemaskerde binnenin inhoud de LLM in staat stelt edge cases te verkennen.
2. Infilling: De gefine-tunde LLM wordt opgewekt om de gemaskerde delen in te vullen.
   • Er wordt speciale aandacht besteed aan "feature"-blokken (bijv. #![feature(...)]) om de generatie van experimentele functies aan te moedigen die bekend staan als instabiel.
   • Als de ingevulde code identiek is aan de originele, wordt deze verworpen om nieuwheid te garanderen.

D. Oracle en Filtering

• Oracles: Het systeem compileert de gegenereerde code met rustc en mrustc.
  • ICE (Internal Compiler Error): Gedetecteerd via crashes of berichten met "internal compiler error".
  • Hang: Gedetecteerd als de compilatie langer duurt dan een time-out van 180 seconden.
• Deduplicatie: Stacktraces en time-passes-informatie worden opgeslagen om dubbele bugs te filteren.

3. Belangrijkste Bijdragen

1. ClozeMask-strategie: Een nieuwe aanpak die door haakjes omsloten code-segmenten in historische bugrapporten maskeert en LLM's gebruikt om ze in te vullen. Dit behoudt de structurele integriteit die nodig is voor Rust, terwijl het gebruik maakt van LLM's om nieuwe, potentieel bug-achtige variaties te genereren.
2. CLOZEMASTER-framework: Het eerste fuzzing-tool specifiek ontworpen voor Rust-compiler dat historische bugdata, data-augmentatie en LLM-fine-tuning integreert.
3. Empirische Validatie: Uitgebreide evaluatie op twee compilers (rustc en mrustc) die een superieure prestatie aantoont ten opzichte van bestaande baselines.

4. Experimentele Resultaten

De auteurs hebben ClozeMaster geëvalueerd tegen drie baselines: RustSmith (generatief), Rustlantis (generatief) en SPE (mutatie-gebaseerd).

• Bugdetectie:
  • Totaal gerapporteerd: 37 bugs.
  • Bevestigd: 27 bugs (10 gerepareerd door ontwikkelaars).
  • Vergelijking: ClozeMaster vond 11 unieke bugs op rustc v1.73, terwijl baselines 0–1 vonden.
  • Nieuwheid: Veel bugs waren latent in versies zo oud als v1.56 (meer dan 2 jaar oud), en ontsnapten aan detectie door andere tools.
• Code-coverage:
  • ClozeMaster behaalde 64,34% code-coverage.
  • Dit vertegenwoordigt een relatieve toename van 95,92% ten opzichte van RustSmith (32,84%) en 117,73% ten opzichte van Rustlantis (29,55%).
  • Het presteerde ook beter dan SPE (62,02%).
• Component-coverage: Bugs werden gevonden in diverse compilercomponenten, waaronder parsers, macro's, traits, lifetimes en const-generics. Opmerkelijk genoeg was de functie "generic const exprs" een belangrijke bron van ICE's.

5. Betekenis en Discussie

• Effectiviteit van historische data: De studie bevestigt dat codefragmenten die historisch bugs hebben geactiveerd, waardevolle domeinspecifieke kennis bevatten. Het gebruik ervan als basis voor masking/infilling is effectiever dan willekeurige generatie of pure LLM-generatie.
• Belang van context: Ablatiestudies toonden aan dat het verwijderen van historische bugdata of het gebruik van een niet-gefine-tuned model de prestaties aanzienlijk verslechterde. Bovendien resulteerde het gebruik van een LLM zonder de "cloze"-context (genereren van scratch) voornamelijk in ongeldige syntaxis.
• Modelselectie: Het artikel benadrukt dat algemene LLM's (zoals GPT-4o) of modellen getraind op algemene code (StarCoder) slecht presteren bij Rust-infilling vanwege syntaxisfouten. Incoder, getraind met willekeurige masking-strategieën, bleek superieur voor deze specifieke taak.
• Impact: ClozeMaster toont aan dat het combineren van historische bugpatronen met LLM-infilling een haalbare en krachtige strategie is voor het testen van complexe, veiligheidskritieke compilers zoals die van Rust, waarbij diepe edge cases worden ontdekt die traditionele fuzzers missen.

Beschikbaarheid van artifacten: De implementatie en de buglijst zijn publiek beschikbaar op https://github.com/clozeMasterPro/clozeMaster.