Bescherming, isolatie en virtuele machines

Een programma heeft genoeg vrijheid nodig om snel te rekenen zonder de controle over de hele computer te krijgen. In gebruikersmodus kan het gewone instructies rechtstreeks uitvoeren. Kernelmodus, ook supervisormodus genoemd, geeft het besturingssysteem toegang tot de instructies die de machine besturen.

Laat de hardware privileges afdwingen

De CPU heeft een actueel privilegeniveau. Optellen, laden, opslaan en springen worden normaal op volle snelheid uitgevoerd, binnen de geldende geheugentoegangsrechten. De kernel controleert niet elke instructie met software. Dit is beperkte directe uitvoering: rechtstreeks uitvoeren totdat een beschermde bewerking of een interrupt de kernel nodig maakt.

Een geprivilegieerde instructie veroorzaakt een trap als gebruikerscode die probeert uit te voeren. Op x86-64 zijn kernelprivileges nodig voor HLT, het beschrijven van het paginatabelbasisregister CR3 en het installeren van een interrupttabel met LIDT. Anders zou een toepassing de CPU kunnen stoppen, haar eigen geheugengrenzen kunnen vervangen of de interruptafhandeling kunnen omleiden.

Stel dat een toepassing HLT uitvoert. De CPU veroorzaakt een algemene beschermingsfout in plaats van te stoppen. Hij gaat naar de door de kernel geregistreerde afhandelaar. Linux stuurt het proces normaal SIGSEGV, waardoor dat proces eindigt terwijl andere programma's doorgaan. De toepassing kan niet zomaar een gunstig adres binnen de kernel kiezen en daar beginnen met uitvoeren.

Passeer de grens via een gecontroleerd toegangspunt

Traps, excepties en interrupts komen binnen via adressen die door de kernel zijn geregistreerd. Hardware verandert het privilegeniveau en draagt de besturing over aan de afhandelaar; de kerneltoegangscode bewaart de toestand die nodig is om terug te keren. Een speciale retourinstructie herstelt de uitvoering in gebruikersmodus op de opgeslagen programmateller. Op x86-64 kan de terugkeer SYSRET of IRETQ gebruiken.

De timer maakt deze besturing ook nuttig wanneer een programma nooit om een dienst vraagt. Voordat de kernel het programma uitvoert, programmeert hij een timer. Wanneer de interrupt arriveert, kan de scheduler een ander proces kiezen. Gebruikerscode kan interrupts niet uitschakelen of die timer opnieuw programmeren, zodat een oneindige lus een processorkern niet voor altijd kan bezetten.

Lees privilegendiagrammen correct

De nummeringsconventies verschillen: een lager x86-ringnummer betekent meer privileges, terwijl een hoger ARM-exceptieniveau meer privileges betekent. Intel-virtualisatie voegt ook VMX-root- en niet-rootuitvoering toe; die staan los van het ringnummer.

Houd identiteit en CPU-modus gescheiden

Root is een gebruikersidentiteit, UID 0, die kernelsoftware herkent. De gewone code van een roottoepassing draait nog steeds in gebruikersmodus en gaat via systeemaanroepen naar de kernel. Een apparaatstuurprogramma dat in kernelmodus draait, heeft veel meer directe macht: een geheugenfout daarin kan de kerneltoestand beschadigen zonder een controle van bestandsrechten te passeren.

De laag die een grens afdwingt, moet de laag daarbinnen beheersen. De kernel dwingt procesgrenzen af met CPU-modi en geheugentabellen. Een hypervisor beheerst op vergelijkbare wijze gastbesturingssystemen met hardwareondersteuning voor virtualisatie.

Een systeemaanroep is een gecontroleerd verzoek om een dienst van de kernel. Bestanden openen, processen aanmaken en netwerkgegevens verzenden vereisen allemaal beslissingen die een toepassing niet veilig zelf kan nemen. Toegang tot de kernel geeft de afhandelaar bevoegdheden; het geeft de aanroeper geen toestemming om alles te doen wat die heeft gevraagd.

Volg het verzoek

Een wrapperfunctie in de C-bibliotheek zoals open() plaatst het aanroepnummer en de argumenten in registers. Die gebruikt SYSCALL op x86-64, SVC op ARM64 of ECALL op RISC-V. De kernel doet vervolgens het volgende:

1. Hij komt binnen via zijn geregistreerde toegangspunt en slaat de gebruikersregisters op.
2. Hij kiest de afhandelaar uit de systeemaanroeptabel en wijst een onbekend nummer af.
3. Hij leest de identiteit en identificatiegegevens van de aanroeper uit het huidige proces.
4. Hij controleert argumenten, toegangsrechten en de betrokken objecten.
5. Hij voert de bewerking uit of retourneert een fout.
6. Hij herstelt de opgeslagen toestand en keert terug naar gebruikersmodus.

De identiteit komt uit de identificatiegegevens van het proces, niet uit een door de gebruiker opgegeven naam. Een aanroeper kan geen rechten van een andere gebruiker krijgen door diens naam aan een verzoek toe te voegen.

Behandel argumenten als niet-vertrouwd

Een pointer is slechts een getal dat de aanroeper opgeeft. De kernel moet het volledige aangevraagde bereik in gebruikersgeheugen controleren, inclusief de lengte en de toegangsrichting. Linux gebruikt gecontroleerde routines zoals copy_from_user en copy_to_user om de grens veilig over te steken.

Bij read(fd, buf, 4096) mag een buf die naar kernelgeheugen wijst geen bestemming voor bestandsgegevens worden. Linux meldt EFAULT voor die ongeldige gebruikersbuffer. Een andere fout heeft een andere oorzaak: write() via een descriptor die met O_RDONLY is geopend, mislukt met EBADF, omdat aan de descriptor nooit schrijftoegang is verleend. Een gewoon geweigerd verzoek retourneert een fout; het beëindigt het proces niet automatisch. In C retourneert de wrapperfunctie meestal −1 en stelt die errno in.

Controleer het object dat daadwerkelijk wordt gebruikt

Een TOCTTOU-raceconditie scheidt een beslissing van het object dat die moest beschermen. Een geprivilegieerd hulpprogramma controleert access("/tmp/report", W_OK) en opent daarna het pad. Een aanvaller vervangt het pad tussen die bewerkingen door een symbolische koppeling naar /etc/passwd. De naam is ongewijzigd, maar het geopende object is anders.

De oplossing is om de toegang met de bedoelde identificatiegegevens uit te voeren op het daadwerkelijk geopende object. Doe afstand van privileges vóór het openen en gebruik vlaggen zoals O_NOFOLLOW wanneer symbolische koppelingen ongewenst zijn. Argumenten één keer naar kernelgeheugen kopiëren voorkomt ook dat veranderlijke gebruikersgegevens steeds opnieuw worden vertrouwd; de gekopieerde structuur moet nog steeds worden gecontroleerd.

Bepaal wat je moet vertrouwen

Een referentiemonitor regelt de toegang. Die moet worden aangeroepen telkens wanneer toegang wordt verkregen, tegen wijzigingen zijn beschermd en klein genoeg zijn om zorgvuldig te onderzoeken. Nadat de kernel een geheugenkoppeling heeft verleend, verlopen afzonderlijke laad- en opslagbewerkingen via de toegangscontroles van de MMU; ze doen niet elk een systeemaanroep.

De vertrouwde computerbasis (TCB) bestaat uit de hardware, firmware en geprivilegieerde software waarvan de bescherming afhankelijk is voor een correcte werking. Daartoe behoren de CPU, de opstartketen, de kernel en vertrouwde aanmeldcomponenten. Door stuurprogramma's of bestandssystemen naar servers in gebruikersmodus te verplaatsen, kan het kernelgedeelte van deze basis kleiner worden, zoals bij microkernelontwerpen. Een gecompromitteerde gewone toepassing misbruikt de rechten die eraan zijn verleend; een gecompromitteerde vertrouwde component kan de controles zelf ondermijnen.

Virtueel geheugen vertaalt adressen en beschermt ook programma's. Een proces kan de fysieke paginaframes bereiken die in zijn actieve paginatabel staan, met de rechten die de kernel heeft ingesteld. De privéframes van een ander proces ontbreken; bewust gemaakte koppelingen voor gedeeld geheugen zijn een expliciete uitzondering.

Controleer elke geheugentoegang

