State-inferer: LLM-Driven State Machine Extraction and Formal Verification for Secure Protocol Implementations
Dit artikel introduceert State-inferer, een white-box framework dat program slicing, large language models en formele model checking integreert om nauwkeurig protocol state machines uit broncode te extraheren en te verifiëren, waarbij een superieure nauwkeurigheid op transitiemateriaal wordt bereikt en vier voorheen onbekende beveiligingskwetsbaarheden in TLS-, IKEv2- en SSH-implementaties wordt blootgelegd.
Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (https://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
De beveiliging van de digitale wereld rust zwaar op de onzichtbare regels die bepalen hoe computers met elkaar communiceren. Deze regels, bekend als netwerkprotocollen, zijn ontworpen om ervoor te zorgen dat gegevens veilig van een zender naar een ontvanger reizen, waarbij identiteiten worden geverifieerd en geheimen worden bewaard. In de kern functioneren deze protocollen als een strikt script: een computer moet zich in een specifieke conditie bevinden, een specifieke boodschap ontvangen, en vervolgens naar een nieuwe conditie overgaan voordat hij kan voortgaan. Als een computer een stap overslaat of een boodschap accepteert terwijl hij zich in de verkeerde conditie bevindt, kan het hele systeem in gevaar komen, waardoor aanvallers beveiligingscontroles kunnen omzeilen of gevoelige informatie kunnen stelen. Decennialang hebben beveiligingsexperts geprobeerd te verifiëren dat de werkelijke code die op servers draait, dit script perfect volgt. De code is echter vaak rommelig, vol verborgen variabelen en complexe logica waar standaard testtools moeite mee hebben om een kaart van te maken. Wanneer het werkelijke gedrag van een programma afwijkt van het geschreven ontwerp, kunnen gevaarlijke gebreken in het volle zicht schuilgaan, wachtend om te worden geëxploiteerd.
Een team onderzoekers van de PLA Information Engineering University heeft een nieuwe methode ontwikkeld om dit probleem op te lossen, door een tool genaamd State-inferer te creëren die fungeert als een vertaler tussen complexe computercode en de logische regels die de code zou moeten volgen. In plaats van te proberen de volledige codebase in één keer te lezen of te raden hoe een programma zich gedraagt door er willekeurige berichten naar te sturen, breekt deze tool de code af in kleine, beheersbare stukjes. Het maakt gebruik van een techniek genaamd program slicing om precies te traceren hoe een specifiek stukje data verandert terwijl het door de software beweegt, waardoor de precieze logica wordt geïsoleerd die ervoor zorgt dat een computer van staat wisselt. Dit proces is vergelijkbaar met het volgen van een enkele draad door een warrige bal wol om te zien waar deze precies naartoe leidt, waarbij de rest van de bende wordt genegeerd. Door zich op deze specifieke draden te concentreren, kan het systeem de exacte sequentie van gebeurtenissen reconstrueren die een programma volgt, inclusief de verborgen interne condities die standaard tools vaak missen.
De onderzoekers voerden deze gereconstrueerde sequenties vervolgens in bij een large language model, een type kunstmatige intelligentie dat getraind is om code te begrijpen en erover te redeneren. In tegen tegenstelling tot eerdere pogingen die simpelweg de AI vroegen om grote blokken tekst te lezen, voorzag dit systeem de AI van één klein, gefocust codefragment voor elke enkele transitie in het protocol. Dit stelde de AI in staat om de volledige context van een staatswissel te zien zonder overweldigd te worden door irrelevante informatie. De AI bouwde vervolgens een volledige kaart van het gedrag van het programma, waarbij niet alleen werd genoteerd welke berichten een verandering triggerden, maar ook welke interne variabelen waar moesten zijn voor die verandering om plaats te vinden. Ten slotte gebruikten de onderzoekers een formele verificatiemotor om deze kaart te controlen tegen de officiële beveiligingsregels. Deze motor fungeert als een rigoureuze auditor die elke mogelijke route die het programma kan nemen systematisch test om te zien of het ooit de regels schendt, zoals het verzenden van gegevens voordat een beveiligde verbinding volledig is opgezet.
Toen de methode werd getest op zeven verschillende open-source implementaties van belangrijke beveiligingsprotocollen, waaronder TLS, IKEv2 en SSH, bleek de nieuwe methode opmerkelijk accuraat te zijn. Het identificeerde het gedrag van de code correct met een precisie van 95,2 procent, waarmee het de beste bestaande tools aanzienlijk versloeg, die slechts ongeveer 78,9 procent haalden. Het verschil was niet slechts een kwestie van kleine fouten; de nieuwe tool slaagde erin complexe interne logica te vangen die andere methoden volledig misten, zoals transities die worden gedreven door interne timers of resource-controles in plaats van externe berichten. Sterker nog, de onderzoekers stelden vast dat oudere methoden vaak bijna de helft van de kritieke transities misten omdat ze vertrouwden op een vereenvoudigd beeld van het programma dat deze interne details negeerde. Door het volledige plaatje te vangen, was de nieuwe tool in staat om vier voorheen onbekende kwetsbaarheden in de software te ontdekken. Deze gebreken, die nog nooit eerder waren ontdekt, waren ernstig genoeg om officiële beveiligingsidentificatoren te krijgen toegewezen en werden gerapporteerd aan de softwarebeheerders voor reparatie.
Een van de belangrijkste bevindingen was dat de gebreken niet slechts theoretische mogelijkheden waren, maar echte, exploiteerbare zwakheden. In één instantie ontdekte de tool dat een server ertoe gebracht kon worden een kritiek beveiligingsbericht te accepteren voordat deze de noodzakelijke sleuteluitwisseling had voltooid, wat effectief de authenticatie omzeilde. In een ander geval zorgde een ontbrekende controle ervoor dat een server een eindeloze stroom berichten kon verwerken, wat potentieel de middelen uitputte. Deze ontdekkingen benadrukken een kritiek gat in de huidige analyse van software: alleen kijken naar de input en output is niet genoeg om te begrijngen hoe een programma echt werkt. De onderzoekers hebben aangetoond dat het, door nauwkeurige codeanalyse te combineren met de redeneerkracht van kunstmatige intelligentie, mogelijk is om een compleet en accuraat model van de interne logica van een programma te bouwen. Deze aanpak vereist niet dat de software wordt gewijzigd of dat de onderzoekers handmatig elke regel code moeten traceren, wat het een schaalbare manier maakt om de complexe systemen te auditeren die onze digitale infrastructuur beschermen.
De studie behandelde ook de beperkingen van eerdere benaderingen die vertrouwden op het ophalen van code op basis van tekstgelijkenis. Die methoden faalden vaak omdat ze niet de verbanden konden leggen tussen verschillende functies die samenwerkten om de toestand van een programma te veranderen. Het nieuwe systeem volgt daarentegen de werkelijke flow van data en controle, waardoor wordt gewaarborgd dat de context die aan de kunstmatige intelligentie wordt verstrekt, compleet en verbonden is. Dit stelde het systeem in staat om beveiligingscontroles te genereren die specifelijk waren afgestemd op de variabelen en de logica van elke unieke implementatie, in plaats van een generiek sjabloon toe te passen dat de plank mogelijk misslaat. Het resultaat is een framework dat kan worden aangepast aan de eigenaardigheden van verschillende codestijlen en nog steeds een betrouwbaar model van het gedrag van het systeem kan produceren.
Uiteindelijk vertegenwoordigt dit werk een verschuiving in hoe we beveiliging van software benaderen. Het beweegt weg van het idee dat we ofwel elke regel code handmatig moeten inspecteren, ofwel moeten vertrouwen op black-box testen die alleen het oppervlak kan zien. In plaats daarvan biedt het een manier om in de machine te kijken, om precies te begrijpen hoe hij denkt en reageert. De onderzoekers ontdekten dat door de code te behandelen als een reeks logische stappen die gesliced, geanalyseerd en geverifieerd kunnen worden, zij fouten konden vinden die al jaren verborgen lagen. Hoewel de tool werd getest op open-source projecten, suggereert de methode een pad voor het beveiligen van de enorme hoeveelheid propriëtaire systemen die het internet draaiende houden. Het vermogen om de state machines van complexe protocollen automatisch te extraheren en te verifiëren betekent dat beveiliging grondiger en sneller dan ooit kan worden gecontroleerd, wat potentieel de soorten breuken kan voorkomen die de digitale wereld al decennia lang teisteren. De bevindingen bevestigen dat de kloof tussen wat een protocol zou moeten doen en wat het daadwerkelijk doet, is waar het gevaar schuilt, en dat het dichten van deze kloof een diepere, meer precieze blik op de code zelf vereist.
Verdrinkt u in papers in uw vakgebied?
Ontvang dagelijkse digests van de nieuwste papers die bij uw onderzoekswoorden passen — met technische samenvattingen, in uw taal.