Passkeys och WebAuthn 2026: En praktisk implementeringsguide för webbutvecklare
Passkeys lovar inloggning utan lösenord utan att lagra lösenordshemligheter, men att implementera WebAuthn korrekt kräver mer än att anropa en webbläsar-API. Lär dig hur registrering, autentisering, serververifiering, upptäckbara autentiseringsuppgifter och återställning av konto passar ihop i en säker webbapplikation.
Passkeys och WebAuthn 2026: En praktisk implementationsguide för webbutvecklare
Lösenord har varit standardautentiseringsmekanism för webbapplikationer i decennier. De är också en bestående källa till säkerhetsproblem.
Användare återanvänder dem. Angripare stjäl dem genom phishing. Servrar måste skydda lösenordshashar, hantera återställningar och försvara sig mot credential-stuffing-attacker.
Passkeys erbjuder ett fundamentalt annorlunda tillvägagångssätt.
Istället för att be användare komma ihåg en delad hemlighet använder passkeys publikkryptering och en autenticator som kontrolleras av användaren. Webbläsaren tillhandahåller ett standardgränssnitt genom WebAuthn, medan servern verifierar kryptografiska bevis på att rätt autentiseringsuppgift användes.
Tekniken är inte längre experimentell. WebAuthn är allmänt tillgängligt i moderna webbläsare, och dess JSON-bekvämlighetsmetoder har avsevärt förenklat integrationen.
Men att bygga en säker passkey-inloggning kräver fortfarande noggrann backend-design.
Denna guide förklarar arkitekturen, demonstrerar webbläsarbaserade flöden och identifierar de serversida kontroller som utvecklare inte får överse.
1. Vad är en passkey egentligen?
En passkey är en identifierbar FIDO-autentiseringsuppgift som används för att autentisera en användare genom publikkryptering.
Vid registrering skapar en autenticator ett kryptografiskt nyckelpar.
Den privata nyckeln förblir skyddad av autenticatorn eller dess ekosystem för hantering av autentiseringsuppgifter. Webbplatsen får den motsvarande publika nyckeln och kopplar den till användarens konto.
Vid autentisering utfärdar servern en ny utmaning. Autenticatorn signerar data kopplade till den utmaningen, och servern verifierar signaturen med den lagrade publika nyckeln.
Det skickas inget återanvändbart lösenord till webbplatsen.
En autenticator kan vara en smartphone, en dator med Windows Hello, en hårdvarusäkerhetsnyckel eller en autentiseringsuppgiftshanterare som stöder synkroniserade passkeys.
Inte alla passkeys synkroniseras över enheter. Vissa autentiseringsuppgifter förblir enhetsbundna, medan andra kan säkerhetskopieras och göras tillgängliga genom en autentiseringsuppgiftsleverantör.
FIDO-specifikationerna är utformade för att motstå phishing genom att binda autentiseringsuppgifter till den förlitande partens domän. Biometriska data, när de används, hanteras lokalt av enheten snarare än att skickas till webbplatsen.
2. WebAuthn är webb-API:et bakom passkeys
WebAuthn är det webbplattforms-API som gör det möjligt för webbplatser att skapa och använda publika nyckelautentiseringsuppgifter.
Två webbläsarmetoder utgör grunden:
navigator.credentials.create()
navigator.credentials.get()
Den första skapar en autentiseringsuppgift. Den andra begär autentisering med en befintlig autentiseringsuppgift.
Båda metoderna fungerar med publicKey-alternativet och kräver en säker kontext, normalt HTTPS.
Viktigt är att webbläsaren inte avgör om användaren är autentiserad. Den returnerar data som backend måste verifiera.
En lyckad webbläsarprompt är inte bevis på att en inloggning ska accepteras.
Servern ansvarar fortfarande för att verifiera utmaningen, ursprunget, förlitande-parts-identifieraren och de kryptografiska bevisen.
3. Förstå den fullständiga arkitekturen
En typisk implementation innehåller fyra komponenter:
- Webbapplikationens frontend, som anropar WebAuthn.
- Applikationens backend, som genererar utmaningar och verifierar svar.
- Autenticatorn eller passkey-leverantören, som skyddar den privata nyckeln.
- Databasen, som lagrar metadata för autentiseringsuppgifter och publika nycklar.
Registreringsflödet är: webbapplikationen begär registreringsalternativ; backenden genererar en utmaning och användardata; webbläsaren och autenticatorn skapar en autentiseringsuppgift och nyckelpar; och backenden verifierar resultatet och lagrar den publika nyckeln.
Servern måste aldro lita på registreringsdata enbart för att de returnerades av webbläsaren.
En ondskapsfull klient kan skicka godtyckliga HTTP-förfrågningar utan att alls använda den förväntade frontend.
Det är därför verifieringen hör hemma på servern.
4. Generera registreringsalternativ på servern
Innan WebAuthn anropas genererar backenden en registreringsutmaning och alternativ.
Ett representativt alternativobjekt ser ut så här:
{
"rp": {
"name": "Example Application",
"id": "example.com"
},
"user": {
"id": "dXNlci0xMjM",
"name": "alex@example.com",
"displayName": "Alex"
},
"challenge": "SERVER_GENERATED_BASE64URL_CHALLENGE",
"pubKeyCredParams": [
{
"type": "public-key",
"alg": -7
}
],
"authenticatorSelection": {
"residentKey": "required",
"userVerification": "required"
},
"attestation": "none",
"timeout": 300000
}
Detta är illustrativ JSON, inte ett komplett produktionssvar.
Flera fält är viktiga.
rp.id identifierar den förlitande parten. Till exempel kan example.com användas för lämpliga underdomäner av den domänen, med beaktande av WebAuthns RP ID-valideringsregler.
user.id bör vara en stabil, opak kontoidentifierare kodad som base64url för JSON-transport. Den bör inte exponera onödig personlig information.
challenge måste genereras med en kryptografiskt säker slumpmässig källa på servern.
residentKey: "required" begär en identifierbar autentiseringsuppgift, vilket är nödvändigt för passkey-upplevelsen.
userVerification: "required" begär lokal användarverifiering, såsom en enhets-PIN eller biometrisk autentisering. Backend måste senare kontrollera att verifiering faktiskt skett.
Googles serversida registreringsguide beskriver dessa fält och rekommenderar att man använder ett underhållet WebAuthn-bibliotek för att generera och validera registreringsdata.
5. Skapa passkey i JavaScript
Moderna webbläsare tillhandahåller en användbar metod:
PublicKeyCredential.parseCreationOptionsFromJSON()
Den konverterar en JSON-representation som innehåller base64url-kodade binära fält till den struktur som WebAuthn förväntar sig.
Detta undviker att skriva anpassad base64url-till-ArrayBuffer-konverteringslogik för varje fält.
Här är en förenklad webbläsarsida registreringsfunktion:
async function registerPasskey() {
const optionsResponse = await fetch(
'/api/passkeys/register/options',
{
method: 'POST',
credentials: 'same-origin',
headers: {
'Content-Type': 'application/json',
'X-CSRF-Token': csrfToken
}
}
);
if (!optionsResponse.ok) {
throw new Error('Unable to start registration');
}
const optionsJson = await optionsResponse.json();
const publicKey =
PublicKeyCredential.parseCreationOptionsFromJSON(
optionsJson
);
const credential = await navigator.credentials.create({
publicKey
});
if (!credential) {
throw new Error('No credential was created');
}
const verifyResponse = await fetch(
'/api/passkeys/register/verify',
{
method: 'POST',
credentials: 'same-origin',
headers: {
'Content-Type': 'application/json',
'X-CSRF-Token': csrfToken
},
body: JSON.stringify(credential.toJSON())
}
);
if (!verifyResponse.ok) {
throw new Error('Registration verification failed');
}
return await verifyResponse.json();
}
Variabeln csrfToken representerar en applikationslevererad anti-CSRF-token. Servern måste validera den. Exemplet antar också att sidan redan är associerad med en säkert autentiserad användare.
credential.toJSON() ger en JSON-vänlig representation av den returnerade autentiseringsuppgiften, vilket undviker ett ytterligare lager av manuell binär serialisering.
Dessa bekvämligheter finns i nuvarande webbläsare, även om applikationer som stödjer äldre webbläsarversioner bör tillhandahålla kompatibilitetshantering.
Koden ovan är bara webbläsarsidan. Det är inte en komplett autentiseringsimplementation.
6. Vad servern måste verifiera vid registrering
När webbläsaren returnerar den nya autentiseringsuppgiften måste backend validera den innan något lagras.
Minst måste verifieringsprocessen fastställa att:
- Den returnerade utmaningen matchar den genererade för detta registreringsförsök.
- Utmaningen är ny och har inte redan förbrukats.
- Det rapporterade ursprunget matchar ett explicit betrott applikationsursprung.
- Autenticatordata motsvarar det förväntade RP ID.
- De krävda användarnärvaro- och användarverifieringsvillkoren är uppfyllda.
- Autentiseringsuppgiftens publika nyckel och identifierare kan extraheras och valideras.
- Registreringen är kopplad till rätt autentiserat konto.
Beroende på applikationens policy kan ytterligare kontroller omfatta stöd för algoritmer, autentiseringsuppgiftsunicitet och attestationskrav.
En lyckad registrering lagrar typiskt:
| Fält | Syfte |
|---|---|
credential_id |
Identifierar autentiseringsuppgiften |
user_id |
Kopplar den till ett konto |
public_key |
Verifierar framtida signaturer |
sign_count |
Spårar autenticatorkräkningsdata |
transports |
Valfria autenticatortransporthints |
created_at |
Registreringstidpunkt |
last_used_at |
Kontohantering och revision |
backup_eligible / backup_state |
Valfria säkerhetskopieringsrelaterade metadata |
Den exakta databasrepresentationen beror på verifieringsbiblioteket och applikationen.
Implementera inte CBOR-parsning, attestationsverifiering eller kryptografisk signaturvalidering från grunden om du inte har en övertygande anledning och expertis att underhålla det.
W3C-specifikationen definierar detaljerade registrerings- och autentiseringsverifieringsprocedurer.
7. Autentisera en befintlig användare
Autentisering följer en liknande struktur men skapar inget nytt nyckelpar.
Servern genererar en ny utmaning och skickar autentiseringsalternativ till webbläsaren.
För en identifierbar passkey-inloggning kan dessa alternativ innehålla:
{
"challenge": "NEW_SERVER_GENERATED_CHALLENGE",
"rpId": "example.com",
"userVerification": "required",
"timeout": 300000
}
Webbläsaren kan då begära en autentiseringsuppgift:
async function authenticateWithPasskey() {
const optionsResponse = await fetch(
'/api/passkeys/login/options',
{
credentials: 'same-origin'
}
);
if (!optionsResponse.ok) {
throw new Error('Unable to start authentication');
}
const optionsJson = await optionsResponse.json();
const publicKey =
PublicKeyCredential.parseRequestOptionsFromJSON(
optionsJson
);
const credential = await navigator.credentials.get({
publicKey
});
if (!credential) {
throw new Error('Authentication was cancelled');
}
const verifyResponse = await fetch(
'/api/passkeys/login/verify',
{
method: 'POST',
credentials: 'same-origin',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify(credential.toJSON())
}
);
if (!verifyResponse.ok) {
throw new Error('Authentication failed');
}
return await verifyResponse.json();
}
Detta exempel antar att backend associerar den utfärdade utmaningen med en kortlivad, anonym inloggningstransaktion, tillämpar lämplig rate limiting och etablerar en ny autentiserad session först efter lyckad verifiering.
Servern måste slå upp autentiseringsuppgifts-ID, verifiera det signerade påståendet med den lagrade publika nyckeln, bekräfta utmaningen och ursprunget, och genomdriva sin användarverifieringspolicy.
Endast då ska den etablera användarens session.
parseRequestOptionsFromJSON() är en del av det moderna WebAuthn-API:et och eliminerar behovet av att manuellt avkoda binära fält i vanliga webbläsarbaserade integrationer.
8. Lägg till passkeys i befintliga inloggningsformulär med villkorlig medling
En av de mest användbara WebAuthn-funktionerna är villkorlig medling, ibland kallad passkey-autofyllning.
Istället för att visa en separat passkey-dialog omedelbart kan webbläsaren erbjuda en tillgänglig passkey bredvid andra sparade autentiseringsuppgifter när användaren interagerar med ett inloggningsfält.
HTML-input kan använda:
<input
type="text"
name="username"
autocomplete="username webauthn"
>
Applikationen kan kontrollera stöd:
const supported =
await PublicKeyCredential.isConditionalMediationAvailable();
if (supported) {
// Request authentication with mediation: 'conditional'.
}
Vid anrop av navigator.credentials.get() använder applikationen:
{
publicKey,
mediation: 'conditional'
}
För identifierbar-autentiseringsuppgift autofyllning bör serverns alternativ inte begränsa begäran till en specifik lista över autentiseringsuppgifts-ID:n.
Villkorlig medling är särskilt användbar under en gradvis migrering från lösenord eftersom användare inte behöver komma ihåg om ett visst konto har en passkey.
Webbläsaren kan presentera lämpliga alternativ i den bekanta inloggningsupplevelsen.
9. Varför utmanings- och ursprungskontroller är avgörande
Passkeys är phishing-resistenta, men det betyder inte att en applikation kan ignorera sitt autentiseringsprotokoll.
Utmaningen skyddar mot replay-attacker.
Utan en ny, oförutsägbar utmaning kan en angripare försöka återanvända autentiseringsdata från en tidigare session.
Ursprungs- och RP ID-kontroller säkerställer att autentiseringsuppgifter används i den avsedda webbplatskontexten.
Till exempel kan en passkey skapad för example.com inte enkelt återanvändas av en liknande phishing-webbplats som examp1e.com.
Webbläsaren och autenticatorn tillämpar viktiga delar av denna domänbindning, medan backend oberoende validerar de resulterande bevisen.
En bra implementation använder kortlivade utmaningar, förbrukar varje utmaning en gång och accepterar aldrig godtyckliga ursprung enbart för att de delar ett bekant utseende värdnamn.
MDN rekommenderar att generera utmaningar i en betrodd miljö ogiltigförklara dem efter en kort period, generellt inte mer än ungefär tio minuter.
10. Missförstå inte signaturkraknare
WebAuthn-autenticatorer kan innehålla en signaturknärare.
Historiskt sett har kraknare hjälpt till att upptäcka potentiellt klonade autenticatorer. Om en knärare oväntat slutar öka kan den förlitande parten betrakta det som en risksignal.
Men inte alla autenticatorer upprätthåller en meningsfull knärare.
Vissa autentiseringsuppgifter rapporterar alltid noll. Synkroniserade autentiseringsuppgifter kan också komplicera knäretolkning eftersom flera enheter kan använda kopior av samma autentiseringsuppgift.
W3C-specifikationen behandlar explicit oväntat knärebeteende som en möjlig signal, inte definitivt bevis på kloning.
Utvecklare bör därför inte blindt avvisa varje inloggning vars knärare är noll eller oförändrad.
Använd knäraren enligt autenticatorbeteendet, WebAuthn-verifieringsbibliotekets vägledning och applikationens säkerhetspolicy.
11. Återställning av konto är en del av passkey-säkerhet
En passkey-implementation är ofullständig utan en återställningsstrategi.
Vad händer när en användare förlorar en enhet?
Vad om de raderar sin enda passkey?
Vad om de byter autentiseringsuppgiftsleverantörer eller inte kan komma åt en synkroniserad autentiseringsuppgift?
En rimlig design gör det möjligt för användare att registrera flera passkeys och hantera dem från sina kontoinställningar.
Hanteringsgränssnittet bör visa igenkännbara autentiseringsuppgiftsnamn, skapandedatum och senaste användningsinformation där det finns tillgängligt.
Användare bör kunna återkalla autentiseringsuppgifter de inte längre litar på.
Men återställningsmekanismen förtjänar särskild omsorg.
Om en angripare kan kringgå passkey-autentisering genom en svag e-post-återställningsprocess, är det övergripande kontot bara lika säkert som den återställningsvägen.
För konton med högre risk, överväg starkare återställningsverifiering, återställningskoder, ytterligare registrerade autenticatorer och notifieringar om känsliga kontoändringar.
Googles passkey UX-vägledning rekommenderar att etablera en återställningsmetod och stödja flera passkeys där det är lämpligt.
12. Vanliga implementationsmisstag
Flera misstag underminerar återkommande annars lovande passkey-integrationer.
Att behandla webbläsarframgång som serverautentisering. Ett löst navigator.credentials.get()-löfte ersätter inte serversidan kryptografisk verifiering.
Att generera utmaningar i JavaScript. Utmaningar ska komma från en betrodd server och vara bundna till rätt autentiseringstransaktion.
Att använda fel RP ID. Domänomfång är en säkerhetsfunktion, inte en kosmetisk inställning. Produktion, staging och lokala utvecklingsmiljöer kräver medveten konfiguration.
Att anta att alla passkeys synkroniseras. Enhetsbundna autentiseringsuppgifter förblir en viktig del av ekosystemet.
Att glömma autentiseringsuppgiftsåterkallande. Användare behöver ett sätt att ta bort en förlorad eller komprometterad autenticator från sitt konto.
Att skapa en svag fallback. En phishing-resistent inloggning förlorar mycket av sitt värde om kontoåterställning kan utnyttjas lätt.
Att ignorera gamla webbläsare. Moderna JSON-bekvämlighetsmetoder minskar komplexiteten, men applikationer med krav på äldre webbläsare kan fortfarande behöva kompatibilitetskod.
Att hoppa över CSRF- och sessionsskydd. Registrering och hantering av autentiseringsuppgifter är känsliga kontoändringar. De behöver samma skydd som andra höginverkan-kontoåtgärder.
Att skriva anpassad kryptografisk verifiering onödigt. Ett underhållet WebAuthn-serverbibliotek är oftast ett säkrare val än att implementera specifikationen direkt.
13. Bör varje webbplats ersätta lösenord omedelbart?
Inte nödvändigtvis.
Passkeys kan förbättra både användbarhet och säkerhet, men migrationsstrategi har betydelse.
För en ny applikation kan lösenordslös registrering vara en rimlig standard om produkten har en välutformad återställningsflöde och stödjer sina målplattformar.
För en befintlig applikation med tusentals användare är inkrementell adoption ofta säkrare.
Börja med att tillåta autentiserade användare att registrera passkeys i kontoinställningar.
Lägg sedan till passkey-inloggning bredvid det befintliga autentiseringssystemet.
Införa villkorlig medling där det stöds.
Mät registringsframgång, autentiseringsfel, enhetskompatibilitet och återställningsbegäranden.
Slutligen, överväg att göra passkeys till föredragen autentiseringsmetod när användarupplevelsen och återställningsmekanismerna är tillräckligt mogna.
En fasad rollout gör det också enklare att identifiera webbläsarspecifika problem utan att låsa ute legitima användare.
14. En produktionsklarhetschecklista
Innan passkeys aktiveras i production, verifiera följande:
- Alla WebAuthn-operationer körs i en lämplig säker kontext.
- RP IDs och betrodda ursprung är explicit konfigurerade.
- Utmaningar är kryptografiskt slumpmässiga, kortlivade och engångsanvända.
- Registrering kräver lämplig kontoauktorisation.
- Serversidan verifiering följer WebAuthn-specifikationen.
- Publika nycklar och autentiseringsuppgiftsidentifierare lagras säkert.
- Inloggning etablerar en session först efter lyckad verifiering.
- Användarverifieringskrav tillämpas på servern.
- Autentiseringsuppgiftsborttagning och kontoåterställning är skyddade.
- Flera autentiseringsuppgifter per konto stöds där det är lämpligt.
- Autentiseringsfel och säkerhetskänsliga kontoändringar övervakas.
- Mobil, skrivbord, cross-enhet och hårdvarunyckel-scenarier testas.
Dessa kontroller är viktigare än om frontend kan visa en attraktiv biometrisk inloggningsprompt.
Slutsats: passkeys är en autentiseringsarkitektur, inte bara en webbläsarfunktion
WebAuthn gör publikknyckelautentisering tillgänglig för vanliga webbapplikationer.
Moderna webbläsar-API:er har borttagit mycket av serialiseringsarbetet som tidigare gjorde passkey-integration krångsam.
Men webbläsaren är bara en del av systemet.
Det riktiga implementationsarbetet ligger i utmaningshantering, serversidan verifiering, autentiseringsuppgiftslagring, domänkonfiguration, kontoåterställning och säkra användarresor.
För utvecklare som bygger moderna applikationer i PHP, JavaScript, Python eller andra backend-miljöer är passkeys allt mer värda att överväga som ett praktiskt alternativ till traditionella lösenord.
Den bästa startpunkten är inte att ersätta ett helt autentiseringssystem över natten.
Det är att implementera ett komplett, korrekt verifierat registrerings- och inloggningsflöde, och sedan bygga en säker migrationsstrategi runt det.