Hoe een passkey werkt en waarom je hem niet kunt phishen
Een passkey vervangt je wachtwoord door iets wat je niet kunt overtypen. Je kijkt in je camera of legt je vinger op de sensor, en je bent binnen. Wat er onder de motorkap gebeurt, is interessanter dan dat gemak: een passkey werkt alleen op het domein waarvoor hij is gemaakt, en dat controleert niet de gebruiker maar de browser. Daarom kun je hem niet phishen, ook niet als je op een perfect nagemaakte inlogpagina belandt.
In dit artikel volg je een inlog met een passkey byte voor byte. Ik heb de drie spelers uit de standaard (apparaat, browser en server) in een klein Python-script nagebouwd volgens de WebAuthn-specificatie van het W3C, sinds 25 augustus 2026 een Recommendation. Daarmee zie je wat er ondertekend wordt, en wat er gebeurt als een phishingsite om dezelfde passkey vraagt.
Een sleutelpaar per site
Bij een wachtwoord kennen jij en de server allebei hetzelfde geheim. Ook als de server het netjes hasht met een salt, typ je het geheim bij elke inlog opnieuw in, en dus ook op een nepsite. Bij TOTP-codes is het niet anders: een code die je overtypt, kan een aanvaller doorsturen.
Een passkey draait dat om. Bij het registreren maakt je apparaat (telefoon, laptop, wachtwoordbeheerder of beveiligingssleutel) een nieuw sleutelpaar. De privésleutel blijft bij jou, de server krijgt alleen de publieke sleutel. In mijn script is dat een P-256-sleutel, het algoritme ES256 dat de specificatie in haar voorbeelden gebruikt. De publieke sleutel is 65 bytes: een byte 04 gevolgd door de x- en y-coördinaat van een punt op de curve. Lekt de database van de server, dan ligt er niets waarmee een aanvaller kan inloggen.
Elke site krijgt een eigen sleutelpaar. De specificatie eist dat sleutels en credential-ID's van verschillende credentials niet aan elkaar te koppelen zijn, zodat twee sites niet kunnen zien dat het om dezelfde gebruiker gaat.
De RP ID: aan welk domein de passkey vastzit
In WebAuthn heet de site de Relying Party, en die heeft een RP ID: een domeinnaam, zonder https:// en zonder poort. Standaard is dat het domein van de pagina waarop je inlogt. De site mag een korter domein kiezen, maar alleen als dat een "registrable domain suffix" is van het eigen domein. Het voorbeeld uit de specificatie: een pagina op https://login.example.com:1337 mag login.example.com of example.com als RP ID gebruiken, maar niet m.login.example.com en ook niet com.
De specificatie is er duidelijk over: een credential kan alleen worden gebruikt bij dezelfde entiteit, aangeduid met de RP ID, waarbij hij is geregistreerd. Een passkey voor wallieweb.nl werkt dus op login.wallieweb.nl, maar nooit op wallieweb-login.nl of wallieweb.nl.evil.com. Er is één uitzondering: met related origins kan een site in https://<rp-id>/.well-known/webauthn andere domeinen opgeven die erbij horen. Dat bestand staat op het echte domein, dus een aanvaller kan het niet invullen.
Wat de browser opschrijft: clientDataJSON
Bij het inloggen stuurt de server een challenge: willekeurige bytes die maar één keer bruikbaar zijn. Volgens de specificatie moeten die minstens 16 bytes zijn; mijn script gebruikt er 32. De browser verpakt de challenge in een klein JSON-object. Dit is de echte uitvoer uit mijn script:
{"type":"webauthn.get","challenge":"X5vF3qetLFY3ik-hhUoZr55ys0XU3PZHRSXcFocecMQ","origin":"https://wallieweb.nl","crossOrigin":false}
Het belangrijke veld is origin. Dat vult de browser zelf in, op basis van de pagina die je echt bezoekt. De pagina kan het niet bepalen. Een phishingsite kan haar uiterlijk perfect namaken, maar in dit veld komt toch haar eigen adres te staan.
Wat het apparaat ondertekent: authenticatorData
Het apparaat maakt daarna een tweede blok, de authenticator data. Bij een inlog is dat in de eenvoudigste vorm precies 37 bytes:
2be14fb01ab88ea298024f917c0ead30d4eee10d7a55735fc1407c3700e5e87a 05 00000001
De eerste 32 bytes zijn de SHA-256-hash van de RP ID. Dat kun je narekenen: printf %s wallieweb.nl | sha256sum geeft exact 2be14fb0…e5e87a. Dan volgt één byte met vlaggen. Bit 0 is User Present (er heeft iemand op iets gedrukt of iets aangeraakt), bit 2 is User Verified (met gezicht, vinger of pincode bevestigd). 05 betekent dat beide aan staan. Bit 3 en 4 zeggen of de passkey gesynchroniseerd mag worden en of dat ook is gebeurd. De laatste 4 bytes zijn een teller.
Het apparaat ondertekent de authenticator data, met daar direct achter de SHA-256-hash van clientDataJSON. In mijn script was die handtekening 71 bytes. Omdat de hash van de clientDataJSON in de handtekening zit, liggen origin en challenge vast: verander je één teken, dan klopt de handtekening niet meer.
Wat de server controleert
Paragraaf 7.2 van de specificatie somt de stappen van de server op. De belangrijkste, in volgorde:
typeiswebauthn.get.challengeis de challenge die de server zojuist zelf heeft verstuurd.originis een origin die de server verwacht.- De eerste 32 bytes van de authenticator data zijn de hash van de eigen RP ID.
- De UP-vlag staat aan, en de UV-vlag als de server om verificatie heeft gevraagd.
- De handtekening klopt met de opgeslagen publieke sleutel.
Dan is er nog de teller. Is die niet hoger dan de vorige keer, dan is dat volgens de specificatie "een signaal, maar geen bewijs" dat de sleutel gekopieerd is. Wat de server daarmee doet, laat de standaard aan de site over. Een apparaat zonder teller houdt hem constant op nul, en dan slaat de server deze controle over.
Op deze machine kostte het controleren van één handtekening 0,33 milliseconde, ondertekenen 0,20 milliseconde. Daar wacht je dus niet op; de tijd zit in het ontgrendelen met je vinger.
Waarom phishing niets oplevert
Stel dat een aanvaller wallieweb-login.nl opzet en daar om de passkey van wallieweb.nl vraagt. In mijn script, dat de regels vereenvoudigd nabootst, weigert de browser dat meteen:
browser: SecurityError: RP ID wallieweb.nl hoort niet bij wallieweb-login.nl
Vraagt de site om een passkey voor haar eigen domein, dan heeft het apparaat er gewoon geen:
browser: geen passkey voor wallieweb-login.nl op dit apparaat
Ook een buitgemaakt antwoord helpt niet. De server stuurt bij elke inlog een nieuwe challenge, en een oud antwoord bevat de oude. Vervangt de aanvaller de challenge in de JSON, dan breekt hij de handtekening:
server (oud antwoord, nieuwe challenge): challenge klopt niet
server (challenge in clientDataJSON vervangen): handtekening ongeldig
server (echte nieuwe login): OK, ingelogd (teller 2)
Het verschil met een wachtwoord of code: de gebruiker hoeft de nepsite niet te herkennen. De browser kijkt naar het echte domein, en daar valt niets aan te veranderen met een mooi logo of een overtuigende mail.
Wil je passkeys in een Microsoft 365-omgeving aanzetten, dan staan de stappen in Passkeys inrichten in Microsoft Entra ID.
Zelf proberen
De hash van een RP ID reken je in elke terminal uit:
printf %s wallieweb.nl | sha256sum
2be14fb01ab88ea298024f917c0ead30d4eee10d7a55735fc1407c3700e5e87a -
Mijn simulatie gebruikt Python met het pakket cryptography (pip install cryptography). De kern is het ondertekenen van authenticator data plus de hash van de clientDataJSON:
auth_data = sha256(rp_id.encode()) + bytes([0x05]) + struct.pack(">I", teller)
sig = priv.sign(auth_data + sha256(client_data_json), ec.ECDSA(hashes.SHA256()))
pub.verify(sig, auth_data + sha256(client_data_json), ec.ECDSA(hashes.SHA256()))
authenticatorData (37 bytes): 2be14fb0...e5e87a0500000001
rpIdHash 2be14fb01ab88ea2... flags 0x5 teller 1
handtekening: 71 bytes
server: OK, ingelogd (teller 1)
Wijzig je in het script de origin of de RP ID, dan zie je dezelfde foutmeldingen als hierboven terug. Sleutel en handtekening verschillen per run, de rpIdHash niet.
Tot slot
Wat me het meest verraste, is hoe klein het stuk is dat de beveiliging draagt. Het zijn 32 bytes hash van een domeinnaam en één veld in een JSON-object dat de browser zelf invult. De cryptografie is gewoon ECDSA, dezelfde soort handtekening die al jaren in certificaten zit. Het slimme zit in de verdeling van het werk: de gebruiker hoeft niets te controleren, omdat de browser de enige partij is die zeker weet op welke site je echt bent.