De geheugenbeheereenheid (MMU) controleert paginatabelvermeldingen bij toegang. Belangrijke rechten en kenmerken zijn aanwezig of geldig, beschrijfbaar, toegankelijk voor gebruikers en uitvoerbaar. Op x86 onderscheidt U/S voor gebruikers toegankelijke pagina's van pagina's die alleen voor de supervisor toegankelijk zijn; NX of XD schakelt uitvoering uit. ARM noemt zijn uitvoeringsbeperking XN.

Een schending veroorzaakt een paginafout. De fout meldt een mislukte hardwarecontrole; de kernel bepaalt of die mislukking verwacht en herstelbaar is. Bekijk twee opslagbewerkingen naar alleen-lezenpagina's:

• Een proces overschrijft een codepagina die niet bij schrijven wordt gekopieerd. De kernel behandelt dit als een ongeldige schrijfbewerking en stuurt normaal SIGSEGV.
• Na fork() schrijft een proces naar gedeelde gegevens die zijn gemarkeerd om bij schrijven te worden gekopieerd. De kernel wijst een privékopie toe, maakt de koppeling beschrijfbaar en probeert de instructie opnieuw.

Beide fouten beginnen bij een beschermingsbit. De administratie van de kernel verklaart waarom de koppelingen alleen-lezen waren en bepaalt de reactie. Een paginafout is dus niet automatisch een crash of een verzoek om gegevens van schijf op te halen.

Bescherm kernelkoppelingen in beide richtingen

Traditionele indelingen koppelen kernelgeheugen aan procesadresruimten als alleen toegankelijk voor de supervisor. Dat maakt toegang tot de kernel eenvoudig en blokkeert tegelijk lezen en schrijven vanuit gebruikersmodus. De Meltdown-aanval uit 2018 liet zien dat sommige processors zulke gegevens via speculatieve uitvoering konden lekken. Isolatie van kernelpaginatabellen (KPTI) verwijdert de meeste kernelkoppelingen terwijl gebruikerscode op getroffen systemen draait.

Kernelcode moet ook worden beschermd tegen omleiding naar geheugen dat door de gebruiker wordt beheerd. x86-SMEP voorkomt uitvoering in kernelmodus vanaf gebruikerspagina's. SMAP blokkeert gegevenstoegang vanuit kernelmodus tot gebruikerspagina's, behalve tijdens bewust toegestane kopieerbewerkingen. ARM biedt verwante bescherming via PXN en PAN. Deze controles beperken de mogelijkheden voor een aanvaller om een kernelfout te gebruiken om code uit te voeren of vervalste kernelgegevens aan te bieden.

Alleen-lezentoegang beschermt de integriteit, niet de geheimhouding. Als een proces een gekoppelde pagina kan lezen, kan het de inhoud ervan te weten komen, ook wanneer schrijfbewerkingen mislukken. Vertrouwelijke gegevens moeten ontoegankelijk zijn voor dat proces: laat ze niet gekoppeld of dwing een passende grens af waarbij ze alleen voor de supervisor toegankelijk zijn.

Geef apparaten een eigen grens

Toepassingen vragen werk van een apparaat meestal aan via een stuurprogramma. Apparaatregisters zijn normaal alleen voor de kernel toegankelijk, al kan een bevoegd proces geselecteerde koppelingen krijgen, zoals bij grafische stuurprogramma's of Linux-I/O in gebruikersruimte.

Een apparaat dat directe geheugentoegang (DMA) uitvoert, leest of beschrijft RAM zonder die toegangen via de MMU van de CPU te laten verlopen. Paginarechten van de CPU alleen kunnen niet voorkomen dat een defect apparaat paginaframes van een ander proces overschrijft. Een IOMMU vertaalt en beperkt apparaatadressen met koppelingen per apparaat. Intel VT-d en AMD-Vi bieden dit mechanisme.

Voor een apparaat dat aan een VM is toegewezen, beperkt de IOMMU DMA tot het aan die VM toegewezen geheugen. Aan de CPU-kant is een vergelijkbare grens nodig: een tweede fase van paginavertaling koppelt fysieke gastadressen alleen aan paginaframes die de hypervisor toestaat. Om een werklast te beschermen moet je zowel CPU-toegang als apparaattoegang afdekken.

Een fout in de geheugenveiligheid kan een aanval mogelijk maken wanneer beschadigde gegevens de besturingsstroom van het programma veranderen. Een bufferoverloop op de stack kan bijvoorbeeld een opgeslagen retouradres overschrijven. Verdedigingsmechanismen van het besturingssysteem beperken wat een aanvaller met die fout kan doen; ze herstellen de foutieve schrijfbewerking niet.

Scheid gegevens van uitvoerbare code

De NX-bit markeert gegevenspagina's als niet-uitvoerbaar. Windows noemt dit Data Execution Prevention (DEP). Instructies in een stackbuffer injecteren is minder nuttig als ernaartoe springen een fout veroorzaakt.

W^X, schrijven xor uitvoeren, is strenger: geen enkele pagina is tegelijk beschrijfbaar en uitvoerbaar. DEP alleen verbiedt een programma niet om expliciet zo'n koppeling aan te vragen. Onder W^X schrijft een just-in-timecompiler gegenereerde code naar beschrijfbaar geheugen en wijzigt daarna de rechten voordat hij de code uitvoert.

Een aanvaller kan in plaats daarvan bestaande uitvoerbare instructies hergebruiken. Retourgeoriënteerd programmeren (ROP) rijgt korte instructiereeksen, gadgets genoemd, aaneen. Willekeurige indeling van de adresruimte (ASLR) verandert de locaties van stacks, heaps, bibliotheken en positieonafhankelijke programma's, waardoor adressen van gadgets moeilijk te voorspellen zijn.

Als de basis van een bibliotheek met gelijke kans uit $2^{28}$ posities wordt gekozen, slaagt één blinde gok met een kans van 1 op 268.435.456. Met slechts $2^8=256$ posities en een indeling die na crashes van werkprocessen behouden blijft, zijn bij het proberen van verschillende posities maximaal 256 pogingen nodig en gemiddeld 128,5. Een uitgelekt adres binnen een bekende bibliotheek onthult de basis en de offsets van gadgets in die bibliotheek. Een afzonderlijk gerandomiseerde stack kan nog steeds onbekend blijven.

Beperk de diensten die een aanvaller kan aanvragen

seccomp-filters van Linux beperken de systeemaanroepen die een proces mag doen. Een proces dat voor een browser pagina's weergeeft, kan bijvoorbeeld aanroepen worden geweigerd om programma's te starten of rechtstreeks bestanden te openen. Filters worden door kindprocessen geërfd en kunnen niet worden verwijderd; latere filters kunnen beperkingen aanscherpen. Een overgenomen weergaveproces beschikt nog steeds over de toegestane bewerkingen, dus een filter vormt een grens rond diensten en is geen bewijs dat het programma foutvrij is. pledge van OpenBSD en de App Sandbox van macOS bieden verwante beperkingen.

Controleer het opstarten en bewaar bewijsmateriaal

Beveiligd opstarten controleert handtekeningen in de opstartketen. Firmware controleert een vertrouwde opstartlader; de lader controleert de kernel; de kernel kan ondertekende modules vereisen. Een gewijzigde component zonder vertrouwde handtekening wordt geweigerd. Dit helpt blijvende wijzigingen aan opstartsoftware tegen te houden, maar een geldige handtekening bewijst niet dat de software geen kwetsbaarheden heeft.

Opstarten met integriteitsmetingen legt hashes van geladen componenten vast, meestal met een Trusted Platform Module (TPM). Deze metingen ondersteunen attestatie: een andere partij kan wat is gestart vergelijken met een verwachte toestand. Meten en weigeren te starten zijn verschillende bewerkingen.

Registratie in een auditlogboek legt aanmeldingen, mislukte authenticatie, geweigerde toegangsverzoeken, accountwijzigingen en geprivilegieerde handelingen zoals sudo vast. Logboeken ondersteunen detectie en reconstructie. Een aanvaller die een host beheerst, kan lokale registraties wissen. Beschermde registratie of registratie op afstand bewaart daarom bewijsmateriaal buiten die host.

Aanvallers kunnen een adreslek, een geheugenbeschadigingsfout en een ontsnapping uit een sandbox combineren. Updates verwijderen de onderliggende kwetsbaarheden die deze verdedigingsmechanismen laten bestaan.

