Automated TEE Adaptation with LLMs: Identifying, Transforming, and Porting Sensitive Functions in Programs

Dit paper introduceert AUTOTEE, een door Large Language Models aangedreven methode die ontwikkelaars helpt om automatisch gevoelige functies in bestaande programma's te identificeren, te transformeren en te porteren naar Trusted Execution Environments (TEEs) voor verbeterde beveiliging.

De kern

Hier is een uitleg van het paper "Automated TEE Adaptation with LLMs" (AUTOTEE), vertaald naar begrijpelijk Nederlands met behulp van alledaagse analogieën.

Het Grote Probleem: De "Gouden Kooi" is te moeilijk te gebruiken

Stel je voor dat TEE (Trusted Execution Environment) een onbreekbare, gouden kluis is binnen je computer. Alles wat je in deze kluis doet (zoals je vingerafdruk scannen of je wachtwoorden opslaan), is veilig. Zelfs als de rest van je computer besmet is met virussen of gehackt wordt, kan niemand bij de inhoud van die kluis komen.

Het probleem is echter dat deze kluis heel lastig te gebruiken is voor gewone softwareontwikkelaars.

1. De taal is anders: Je gewone programma's spreken "Hoog-Nederlands" (Java, Python), maar de kluis spreekt alleen "Oud-Grieks" (Rust, C). Je moet je hele verhaal vertalen.
2. De regels zijn streng: Je mag in de kluis geen telefoon bellen, geen bestanden lezen of geen lange wachtrijen maken.
3. Het is gevaarlijk: Als je de verkeerde code in de kluis stopt, breekt de hele kluis of wordt hij onveilig.

Vroeger moest een menselijke expert (een "kluis-specialist") handmatig zoeken naar welke stukjes code veiligheidsgevoelig zijn, die stukjes uitschrijven en ze opnieuw in het "Oud-Grieks" typen. Dit kostte veel tijd, was duur en zat vol fouten.

De Oplossing: AUTOTEE (De Slimme Vertaler)

De auteurs van dit paper hebben AUTOTEE bedacht. Dit is een systeem dat gebruikmaakt van een LLM (een super-slimme AI, zoals een zeer intelligente robot-vertaler) om dit hele proces automatisch te doen.

Je kunt AUTOTEE zien als een slimme architect en vertaler in één. Hier is hoe het werkt, stap voor stap:

1. De Scan: "Wie heeft er een paspoort nodig?"

De AI kijkt eerst door het hele programma (de "stad") en zoekt naar de specifieke gebouwen die veiligheidsgevoelig zijn.

• Analogie: Stel je voor dat je een stad hebt en je wilt weten welke huizen waardevolle juwelen bevatten. De AI scannt alle straten en zoekt naar sleutelswoorden zoals "versleutelen", "wachtwoord" of "handtekening".
• De slimme truc: De AI zoekt niet naar hele gebouwen, maar alleen naar de kleinste kamertjes (leaf functions) die niet afhankelijk zijn van andere kamers. Dit maakt het makkelijker om ze veilig te verplaatsen.

2. De Vertaling: "Van Hoog-Nederlands naar Oud-Grieks"

Als de AI een gevoelige kamer heeft gevonden, moet deze naar de kluis verhuizen. Maar de taal is anders.

• Analogie: De AI neemt een tekst in het Nederlands en schrijft hem opnieuw in het Oud-Grieks, maar dan zo dat de betekenis exact hetzelfde blijft.
• De test: De AI is niet zomaar klaar. Het systeem test de nieuwe tekst direct.
  • Past de tekst in de kluis? (Compile-check)
  • Geeft de nieuwe tekst hetzelfde antwoord als de oude? (Functional equivalence).
  • Als het antwoord "nee" is, denkt de AI na (ReAct-strategie), past de tekst aan en test het opnieuw. Dit doet het net zolang tot het perfect werkt.

3. De Koppeling: "De Veilige Tunnel"

Nu heb je een stukje code dat veilig in de kluis draait, en de rest van je programma die buiten de kluis draait. Hoe praten ze met elkaar?

