Protecting Cryptographic Libraries against Side-Channel and Code-Reuse Attacks
Dit artikel analyseert de beveiligingskwetsbaarheden van populaire cryptografische bibliotheken tegen zijkanaal- en geheugenbeschadigingsaanvallen, evalueert hun huidige verdedigingsmechanismen en stelt verbeteringen voor hun ontwikkelingsprocessen voor.
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
Stel cryptografische bibliotheken voor als de high-tech kluisjes van het internet. Het zijn de softwaretools die je wachtwoorden vergrendelen, je berichten versleutelen en je identiteit verifiëren. Zonder hen zou onze digitale wereld wijd open staan. Deze paper betoogt echter dat zelfs de beste kluisjes zwakke plekken hebben, en dat de mensen die ze bouwen (de ontwikkelaars) en de tools die ze gebruiken om ze te bouwen (de compilers) niet altijd genoeg doen om ze te beschermen.
Hier volgt een uiteenzetting van de belangrijkste punten van de paper, met behulp van eenvoudige analogieën.
1. De twee soorten inbrekers
De paper identificeert twee hoofdwijzen waarop aanvallers proberen deze digitale kluisjes te kraken:
De "Stopwatch-dief" (Side-Channel-aanvallen):
Stel je een dief voor die niet probeert het slot te openen. In plaats daarvan staat hij buiten de kluis en luistert. Hij merkt op dat wanneer de bewaker een specifieke sleutel probeert, de kluisdeur iets langer doet om dicht te klikken dan wanneer ze een verkeerde sleutel proberen. Door deze kleine verschillen te timen, kan de dief de geheime code achterhalen zonder het slot ooit aan te raken.- Het punt van de paper: Cryptografische code bevat vaak stappen die afhankelijk zijn van een geheim. Als de code verschillende hoeveelheden tijd kost om uit te voeren, afhankelijk van een wachtwoord, kan een hacker een stopwatch gebruiken om dat wachtwoord te stelen.
De "Kopieer-Plak-kaper" (Code-Reuse-aanvallen):
Stel je een bibliotheek voor waar de boeken zijn geschreven in een rommelige, onveilige taal. Een dief vindt een gat in de vloer (een geheugenfout) en laat een bom vallen die de vloerplanken breekt. Zodra de vloer gebroken is, hoeft de dief geen nieuw wapen te bouwen; hij pakt gewoon een hamer, een zaag en een ladder die al in de opslagruimte van de bibliotheek stonden. Hij "naait" deze bestaande tools samen om naar buiten te klimmen en het gebouw over te nemen.- Het punt van de paper: Veel bibliotheken zijn geschreven in talen zoals C of C++ die geheugenfouten toestaan. Hackers gebruiken deze fouten om de stroom van het programma te kapen, waarbij ze kleine, onschadelijke stukjes code die al in de bibliotheek zitten, gebruiken om een enorme aanval te lanceren.
2. De huidige staat van de kluis
De auteurs keken naar 11 populaire cryptografische bibliotheken (zoals OpenSSL, dat door miljoenen websites wordt gebruikt) om te zien hoe goed ze beschermd zijn.
- Het "Stopwatch"-probleem: De meeste ontwikkelaars kennen timing-aanvallen en proberen ze te verhelpen door code te schrijven die exact dezelfde hoeveelheid tijd kost om uit te voeren, ongeacht wat er gebeurt. De paper vond echter dat slechts 2 van de 11 bibliotheken hun eindproduct daadwerkelijk testen om ervoor te zorgen dat de "stopwatch"-truc niet werkt. Het is alsof een kok de soep proeft voordat hij hem serveert, maar vergeet te controleren of het zout daadwerkelijk is opgelost.
- Het "Kopieer-Plak"-probleem: Ontwikkelaars gebruiken standaard veiligheidstools (zoals "stack canaries", die lijken op valstrikken) om geheugenfouten te stoppen. Hoewel deze helpen, zijn ze niet perfect. De paper vond dat de meeste bibliotheken niet de sterkste beschikbare veiligheidsinstellingen gebruiken, waardoor ze kwetsbaar blijven voor geavanceerde kapen.
3. De gebrekkige blauwdruk (het compiler-probleem)
Dit is de kern van het betoog van de paper. Ontwikkelaars schrijven de code (de blauwdruk), maar een compiler is de machine die die blauwdruk vertaalt naar de daadwerkelijke werkende machinecode.
- Het conflict: Compilers zijn ontworpen om code snel en efficiënt te maken. Ze zijn als een zeer ijverige redacteur die elke "opvulling" wil wegknippen om het verhaal korter te maken.
- De vergissing: Soms is de "opvulling" die de compiler weghaalt, eigenlijk een veiligheidsmaatregel. Een ontwikkelaar schrijft bijvoorbeeld extra code om ervoor te zorgen dat een proces even lang duurt (om de Stopwatch-dief te stoppen). De compiler, die denkt dat deze extra code nutteloze verspilling is, verwijdert deze. Het resultaat? De code is weer snel, maar het veiligheidsgat is terug.
4. Nieuwe tools voor de klus (Secure Compilation)
De paper stelt dat we een nieuw soort "redacteur" of compiler nodig hebben die net zo goed beveiliging begrijpt als snelheid. Ze testten vier verschillende experimentele tools:
- De "Hoeder" (SecComp): Deze tool laat ontwikkelaars bepaalde delen van de code markeren als "niet aanraken". Het dwingt de compiler om de veiligheidsmaatregelen op hun plaats te houden. Nadeel: Het is nog niet gratis te gebruiken.
- De "Schuiver" (Multicompiler/MCR): Deze tool neemt de code en verplaatst de meubels elke keer als het programma wordt gebouwd. Het is alsof je elke dag de hamer en de zaag naar andere kamers verplaatst. Als een dief binnenbreekt, kan hij de tools die hij nodig heeft niet vinden omdat de indeling is veranderd. Nadeel: Het vertraagt het programma aanzienlijk als het wordt gebruikt om de "Stopwatch-dief" te stoppen.
- De "Architect" (SecDivCon): Deze tool bouwt de code met veiligheidsregels die vanaf het begin zijn ingebouwd, zodat het eindproduct zowel snel als veilig is. Nadeel: Het kost zeer lang om te bouwen en werkt alleen goed voor kleine, specifieke taken.
- De "Lineair-maker" (PCFL): Deze tool herschrijft rommelige code automatisch tot een rechte, voorspelbare lijn die onmogelijk te timen is. Nadeel: Het stopt geen "Kopieer-Plak-kaper"-aanvallen.
5. Het definitieve oordeel
De paper concludeert dat we momenteel vastzitten in een kloof tussen snelheid en veiligheid.
- Ontwikkelaars proberen handmatig veilige code te schrijven, maar missen vaak het doel.
- Compilers zijn te gefocust op snelheid en verwijderen per ongeluk veiligheidsfuncties.
- Huidige tools zijn te traag, te complex, of dekken niet alle soorten aanvallen.
De oplossing: De auteurs roepen op tot een drieledige inspanning:
- Compiler-makers moeten ontwikkelaars meer controle geven, zodat ze kunnen zeggen: "Verwijder deze veiligheidsfunctie niet, zelfs niet als het er traag uitziet."
- ** makers van beveiligde compilers** moeten tools bouwen die zowel timing- als kap-aanvallen tegelijkertijd afhandelen, niet slechts de een of de ander.
- Bibliotheek-ontwikkelaars moeten stoppen met vertrouwen op hoop en beginnen met het gebruik van deze nieuwe, veiligere compilatietools om ervoor te zorgen dat hun kluisjes echt vergrendeld zijn.
Kortom: We hebben de blauwdrukken voor veilige kluisjes, maar de machines die ze bouwen zijn te enthousiast om hoekjes af te hakken. We moeten de machines leren om veiligheid net zo hoog te prioriteren als snelheid.
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.