Een geslaagde aanmelding koppelt de identiteit van een persoon aan procesidentificatiegegevens die de kernel bewaart. Authenticatie controleert de opgegeven identiteit; autorisatie bepaalt wat die identiteit mag doen. Een beveiligingssubject kan een persoon of een serviceaccount zijn, en processen handelen namens dat subject.

Geef identiteit mee aan draaiende programma's

Unix-achtige systemen identificeren gebruikers met numerieke UID's en groepen met GID's. /etc/passwd koppelt namen aan UID's, persoonlijke directory's en shells. De kernel vergelijkt de nummers: twee accountnamen met één UID zijn voor toegangscontroles één identiteit. UID 0 is root en omzeilt de meeste gewone toegangscontroles.

Windows gebruikt beveiligingsidentificaties (SID's) voor gebruikers en groepen. Het toegangstoken van een proces legt de gebruikers-SID, groeps-SID's en privileges vast. Op beide platforms leveren de identificatiegegevens van het draaiende programma de identiteit voor latere beslissingen.

Een typische aanmelding met een wachtwoord onder Linux verloopt als volgt:

1. Een geprivilegieerde aanmeldservice, zoals login, sshd of een grafische aanmeldbeheerder, ontvangt de identificatiegegevens.
2. PAM, Pluggable Authentication Modules, controleert die via geconfigureerde authenticatiemodules.
3. De service stelt de aanvullende groepen en GID van de gebruiker in en wijzigt daarna de UID om afstand te doen van rootrechten.
4. De service start de shell. Kindprocessen erven deze identificatiegegevens via fork() en behouden ze normaal na execve().

De volgorde is van belang. Als het proces afstand doet van rootrechten voordat de groepen zijn ingesteld, kan het de geërfde lijst met geprivilegieerde groepen mogelijk niet meer vervangen. Ook worden bij het wijzigen van de groepslidmaatschappen van een account de identificatiegegevens van al draaiende processen niet herschreven; een nieuwe aanmeldsessie krijgt de nieuwe lijst.

Begrijp een gecontroleerde privilegewijziging

Een proces heeft een werkelijke UID, die normaal aangeeft wie het heeft gestart; een effectieve UID, die voor de meeste toegangscontroles wordt gebruikt; en een opgeslagen set-user-ID, die gecontroleerde terugkeer na een tijdelijke verlaging ondersteunt. Bij gewone programma's zijn alle drie gelijk.

Het aan root toebehorende /usr/bin/passwd illustreert setuid. De rechtennotatie 4755, weergegeven als -rwsr-xr-x, maakt de effectieve UID root wanneer een gewone gebruiker het uitvoert. Als alice UID 1000 heeft, blijft haar werkelijke UID 1000 terwijl de effectieve UID 0 wordt. Het programma kan /etc/shadow bijwerken en gebruikt de werkelijke identiteit van de aanroeper om te beperken van wie het wachtwoord mag worden gewijzigd. Een uitvoerbaar setgid-bestand verandert op vergelijkbare wijze de effectieve groep.

Dat kleine vertrouwde programma bezit gevaarlijke bevoegdheden. Een fout kan rootrechten blootstellen, dus beperken systemen het aantal setuid-programma's en doen ze vroeg afstand van privileges. Voor een service die alleen een poort met een laag nummer nodig heeft, verleent CAP_NET_BIND_SERVICE een beperkter Linux-privilege dan volledige rootrechten.

Beheer zonder één identiteit te delen

sudo authenticeert de aanroepende gebruiker, controleert welke commando's die gebruiker als welke doelidentiteit mag uitvoeren en legt het gebruik vast. Het beleid staat meestal in /etc/sudoers. Afzonderlijke identiteiten zorgen voor individuele verantwoording, die bij het delen van een rootwachtwoord verloren gaat. Onder Windows start UAC de programma's van een beheerder normaal met een gefilterd token en vraagt het om toestemming voor verhoging van privileges.

Dagelijkse toepassingen moeten met gewone rechten draaien en services moeten eigen accounts hebben zoals www-data. Een overgenomen documentviewer erft dan die beperkte identificatiegegevens in plaats van de volledige bevoegdheden van een beheerder.

Een wachtwoordverificatiesysteem moet een correct wachtwoord herkennen zonder een terug te halen kopie op te slaan. Het slaat een wachtwoordhash op met de informatie die nodig is om de controle te herhalen. Bij het aanmelden berekent het de hash opnieuw uit het ingevoerde wachtwoord en vergelijkt het de resultaten; het ontsleutelt de opgeslagen hash nooit.

Bescherm de opgeslagen verificatiegegevens

Onder Linux bevat /etc/shadow beschermde wachtwoordhashes. Het breed leesbare /etc/passwd bevat accountinformatie en een x op de plaats van het wachtwoord. Een wachtwoordveld in shadow vermeldt een algoritme-identificatie, kostenparameters, een salt en de resulterende hash. $y$ staat voor yescrypt, dat standaard wordt gebruikt in Debian 11, Ubuntu 22.04, Fedora 35 en latere versies; $6$ staat voor SHA-512-crypt.

Een gestolen hashbestand maakt een offlineaanval mogelijk. De aanvaller hasht gokpogingen op afzonderlijke hardware zonder de vertragingen van de aanmeldservice. Een bruteforceaanval probeert tekenreeksen systematisch; een woordenboekaanval begint met waarschijnlijke woorden, uitgelekte wachtwoorden en varianten zoals “Wachtwoord1!”.

Voor precies acht kleine letters zijn ${26}^8=\mathrm{208.827.064.576}$ tekenreeksen mogelijk. Bij ${10}^{10}$ pogingen per seconde duurt het ongeveer 21 seconden om alle mogelijkheden te doorzoeken. Bij ${10}^4$ pogingen per seconde duurt het ongeveer $\mathrm{2,09}\times {10}^7$ seconden, ongeveer 242 dagen. Dit zijn tijden voor een volledige doorzoeking, geen garanties voor een afzonderlijk wachtwoord. Twaalf kleine letters geven ongeveer $\mathrm{9,5}\times {10}^{16}$ tekenreeksen, zelfs bij de hogere snelheid ongeveer 110 dagen.

Maak elk account kostbaar om aan te vallen

Een salt is een nieuwe willekeurige waarde die naast elke wachtwoordhash wordt opgeslagen. Die zorgt dat gelijke wachtwoorden verschillende hashes opleveren en maakt herbruikbare vooraf berekende tabellen onbruikbaar. De salt is openbaar; zijn taak is afzonderlijk werk voor verschillende accounts af te dwingen.

Neem 1.000 accounts en een lijst met ${10}^6$ gokpogingen, gecontroleerd met ${10}^4$ hashes per seconde. Zonder salts duurt het 100 seconden om de lijst één keer te berekenen en kan die voor alle accounts worden gebruikt. Unieke salts vereisen ${10}^9$ berekeningen, ongeveer ${10}^5$ seconden of 27,8 uur. Een veelvoorkomend wachtwoord kan nog steeds aan het begin van de lijst worden gevonden.

Wachtwoordhashmethoden zoals bcrypt, scrypt, yescrypt, Argon2 en PBKDF2 hebben instelbare rekenkosten. Scrypt, yescrypt en Argon2 brengen ook geheugenkosten met zich mee. Bij een praktische aanmelding is een fractie van een seconde aanvaardbaar; een grote gokaanval herhaalt die kosten miljoenen keren. Eén snelle SHA-256-berekening mist deze bewuste kostenfactor.

Richt het aanmeldbeleid in op gokaanvallen

NIST SP 800-63B-4 (2025) vereist salts van ten minste 32 bits en een wachtwoordhashkostenfactor die zo hoog is als praktisch haalbaar. De wachtwoordrichtlijn vereist ten minste 15 tekens voor authenticatie met alleen een wachtwoord, of ten minste acht wanneer het wachtwoord deel uitmaakt van MFA, en beveelt aan ten minste 64 tekens te accepteren.

De richtlijn wijst verplichte combinaties zoals één cijfer en één symbool en routinematige verplichte wachtwoordwijzigingen af. Ze vereist dat veelvoorkomende of gecompromitteerde keuzes worden geblokkeerd, online gokpogingen worden beperkt en een wijziging wordt afgedwongen wanneer compromittering duidelijk is. Snelheidslimieten voor online pogingen beschermen de actieve service; trage hashing met salts beschermt gestolen verificatiegegevens. Een langer wachtwoord dat voorspelbaar uit een veelgebruikte lijst wordt gekozen, kan nog steeds zwak zijn.

Wachtwoorden bewijzen kennis. Andere authenticatiemiddelen bewijzen bezit van een voorwerp of een lichamelijk kenmerk. Het besturingssysteem koppelt uiteindelijk de geauthenticeerde identiteit aan processen, maar de weg naar die identiteit bepaalt mede hoe gemakkelijk een aanvaller zich als de gebruiker kan voordoen.

Combineer verschillende factortypen

De drie factortypen zijn iets wat je weet, zoals een wachtwoord of pincode; iets wat je hebt, zoals een telefoon, smartcard of beveiligingssleutel; en iets wat je bent, zoals een vingerafdruk. Multifactorauthenticatie (MFA) combineert verschillende typen. Een wachtwoord plus een beveiligingsvraag herhaalt de kennisfactor.

Tijdgebonden eenmalige wachtwoorden (TOTP) gebruiken een gedeeld geheim en een tijdstap, meestal 30 seconden, om overeenkomende codes te maken op een authenticatiemiddel en een server. RFC 6238 definieert de methode. Een code verloopt snel, maar een valse aanmeldpagina kan een verse code doorgeven voordat die verloopt. Appcodes voorkomen simkaartfraude; sms-codes zijn afhankelijk van de controle over het telefoonnummer en kunnen worden omgeleid als dat wordt overgenomen.

Bewijs bezit zonder de sleutel te versturen

Een authenticatiemiddel met een publieke sleutel ondertekent een nieuwe uitdaging met een privésleutel. De server verifieert die met een opgeslagen publieke sleutel, die zelf niet opnieuw kan worden gebruikt om een aanmelding te ondertekenen. FIDO2-beveiligingssleutels en passkeys koppelen de authenticatie ook aan de identiteit van de site, zodat een antwoord voor een valse site niet kan authenticeren bij de echte site. Een gewone SSH-sleutel bewijst ook bezit, maar je mag er niet van uitgaan dat die hetzelfde mechanisme voor binding aan een website heeft.

De opslag verandert het risico. Apparaatgebonden sleutels in een hardwarebeveiligingssleutel, TPM of beveiligde enclave ondertekenen binnen de hardware zonder de privésleutel prijs te geven. Gesynchroniseerde passkeys kopiëren versleuteld sleutelmateriaal tussen apparaten via een platformaccount. Dat maakt herstel eenvoudiger, maar brengt dat account binnen de vertrouwensgrens. Een gewone SSH-privésleutel is een bestand dat wordt beschermd door toegangsrechten en eventueel een wachtwoordzin.

Interpreteer biometrische fouten

Een biometrisch systeem vergelijkt gemeten kenmerken met een opgeslagen sjabloon. Het accepteert wanneer een overeenkomstscore een drempel bereikt; het vereist niet elke keer een identieke afbeelding.

Twee geaccepteerde onbevoegden op 10.000 geven een FAR van 0,02%. Dertig afwijzingen op 1.000 pogingen van bevoegde gebruikers geven een FRR van 3%. Een hogere overeenkomstsdrempel verlaagt FAR en verhoogt FRR. Een strengere overeenkomst vermindert het aantal geslaagde pogingen om zich als iemand anders voor te doen, maar maakt herhaalde pogingen van bevoegde gebruikers gebruikelijker.

Een uitgelekt biometrisch kenmerk kan niet zoals een wachtwoord worden gewijzigd, en sensoren hebben bescherming nodig tegen foto's of gekopieerde vingerafdrukken. Een nuttig ontwerp gebruikt biometrie lokaal om een beschermde sleutel te ontgrendelen en stuurt alleen een handtekening naar de server.

Authenticeer ook processen

Voor een lokale Unix-domeinverbinding haalt Linux met SO_PEERCRED identificatiegegevens van de andere partij bij de kernel op in plaats van een naam te vertrouwen die de client stuurt. Tussen machines gebruiken services sleutels, certificaten of tokens die zijn opgeslagen met beperkte toegang voor het serviceaccount. Na het aanmelden gebruiken gewone toegangscontroles van het besturingssysteem de UID of het toegangstoken; ze vragen niet of de gebruiker een wachtwoord heeft getypt of een sleutel heeft aangeraakt.

Een toegangsbeslissing heeft drie onderdelen: een subject vraagt om een bewerking op een object uit te voeren. Het subject is meestal een proces dat namens een beveiligingssubject handelt; objecten zijn onder meer bestanden, apparaten en andere processen. Een toegangsmatrix geeft de rechten weer in cellen, met subjecten als rijen en objecten als kolommen.

Sla dezelfde rechten op twee manieren op

Stel dat alice report.txt kan lezen en beschrijven, bob het alleen kan lezen en de back-upservice zowel report.txt als payroll.db kan lezen. Bob kan ook payroll.db lezen en beschrijven. Alice en bob mogen de printer gebruiken; de back-upservice niet. De meeste cellen in de veel grotere matrix van een werkelijk systeem zijn leeg.

Een toegangscontrolelijst (ACL) slaat een kolom op bij het bijbehorende object. De lijst bij report.txt vermeldt alice, bob en backup met hun respectieve rechten. Een lijst met bevoegdheidstokens slaat een rij op bij het subject. Bob bezit tokens om het rapport te lezen, de salarisadministratie te lezen en te beschrijven en de printer te gebruiken.

Een bevoegdheidstoken vermeldt zowel een object als toegestane bewerkingen en kan niet door de houder worden vervalst of uitgebreid. Toegestaan kopiëren en delegeren zijn mogelijk. De kernel kan het echte token bewaren terwijl gebruikerscode een index bezit; een ander ontwerp beschermt een token cryptografisch.

Volg een descriptor na het openen

Unix combineert beide benaderingen. open() controleert de aanroeper aan de hand van de toegangsrechten van het bestand en retourneert daarna een bestandsdescriptor die de verleende toegang vastlegt. Latere lees- en schrijfbewerkingen controleren die geopende handle. Een kindproces kan die erven via fork(), of een proces kan die via een Unix-domeinsocket ontvangen.

Alice opent app.log om te schrijven. De eigenaar wijzigt de rechtennotatie in 444. De al geopende descriptor van alice kan nog steeds schrijven; een nieuwe poging om het bestand voor schrijven te openen krijgt met de nieuwe rechten te maken. De ACL bijwerken die toekomstige openingen regelt, trekt niet elk al uitgegeven bevoegdheidstoken in. Windows-handles volgen hetzelfde algemene patroon.

Capsicum van FreeBSD maakt dit bruikbaar voor afscherming. Na cap_enter() kan een proces geen willekeurig absoluut pad openen. Het kan werken via bestaande descriptoren, descriptoren ontvangen en openat() gebruiken onder een directorydescriptor die het bezit. Een ouderproces kan een werkproces daardoor precies de bestanden geven die het nodig heeft. Kernels gebaseerd op bevoegdheidstokens, zoals seL4 en Fuchsia, breiden het idee uit naar kernelobjecten in het algemeen.

Onderscheid de andere betekenis van capability in Linux

Afzonderlijke Linux-privileges verdelen de privileges van root in categorieën. CAP_NET_BIND_SERVICE staat het binden van poorten met lage nummers toe; CAP_DAC_OVERRIDE omzeilt gewone toegangscontroles voor bestanden. Deze privileges wijzen niet één specifiek object aan en verschillen daarom van een bevoegdheidstoken in een toegangsmatrix. Eén Linux-privilege kan een klasse van bewerkingen op veel objecten toestaan.

Unix-rechten koppelen rechten aan de eigenaar, de groep van de eigenaar en alle anderen. Om over toegang te beslissen, bepaal je eerst de bewerking en het relevante object. Bestandsinhoud lezen, een directory doorzoeken en een naam verwijderen vereisen verschillende rechten.

Ontcijfer en selecteer de bits

Lezen is 4, schrijven 2 en uitvoeren 1. Tel deze waarden voor elke klasse op: 754 betekent rwxr-xr--; 640 betekent rw-r-----. chmod 640 notes.txt stelt de rechtennotatie in, terwijl chmod g+w,o-r notes.txt geselecteerde bits wijzigt. De eigenaar of root mag de rechtennotatie wijzigen; de eigenaar wijzigen vereist rootbevoegdheid, onder Linux vertegenwoordigd door CAP_CHOWN.

De kernel kiest de eerste overeenkomende klasse: eigenaar als de effectieve UID overeenkomt, anders groep als een groep van het proces overeenkomt, anders anderen. Hij combineert geen klassen en probeert geen ruimere klasse. Alice bezit een bestand met rechtennotatie 077: de eigenaarbits zijn leeg, dus kan zij het niet lezen, ook al hebben groep en anderen volledige rechten. Als eigenaar kan zij de rechtennotatie nog steeds wijzigen.

Root omzeilt normaal lees- en schrijfcontroles. Om een gewoon bestand onder de gebruikelijke discretionaire controles van Linux uit te voeren, moet ten minste één uitvoerbit zijn ingesteld. Verplicht beleid kan verdere beperkingen opleggen.

Interpreteer directorybits en speciale bits

Leesrecht op een directory laat namen zien; uitvoerrecht staat doorzoeken en opzoeken toe; schrijfrecht samen met uitvoerrecht staat aanmaken, verwijderen en hernoemen van vermeldingen toe. Een naam verwijderen wijzigt de directory ervan, zodat een bestand met rechtennotatie 000 kan worden verwijderd door iemand met de benodigde directoryrechten.

Setuid voegt octaal 4000 toe aan de rechtennotatie van een uitvoerbaar bestand en wijzigt de effectieve gebruikersidentiteit bij uitvoering. Setgid voegt 2000 toe en wijzigt op vergelijkbare wijze de groep; op een directory zorgt het dat nieuwe bestanden de groep van de directory erven. De stickybit voegt 1000 toe. Een directory zoals /tmp, met rechtennotatie 1777, staat verwijderen of hernoemen alleen toe aan de bestandseigenaar, de directoryeigenaar of een geprivilegieerd proces, waarbij de gewone directoryrechten nog steeds vereist zijn.

Verwijder bits bij het aanmaken van bestanden

Een umask wist bits uit de rechtennotatie die een programma aanvraagt. Het is een bitbewerking, geen octale aftrekking. Bij de gebruikelijke aanvragen van 666 voor bestanden en 777 voor directory's:

Een umask kan geen uitvoerrechten toevoegen die in de bestandsaanvraag ontbraken.

Lees uitgebreidere toegangslijsten

POSIX-ACL's voegen genoemde gebruikers en groepen toe. setfacl -m u:bob:r report.txt geeft bob een leesvermelding op naam; getfacl toont die en ls -l markeert de uitgebreide ACL met +. Het ACL-masker beperkt genoemde gebruikers, genoemde groepen en de groep van de eigenaar, zodat een vermelding op naam meer rechten kan tonen dan effectief zijn.

Windows NTFS gebruikt een beveiligingsdescriptor met een eigenaar-SID en een DACL van geordende ACE's die rechten toestaan of weigeren. De beoordeling stopt wanneer een gevraagd recht wordt geweigerd of alle gevraagde rechten zijn verleend; rechten die niet zijn verleend, worden geweigerd. De voorkeursvolgorde plaatst expliciete vermeldingen vóór geërfde vermeldingen, met weigeringen vóór toestemmingen binnen elke groep. Een expliciete toestemming kan daardoor een verzoek afhandelen voordat een geërfde weigering wordt bereikt. Een afzonderlijke SACL selecteert toegangsgebeurtenissen voor registratie in het auditlogboek.

Verschillende modellen voor toegangscontrole beantwoorden verschillende beheervragen. Wie mag toegang verlenen? Kan een gecompromitteerd programma gegevens van een gebruiker delen? Hoe kan een beheerder de rechten van veel medewerkers wijzigen zonder elk bestand te bewerken? Eén besturingssysteem kan meerdere modellen op hetzelfde verzoek toepassen.

Onderscheid de keuze van de eigenaar van systeembeleid

Bij discretionaire toegangscontrole (DAC) beslist de eigenaar van een object wie het mag gebruiken. Unix-rechtennotaties en ACL's zijn bekende mechanismen. Het zwakke punt is dat een kwaadaardig programma dat als de gebruiker handelt, de rechten van die gebruiker kan uitoefenen, inclusief het elders naartoe kopiëren van leesbare gegevens.

Bij verplichte toegangscontrole (MAC) beperkt het systeembrede beleid van een beheerder de toegang onafhankelijk van de wensen van de eigenaar. De kernel past MAC toe naast DAC. Beide controles moeten toegang toestaan, dus een ruime bestandsrechtennotatie gaat niet boven een verplichte weigering.

Het Bell–LaPadula-model beschermt vertrouwelijkheid met geordende niveaus en twee regels: niet omhoog lezen en niet omlaag schrijven. Een proces op niveau Geheim kan vertrouwelijke gegevens lezen en naar een zeer geheime bestemming schrijven. Het kan geen zeer geheime gegevens lezen of vertrouwelijke gegevens schrijven. Een programma kan informatie niet van Geheim naar Vertrouwelijk verplaatsen door die simpelweg te lezen en opnieuw te schrijven. Biba keert de lees- en schrijfrichtingen om om integriteit te beschermen.

Beperk een service ook wanneer die root is

SELinux geeft bestanden een label met een type en voert processen uit in domeinen. Het beleid vermeldt welk domein welke bewerkingen op elk type mag uitvoeren; niet-vermelde toegang wordt geweigerd. Een webserver in httpd_t mag pagina's met het label httpd_sys_content_t lezen, terwijl toegang tot user_home_t wordt geblokkeerd, zelfs als gewone Unix-rechten het lezen toestaan. ls -Z toont labels.

In afdwingende modus blokkeert SELinux schendingen en legt die vast. In toelatende modus legt het schendingen vast zonder ze te blokkeren. Root in een beperkt domein moet nog steeds aan het afdwingende beleid voldoen. UID 0 en onbeperkte toegang zijn daarom verschillende beweringen.

AppArmor beperkt programma's met profielen op basis van bestandspaden en toegestane afzonderlijke Linux-privileges. Het wordt vaak gebruikt op Ubuntu en SUSE. SELinux en AppArmor werken via aanknopingspunten van Linux-beveiligingsmodules (LSM) bij beveiligingsbeslissingen. Android combineert appspecifieke UID's met SELinux; systemen van Apple gebruiken ook sandboxprofielen voor toepassingen.

Wijs functies toe in plaats van afzonderlijke rechten

Bij rolgebaseerde toegangscontrole (RBAC) worden rechten aan rollen gekoppeld en krijgen gebruikers rollen toegewezen. Als iemand van functie verandert, wijzigen de roltoewijzingen in plaats van veel afzonderlijke objectrechten.

Stel dat 50 medewerkers elk 20 rechten nodig hebben. Directe toewijzing vereist 1.000 koppelingen tussen gebruikers en rechten. Als vijf rollen elk 20 rechten hebben en elke medewerker één rol heeft, vereist het beheer 50 koppelingen tussen gebruikers en rollen en 100 koppelingen tussen rollen en rechten: 150 in totaal. De besparing komt door gedeelde functiepatronen, niet door vereiste rechten te verwijderen.

Windows-groepen die als rollen worden gebruikt en groepsgebaseerd sudo-beleid passen dit patroon toe. DAC is geschikt voor bestanden die door eigenaren worden beheerd, MAC beperkt services met centraal afgedwongen regels en RBAC ordent administratieve toewijzingen. Een service kan zijn functierechten via een rol krijgen terwijl DAC en MAC beide de daadwerkelijke bestandstoegang controleren.

Een virtuele machine (VM) geeft een volledig besturingssysteem een schijnbaar eigen computer. Dat besturingssysteem is het gastbesturingssysteem. De fysieke computer is de host en de hypervisor, of monitor voor virtuele machines (VMM), wijst echte processortijd, geheugen en apparaten toe aan de gastbesturingssystemen.

Behoud het gedrag en houd de controle

Het model van Popek en Goldberg uit 1974 onderscheidt drie eigenschappen. Equivalentie betekent dat programma's zich gedragen zoals op een echte machine, afgezien van timing en beschikbare bronnen. Bronbeheer betekent dat de hypervisor de hardware blijft besturen. Efficiëntie betekent dat de meeste instructies van het gastbesturingssysteem rechtstreeks op de processor worden uitgevoerd.

De hypervisor plant virtuele CPU's (vCPU's) op fysieke processorkernen. Een machinewisseling slaat de volledige uitvoeringstoestand van één VM op, inclusief geprivilegieerde registers en interruptinstellingen, en herstelt vervolgens die van een andere VM. Een gastbesturingssysteem ziet zijn eigen toestand, ook wanneer het een fysieke processorkern met andere gastbesturingssystemen deelt.

