Lösenordsfri autentisering med WebAuthn och Passkeys

Lösenord är den svagaste länken i kontosäkerhet. De kan bli phishade, läckta, återanvända eller bortglömda. Därför har vi lagt till stöd för WebAuthn Passkeys - en phishing-resistent, lösenordsfri autentiseringsmetod som är både säkrare och bekvämare.

Vad är Passkeys?

Passkeys är kryptografiska inloggningsuppgifter som lagras på din enhet (telefon, laptop, säkerhetsnyckel) och ersätter lösenord för autentisering. De använder WebAuthn-standarden (del av FIDO2) och ger flera fördelar:

• Phishing-resistent - Passkeys är bundna till webbplatsens domän, så de kan inte användas på falska webbplatser
• Inga hemligheter att läcka - Endast den publika nyckeln lagras på servern
• Enhetsbunden - Den privata nyckeln lämnar aldrig din enhet
• Biometriskt skyddad - Vanligtvis säkrad med Face ID, Touch ID eller Windows Hello
• Synkronisering mellan enheter - Moderna plattformar synkroniserar Passkeys mellan enheter via iCloud-, Google- eller Microsoft-konton

Vår implementation

Vi integrerade stöd för WebAuthn Passkeys i vår befintliga django-allauth-autentiseringsstack och tillhandahåller både webb- och mobil-API-ändpunkter.

Registreringsflöde

När en användare registrerar en ny Passkey fungerar flödet så här:

1. Klienten begär registreringsalternativ från servern
2. Servern genererar en utmaning med användar- och relying party-information
3. Webbläsarens WebAuthn API uppmanar användaren (biometri eller säkerhetsnyckel)
4. Klienten skickar inloggningsuppgifter tillbaka till servern
5. Servern verifierar och lagrar den publika nyckeln

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# API endpoint to begin registration
class WebAuthnRegistrationOptionsView(APIView):
    permission_classes = [IsAuthenticated]

    def get(self, request):
        from allauth.mfa.webauthn.internal import auth as webauthn_auth

        # Generate credential creation options
        creation_options = webauthn_auth.begin_registration(
            request.user,
            passwordless=False  # Use as 2FA, not passwordless
        )

        return Response({
            "success": True,
            "creation_options": creation_options,
        })

Autentiseringsflöde

För tvåfaktorsautentisering med en Passkey:

1. Användaren slutför primär autentisering (användarnamn/lösenord eller social inloggning)
2. Servern returnerar en utmaning för WebAuthn-verifiering
3. Webbläsaren begär Passkey (biometrisk beröring)
4. Inloggningsuppgifter verifieras mot den lagrade publika nyckeln
5. Användaren är fullständigt autentiserad

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

class WebAuthnVerifyView(APIView):
    def post(self, request):
        credential = request.data.get("credential")

        # Complete authentication and verify credential
        authenticator = webauthn_auth.complete_authentication(
            request.user,
            credential
        )

        # Record usage for security monitoring
        authenticator.last_used_at = timezone.now()
        authenticator.save()

        return Response({"success": True})

Passkey-hantering

Användare kan hantera sina registrerade Passkeys:

• Lista alla Passkeys med registreringsdatum och senaste användning
• Byt namn på Passkeys för enklare identifiering (t.ex. “iPhone”, “MacBook”)
• Ta bort Passkeys (med skydd mot att ta bort den sista autentiseraren)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class WebAuthnListView(APIView):
    def get(self, request):
        authenticators = Authenticator.objects.filter(
            user=request.user,
            type=Authenticator.Type.WEBAUTHN
        ).order_by("-created_at")

        return Response({
            "passkeys": [
                {
                    "id": auth.pk,
                    "name": auth.wrap().name,
                    "created_at": auth.created_at.isoformat(),
                    "last_used_at": auth.last_used_at.isoformat() if auth.last_used_at else None,
                }
                for auth in authenticators
            ]
        })

API-ändpunkter

Vårt REST API ger fullt WebAuthn-stöd för mobilappen:

Säkerhetsöverväganden

Återställningskoder

När en användare registrerar sin första autentiserare (Passkey eller TOTP) genererar vi automatiskt återställningskoder. Dessa engångskoder kan användas om alla andra autentiseringsmetoder blir otillgängliga:

1
2

if Authenticator.objects.filter(user=request.user).count() == 1:
    auto_generate_recovery_codes(request._request)

Förhindra utelåsning

Användare kan inte ta bort sin sista Passkey om det skulle lämna dem utan någon tvåfaktorsautentiseringsmetod:

1
2
3
4

if not adapter.can_delete_authenticator(authenticator):
    return Response({
        "message": "Cannot delete - you must have at least one authentication method"
    }, status=400)

Övervakning

Vi spårar Passkey-användning via Datadog-mätvärden för säkerhetsövervakning:

1
2
3

increment("webauthn.registration.success")
increment("webauthn.verify.success")
increment("webauthn.verify.failed")

Webbläsarstöd

WebAuthn stöds i alla moderna webbläsare:

• Chrome 67+
• Firefox 60+
• Safari 13+
• Edge 79+
• Mobil Chrome, Safari, Firefox

För äldre webbläsare kan användare fortfarande använda TOTP (autentiseringsappar) eller återställningskoder.

Användarupplevelsen

Att lägga till en Passkey tar bara några sekunder:

1. Gå till Inställningar → Säkerhet → Tvåfaktorsautentisering
2. Klicka på Lägg till Passkey
3. Namnge din enhet (t.ex. “iPhone 15”)
4. Autentisera med Face ID / Touch ID / Windows Hello
5. Klart! Din Passkey är registrerad

Framtida inloggningar kräver bara en biometrisk bekräftelse - inget skrivande av lösenord eller kopiering av koder från autentiseringsappar.

Varför vi valde Passkeys

Passkeys representerar framtiden för autentisering. De stöds redan av Apple-, Google- och Microsoft-plattformar, vilket gör dem tillgängliga för nästan alla våra användare.

Redo att bli lösenordsfri? Aktivera Passkeys i dina säkerhetsinställningar!