LLM4C2Rust: Large Language Models for Automated Memory-Safe Code Transpilation

1. Probleemstelling

De C- en C++-programmeertalen vormen de ruggengraat van veel kritieke systemen (besturingssystemen, embedded controllers), maar ze missen ingebouwde beveiliging tegen geheugenveiligheidsproblemen. Ongeveer 70% van de gerapporteerde beveiligingskwetsbaarheden (zoals bufferoverlopen, hangende pointers en data-races) is het gevolg van geheugenveiligheidsfouten.

Hoewel Rust een moderne taal is die deze problemen oplost door strikte eigendom- en leenregels (ownership-and-borrowing) op compileertijd af te dwingen, is het handmatig migreren van legacy C/C++-code naar Rust tijdrovend, duur en foutgevoelig. Bestaande geautomatiseerde transpilatie-methoden zijn vaak:

• Regelgebaseerd: Ze genereren vaak onveilige Rust-code die nog steeds lage-niveau C-idioom bevat.
• LLM-gebaseerd (zonder context): Hoewel Large Language Models (LLMs) vloeiendere code kunnen genereren, lijden ze aan "hallucinaties" (het creëren van niet-bestaande of onjuiste code) en gebrek aan semantische garanties, wat leidt tot code die niet compileert of onveilig blijft.

Het doel van dit onderzoek is een geautomatiseerde methode te ontwikkelen die C/C++ naar veilige Rust code transpileert, waarbij de functionaliteit behouden blijft maar geheugenveiligheid wordt gegarandeerd.

2. Methodologie

De auteurs stellen een nieuw framework voor dat een Retrieval-Augmented Generation (RAG) pipeline integreert met LLM's en Small Language Models (SLMs). De architectuur bestaat uit drie hoofdblokken:

A. Segmentatie en Transpilatie-pipeline

In plaats van code functie voor functie te verwerken, wordt de C/C++-broncode opgesplitst in gebalanceerde blokken (segmenten) op basis van accolades ({ en }) en een minimale lengte (500 tekens). Dit zorgt ervoor dat:

• Code niet in het midden van een logische eenheid wordt onderbroken.
• De context groot genoeg is voor de LLM, maar binnen de token-limieten blijft.
• Elk segment krijgt een samenvatting van het totale programma om de globale intentie te behouden.

B. Twee-staps Transpilatie naar Veilige Rust

Het proces verloopt in twee fasen:

1. Initiële transpilatie: De LLM converteert het C-segment naar een eerste versie van Rust-code. Hierbij is het gebruik van unsafe blokken toegestaan om het oorspronkelijke gedrag te behouden.
2. Verfijning (Refinement): De gegenereerde Rust-code wordt opnieuw naar de LLM gestuurd met een specifieke prompt om de veiligheid te verbeteren. De instructies zijn expliciet gericht op het elimineren van Raw Pointer Dereferences (RPDs) en Unsafe Type Casts (UTCs).

C. RAG-pipeline (Retrieval-Augmented Generation)

Om hallucinaties te verminderen en de kwaliteit te verhogen, wordt tijdens het genereren context opgehaald uit een externe kennisbron:

• Kennisbron: Documentatie van Rust, veiligheidsrichtlijnen en voorbeelden van veilige pointer-handhaving.
• Proces: De query (de C-code) wordt geëmbed en vergeleken met de documentatie-chunks via een similariteitszoekopdracht (bijv. Cosine Similarity). De meest relevante stukken worden toegevoegd aan de prompt van de LLM.
• Doel: De LLM krijgt toegang tot domeinspecifieke kennis, wat de kans op hallucinaties verkleint en de code meer "idiomaatisch" en veilig maakt.

D. Verificatie

De gegenereerde code wordt niet alleen door de LLM zelf beoordeeld, maar ook geverifieerd door de Rust-compiler (rustc) en een aangepast Bash-script. Er wordt gekeken naar:

• Compiler-foutcodes gerelateerd aan RPDs en UTCs.
• Het aantal unsafe blokken en lijnen (ULoCs).