KVM maakt van de Linux-kernel zelf een hypervisor en wordt meestal als type 1 ingedeeld. Een volledige Linux-host blijft beschikbaar, waardoor het eenvoudige onderscheid tussen twee typen minder duidelijk is. Bepaal om de bescherming te begrijpen welke component de CPU- en geheugenvirtualisatie daadwerkelijk beheert.

Gebruik de machineabstractie

Serverconsolidatie brengt licht gebruikte systemen samen. Twaalf servers die elk gemiddeld 5% van een computer met acht processorkernen gebruiken, hebben samen 60% van één zo'n computer nodig. Dat gemiddelde suggereert dat consolidatie mogelijk is, maar voor gelijktijdige pieken en de vraag naar RAM en apparaten blijft reservecapaciteit nodig.

Een momentopname slaat de toestand van een VM op om die later te herstellen. Alleen een schijfimage kopiëren legt een draaiende CPU en het geheugen daarvan niet vast. Livemigratie verplaatst een draaiende VM naar een andere host door geheugen te kopiëren en de uitvoering na een korte pauze over te schakelen. Deze bewerkingen zijn mogelijk omdat de machinetoestand van het gastbesturingssysteem wordt weergegeven als gegevens die de hypervisor beheert.

VM's ondersteunen ook het testen van oude systemen, het scheiden van conflicterende software en het uitvoeren van verschillende besturingssystemen op compatibele hardware. Een VM met een Windows-gastbesturingssysteem kan naast een Linux-gastbesturingssysteem draaien, elk met een eigen kernel. Cloudserverinstanties gebruiken vaak deze grens.