• Analogie: De AI bouwt een beveiligde tunnel met een dubbele deur.
  1. De buitenkant vraagt: "Ben jij echt de kluis?" (Dit heet attestation of identiteitsbewijs).
  2. Als de kluis ja zegt, wordt er een versleutelde tunnel geopend.
  3. De gegevens gaan door de tunnel, worden in de kluis verwerkt, en het antwoord komt veilig terug.

Wat hebben ze ontdekt? (De Resultaten)

De auteurs hebben dit systeem getest met echte programma's (Java en Python).

• Hoe goed is de AI? De AI kon in 94% van de gevallen precies vinden welke code gevoelig was.
• Hoe goed is de vertaling? Met de krachtigste AI (GPT-4o) lukte het om 91,8% van de Java-code en 84,3% van de Python-code succesvol en veilig naar de kluis te verplaatsen.
• Snelheid: Het kostte de AI gemiddeld slechts een paar seconden per stukje code om te vertalen en te testen.

Waarom is dit belangrijk?

Vroeger was het gebruik van deze super-veilige "gouden kooi" (TEE) alleen weggelegd voor dure specialisten. Met AUTOTEE kan elke ontwikkelaar nu, met een paar klikken, zijn gevoelige data in de kluis stoppen.

Kort samengevat:
AUTOTEE is als een robot-bouwvakker die automatisch de kwetsbare delen van je huis (je software) herkent, ze verplaatst naar een onbreekbare bunker (de TEE), en ze daar in een nieuwe taal vertaalt, zodat je huis nog steeds werkt, maar nu onkraakbaar veilig is.

Technische samenvatting

Hier is een gedetailleerde technische samenvatting van het artikel "Automated TEE Adaptation with LLMs: Identifying, Transforming, and Porting Sensitive Functions in Programs" in het Nederlands.

Titel: Automatische TEE-adaptatie met LLM's: Identificeren, Transformeren en Porten van Gevoelige Functies in Programma's

1. Het Probleem

