🤖 AI

Decaf: Improving Neural Decompilation with Automatic Feedback and Search

Het artikel introduceert Decaf, een systeem dat gebruikmaakt van compilerfeedback en zoekopdrachten om de semantische correctheid van neurale decompilatie-outputs aanzienlijk te verbeteren, waardoor het slagingspercentage op de Real-O2-split van 26,0% naar 83,9% stijgt zonder afbreuk te doen aan de gelijkenis met de oorspronkelijke broncode.

Oorspronkelijke auteurs: Alexander Shypula, Osbert Bastani, Edward Schwartz

Gepubliceerd 2026-05-13

📖 5 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Alexander Shypula, Osbert Bastani, Edward Schwartz

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Het Grote Probleem: De "Verloren Vertaling"

Stel je voor dat je een boek hebt geschreven in een complexe, hoog-niveau taal (zoals Nederlands). Een machine vertaalt dit boek naar een geheime code (machinecode) om op een computer te draaien. Zodra de vertaling plaatsvindt, gooit de machine het originele boek, de hoofdstuktitels, de personages en zelfs de grammaticaregels weg.

Nu stel je je voor dat je een detective bent die probeert uit te vinden wat het originele verhaal was, maar je hebt alleen de geheime code. Dit is decompilatie.

Traditionele tools (zoals Ghidra) zijn als een zeer letterlijke vertaler. Ze kunnen de geheime code terugvertalen naar woorden, maar het resultaat is een puinhoop. De zinnen zijn onhandig, de namen zijn vervangen door "Variabele_1" en "Variabele_2", en de logica is moeilijk te volgen. Het is technisch correct, maar onleesbaar.

Aan de andere kant is moderne AI (Grote Taalmodellen) als een creatieve schrijver. Het kan het verhaal raden, coole personagenamen bedenken en vloeiende zinnen schrijven. Maar omdat het zo creatief is, hallucineert het soms. Het kan een plotwending verzinnen die nooit heeft plaatsgevonden of een cruciaal detail missen, waardoor het verhaal feitelijk onjuist is, zelfs als het prachtig leest.

De Oplossing: "Decaf" (Decompilatie met Geautomatiseerde Feedback)

De auteurs van dit paper, Alexander Shypula en zijn team, beseften dat het vertrouwen op slechts één gok van de AI niet genoeg is. Ze bouwden een systeem genaamd Decaf dat werkt als een talentshow met een strenge jury.

Zo werkt het Decaf-proces, stap voor stap:

1. De "Talentshow" (Het Genereren van Veel Kandidaten)

In plaats van de AI te vragen het verhaal één keer te schrijven en te hopen op het beste, vraagt Decaf de AI om 32 verschillende versies van het verhaal te schrijven.

Analogie: Stel je voor dat je 32 verschillende chefs vraagt om hetzelfde gerecht te bereiden. Sommigen kunnen het verbranden, anderen kunnen het te zout maken, maar één van hen zou zomaar de perfecte versie kunnen maken.
Het paper vond dat als je maar één gerecht vraagt, je een kans van 60% hebt om iets eetbaars te krijgen. Als je 32 vraagt, heb je een kans van 88% dat ten minste één daarvan perfect is.

2. De "Proeverij" (Geautomatiseerde Feedback)

Nu heb je 32 verschillende versies van de code. Hoe weet je welke de echte originele is? Je kunt ze niet zomaar lezen; ze zien er allemaal uit als code.

De Truc: Decaf neemt elke door AI gegenereerde versie en compileert deze opnieuw. Het zet de code terug om in de geheime machinecode.
De Vergelijking: Vervolgens vergelijkt het deze nieuwe geheime code met de originele geheime code waarmee je begon.
Analogie: Stel je voor dat je het originele geheime recept hebt. Je zet de 32 gerechten van de chefs terug om in ingrediënten en kijkt welke set ingrediënten exact overeenkomt met de originele lijst. Als de ingrediënten overeenkomen, is het gerecht correct.

3. De "Hoofdjury" (De Neurale Herordener)