Onderscheid virtualisatie van volledige emulatie

Een emulator kan een instructieset voor een andere processor interpreteren of vertalen, zoals ARM-code op x86. Hardwarevirtualisatie voert gastinstructies normaal rechtstreeks op een compatibele processor uit en grijpt in bij gevoelige gebeurtenissen. Dat verklaart zowel de snelheid als de noodzaak van CPU-ondersteuning.

Afzonderlijke gastkernels vormen een bruikbare grens: de overname van één gastkernel geeft niet rechtstreeks controle over de hostkernel. De grens hangt nog steeds af van correcte code in de hypervisor en het apparaatmodel. Een ontsnapping uit een virtuele machine maakt misbruik van die laag, terwijl een zijkanaal gegevens via gedeelde hardware kan lekken zonder gewone geheugentoegang te verlenen. Een VM kiezen vermindert de interfaces die aan een niet-vertrouwd gastbesturingssysteem worden blootgesteld; gedeelde hardware wordt er niet onfeilbaar door.

Een gastkernel verwacht zijn machine te besturen. De hypervisor moet die schijn ophouden zonder de echte computer over te dragen. CPU-virtualisatie laat gewone gastinstructies rechtstreeks uitvoeren en onderschept bewerkingen die een wijziging van de toestand van de virtuele machine vereisen.