Trusted Execution Environments (TEE's) bieden robuuste beveiliging door een geïsoleerd geheugengebied te creëren dat zelfs bij een gecompromitteerd besturingssysteem ontoegankelijk is voor de "normale wereld". Hoewel TEE's essentieel zijn voor het beschermen van gevoelige operaties (zoals encryptie, vingerafdrukverificatie en remote attestation), is het aanpassen van bestaande programma's om gebruik te maken van deze beveiliging uiterst moeilijk. Dit komt door twee hoofdoorzaken:

• Complexiteit van isolatie: Ontwikkelaars moeten nauwkeurig bepalen welke code gevoelig is en geïsoleerd moet worden, wat diepgaande expertise vereist.
• Beperkte uitvoeringsomgeving: TEE's draaien vaak op laag niveau (bijv. C of Rust) en hebben beperkte API's (geen bestands-I/O, timers, etc.). Het porten van hoog-niveau talen zoals Java of Python naar deze omgeving vereist handmatige, foutgevoelige transformaties en het opzetten van complexe communicatiekanalen.

Bestaande oplossingen vereisen vaak veel handmatig werk of introduceren aanzienlijke overhead door volledige runtime-omgevingen te porteren.

2. Methodologie: AUTOTEE

De auteurs stellen AUTOTEE voor, het eerste benaderingsmodel dat Large Language Models (LLM's) gebruikt om het proces van identificatie, transformatie en porting van gevoelige functies naar TEE's te automatiseren. Het systeem werkt in drie hoofdmodules:

• A. Identificatie van Gevoelige Functies (Sensitive Function Identifier):

  • Het systeem bouwt een Abstract Syntax Tree (AST) van het bronprogramma (Java of Python).
  • Het extrahert leaf-functies (functies die geen andere gebruikersgedefinieerde functies aanroepen) om de complexiteit te beperken en de afhankelijkheden te minimaliseren.
  • Een LLM-agent analyseert deze functies om gevoelige operaties te detecteren, specifiek gericht op cryptografie (encryptie, decryptie, hashing, sleutelbeheer) en serialisatie.
  • Het gebruikt een multi-round prompt-strategie om de nauwkeurigheid te verhogen en de specifieke gevoelige type en de bijbehorende code-statementen te identificeren.
  • Het genereert ook testinputs met behulp van een coverage-gestuurde strategie (lijn- en takdekking) om later functionaliteit te valideren.

• B. Code Transformatie (Code Transformer):

  • De geïdentificeerde functies worden getransformeerd naar Rust, een geheugenveilige native taal die geschikt is voor TEE's.
  • Het proces gebruikt Few-Shot Learning (voorbeelden van transformaties) voor de initiële transformatie.
  • Iteratieve verfijning met ReAct-strategie: Als de transformatie niet compileert of niet functioneel equivalent is, gebruikt het systeem de ReAct (Reasoning + Acting) methode. De LLM voert acties uit zoals:
    • Zoeken naar compilerfouten en oplossingen.
    • Code aanpassen.
    • Dependencies updaten.
    • Compileren en uitvoeren van tests.
  • Dit proces herhaalt zich totdat de code compileert en dezelfde output levert als het origineel onder dezelfde testinputs.

• C. Uitvoeringskoppeling (Execution Linker):

  • AUTOTEE integreert de getransformeerde Rust-code (die in de TEE draait) met het originele programma (dat in de normale wereld draait).
  • Het vervangt de oorspronkelijke functie-implementatie door een externe aanroep via een beveiligd port-based communicatiekanaal.
  • Dit omvat remote attestation om de authenticiteit van de TEE-code te verifiëren en een TLS-kanaal voor versleutelde communicatie tussen de twee omgevingen.

3. Belangrijkste Bijdragen

• AUTOTEE: Een geautomatiseerd framework dat programma's opnieuw engineer voor TEE-adaptatie, waardoor handmatige code-aanpassingen voor Java en Python tot een minimum worden beperkt.
• Robuuste Validatie: Een iteratief transformatie- en validatiemechanisme dat gebruikmaakt van compilerfeedback en functionele equivalentiechecks (via gegenereerde testcases) om de uitvoerbaarheid en correctheid te garanderen.
• Naadloze Integratie: Een mechanisme voor het veilig integreren van TEE-aangepaste functies in bestaande applicaties, inclusief beveiligde attestatie en communicatiekanalen.

4. Resultaten

De auteurs hebben een benchmarkdataset samengesteld van 385 gevoelige leaf-functies (uit 68 repositories: 232 Java en 153 Python) om AUTOTEE te evalueren.

• Identificatie: AUTOTEE bereikte een gemiddelde F1-score van 0,94 voor Java en 0,87 voor Python bij het detecteren van gevoelige functies (met GPT-4o als model).
• Transformatiesucces: Bij het gebruik van GPT-4o voor de transformatie naar Rust:
  • 91,8% van de Java-functies werd succesvol getransformeerd.
  • 84,3% van de Python-functies werd succesvol getransformeerd.
  • Andere modellen zoals DeepSeek presteerden ook goed (87,5% voor Java), terwijl open-source modellen zoals LLaMA3.1 aanzienlijk minder succesvol waren.
• Validatie: De getransformeerde code behield functionele equivalentie met het origineel en compileerde succesvol.
• Resourceverbruik: Hoewel TEE-exectie een overhead introduceert (voornamelijk door attestatie en communicatie), varieerde dit van 1,6x voor zware cryptografische taken tot 1255x voor zeer snelle operaties (waar de vaste overhead dominant is).

5. Betekenis en Toekomst

Dit onderzoek is significant omdat het de drempel voor het gebruik van TEE's voor ontwikkelaars verlaagt. Door LLM's te gebruiken, wordt de noodzaak voor diepgaande TEE-expertise en handmatig refactoring weggenomen.

• Toekomstig werk: De auteurs plannen om de ondersteuning uit te breiden naar complexere datastructuren en niet-standaard bibliotheken, en om geautomatiseerde integratietests toe te voegen om fouten bij het samenvoegen van de twee delen van de applicatie te voorkomen.

Kortom, AUTOTEE demonstreert dat het mogelijk is om bestaande, complexe applicaties in hoog-niveau talen veilig en automatisch te migreren naar Trusted Execution Environments met minimale menselijke interventie.