Soms is de stap van opnieuw compileren niet genoeg, omdat de ingrediënten er misschien iets anders uitzien maar wel hetzelfde smaken. Daarom gebruikt Decaf een tweede AI, een Reranker, die fungeert als Hoofdjury.

Deze jury kijkt naar de "geheime code" van het origineel en de "geheime code" van de gok van de AI.
Het kijkt niet alleen naar de woorden; het kijkt naar de logica. Het vraagt zich af: "Doen deze twee stukken code exact hetzelfde?"
De jury kiest de winnaar en verwijdert de rest.

De Resultaten: Waarom Dit Belangrijk Is

Het paper testte dit systeem op een enorme benchmark genaamd ExeBench. Dit is wat er gebeurde:

Voor Decaf: De beste AI-modellen konden de logica slechts ongeveer 26% van de tijd correct krijgen. Ze waren ofwel te rommelig (zoals traditionele tools) of te creatief (met hallucinatiefouten).
Met Decaf: Het systeem steeg naar 83,9% nauwkeurigheid.
De "Perfecte Match": Nog beter, de door Decaf geproduceerde code was zo vergelijkbaar met het origineel dat, in 70,9% van de gevallen, als je het opnieuw compileerde, de computercode byte-voor-byte identiek was aan het origineel.

Een Voorbeeld uit de Wereld uit het Paper

Het paper toont een specifieke functie (een klein stukje code) die getallen berekent.

Traditionele Tool (Ghidra): Gaf een correct maar lelijk antwoord met namen zoals iVar1 en iVar2.
Standaard AI (LLM4Decompile): Gaf een mooi, leesbaar antwoord, maar het mistte een kritieke stap (een "break"-conditie), waardoor de logica verkeerd was.
Decaf: Genereerde 32 versies. Het vond degene die de mooie namen en de correcte logica had. Het slaagde erin de winnaar te kiezen met zijn "proeverij" en "Hoofdjury".

De "Stress Test"

De auteurs testten ook of hun systeem werkte als de "ingrediënten" veranderden. Ze probeerden een andere compiler (Clang in plaats van GCC) te gebruiken om de antwoorden te controleren.

Resultaat: Het systeem werkte nog steeds goed, hoewel het iets minder nauwkeurig werd. Dit is als een jury die gewend is om Italiaans eten te proeven, maar wordt gevraagd Frans eten te beoordelen; ze kunnen nog steeds zeggen of het gerecht goed is, maar ze zijn niet helemaal zo perfect als wanneer ze hun eigen keuken beoordelen.

Samenvatting

Decaf probeert de AI niet slimmer te maken door het meer data te geven. In plaats daarvan verandert het de strategie:

Genereer veel opties (stel je niet tevreden met de eerste gok).
Verifieer ze automatisch door ze terug te zetten naar machinecode.
Gebruik een slimme jury om degene te kiezen die zowel leesbaar als feitelijk correct is.

Deze aanpak verandert een "gokspel" in een "zoek-en-verifieer"-proces, wat de mogelijkheid om gecompileerde computercode te begrijpen die is ontdaan van zijn oorspronkelijke betekenis, drastisch verbetert.

Technische Samenvatting: DECAF - Verbetering van Neuraal Decompileren met Automatische Feedback en Zoeken

1. Probleemstelling