Onderschep en emuleer de virtuele toestand

Bij klassiek onderscheppen en emuleren draait de gastkernel met verlaagde privileges. Een poging om een paginatabelregister te laden of een traptabel te installeren veroorzaakt een trap naar de hypervisor. De hypervisor werkt het virtuele register of de virtuele tabel van het gastbesturingssysteem bij en hervat de uitvoering. Hij laat het gastbesturingssysteem de echte besturingsstructuren van de hypervisor niet vervangen.

Een gast-systeemaanroep kan in dit ontwerp meerdere overgangen vereisen. De gasttoepassing veroorzaakt een trap naar de echte afhandelaar van de hypervisor. De hypervisor draagt de uitvoering met verlaagde privileges over aan de geregistreerde afhandelaar van de gastkernel. Wanneer de gastkernel terugkeert, veroorzaakt die geprivilegieerde terugkeer opnieuw een trap; de hypervisor voltooit de echte terugkeer naar de gasttoepassing.

De voorwaarde van Popek en Goldberg voor deze techniek is dat elke gevoelige instructie geprivilegieerd moet zijn. Gevoelig betekent dat de instructie de machineconfiguratie wijzigt of zich anders gedraagt afhankelijk van het privilegeniveau. Geprivilegieerd betekent dat de instructie buiten de modus met de meeste privileges een trap veroorzaakt. Stilzwijgende verschillen kunnen niet worden geëmuleerd als de hypervisor nooit merkt dat ze zijn opgetreden.

Begrijp het klassieke x86-probleem

De analyse van Robin en Irvine uit 2000 vond 17 gevoelige, niet-geprivilegieerde x86-instructies. Zo kan POPF met voldoende privileges de vlag herstellen die interrupts inschakelt, maar die bij verlaagde privileges stilzwijgend ongewijzigd laten. Een gastbesturingssysteem met verlaagde privileges kan denken dat het interrupts heeft uitgeschakeld, terwijl geen trap de hypervisor heeft verteld de virtuele interrupttoestand bij te werken.

Drie benaderingen lossen dit probleem op:

VMware gebruikte binaire vertaling in 1999; Xen gebruikte paravirtualisatie in 2003. Intel VT-x kwam in 2005 en AMD-V in 2006. Gewone gasttoepassingen kunnen nog steeds rechtstreeks draaien wanneer kernelcode vertaling of hypercalls nodig heeft.

Houd ringnummer en virtualisatiemodus gescheiden

Met Intel VT-x draait de hypervisor in VMX-rootmodus en een gastbesturingssysteem in niet-rootmodus. De gastkernel kan daar ring 0 gebruiken. Ring 0 in een gastbesturingssysteem betekent geen controle over de fysieke host.

Geconfigureerde gebeurtenissen veroorzaken een VM exit, waarbij de vCPU-toestand wordt opgeslagen in een besturingsstructuur zoals de VMCS. De hypervisor handelt de gebeurtenis af en hervat via een VM entry. Veel systeemaanroepen kunnen volledig binnen het gastbesturingssysteem blijven. ARM gebruikt EL2 voor de hypervisor; RISC-V biedt een hypervisoruitbreiding.

Als een gastbesturingssysteem HLT uitvoert en die gebeurtenis is geconfigureerd om naar de hypervisor over te gaan, markeert de hypervisor zijn vCPU als wachtend en plant ander werk totdat een virtuele interrupt arriveert. De fysieke processorkern hoeft niet ongebruikt te blijven. Overgangen heen en terug kosten nog steeds tijd, doorgaans honderden tot duizenden cycli, dus blijven bundeling en paravirtuele interfaces waardevol.

Een gasttoepassing gebruikt een virtueel gastadres. De kernel daarvan vertaalt dat naar een fysiek gastadres, de kijk van het gastbesturingssysteem op RAM. De hypervisor koppelt dat adres vervolgens aan een fysiek hostadres, of machineadres. Elk gastbesturingssysteem kan denken dat zijn RAM bij nul begint terwijl het andere echte paginaframes gebruikt.

Behoud de paginaoffset

Gebruik pagina's van 4 KiB. Het gastbesturingssysteem koppelt virtuele pagina 2 aan gastpaginaframe 7; de hypervisor koppelt gastpaginaframe 7 aan machinepaginaframe 42. Voor adres 0x2ABC:

1. Splits het in pagina 2 en offset 0xABC.
2. Vervang pagina 2 door gastpaginaframe 7, wat 0x7ABC oplevert.
3. Vervang gastpaginaframe 7 door machinepaginaframe 42, hexadecimaal 0x2A.
4. Behoud de offset, wat machineadres 0x2AABC oplevert, of 174.780 bytes vanaf adres nul.

Alleen het paginanummer verandert. Als je het fysieke gastadres als een echt RAM-adres behandelt, omzeil je de toewijzings- en isolatiebeslissing van de hypervisor.

Vergelijk vertaling door software en hardware

Schaduwpaginatabellen koppelen virtuele gastpagina's rechtstreeks aan machinepaginaframes. De echte MMU gebruikt deze door de hypervisor gebouwde tabellen. De hypervisor beveiligt pagina's met gastpaginatabellen tegen schrijven en onderschept wijzigingen en wisselingen van gasttabellen, zodat de schaduwtabellen consistent blijven. Frequente wijzigingen van gastadresruimten veroorzaken daardoor extra traps.

Geneste paginering, Intel EPT of AMD NPT, geeft de MMU beide fasen. De hardware doorloopt de gasttabellen en de tabellen van fysiek gastadres naar machineadres. Wijzigingen in gastpaginatabellen hoeven niet langer allemaal door software te worden onderschept. De TLB bewaart de gecombineerde uiteindelijke vertaling.