3. Experimentele Opzet

• Dataset: Zeven programma's uit de GNU Coreutils (uniq, cat, pwd, truncate, head, split, tail).
• Modellen: Drie OpenAI-modellen werden getest:
  • GPT-4o en GPT-4-Turbo (grote LLM's).
  • o3-mini (een Small Language Model).
• Metrieken:
  • Aantal Raw Pointer Dereferences (RPDs).
  • Aantal Unsafe Type Casts (UTCs).
  • Aantal Unsafe Lines of Code (ULoCs).
  • Vergelijking tussen zelfgerapporteerde resultaten van de LLM en compiler-geverifieerde resultaten (om hallucinaties te meten).

4. Belangrijkste Resultaten

De experimenten leverden de volgende inzichten op:

• Verbetering van Geheugenveiligheid: De RAG-versterkte pipeline verbeterde over het algemeen de veiligheid van de gegenereerde code. Voor veel programma's (zoals uniq, head, split) slaagden GPT-4o en GPT-4-Turbo erin om alle RPDs en UTCs te elimineren.
• Prestaties per Model:
  • GPT-4-Turbo: Bereikte de beste resultaten, met vaak 0 RPDs in de finale code en een drastische reductie van unsafe blokken.
  • GPT-4o: Toonde sterke verbeteringen, maar had soms kleine regressies in complexere programma's.
  • o3-mini (SLM): Hoewel de code syntactisch correct was, vertoonde dit model de hoogste hallucinatiegraad. Het rapporteerde vaak grote veiligheidsverbeteringen die door de compiler niet werden bevestigd (soms zelfs verslechtering van de veiligheid). Het neigde er ook toe om veiligheidsinstructies (zoals #![forbid(unsafe_code)]) toe te voegen zonder de onderliggende onveilige code daadwerkelijk te verwijderen.
• Effect van RAG: De integratie van RAG verminderde de hallucinaties aanzienlijk. De kloof tussen wat de LLM beweerde te hebben bereikt en wat de compiler daadwerkelijk vond, werd kleiner. Dit bevestigt dat contextuele ophaaltechnieken de feitelijke grondslagen van de AI verbeteren.
• Vergelijking met Bestaande Methoden: De voorgestelde methode presteerde beter dan eerdere benaderingen zoals C2SaferRust en LAC2R, vooral in het elimineren van onveilige constructies en het behouden van idiomaatische Rust-code.

5. Bijdragen en Betekenis

De paper levert de volgende bijdragen aan het veld van Software Engineering en AI:

1. Nieuw Framework: Een innovatief transpilatieframework dat LLM's combineert met RAG om C/C++ naar veilige Rust te converteren, met een specifieke focus op het elimineren van geheugenveiligheidsfouten.
2. Validatie van RAG voor Code: Het bewijst dat RAG-pipelines niet alleen nuttig zijn voor tekst, maar ook cruciaal zijn om hallucinaties in complexe code-taakken te reduceren en de correctheid van transpilatie te verhogen.
3. Empirische Evaluatie: Een grondige vergelijking van verschillende modelgroottes (LLM vs. SLM) en hun vermogen om veilige code te genereren, waarbij wordt aangetoond dat grotere modellen met RAG context superieur zijn aan kleinere modellen voor deze specifieke taak.
4. Praktische Impact: De resultaten suggereren dat geautomatiseerde migratie van legacy systemen naar Rust haalbaar is, wat een grote stap voorwaarts is voor de beveiliging van kritieke infrastructuur en het verminderen van softwarekwetsbaarheden.

Conclusie:
Het onderzoek toont aan dat LLM's, wanneer ze worden versterkt met Retrieval-Augmented Generation, een krachtig hulpmiddel kunnen zijn voor het moderniseren van software. Ze kunnen niet alleen functioneel equivalente code genereren, maar ook actief bijdragen aan het verbeteren van de geheugenveiligheid, mits ze worden begeleid door relevante context en strikt geverifieerd door compilers. Dit biedt een veelbelovende richting voor de toekomst van AI-gestuurde softwareherstel en migratie.