Decompileren is het proces van het vertalen van laag-niveau assemblercode terug naar hoog-niveau broncode. Waar traditionele decompilers (bijv. Ghidra, Hex-Rays) geavanceerde programma-analyse inzetten om variabelen en besturingsflow te herstellen, slagen ze er vaak niet in om idiomatische syntaxis, betekenisvolle identificatienamen en aangepaste datatypen te reconstrueren. Daarentegen excelleren recente neurale decompiler-modellen, met name die gebaseerd zijn op Large Language Models (LLM's), in het genereren van leesbare, idiomatische code, maar lijden ze onder "hallucinaties". Deze modellen produceren frequent semantisch incorrecte code, laten kritieke logica (zoals break-condities) weg, of genereren code die niet correct compileert of uitvoert.

De kernuitdaging die door dit artikel wordt aangepakt, is de afweging tussen idiomaticiteit (leesbaarheid en structuur) en functionele correctheid (semantische equivalentie met het originele binaire bestand). Bestaande neurale benaderingen genereren doorgaans één kandidaat-uitvoer, waardoor het potentieel voor correcte oplossingen onbenut blijft als de eerste gok van het model flawed is. Bovendien is het verifiëren van de correctheid van gedecompileerde code in het algemeen geval een onbeslisbaar probleem, wat het moeilijk maakt om automatisch de beste kandidaat te selecteren uit een set van mogelijkheden.

2. Methodologie

De auteurs stellen DECAF (DECompilation with Automated Feedback) voor, een systeem dat neurale decompilatie verbetert door meerdere kandidaat-decompilaties te genereren en automatisch de meest veelbelovende te selecteren aan de hand van compilerfeedback en een getraind neurale her-ranker.

2.1. De DECAF-pijplijn

Het systeem werkt in drie hoofdfasen:

Initieel Decompileren: Een traditionele decompiler (Ghidra) verwerkt het doelbinaire bestand om een initiële, vaak niet-idiomatische, C-achtige representatie te produceren.
Kandidaatgeneratie: Deze uitvoer wordt ingevoerd in een neurale generator-model (een LLM). In plaats van één inferentie, gebruikt het systeem temperatuur-sampling om een diverse set van $N$ kandidaat-decompilaties te genereren (bijv. $N=32$ ).
Automatische Feedback en Her-ranking:
- Compilatiefilter: Elke kandidaat wordt gecompileerd (bijv. met gcc -c). Kandidaten die niet compileren, worden verworpen.
- Her-ranking: De overgebleven kandidaten worden geëvalueerd tegen het originele binaire bestand. De auteurs stellen drie her-rankingsstrategieën voor:
  - Log-kans: Ranking gebaseerd op de genormaliseerde log-kans van het generator-model.
  - Byte-afstand: Het compileren van de kandidaat en het berekenen van een gewijzigde Levenshtein-afstand tussen de binaire bytes van de kandidaat en die van het originele binaire bestand. Deze afstand houdt rekening met verplaatsingsartefacten door specifieke offsets als wildcards te behandelen.
  - Neurale Her-ranker: Een dedicated LLM (Decaf-ReRanker) getraind om de waarschijnlijkheid te voorspellen dat twee assemblersequenties (de originele en de hergecompileerde kandidaat) functioneel equivalent zijn.

2.2. Data en Training

Generator-model: De auteurs hebben LLM4Decompile-Ref-22b-v2 (22B parameters) fijn afgestemd op het EXEBENCH-dataset. Ze introduceerden type-bewuste supervisie, waarbij het model werd getraind om noodzakelijke #include-statements, voorwaartse declaraties en type-definities te genereren om te zorgen dat de uitvoer compileerbaar is. Ze trainden modellen ook op gestripte binaire bestanden om real-world reverse engineering-scenario's te simuleren.
Her-ranker-model: Een model van 32 miljard parameters (QWEN3-32B) werd getraind om te onderscheiden tussen functioneel equivalent en niet-equivalent assemblerparen. De trainingsdata werd geconstrueerd door meerdere kandidaten te genereren, deze uit te voeren tegen testcases, en succesvolle uitvoeringen (positief) te koppelen aan fouten of mismatches (negatief).
Herstel van Kwetsbaarheden: Voor specifieke experimenten gebruikten de auteurs de Juliet Test Suite om het vermogen van het systeem te evalueren om code met bekende kwetsbaarheden (CWE-classes) te herstellen uit gestripte binaire bestanden.

3. Belangrijkste Bijdragen

DECAF-systeem: Een nieuw raamwerk dat neurale generatie combineert met compilerfeedback en zoeken (het sampling van meerdere kandidaten) om de afweging tussen leesbaarheid en correctheid op te lossen.
Decaf-Gen-22b: Een nieuw LLM-generator-model dat bestaande state-of-the-art neurale decompilers (inclusief LLM4Decompile en Idioms-Gemma-7b) overtreft op functionele nauwkeurigheid en byte-voor-byte matching, vooral wanneer getraind met type-bewuste supervisie en gestripte binaire invoer.
Decaf-ReRanker-32b: Een gespecialiseerd her-ranker-model dat functioneel correcte decompilaties effectief identificeert uit een pool van kandidaten, en in veel scenario's aanzienlijk beter presteert dan eenvoudige log-kans- of byte-afstand-heuristieken.
Methodologisch Inzicht: De demonstratie dat het sampling van meerdere kandidaten (bijv. 32) de kans dramatisch vergroot om een functioneel correcte oplossing te vinden (het verhogen van het bovengrens van ~60% naar ~88% in sommige splits), mits een effectief her-rankingsmechanisme aanwezig is.
Generaliseerbaarheid: Bewijs dat de her-rankingsmethodologie zwakkere modellen kan versterken (bijv. het toepassen van de DECAF her-ranker op LLM4Decompile-uitvoer levert aanzienlijke winsten op).

4. Experimentele Resultaten

De auteurs evalueerden hun aanpak op het EXEBENCH-dataset over verschillende splits (Real/Synth, Stripped/Unstripped, -O0/-O2).

Functionele Correctheid: Op de Stripped REAL -O2 split bereikte DECAF een 83,9% rate voor functionele correctheid met her-ranking, vergeleken met 26,0% voor het beste eerdere neurale model (Idioms-Gemma-7b) en 59,1% voor de generator alleen (enkele sample).
Byte-voor-byte Match: DECAF bereikte een 70,9% exacte byte-voor-byte match op dezelfde split, wat aanzienlijk beter is dan de 19,1% van Idioms-Gemma-7b.
Vergelijkbaarheid met Bron: In tegenstelling tot de intuïtie dat optimalisatie voor correctheid de leesbaarheid zou kunnen verminderen, vonden de auteurs dat her-ranking voor functionele correctheid over het algemeen de vergelijkbaarheid (lagere Edit Distance) met de originele broncode verbeterde.
Herstel van Kwetsbaarheden: Op de Juliet test suite bereikte DECAF een F1-score van 29,8% voor herstel van kwetsbaarheden, wat aanzienlijk beter is dan Ghidra (1,7%) en hoge precisie aantoont (95,5%).
Robuustheid: Wanneer getest met een andere compiler (Clang) voor feedback dan die welke werd gebruikt voor generatie (GCC), daalde de prestatie van de neurale her-ranker op niet-gestripte splits vanwege een verschuiving in verdeling, wat een afhankelijkheid van diversiteit in trainingsdata benadrukt.

5. Betekenis en Claims

Het artikel stelt dat de beperkingen van huidige neurale decompilers niet uitsluitend te wijten zijn aan een gebrek aan data of modelgrootte, maar eerder aan het gebrek aan verificatie en zoeken. Door decompilatie te behandelen als een zoekprobleem waarbij meerdere kandidaten worden gegenereerd en gefilterd via compilerfeedback, kan het systeem hoogwaardige broncode herstellen die zowel leesbaar als semantisch correct is.

De auteurs claimen dat DECAF een aanzienlijke vooruitgang vertegenwoordigt in de state-of-the-art voor neurale decompilatie, en voorbijgaat aan het paradigma van de "beste enkele gok". Ze benadrukken dat hun aanpak algemeen is en kan worden toegepast om elk neurale decompiler te versterken dat in staat is diverse kandidaten te produceren. Het werk benadrukt ook het praktische nut van deze methoden in beveiligingstaken, zoals het herstellen van kwetsbaarheden uit gestripte binaire bestanden, waar traditionele tools vaak falen in het leveren van actievere, hoog-niveau code.

De auteurs erkennen beperkingen, waaronder de afhankelijkheid van toegang tot de referentiecompilerconfiguratie voor byte-voor-byte matching en de uitdagingen om te generaliseren naar verschillende compilerarchitecturen (bijv. Clang versus GCC) zonder specifieke training. Ze concluderen dat toekomstig werk zich moet richten op het trainen van her-rankers op meer diverse compilerconfiguraties en het verkennen van reinforcement learning voor iteratieve verfijning.