Een cachemisser kan nog steeds duur zijn. Met vier niveaus in elke fase heeft elk van de vier gasttabelvermeldingen vier verwijzingen naar geneste tabellen plus de vermelding zelf nodig: 20 verwijzingen. Voor de vertaling van het uiteindelijke fysieke gastadres van de gegevens komen er nog vier bij, wat vóór de gegevenstoegang 24 vertaalverwijzingen oplevert. Grote pagina's en caches voor het doorlopen van paginatabellen verminderen dit werk in het slechtste geval zonder cache.

Win geheugen terug met beperkte kennis van het gastbesturingssysteem

Bij geheugenoverboeking wordt aan gastbesturingssystemen samen meer geheugen toegezegd dan de host heeft. Vier VM's van 16 GiB komen samen op 64 GiB op een host met 48 GiB. Dit werkt alleen zolang hun actieve behoeften binnen de capaciteit passen; als ze allemaal druk worden, is terugwinning of uitwisseling nodig.

Een balloonstuurprogramma binnen een gastbesturingssysteem wijst op verzoek van de hypervisor pagina's toe. Het gastbesturingssysteem kiest wat het vrijgeeft, terwijl de hypervisor de machinepaginaframes achter de balloonpagina's terugneemt. Dit verkleint de informatiekloof: het gastbesturingssysteem weet welke gegevens belangrijk zijn, terwijl de hypervisor toewijzingen ziet zonder hun volledige betekenis te kennen.

Delen van pagina's, zoals Linux KSM, voegt identieke pagina's samen tot één alleen-lezenkopie en splitst die bij een schrijfbewerking. Uitwisseling door de hypervisor is een andere terugvaloptie, maar kan een slechte keuze maken omdat de kennis van het gastbesturingssysteem ontbreekt. Een apparaat dat rechtstreeks aan de VM is toegewezen, heeft ook een IOMMU nodig om zijn DMA-adressen te vertalen en te beperken.

Identieke pagina's delen tussen klanten heeft gevolgen voor de privacy: de tijd die kopiëren bij schrijven kost, kan onthullen of een ander gastbesturingssysteem dezelfde gegevens bezit. Cloudaanbieders schakelen die vorm van delen tussen klanten vaak uit, ook al bespaart die geheugen.

Een VM heeft naast CPU-tijd en RAM ook opslag, netwerken en andere apparaten nodig. De apparaatinterface beïnvloedt compatibiliteit, prestaties en de code die een niet-vertrouwd gastbesturingssysteem kan bereiken. Een snelle interface en een kleine vertrouwde interface zijn verwante ontwerpkeuzes, maar niet dezelfde eigenschap.

Kies hoe het gastbesturingssysteem een apparaat bereikt

Een hulpprogramma zoals QEMU kan een Intel e1000-netwerkkaart emuleren. Het gewone gaststuurprogramma schrijft naar bekende registers; het hulpprogramma voert het effect uit. Frequente registertoegang kan veel overgangen naar de hypervisor en softwarebewerkingen veroorzaken.

Een virtio-stuurprogramma wisselt daarentegen verzoeken uit via wachtrijen in gedeeld geheugen. Het kan meerdere bewerkingen in de wachtrij plaatsen en de achterliggende component één keer informeren. De vmxnet3 van VMware en VMBus-apparaten van Hyper-V volgen verwante ontwerpen die rekening houden met virtualisatie. Een paravirtueel apparaatstuurprogramma betekent niet dat de hele gastkernel paravirtuele CPU-bewerkingen moet gebruiken.

Bij rechtstreekse apparaattoewijzing beschikt het gastbesturingssysteem over een fysiek apparaat of een virtuele SR-IOV-functie. De IOMMU beperkt DMA tot het geheugen van de VM. Rechtstreekse toewijzing vermindert tussenkomst van software, maar het overdragen van de apparaattoestand naar een andere host kan livemigratie moeilijk maken.

Behandel virtuele schijven als beheerde toestand

Een virtuele schijf is meestal een bestand op de host, zoals qcow2, VMDK of VHDX, of een opslagvolume. Images met kopiëren bij schrijven laten veel gastbesturingssystemen een basis delen terwijl afzonderlijke wijzigingen worden vastgelegd. Momentopnamen kunnen de schijftoestand goedkoop bewaren, en een volledige momentopname van een draaiende VM heeft ook de uitvoerings- en geheugentoestand nodig. Klonen en migratie steunen op het vermogen van de hypervisor om deze representaties te beheren.

Zoek de grens die een aanvaller moet oversteken

Een gecompromitteerde gastkernel beheerst die VM al, maar om de host te bereiken is een ontsnapping uit een virtuele machine of een andere doorbroken grens nodig. De VENOM-kwetsbaarheid uit 2015 trof de geëmuleerde diskettestationcontroller van QEMU en kon gastcode laten uitvoeren in het QEMU-proces van de host. Door apparaatemulatie in een afzonderlijk proces met een sandbox te houden, worden de bevoegdheden beperkt die via zo'n fout worden blootgesteld.

Gedeelde CPU-caches, vertakkingsvoorspellers en geheugenbussen creëren ook zijkanalen. Spectre en L1TF lieten zien dat isolatie niet alleen op basis van paginakoppelingen kan worden beoordeeld. Maatregelen omvatten processor- en microcode-updates, het wissen van relevante toestand tussen gastbesturingssystemen en het vermijden dat verschillende klanten tegelijk op verwante hardwarethreads van één processorkern worden geplaatst.

Vertrouwelijke gegevensverwerking, waaronder AMD SEV-SNP en Intel TDX, beschermt gastgeheugen tegen de hypervisor met versleutelingssleutels die de hardware bewaart en ondersteunt attestatie van de gestarte omgeving. Dit breidt de vertrouwensgrens uit tegen een gecompromitteerde host of beheerder. Het verwijdert niet elk zijkanaal of elke manier waarop een host de dienstverlening kan onderbreken. VM-beveiliging blijft afhankelijk van de hypervisor, apparaatinterfaces, hardware en de configuratie daarvan.

Een Linux-container is een verzameling processen die de hostkernel gebruikt met beperkte weergaven en privileges. Een container heeft geen afzonderlijke kernel of geëmuleerde computer. Naamruimten geven processen eigen instanties van bronnen die anders globaal zouden zijn.

Koppel elke naamruimte aan zijn weergave

clone() met naamruimtevlaggen maakt een kindproces in geselecteerde nieuwe naamruimten. unshare() scheidt de naamruimtecontext en setns() sluit zich aan bij een bestaande naamruimte via een descriptor, zoals een descriptor die is geopend vanuit /proc/1234/ns/net. Opnieuw koppelen aan een PID-naamruimte beïnvloedt latere kindprocessen zonder de aanroeper te verplaatsen. Voor tijdnaamruimten bereidt unshare(CLONE_NEWTIME) ook een naamruimte voor latere kindprocessen voor; setns() kan de aanroeper naar een bestaande tijdnaamruimte verplaatsen. Tijdnaamruimten worden met unshare() aangemaakt.

Zo gebruikt unshare --pid --fork --mount-proc bash --fork om de shell binnen de nieuwe PID-naamruimte aan te maken. Die shell is daar PID 1, ook als de host-PID 48213 is. PID 1 adopteert weesprocessen; als het eindigt, beëindigt de kernel de overige processen van de naamruimte. Processen in een bovenliggende naamruimte kunnen onderliggende processen zien, terwijl processen binnen de naamruimte niet naar buiten kunnen kijken in bovenliggende PID-naamruimten.

Scheid bestanden en netwerken

Een naamruimte voor bestandssysteemkoppelingen geeft een eigen koppellijst. Een uitvoeringsomgeving stelt een bestandsboom samen en maakt die met pivot_root tot root. Een container kan /etc en /usr van een andere Linux-distributie gebruiken terwijl hij nog steeds de hostkernel aanroept. chroot alleen verandert slechts het startpunt voor het opzoeken van paden; het is geen veilige grens tegen een geprivilegieerd proces.

Een nieuwe netwerknaamruimte heeft een loopbackinterface. Een uitvoeringsomgeving kan die verbinden via een veth-paar, met één eindpunt binnen de container en een ander verbonden met een brug op de host. Door afzonderlijke stacks kunnen twee containers allebei op poort 80 luisteren zonder om de poort van één naamruimte te concurreren.

Vertaal identiteiten over een gebruikersnaamruimte heen

Een regel in /proc/<pid>/uid_map vermeldt de eerste interne ID, de eerste externe ID en de lengte van het bereik. De regel 0 100000 65536 koppelt interne ID's 0–65535 aan host-ID's 100000–165535. Interne UID 1000 wordt dus extern aan 101000 gekoppeld. ID's zonder bruikbare koppeling worden normaal weergegeven als de overloop-UID 65534.

Root binnen die naamruimte heeft privileges voor bronnen die door die naamruimte worden beheerd, geen bevoegdheid op de hele host. Een kernelmodule laden of de echte systeemklok wijzigen vereist nog steeds privileges in de oorspronkelijke gebruikersnaamruimte. Een UID-koppeling beschermt een geprivilegieerde besturingssocket van de uitvoeringsomgeving niet als die aan de container wordt gegeven.

Een eigen weergave beperkt ook het verbruik niet. Een proces met eigen PID- en koppelnaamruimten kan nog steeds CPU en RAM verbruiken. Cgroups beperken hoeveelheden, terwijl privilegebeperkingen en seccomp bewerkingen beperken.

Een controlegroep, of cgroup, groepeert processen om brongebruik te registreren en te beheersen. Naamruimten bepalen hun weergave; cgroups beheren hoeveelheden zoals CPU-tijd, geheugen en het aantal taken. Kindprocessen erven de groep van hun ouderproces en de hiërarchie voorkomt dat een onderliggende groep aan de grenzen van een bovenliggende groep ontsnapt.

Lees de bestanden van cgroup v2

Cgroup v2 gebruikt één gemeenschappelijke hiërarchie, normaal op /sys/fs/cgroup. Een bovenliggende groep schakelt controllers voor onderliggende groepen in via cgroup.subtree_control, bijvoorbeeld +cpu +memory +pids. Afzonderlijke bestanden in elke onderliggende groep bevatten grenzen en tellers.

Controllers omvatten cpu, cpuset, memory, io, pids, hugetlb en rdma. Ze beheren CPU-tijd, plaatsing op CPU's en geheugenknooppunten, gewoon geheugen, blok-I/O, het aantal taken, grote pagina's en RDMA-bronnen. Prestatiegebeurtenissen die rekening houden met cgroups ondersteunen metingen, en cgroup.freeze pauzeert de uitvoering van een groep.

Onderscheid een CPU-bovengrens van een aandeel

cpu.max bevat quotum en periode in microseconden. 50000 100000 staat per 100 ms 50 ms CPU-uitvoering toe, gelijk aan de helft van één CPU. 200000 100000 staat de hoeveelheid tijd van twee CPU's toe, eventueel verdeeld over processorkernen. max 100000 betekent geen quotumbovengrens. Zodra het quotum is verbruikt, wacht de groep op de volgende periode, ook als een CPU niets doet.

cpu.weight stelt bij concurrentie een relatief aandeel in, van 1 tot 10.000 met standaardwaarde 100. Voor op gelijke wijze geplaatste groepen die kunnen draaien op vier CPU's, verdelen de gewichten 100 en 300 de beschikbare tijd als 1:3: ongeveer één CPU en drie CPU's. Als de zwaardere groep niets meer doet, kan de andere alle vier gebruiken, tenzij een andere beperking ingrijpt. Een gewicht is geen reservering of harde bovengrens.

Beperk uitputting van geheugen en taken

memory.high oefent boven zijn drempel druk uit om geheugen terug te winnen en vertraagt taken. memory.max stelt een harde grens. De kernel probeert eerst geheugen terug te winnen, waaronder cache en beschikbare wisselruimte. Als hij niet genoeg kan terugwinnen, beëindigt de OOM-afhandeling van de cgroup een daarvoor in aanmerking komend proces binnen de getroffen groep.

Bij een memory.max van 512M is de grens 536.870.912 bytes, of 512 MiB. Een proces met een geheugenlek kan terugwinning en uiteindelijk beëindiging door de OOM-killer veroorzaken, maar het slachtoffer wordt door de kernel gekozen en is niet gegarandeerd dat proces. De groepsgrens houdt de gebeurtenis binnen de groep in plaats van een niet-gerelateerd hostproces te kiezen.

pids.max telt processen en threads. Bij een grens van 100 mislukt verdere aanmaak met EAGAIN, waardoor de groei van het aantal taken door een forkbom wordt ingeperkt. Een I/O-grens zoals 8:0 rbps=10485760 in io.max begrenst lezen van blokapparaat 8:0 tot 10 MiB/s.

Deze bestanden verbergen geen hostprocessen of bestandsnamen. Ook kunnen /proc/meminfo en hulpmiddelen die dat bestand lezen het host-RAM tonen in plaats van memory.max; het weergegeven totaal alleen bewijst niet dat een cgroup geen grens heeft. Bronmetingen moet je lezen op de laag die de grens afdwingt.

Een bruikbare containergrens combineert weergaven, bronbeperkingen en beperkte bevoegdheden. Een eigen bestandsboom alleen houdt gevaarlijke systeemaanroepen niet tegen, en een CPU-quotum houdt toegang tot een blootgesteld hostbestand niet tegen. De hostkernel dwingt elk van deze controles af.

Verminder de bevoegdheden van het proces

Een uitvoeringsomgeving combineert naamruimten, cgroups en een bestandssysteemimage met programma's en bibliotheken. Ze kan de grens versterken door:

• De werklast niet als root uit te voeren of container-ID's via een gebruikersnaamruimte te koppelen.
• Afzonderlijke Linux-privileges te laten vervallen, vooral ruime bevoegdheden zoals CAP_SYS_ADMIN en CAP_SYS_MODULE.
• Seccomp toe te passen om onnodige aanroepen te beperken.
• Een SELinux- of AppArmor-beleid toe te passen.
• Het rootbestandssysteem waar praktisch mogelijk alleen-lezen te maken.
• no_new_privs in te stellen zodat setuid-uitvoering privileges niet kan verhogen.

Elke controle dekt een andere route af. Een alleen-lezenrootbestandssysteem staat nog steeds toegestane netwerkbewerkingen toe; een seccomp-filter staat nog steeds de aanroepen op zijn lijst toe. Het ontwerp moet passen bij de bewerkingen die de toepassing daadwerkelijk nodig heeft.

Herken het risico van een gedeelde kernel

Alle gewone containers delen de hostkernel. Een bereikbare kernelfout kan daardoor de host en andere containers compromitteren. In een VM geeft misbruik van de gastkernel controle over dat gastbesturingssysteem; om de host te bereiken moet ook de grens van de hypervisor of een apparaat worden doorbroken.

Root binnen een container is bijzonder gevoelig. Zonder gebruikersnaamruimte is die voor de hostkernel UID 0, beperkt door afzonderlijke privileges, filters en verplicht beleid. Geprivilegieerde modus of toegang tot het rootbestandssysteem van de host kan die beperkingen wegnemen. Een besturingssocket van de uitvoeringsomgeving die eigendom is van root is ook gevaarlijk: de client ervan kan de uitvoeringsomgeving vragen geprivilegieerde handelingen uit te voeren. Root in de container koppelen aan een ongeprivilegieerde host-ID maakt die socket niet veilig en verwijdert geen kernelkwetsbaarheden.

Kies een grens voor de werklast

Een Linux-container heeft een Linux-kernel nodig. Platforms op Windows en macOS bieden daarom vaak een Linux-VM onder Linux-containers. VM's starten een besturingssysteem op en wijzen voor elke kernel geheugen toe; containers starten gewone processen en kunnen werklasten dichter op elkaar plaatsen.

Herken tussenliggende ontwerpen

gVisor handelt veel containersysteemaanroepen af in een kernel in gebruikersruimte, waardoor minder direct contact met de hostkernel nodig is. Kata Containers geeft elke sandbox, meestal een Kubernetes-pod, een lichtgewicht VM; containers in die sandbox delen de gastkernel ervan. Firecracker levert micro-VM's met een minimaal apparaatmodel voor platforms die functies of containerwerklasten uitvoeren, waaronder AWS Lambda.

Cloudsystemen plaatsen containers vaak binnen VM's: een VM scheidt klanten, terwijl containers de toepassingen van één klant ordenen. De gastkernels en de hostkernel blijven gescheiden, dus een ontsnapping uit een container binnen een VM bewijst op zichzelf geen ontsnapping uit de hypervisor.