WebAuthn-Passkeys aktivieren

Passkeys bieten eine moderne, phishingsichere Authentifizierungsmethode basierend auf den Standards Web Authentication API (WebAuthn) und FIDO2 . Sie sind eine sichere Alternative zu Kennwörtern mithilfe von Kryptografie und gerätebasierter Authentifizierung. In diesem Artikel wird erläutert, wie Sie eine ASP.NET Core-App für die Authentifizierung von Benutzern mithilfe von Passkeys konfigurieren.

Anleitungen für neue und vorhandene Blazor Web Apps finden Sie unter Implementieren von Passkeys in ASP.NET Core Blazor Web Apps nach dem Lesen dieses Artikels.

Was sind Passkeys?

Passkeys sind ein Ersatz für Kennwörter, die kryptografische Schlüsselpaare verwenden. Der private Schlüssel wird sicher auf dem Gerät des Benutzers gespeichert, z. B. in einem Hardwaresicherheitsmodul, plattformauthentifikator (Beispiele: Windows Hello, Touch ID, Face ID) oder ein Kennwort-Manager, während der öffentliche Schlüssel von der Web-App gespeichert wird. Während der Authentifizierung beweist der Benutzer den Besitz des privaten Schlüssels, ohne dass er sein Gerät verlassen muss.

Zu den wichtigsten Vorteilen von Passkeys gehören:

  • Phishingresistenz: Passkeys sind an bestimmte Websites gebunden und können nicht auf gefälschten Websites verwendet werden.
  • Keine freigegebenen geheimen Schlüssel: Der Server speichert nur öffentliche Schlüssel, wodurch das Risiko von Kennwortdatenbankverletzungen beseitigt wird.
  • Benutzerfreundlichkeit: Die einfache biometrische oder PIN-Überprüfung ersetzt komplexe Kennwortanforderungen.
  • Geräteübergreifende Synchronisierung: Viele Kennungsanbieter synchronisieren Anmeldeinformationen auf den Geräten eines Benutzers.

Weitere Informationen finden Sie in der Webauthentifizierungs-API (MDN-Dokumentation).

Passkeys in ASP.NET Core Identity

ASP.NET Core Identity umfasst integrierte Unterstützung für die Passkeyregistrierung und Authentifizierung:

  • Nahtlose Integration mit Identity Infrastruktur.
  • Unterstützung der Benutzerauthentifizierung für die am häufigsten verwendeten WebAuthn-Szenarien.
  • In die Blazor Web App-Projektvorlage integriert, sodass nur eine Konfiguration durch den Entwickler erforderlich ist.

Von Bedeutung

Die Passkeyimplementierung in ASP.NET Core Identity ist bewusst auf Authentifizierungsszenarien ausgelegt. Sie ist nicht als allgemeine WebAuthn-Bibliothek gedacht. Entwickler, die vollständige WebAuthn-Funktionen benötigen, sollten Communitybibliotheken berücksichtigen, die umfassende Protokollunterstützung bieten.

Unterstützte Szenarien

Die ASP.NET Core-Passkeyimplementierung Identity unterstützt die folgenden primären Szenarien:

  • Hinzufügen von Passkeys zu vorhandenen Konten: Benutzer mit kennwortbasierten Konten können Passkeys als zusätzliche Authentifizierungsmethode registrieren.
  • Kennwortlose Kontoerstellung: Benutzer können Konten ohne Kennwort erstellen, indem sie einen Passkey bei der Kontoerstellung registrieren.
  • Kennwortlose Anmeldung: Benutzer können sich nur mit ihrem Passkey authentifizieren, ohne ein Kennwort einzugeben.

Einschränkungen

Die aktuelle Implementierung hat die folgenden Einschränkungen:

  • Beschränkt auf ASP.NET Core Identity: Die APIs sind speziell für Identity-Authentifizierungsszenarien konzipiert.
  • Keine Standardmäßige Nachweisüberprüfung: Die Implementierung überprüft standardmäßig keine Nachweisanweisungen.
  • Vorlagenunterstützung: Nur die Blazor Web App Vorlage enthält passkey-Unterstützung.
  • Keine integrierte 2FA-Unterstützung: Passkeys werden als primärer Authentifizierungsfaktor behandelt, nicht als zweiter Faktor.

Kernkonzepte

Zwei grundlegende Prozesse bilden die Grundlage für Passkey-Abläufe: Attestierung und Assertion.

Nachweis (Registrierung)

Attestierung ist der Prozess zum Erstellen und Registrieren eines neuen Passkeys. Während der Attestierung generiert der Server eine eindeutige Challenge, die der Authentifikator in die zurückgegebenen Anmeldedaten aufnehmen muss. Der Authentifikator erstellt ein neues Schlüsselpaar und gibt den öffentlichen Schlüssel zusammen mit Nachweisdaten zurück, die den Ursprung des Schlüssels belegen. Anschließend überprüft der Server diesen Nachweis und speichert den öffentlichen Schlüssel für zukünftige Authentifizierungsversuche.

Assertion (Authentifizierung)

Assertion ist der Prozess der Authentifizierung mit einem vorhandenen Kennungsschlüssel. Der Server generiert eine eindeutige Herausforderung, die der Authentifikator mit dem privaten Schlüssel signiert. Der Authentifikator gibt diese signierte Assertion an den Server zurück, wodurch die Signatur mithilfe des zuvor gespeicherten öffentlichen Schlüssels überprüft wird. Wenn die Signatur gültig ist, wird der Benutzer authentifiziert.

Voraussetzungen

  • .NET SDK (.NET 10 oder höher)
  • Ein moderner Webbrowser, der WebAuthn unterstützt.
  • Ein Gerät mit einem Plattformauthentifikator, z. B. Windows Hello oder Apple secure Enklave, oder ein Sicherheitsschlüssel.

Sicherheitsüberlegungen

Stellen Sie bei der Implementierung von Schlüsseln in ASP.NET Core Identitysicher, dass die App die in diesem Abschnitt beschriebenen Sicherheitsanforderungen erfüllt.

Überprüfung des Hostheaders

Die Implementierung leitet die ID der vertrauenden Seite aus dem Hostheader ab, wenn ServerDomain sie nicht explizit konfiguriert ist. Die Hostingumgebung muss Host-Header validieren, um Credential-Scoping-Angriffe zu verhindern, bei denen kompromittierte oder gestohlene Benutzeranmeldeinformationen (Benutzernamen, Kennwörter, Token) verwendet werden, um unbefugten Zugriff zu erlangen.

Abhilfemaßnahme: Entweder ServerDomain in IdentityPasskeyOptions explizit konfigurieren oder sicherstellen, dass die Hostingumgebung (Kestrel, IIS, Reverseproxy) Hostheader validiert. Ausführliche Informationen zur Konfiguration finden Sie in der Dokumentation Ihrer Hostingplattform. Darüber hinaus konfigurieren Sie AllowedHosts explizit, wenn Sie die Middleware für weitergeleitete Header verwenden.

Subdomänensicherheit

ASP.NET Core-Passkeys-Implementierung behandelt die Unterdomänensicherheit über die ServerDomain Konfigurationsoption. Wenn ServerDomain nicht explizit angegeben wird, verwendet die Implementierung den Hostheader, um die Domäne zu bestimmen. Dies bedeutet, dass die Seite, auf der der Schlüssel registriert wurde, die Domäne für diese Anmeldeinformationen steuert.

Beispiel:

  • Wenn auf app.contoso.com ein Passkey registriert ist, funktioniert er auch auf *.app.contoso.com.
  • Wenn es auf contoso.com registriert ist, funktioniert es auch auf *.contoso.com.
  • Der Browser erzwingt, dass Passkeys nur für die Domäne (und Unterdomänen) verwendet werden können, in der sie registriert wurden.

Anforderung: Apps, die eine strikte Kontrolle der Domäne erfordern, sollten ServerDomain explizit festlegen, anstatt sich auf den Host-Header zu verlassen. Stellen Sie keine nicht vertrauenswürdigen Inhalte auf einer Unterdomäne innerhalb des ServerDomain-Bereichs bereit. Wenn Sie dies nicht garantieren können, implementieren Sie die benutzerdefinierte Ursprungsüberprüfung , um die Verwendung von Passkeys auf bestimmte Ursprünge einzuschränken.

HTTPS-Anforderung

Alle Passkey-Operationen erfordern HTTPS. Die Implementierung speichert Authentifizierungsdaten in verschlüsselten und signierten Cookies, die über unverschlüsselte Verbindungen abgefangen werden könnten.

Anforderung: Immer HTTPS in der Produktion verwenden. Konfigurieren Sie das HTTP Strict Transport Security (HSTS)-Protokoll , um Protokollabstufungsangriffe zu verhindern.

Kontowiederherstellung

Die Kontowiederherstellung ist in erster Linie ein Problem für Apps, die Passkeys als einzigen Authentifizierungsmechanismus zulassen. Die Standardprojektvorlage Blazor Web App erfordert bereits, dass Benutzer beim Erstellen eines Kontos eine Sicherungsauthentifizierungsmethode (Kennwort oder externer Anbieter) einrichten, sodass die Kontowiederherstellung über diese vorhandenen Mechanismen verarbeitet wird.

Empfehlungen:

Für Anwendungen, die die nur passkey-Authentifizierung implementieren, sollten Sie Folgendes in Betracht ziehen:

  • Wiederherstellungscodes, die während der Kontoerstellung generiert wurden.
  • E-Mail-basierte Wiederherstellungsabläufe.
  • Obligatorische Registrierung mehrerer Passkeys.
  • Überwachen Sie das IsBackedUp-Flag auf UserPasskeyInfo, um Benutzer aufzufordern, zusätzliche Anmeldeinformationen hinzuzufügen.

Administrative Steuerelemente

Wenn festgestellt wird, dass ein Authentifikatormodell Sicherheitslücken aufweist, müssen Sie möglicherweise betroffene Anmeldeinformationen widerrufen. Die Implementierung speichert das vollständige Nachweisobjekt mit den einzelnen Anmeldeinformationen, einschließlich der Authenticator Attestation GUID (AAGUID), bei der es sich um einen 128-Bit-Bezeichner handelt, der den Schlüsseltyp angibt.

Implementierung: Extrahieren von AAGUIDs aus gespeicherten Nachweisobjekten, Vergleichen mit bekannten kompromittierten Modellen und Widerrufen betroffener Anmeldeinformationen. Die Zuverlässigkeit der AAGUID hängt davon ab, ob Ihre App Attestierungsaussagen validiert. Informationen zum Einbinden benutzerdefinierter Validierungslogik für Nachweisanweisungen finden Sie unter Validierung benutzerdefinierter Nachweisanweisungen. Drittanbieterbibliotheken sind für die Nachweisüberprüfung verfügbar, z. B. die Passkeys - FIDO2 .NET Library (WebAuthn) (passwordless-lib/fido2-net-lib GitHub-Repository)†.

Warnung

†Third-Party-Bibliotheken, einschließlich passwordless-lib/fido2-net-lib, gehören oder werden von Microsoft nicht verwaltet und unterliegen keinem Microsoft-Supportvertrag oder einer Lizenz. Verwenden Sie Vorsicht bei der Einführung einer Drittanbieterbibliothek, insbesondere für Sicherheitsfeatures. Vergewissern Sie sich, dass die Bibliothek offizielle Spezifikationen befolgt und bewährte Methoden für die Sicherheit verwendet. Halten Sie die Version der Bibliothek aktuell, um die neuesten Fehlerbehebungen zu erhalten.

Ressourcenbeschränkungen

Um Datenbankausschöpfungsangriffe zu verhindern, sollten Apps Grenzwerte für die Passkeyregistrierung erzwingen, z. B.:

  • Maximale Anzahl von Passkeys pro Benutzerkonto.
  • Maximale Länge für Passkey-Anzeigenamen.

Die Blazor Web App Vorlage erzwingt diese Grenzwerte standardmäßig auf Anwendungsebene. Beispiele finden Sie in den folgenden Razor Komponenten in der Blazor Web App Projektvorlage:

Hinweis

Dokumentationslinks zur .NET-Referenzquelle laden in der Regel die Standard-Branch des Repositorys, die die aktuelle Entwicklung der nächsten Version von .NET darstellt. Um ein Tag für ein bestimmtes Release auszuwählen, wählen Sie diesen mit der Dropdownliste Switch branches or tags (Branches oder Tags wechseln) aus.

Konfigurieren von Passkeyoptionen

ASP.NET Core Identity bietet verschiedene Optionen zum Konfigurieren des Passkey-Verhaltens über die IdentityPasskeyOptions-Klasse, darunter:

  • AuthenticatorTimeout: Ruft die Zeitspanne ab, die der Browser warten soll, bis der Authentifikator einen Passkey als TimeSpan bereitstellt, oder legt diese fest. Diese Option gilt sowohl für das Erstellen eines neuen Passkeys als auch für das Anfordern eines vorhandenen Passkeys. Diese Option wird als Hinweis für den Browser behandelt, und der Browser ignoriert möglicherweise die Option. Der Standardwert beträgt 5 Minuten.
  • ChallengeSize: Ruft die Größe der Challenge in Bytes ab, die während der Attestierung und Assertion an den Client gesendet werden, oder legt sie fest. Diese Option gilt sowohl für das Erstellen eines neuen Passkeys als auch für das Anfordern eines vorhandenen Passkeys. Der Standardwert ist 32 Byte.
  • ServerDomain: Ruft die effektive Relying-Party-ID (Domäne) des Servers ab oder legt sie fest. Dies sollte eindeutig sein und als Identität für den Server verwendet werden. Diese Option gilt sowohl für das Erstellen eines neuen Passkeys als auch für das Anfordern eines vorhandenen Passkeys. Wenn nullder Standardwert ist, wird der Ursprung des Servers verwendet. Weitere Informationen finden Sie unter RP-ID der vertrauenden Seite.

Beispielkonfiguration:

builder.Services.Configure<IdentityPasskeyOptions>(options =>
{
    options.ServerDomain = "contoso.com";
    options.AuthenticatorTimeout = TimeSpan.FromMinutes(3);
    options.ChallengeSize = 64;
});

Eine vollständige Liste der Konfigurationsoptionen finden Sie unter IdentityPasskeyOptions. Die meisten up-to-date-Browserstandardwerte finden Sie in der W3C WebAuthn-Spezifikation.

Hinweis

Dokumentationslinks zur .NET-Referenzquelle laden in der Regel den Standardbranch des Repositorys, der die aktuelle Entwicklung für das nächste Vorschauversion von .NET darstellt. Um ein Tag für ein bestimmtes Release auszuwählen, wählen Sie diesen mit der Dropdownliste Switch branches or tags (Branches oder Tags wechseln) aus.

Validierung der benutzerdefinierten Attestierungserklärung

Standardmäßig überprüft ASP.NET Core Identity keine Attestierungsaussagen. Dies eignet sich für die meisten Verbraucherauthentifizierungsszenarien. Wenn Ihre App die Überprüfung von Authentifikatoreigenschaften erfordert oder sie bestimmte Authentifikatoren nicht zulassen möchten, z. B. in Unternehmensumgebungen, die eine höhere Sicherheitsstufe erfordern, können Sie eine benutzerdefinierte Nachweisüberprüfung implementieren:

builder.Services.Configure<IdentityPasskeyOptions>(options =>
{
    options.VerifyAttestationStatement = async (context) =>
    {
        // Custom attestation validation logic
        // Return 'true' if the attestation is valid
        // Return 'false' if the attestation is invalid
        return true;
    };
});

Warnung

Die Validierung der Attestierung ist komplex und erfordert die Pflege von Vertrauensspeichern für Zertifikate von Authentifikatoren. Implementieren Sie nur eine benutzerdefinierte Überprüfung, wenn Ihre App die Überprüfung bestimmter Authentifikatoreigenschaften erfordert.

Überprüfung des benutzerdefinierten Ursprungs

Die Standardursprungüberprüfung ermöglicht Anforderungen von Unterdomänen und verbietet ursprungsübergreifende iFrames. So passen Sie dieses Verhalten an:

builder.Services.Configure<IdentityPasskeyOptions>(options =>
{
    options.ValidateOrigin = async (context) =>
    {
        // Custom origin validation logic
        //   Access the origin via 'context.Origin'
        //   Access the HTTP context via 'context.HttpContext'
        // Return 'true' if the origin is valid
        // Return 'false' if the origin is invalid
        return true;
    };
});

Anpassen des Passkeyhandlers

IPasskeyHandler<TUser> ist der Dienst, der Passkeyoptionen generiert und Nachweise und Assertionen durchführt. ASP.NET Core Identity registriert PasskeyHandler<TUser> als Standardimplementierung, und SignInManager<TUser> ruft diese auf. Die Schnittstelle verfügt über vier Methoden:

  • MakeCreationOptionsAsync: Generiert die Erstellungsoptionen und den Nachweisstatus für die Registrierung eines Kennungsschlüssels.
  • MakeRequestOptionsAsync: Generiert die Anforderungsoptionen und den Assertionsstatus für die Authentifizierung mit einem vorhandenen Passkey.
  • PerformAttestationAsync: Überprüft die Anmeldeinformationen, die der Browser während der Registrierung zurückgibt.
  • PerformAssertionAsync: Überprüft die Anmeldeinformationen, die der Browser während der Authentifizierung zurückgibt.

Die meisten Apps sollten die SignInManager<TUser> im Abschnitt " Registrierung" und " Authentifizierungsfluss " angezeigten Methoden verwenden, anstatt den Handler direkt aufzurufen. Diese Methoden verwalten den temporären Zustand, den die Zwei-Anforderung-Registrierungs- und Authentifizierungszeremonien erfordern, und sie schützen diesen Zustand im Namen der App.

Wann muss ich implementieren? IPasskeyHandler<TUser>

Verwenden Sie für die meisten Anpassungen die IdentityPasskeyOptions Rückrufe, die in den Abschnitten "Überprüfung der benutzerdefinierten Nachweisanweisung " und " Benutzerdefinierte Ursprungsüberprüfung " beschrieben sind. Implementieren Sie IPasskeyHandler<TUser> nur für Szenarien, die die Optionen nicht ausdrücken können, z. B.:

  • Unterschiedliche Passkey-Optionen pro Anfrage oder pro Mandant.
  • Auflösen von Benutzern aus einer anderen Quelle als UserManager<TUser>.
  • Hinzufügen von Prüfungen, die vor oder nach der integrierten WebAuthn-Überprüfung ausgeführt werden.

Das Implementieren der Schnittstelle von Grund auf bedeutet, dass die Überprüfungsschritte von WebAuthn neu implementiert werden, was fehleranfällig ist. Implementieren Sie die Schnittstelle nach Möglichkeit als Wrapper, der an eine innere PasskeyHandler<TUser> Instanz delegiert wird, und fügt nur das erforderliche Verhalten hinzu.

Warnung

Eine App, die IPasskeyHandler<TUser> direkt aufruft, anstatt über SignInManager<TUser>, ist selbst dafür verantwortlich, den Attestierungsstatus sicher zu speichern. Eine App, die dies nicht tut, ermöglicht es einem Angreifer, einen Passkey für ein Konto zu registrieren, das er nicht besitzt.

Attestierungsstatus

Die Registrierung eines Passkeys erfolgt in zwei Anfragen. Die erste Anforderung ruft Erstellungsoptionen ab, und die zweite Anforderung sendet die neuen Anmeldeinformationen. Der Nachweisstatus ist die Information, die der Server zwischen den beiden Anforderungen speichert.

MakeCreationOptionsAsync gibt ein PasskeyCreationOptionsResult mit zwei Teilen zurück:

Der Zustand, den der Standard-Handler erzeugt, enthält die Challenge und das PasskeyUserEntity, das das Konto identifiziert, für das der Passkey registriert ist. Der Zustand wird als JSON ohne Signatur oder Verschlüsselung serialisiert, sodass er keinen Eigenen Integritätsschutz bietet.

Der Status ist der einzige Ort, an dem das Konto aufgezeichnet wird. Eine Attestierungsantwort vom Browser enthält einen neuen öffentlichen Schlüssel und die signierte Challenge, aber nichts, was einen Benutzer identifiziert; daher meldet PerformAttestationAsync den Benutzer, der dem Zustand in UserEntity entnommen wird. Wenn der Status geändert wird, bevor die Anmeldedaten übermittelt werden, wird der Passkey für das Konto registriert, das im geänderten Status angegeben ist.

Integrität und Eigentümerschaft validieren

Eine App, die den Nachweisstatus selbst verwaltet, muss die folgenden drei Anforderungen erfüllen.

Integrität: Der Client darf den Zustand nicht ändern können. Platzieren Sie den Zustand nicht in einem ausgeblendeten Formularfeld, einem Anforderungstext oder einem nicht geschützten Browserspeicher. Ein Angreifer, der die Benutzer-ID im Statusparameter ändert, schließt die Registrierung normal ab, und sein Authentifikator wird in dem Konto gespeichert, das im geänderten Status angegeben ist, wodurch er Anmeldezugriff auf dieses Konto erhält. Behalten Sie den Status auf dem Server bei, oder schützen Sie ihn mit den ASP.NET Core Datenschutz-APIs, bevor Sie ihn an den Browser senden.

Eigentum: Der Status muss an die Sitzung gebunden sein, die die Erstellungsoptionen angefordert hat, und die Bindung muss überprüft werden, wenn die Anmeldeinformationen übermittelt werden. Vergleichen Sie UserEntity mit dem angemeldeten Nutzer, bevor Sie den Passkey speichern. Der Handler führt diese Überprüfung nicht aus, da er keinen unabhängigen Datensatz des Benutzers enthält, mit dem verglichen werden soll.

Einzelne Verwendung und Ablauf: Verwerfen Sie den Status nach dem Lesen, und geben Sie ihm eine kurze Lebensdauer. Ein Zustand, der gültig bleibt, kann erneut abgespielt werden.

Als Referenz erfüllt SignInManager<TUser> diese Anforderungen wie folgt:

  • Speichern des Zustands in einer Authentifizierung cookie , die durch die Datenschutz-APIs geschützt ist, die der Browser nicht lesen oder ändern kann.
  • Abmelden des Status, sobald er gelesen wurde, wodurch der Status auf eine einmalige Verwendung beschränkt wird.
  • Aufzeichnen, ob der Status für die Attestierung oder die Zusicherung erstellt wurde, und eine Nichtübereinstimmung zurückweisen.

Beispiel für registrierung

Im folgenden Beispiel wird IPasskeyHandler<TUser> direkt aufgerufen und der Nachweisstatus in einem datengeschützten cookie beibehalten. Beide Endpunkte erfordern einen angemeldeten Nutzer, da der Passkey dem angemeldeten Konto hinzugefügt wird:

const string AttestationStateCookieName = "PasskeyAttestationState";
const string AttestationStatePurpose = "Contoso.Passkeys.AttestationState.v1";

app.MapPost("/Account/PasskeyCreationOptions", async (
    HttpContext context,
    UserManager<ApplicationUser> userManager,
    IPasskeyHandler<ApplicationUser> passkeyHandler,
    IDataProtectionProvider dataProtectionProvider) =>
{
    var user = await userManager.GetUserAsync(context.User);

    if (user is null)
    {
        return Results.Unauthorized();
    }

    var userId = await userManager.GetUserIdAsync(user);
    var userName = await userManager.GetUserNameAsync(user) ?? "User";

    var options = await passkeyHandler.MakeCreationOptionsAsync(new()
    {
        Id = userId,
        Name = userName,
        DisplayName = userName
    }, context);

    var attestationState = options.AttestationState 
        ?? throw new InvalidOperationException("No attestation state was created.");

    var protector = 
        dataProtectionProvider.CreateProtector(AttestationStatePurpose);

    context.Response.Cookies.Append(
        AttestationStateCookieName,
        protector.Protect(attestationState),
        new CookieOptions
        {
            HttpOnly = true,
            Secure = true,
            SameSite = SameSiteMode.Strict,
            MaxAge = TimeSpan.FromMinutes(5)
        });

    return TypedResults.Content(options.CreationOptionsJson, 
        contentType: "application/json");
}).RequireAuthorization();

Der vorherige Code:

  • Schützt den Nachweisstatus mit den Datenschutz-APIs, bevor der Zustand den Browser erreicht, sodass der Client ihn nicht lesen oder ändern kann.
  • Schränkt die cookie Lebensdauer von fünf Minuten ein, was angibt, wie lange eine Registrierung geöffnet bleiben kann.

Wenn die Anmeldeinformation eingeht, stellt die App den Zustand wieder her, überprüft, ob die Attestierung zu dem angemeldeten Benutzer gehört, und speichert den Passkey erst dann:

app.MapPost("/Account/PasskeyRegistration", async (
    PasskeyRegistrationRequest request,
    HttpContext context,
    UserManager<ApplicationUser> userManager,
    IPasskeyHandler<ApplicationUser> passkeyHandler,
    IDataProtectionProvider dataProtectionProvider) =>
{
    var user = await userManager.GetUserAsync(context.User);

    if (user is null)
    {
        return Results.Unauthorized();
    }

    if (!context.Request.Cookies.TryGetValue(AttestationStateCookieName, 
        out var protectedState))
    {
        return Results.BadRequest("No passkey registration is underway");
    }

    context.Response.Cookies.Delete(AttestationStateCookieName);

    var protector = 
        dataProtectionProvider.CreateProtector(AttestationStatePurpose);
    string attestationState;

    try
    {
        attestationState = protector.Unprotect(protectedState);
    }
    catch (CryptographicException)
    {
        return Results.BadRequest("The passkey registration state isn't valid");
    }

    var attestationResult = await passkeyHandler.PerformAttestationAsync(new()
    {
        HttpContext = context,
        CredentialJson = request.CredentialJson,
        AttestationState = attestationState
    });

    if (!attestationResult.Succeeded)
    {
        return Results.BadRequest($"Error: {attestationResult.Failure.Message}");
    }

    var userId = await userManager.GetUserIdAsync(user);

    if (!string.Equals(attestationResult.UserEntity.Id, userId, 
        StringComparison.Ordinal))
    {
        return Results.BadRequest("The passkey isn't registered to the current user");
    }

    var addResult = 
        await userManager.AddOrUpdatePasskeyAsync(user, attestationResult.Passkey);

    if (!addResult.Succeeded)
    {
        return Results.BadRequest("Failed to store passkey");
    }

    return Results.Ok();
}).RequireAuthorization();

Der vorherige Code:

  • Löscht den Zustand cookie , bevor der Zustand verwendet wird, sodass der Zustand für eine einzelne Registrierung gut ist.
  • Lehnt die Anforderung ab, wenn der Zustand nicht geschützt werden kann, was geschieht, wenn der Wert manipuliert oder mit einem anderen Schlüssel geschützt wurde.
  • Bestätigt, dass das Nachweisergebnis den angemeldeten Benutzer benennt, bevor der Schlüssel gespeichert wird. Der Handler entnimmt das Konto dem Attestierungsstatus. Diese Prüfung verhindert, dass ein Passkey mit einem anderen Konto verknüpft wird.

Der PasskeyRegistrationRequest Typ enthält die serialisierten Anmeldedaten vom Browser:

public record PasskeyRegistrationRequest(string CredentialJson);

Registrieren eines benutzerdefinierten Handlers

AddSignInManager registriert den Standardhandler bei AddScoped statt bei TryAddScoped, daher muss ein benutzerdefinierter Handler nach den Identity-Diensten registriert werden, damit er als aufgelöste Implementierung verwendet wird:

builder.Services.AddIdentityCore<ApplicationUser>()
    .AddEntityFrameworkStores<ApplicationDbContext>()
    .AddSignInManager();

builder.Services
    .AddScoped<IPasskeyHandler<ApplicationUser>, CustomPasskeyHandler>();

Registrierungsablauf

In diesem Abschnitt werden die einzelnen Schritte des Kennungsregistrierungsprozesses erläutert, wie ASP.NET Core Identity die Erstellung und Speicherung von Passkey-Anmeldeinformationen erleichtert.

sequenceDiagram
    participant Authenticator
    participant User
    participant Browser
    participant Server

    User->>Browser: Click "Add passkey"
    Browser->>Server: Request creation options
    Server->>Browser: Return creation options
    Browser->>Authenticator: Request new credential
    Authenticator->>User: Verify identity (biometric/PIN)
    User->>Authenticator: Approve
    Authenticator->>Browser: Return credential
    Browser->>Server: Submit credential
    Server->>Server: Verify and store
    Server->>Browser: Registration complete
    Browser->>User: Success message

Schritt 1: Initiieren der Registrierung

Der Registrierungsprozess beginnt, wenn ein Benutzer entscheidet, einem Konto einen Kennungsschlüssel hinzuzufügen. Dies geschieht in der Regel über eine Schaltfläche oder einen Link auf der Benutzeroberfläche der App. Wenn dieses Element ausgewählt ist, löst dieses Element JavaScript-Code aus, um den Registrierungsfluss zu koordinieren.

Die clientseitige Implementierung variiert erheblich zwischen Apps. In der Blazor Web App Vorlage finden Sie ein vollständiges Beispiel, PasskeySubmit.razor.jsin dem gezeigt wird, wie eine benutzerdefinierte Webkomponente die Registrierunginitiierung verarbeitet und die nachfolgenden WebAuthn-API-Aufrufe verwaltet.

Schritt 2: Anfordern von Erstellungsoptionen

Nachdem die Registrierung initiiert wurde, muss der Browser Erstellungsoptionen vom Server abrufen. Diese Optionen teilen dem Browser mit, welche Art von Anmeldedaten erstellt werden soll, und enthalten wichtige Sicherheitsparameter, wie z. B. die Challenge, die signiert werden muss.

Aus Sicht des Browsers besteht dieser Schritt darin, eine HTTP-Anforderung an den Server zu erstellen:

async function createCredential(signal) {
  // Step 2: Request creation options from the server
  const optionsResponse = 
    await fetchWithErrorHandling('/Account/PasskeyCreationOptions', 
    {
      method: 'POST',
      signal,
    });
  const optionsJson = await optionsResponse.json();
  const options = PublicKeyCredential.parseCreationOptionsFromJSON(optionsJson);
  return await navigator.credentials.create({ publicKey: options, signal });
}
async function createCredential(headers, signal) {
  // Step 2: Request creation options from the server
  const optionsResponse = 
    await fetchWithErrorHandling('/Account/PasskeyCreationOptions', 
    {
      method: 'POST',
      headers,
      signal,
    });
  const optionsJson = await optionsResponse.json();
  const options = PublicKeyCredential.parseCreationOptionsFromJSON(optionsJson);
  return await navigator.credentials.create({ publicKey: options, signal });
}

Die Anwendung sollte einen Endpunkt definieren, der diese Optionen generiert:

app.MapPost("/Account/PasskeyCreationOptions", async (
    HttpContext context,
    UserManager<ApplicationUser> userManager,
    SignInManager<ApplicationUser> signInManager) =>
{
    var user = await userManager.GetUserAsync(context.User);

    if (user is null)
    {
        return Results.NotFound();
    }

    var userId = await userManager.GetUserIdAsync(user);
    var userName = await userManager.GetUserNameAsync(user) ?? "User";
    
    var optionsJson = await signInManager.MakePasskeyCreationOptionsAsync(new()
    {
        Id = userId,
        Name = userName,
        DisplayName = userName
    });
    
    return TypedResults.Content(optionsJson, contentType: "application/json");
});

Die MakePasskeyCreationOptionsAsync Methode ist für diesen Prozess zentral. Die Methode akzeptiert einen PasskeyUserEntity , der den Benutzer beschreibt, für den der Schlüssel erstellt wird. Diese Entität enthält die ID des Benutzers, den Benutzernamen (in der Regel eine E-Mail-Adresse) und einen lesbaren Anzeigenamen. Die Methode gibt eine JSON-Zeichenfolge zurück, die dem WebAuthn-Schema PublicKeyCredentialCreationOptions entspricht, das der Browser im nächsten Schritt verwendet. Im Hintergrund speichert diese Methode auch den temporären Zustand in einer Authentifizierung cookie , um sicherzustellen, dass die Antwort vom Browser diesen spezifischen Optionen entspricht. Apps, die diesen Zustand selbst verwalten, müssen ihn schützen, wie im Abschnitt "Anpassen des Passkeyhandlers " beschrieben.

Schritt 3: Server generiert Optionen

Wenn MakePasskeyCreationOptionsAsync ausgeführt wird, wird die IdentityPasskeyOptions-Konfiguration der App verwendet, um die spezifischen Parameter für die Erstellung von Anmeldeinformationen zu bestimmen. Diese Optionen steuern verschiedene Aspekte des Passkey-Erstellungsprozesses.

Sie können diese Optionen während des Anwendungsstarts anpassen. Beispiel:

builder.Services.Configure<IdentityPasskeyOptions>(options =>
{
    options.ServerDomain = "contoso.com";
    options.AuthenticatorTimeout = TimeSpan.FromMinutes(3);
    options.UserVerificationRequirement = "required";
    options.ResidentKeyRequirement = "preferred";
});

Die UserVerificationRequirement Option bestimmt, ob der Authentifikator die Identität des Benutzers (über biometrische oder PIN-Methoden) überprüfen muss, während ResidentKeyRequirement angegeben wird, ob die Anmeldeinformationen auffindbar sein sollen, was die Authentifizierung ermöglicht, ohne zuerst einen Benutzernamen anzugeben. Weitere Informationen finden Sie unter IdentityPasskeyOptions.

Schritt 4: Client fordert Anmeldeinformationen an

Mit den verfügbaren Erstellungsoptionen übergibt das clientseitige JavaScript die Optionen an die WebAuthn-API, um eine neue Anmeldeinformation zu erstellen:

async function createCredential(signal) {
  // Step 4: Parse the options and request a new credential from the authenticator
  const optionsResponse = 
    await fetchWithErrorHandling('/Account/PasskeyCreationOptions', 
    {
      method: 'POST',
      signal,
    });
  const optionsJson = await optionsResponse.json();
  const options = PublicKeyCredential.parseCreationOptionsFromJSON(optionsJson);
  return await navigator.credentials.create({ publicKey: options, signal });
}
async function createCredential(headers, signal) {
  // Step 4: Parse the options and request a new credential from the authenticator
  const optionsResponse = 
    await fetchWithErrorHandling('/Account/PasskeyCreationOptions', 
    {
      method: 'POST',
      headers,
      signal,
    });
  const optionsJson = await optionsResponse.json();
  const options = PublicKeyCredential.parseCreationOptionsFromJSON(optionsJson);
  return await navigator.credentials.create({ publicKey: options, signal });
}

Die parseCreationOptionsFromJSON Funktion konvertiert die JSON-Antwort in das von der WebAuthn-API erwartete Format und navigator.credentials.create() initiiert den Anmeldeinformationserstellungsprozess mit dem Authentifikator.

Schritt 5: Authentifizierungsinteraktion

An diesem Punkt kommuniziert der Browser mit dem Authentifikator, um die Anmeldeinformationen zu erstellen. Der Authentifikator fordert den Benutzer zur Überprüfung auf, was das Scannen eines Fingerabdrucks, das Eingeben einer PIN oder die Verwendung der Gesichtserkennung umfassen kann. Diese Interaktion wird vollständig vom Browser und vom Authentifikator behandelt, für den kein App-Code erforderlich ist. Die Benutzererfahrung variiert je nach Art des Authentifikators und den Funktionen der Plattform.

Schritt 6: Übermittlung von Anmeldedaten

Nachdem der Authentifikator die Anmeldeinformationen erstellt hat, muss der Browser die Anmeldeinformationen zur Überprüfung und Speicherung an den Server zurücksenden. Die Anmeldeinformationen müssen vor der Übermittlung in JSON serialisiert werden:

async function createCredentialJson(signal) {
  const credential = await createCredential(signal);
  return JSON.stringify(credential);
}
async function createCredentialJson(headers, signal) {
  const credential = await createCredential(headers, signal);
  return JSON.stringify(credential);
}

In der Blazor Web App Vorlage werden die zurückgegebenen Anmeldeinformationen automatisch serialisiert und über ein Formular übermittelt, aber der genaue Übermittlungsmechanismus variiert je nach Anwendung.

Schritt 7: Serverüberprüfung und -speicherung

Wenn der Server die Anmeldeinformationen empfängt, muss er seine Gültigkeit überprüfen und den öffentlichen Schlüssel für die zukünftige Authentifizierung speichern. Hier werden ASP.NET Core-Passkey-APIs Identityentscheidend.

Die PerformPasskeyAttestationAsync Methode überprüft die Bestätigungsantwort vom Client. Dieser umfassende Validierungsprozess:

  • Überprüft, ob der Typ der Anmeldeinformationen den Erwartungen entspricht.
  • Überprüft den JSON-Code für Clientdaten, einschließlich Ursprung und Herausforderung.
  • Überprüft Authentifikator-Datenkennzeichnungen auf Benutzerpräsenz und Überprüfung
  • Extrahiert und überprüft den öffentlichen Schlüssel.

Wenn alle Prüfungen erfolgreich sind, gibt die Methode ein PasskeyAttestationResult zurück, das die verifizierten Passkey-Informationen enthält.

Nachdem die Attestierung verifiziert wurde, verwendet die App AddOrUpdatePasskeyAsync, um den Passkey in der Datenbank zu speichern:

var attestationResult = 
    await signInManager.PerformPasskeyAttestationAsync(credentialJson);

if (!attestationResult.Succeeded)
{
    return Results.BadRequest($"Error: {attestationResult.Failure.Message}");
}

var addResult = 
    await userManager.AddOrUpdatePasskeyAsync(user, attestationResult.Passkey);

if (!addResult.Succeeded)
{
    return Results.BadRequest("Failed to store passkey");
}

Das gespeicherte UserPasskeyInfo enthält alle erforderlichen Informationen für künftige Authentifizierungen, einschließlich der Anmeldedaten-ID, des öffentlichen Schlüssels, des Signaturzählers zum Schutz vor Replay-Angriffen sowie von Kennzeichnungen, die angeben, ob der Passkey gesichert ist oder gesichert werden kann.

Schritt 8: Aufgaben nach der Registrierung

Nach der erfolgreichen Registrierung eines Passkeys führen Apps häufig zusätzliche Aufgaben aus, um die Benutzererfahrung zu verbessern. Ein gängiger Ansatz besteht darin, Benutzer aufzufordern, für ihren Passkey einen leicht erkennbaren Namen anzugeben, damit er sich unter mehreren Anmeldedaten leichter identifizieren lässt. Die UserPasskeyInfo.Name Eigenschaft speichert diesen benutzerfreundlichen Namen, der mit derselben AddOrUpdatePasskeyAsync Methode aktualisiert werden kann:

passkey.Name = "My iPhone";
await userManager.AddOrUpdatePasskeyAsync(user, passkey);

Authentifizierungsfluss

In diesem Abschnitt wird erläutert, wie Benutzer sich mit ihren Kennungen authentifizieren, von der Einleitung des Anmeldevorgangs bis zum Einrichten einer authentifizierten Sitzung.

sequenceDiagram
    participant Authenticator
    participant User
    participant Browser
    participant Server

    User->>Browser: Click "Sign in with passkey"
    Browser->>Server: Request authentication options
    Server->>Browser: Return authentication options
    Browser->>Authenticator: Request assertion
    Authenticator->>User: Verify identity
    User->>Authenticator: Approve
    Authenticator->>Browser: Return signed assertion
    Browser->>Server: Submit assertion
    Server->>Server: Verify signature
    Server->>Browser: Authentication complete
    Browser->>User: Redirect to app

Schritt 1: Initiieren der Authentifizierung

Benutzer initiieren in der Regel die Passkey-Authentifizierung über eine dedizierte Schaltfläche oder einen Link auf der Anmeldeseite. Einige Apps unterstützen auch die bedingte Benutzeroberfläche, bei der Passkeys als Vorschläge zum automatischen Ausfüllen im Benutzernamenfeld angezeigt werden. Die Initiierungsmethode löst JavaScript-Code aus, der den Authentifizierungsfluss verwaltet, ähnlich wie der Registrierungsprozess.

Schritt 2: Anfordern von Authentifizierungsoptionen

Der Browser fordert Authentifizierungsoptionen vom Server an, um den Authentifizierungsprozess zu starten. Zu diesen Optionen gehören eine Liste zulässiger Anmeldeinformationen und eine neue Challenge, die signiert werden muss:

async function requestCredential(email, mediation, signal) {
  // Step 2: Request authentication options from the server
  const optionsResponse = 
    await fetchWithErrorHandling(`/Account/PasskeyRequestOptions?username=${encodeURIComponent(email)}`,
    {
      method: 'POST',
      signal,
    });
  const optionsJson = await optionsResponse.json();
  const options = PublicKeyCredential.parseRequestOptionsFromJSON(optionsJson);
  return await navigator.credentials.get({ publicKey: options, mediation, signal });
}
async function requestCredential(email, mediation, headers, signal) {
  // Step 2: Request authentication options from the server
  const optionsResponse = 
    await fetchWithErrorHandling(`/Account/PasskeyRequestOptions?username=${encodeURIComponent(email)}`,
    {
      method: 'POST',
      headers,
      signal,
    });
  const optionsJson = await optionsResponse.json();
  const options = PublicKeyCredential.parseRequestOptionsFromJSON(optionsJson);
  return await navigator.credentials.get({ publicKey: options, mediation, signal });
}

Die MakePasskeyRequestOptionsAsync Methode generiert diese Optionen. Wenn Sie einen bestimmten Benutzer angeben, schließt er nur die Anmeldeinformationen dieses Benutzers in die Zulassungsliste ein. Wenn er ohne Benutzer aufgerufen wird, werden Optionen generiert, die für die bedingte UI oder die Authentifizierung ohne Benutzernamen geeignet sind:

app.MapPost("/Account/PasskeyRequestOptions", async (
    SignInManager<ApplicationUser> signInManager,
    string? username) =>
{
    var user = string.IsNullOrEmpty(username) 
        ? null 
        : await userManager.FindByNameAsync(username);

    var optionsJson = await signInManager.MakePasskeyRequestOptionsAsync(user);

    return TypedResults.Content(optionsJson, contentType: "application/json");
});

Schritt 3: Server generiert Optionen

Der Server generiert Authentifizierungsoptionen mit der gleichen IdentityPasskeyOptions Konfiguration, die während der Registrierung verwendet wird. Die ServerDomain Domäne muss mit der Domäne übereinstimmen, in der der Schlüssel ursprünglich registriert wurde, oder die Authentifizierung schlägt fehl. Die UserVerificationRequirement Bestimmt, ob der Authentifikator die Identität des Benutzers während der Authentifizierung überprüfen muss.

Schritt 4: Anforderung einer Assertion durch den Client

Das clientseitige JavaScript übergibt die Authentifizierungsoptionen an die WebAuthn-API, um eine Assertion vom Authentifikator anzufordern:

async function requestCredential(email, mediation, signal) {
  // Step 4: Parse the options and request an assertion from the authenticator
  const optionsResponse = 
    await fetchWithErrorHandling(`/Account/PasskeyRequestOptions?username=${encodeURIComponent(email)}`,
    {
      method: 'POST',
      signal,
    });
  const optionsJson = await optionsResponse.json();
  const options = PublicKeyCredential.parseRequestOptionsFromJSON(optionsJson);
  return await navigator.credentials.get({ publicKey: options, mediation, signal });
}
async function requestCredential(email, mediation, headers, signal) {
  // Step 4: Parse the options and request an assertion from the authenticator
  const optionsResponse = 
    await fetchWithErrorHandling(`/Account/PasskeyRequestOptions?username=${encodeURIComponent(email)}`,
    {
      method: 'POST',
      headers,
      signal,
    });
  const optionsJson = await optionsResponse.json();
  const options = PublicKeyCredential.parseRequestOptionsFromJSON(optionsJson);
  return await navigator.credentials.get({ publicKey: options, mediation, signal });
}

Der navigator.credentials.get() Aufruf initiiert den Authentifizierungsprozess mit dem Authentifikator, der den Benutzer zur Überprüfung auffordert.

Schritt 5: Authentifizierungsüberprüfung

Der Authentifikator überprüft die Identität des Benutzers und signiert die Abfrage mit dem privaten Schlüssel. Dieser Prozess wird vollständig vom Browser und Authentifikator verarbeitet, ähnlich wie der Überprüfungsschritt bei der Registrierung. Die Benutzererfahrung hängt vom Authentifikatortyp ab und kann eine biometrische Überprüfung oder PIN-Eingabe umfassen.

Schritt 6: Assertionsübermittlung

Nachdem der Authentifikator die signierte Assertion erstellt hat, serialisiert der Browser sie in JSON und sendet sie an den Server:

async function requestCredentialJson(email, mediation, signal) {
  const credential = await requestCredential(email, mediation, signal);
  return JSON.stringify(credential);
}
async function requestCredentialJson(email, mediation, headers, signal) {
  const credential = await requestCredential(email, mediation, headers, signal);
  return JSON.stringify(credential);
}

Der Übermittlungsmechanismus variiert je nach App, umfasst jedoch in der Regel entweder eine Formularübermittlung oder einen API-Aufruf.

Schritt 7: Serverüberprüfung

Der Server überprüft die Assertion, um den Benutzer zu authentifizieren. ASP.NET Core Identity stellt die PasskeySignInAsync Methode bereit, die den vollständigen Authentifizierungsfluss in einem einzigen Aufruf durchführt:

var result = await signInManager.PasskeySignInAsync(credentialJson);

if (result.Succeeded)
{
    return Results.Ok("Authentication successful");
}

return Results.Unauthorized();

Die Methode PasskeySignInAsync ruft intern PerformPasskeyAssertionAsync auf:

  • Überprüfen Sie die Assertionssignatur mithilfe des gespeicherten öffentlichen Schlüssels.
  • Überprüfen Sie, ob die Challenge mit der ursprünglich gesendeten Challenge übereinstimmt.
  • Überprüfen Sie die Authentifikatorkennzeichnungen für die Anwesenheit und Überprüfung des Benutzers.
  • Aktualisieren Sie den Signaturzähler, um Wiederholungsangriffe zu verhindern.

Wenn alle Prüfungen erfolgreich sind, meldet die Methode den Benutzer an und gibt ein SignInResult zurück, das den Erfolg angibt.

Die Methode unterscheidet zwischen einer wiederherstellbaren Benutzeraktion und einem App-Fehler. Wenn der Passkey-Sitzungszustand fehlt oder abgelaufen ist, z. B. weil der Benutzer zu lange gedauert hat, um auf den Authentifikator zu reagieren, gibt die Methode zurück SignInResult.Failed. Wenn Sie die Methode ohne vorherigen Aufruf von MakePasskeyRequestOptionsAsync aufrufen, wird eine InvalidOperationException ausgelöst, da dies auf ein Problem in der App hindeutet und nicht auf etwas, das der Benutzer erneut versuchen kann.

Für Szenarien, die mehr Kontrolle erfordern, können Sie PerformPasskeyAssertionAsync direkt verwenden, um die Assertion zu validieren, ohne den Benutzer sofort anzumelden:

Schritt 8: Sitzungseinrichtung

Bei erfolgreicher Authentifizierung richtet ASP.NET Core Identity eine authentifizierte Sitzung für den Benutzer ein. Die PasskeySignInAsync Methode behandelt dies automatisch, wodurch die erforderlichen Authentifizierungscookies und Ansprüche erstellt werden. Die App leitet den Benutzer dann an geschützte Ressourcen weiter oder zeigt personalisierte Inhalte an.

Abschwächung des PublicKeyCredential.toJSON Fehlers (TypeError: Illegal invocation)

Die PublicKeyCredential.toJSON Methode gibt eine JSON-Darstellung einer PublicKeyCredential. Die Methode wird vom Kennwort-Manager aufgerufen, wenn die App versucht, eine PublicKeyCredential durch Aufrufe JSON.stringify beim Registrieren oder Authentifizieren eines Benutzers zu serialisieren.

Einige Kennwortmanager implementieren die PublicKeyCredential.toJSON Methode nicht ordnungsgemäß, was erforderlich ist, damit JSON.stringify beim Serialisieren von Passkey-Anmeldeinformationen richtig funktioniert. Beim Registrieren oder Authentifizieren eines Benutzers mit einer App basierend auf der Blazor Web App Projektvorlage wird der folgende Fehler von einigen Kennwortmanagern ausgelöst, wenn Sie versuchen, einen Kennungsschlüssel hinzuzufügen:

Error: Could not add a passkey: Illegal invocation

Bis Der ausgewählte Kennwort-Manager aktualisiert wird, um die PublicKeyCredential.toJSON Methode richtig zu implementieren, nehmen Sie die folgenden Änderungen an der App vor. Der folgende Code serialisiert das PublicKeyCredential manuell in JSON.

Suchen Sie in der Components/Account/Shared/PasskeySubmit.razor.js Datei den Codeblock für die passkey-submit benutzerdefinierte Elementdefinition:

customElements.define('passkey-submit', class extends HTMLElement {
  ...
});

Fügen Sie die folgende convertToBase64 Funktion zum Codeblock hinzu:

convertToBase64(o) {
  if (!o) {
    return undefined;
  }

  // Normalize Array to Uint8Array
  if (Array.isArray(o)) {
    o = Uint8Array.from(o);
  }

  // Normalize ArrayBuffer to Uint8Array
  if (o instanceof ArrayBuffer) {
    o = new Uint8Array(o);
  }

  // Convert Uint8Array to base64
  if (o instanceof Uint8Array) {
    let str = '';
    for (let i = 0; i < o.byteLength; i++) {
      str += String.fromCharCode(o[i]);
    }
    o = window.btoa(str);
  }

  if (typeof o !== 'string') {
    throw new Error("Could not convert to base64 string");
  }

  // Convert base64 to base64url
  o = o.replace(/\+/g, "-").replace(/\//g, "_").replace(/=*$/g, "");

  return o;
}

Suchen Sie in der obtainAndSubmitCredential Funktion des Codeblocks die Zeile, die mit den Anmeldeinformationen des Benutzers aufruft JSON.stringify , und entfernen Sie die Zeile:

- const credentialJson = JSON.stringify(credential);

Ersetzen Sie die vorangehende Zeile durch den folgenden Code:

const credentialJson = JSON.stringify({
  authenticatorAttachment: credential.authenticatorAttachment,
  clientExtensionResults: credential.getClientExtensionResults(),
  id: credential.id,
  rawId: this.convertToBase64(credential.rawId),
  response: {
    attestationObject: this.convertToBase64(credential.response.attestationObject),
    authenticatorData: this.convertToBase64(credential.response.authenticatorData ?? 
      credential.response.getAuthenticatorData?.() ?? undefined),
    clientDataJSON: this.convertToBase64(credential.response.clientDataJSON),
    publicKey: this.convertToBase64(credential.response.getPublicKey?.() ?? undefined),
    publicKeyAlgorithm: credential.response.getPublicKeyAlgorithm?.() ?? undefined,
    transports: credential.response.getTransports?.() ?? undefined,
    signature: this.convertToBase64(credential.response.signature),
    userHandle: this.convertToBase64(credential.response.userHandle),
  },
  type: credential.type,
});

Die vorherige Problemumgehung ist nur erforderlich, bis der Kennwort-Manager aktualisiert wird, um die PublicKeyCredential.toJSON Methode ordnungsgemäß zu implementieren. Wir empfehlen, die Versionshinweise Ihres Kennwort-Managers nachzuverfolgen und die vorherigen Änderungen zurückzusetzen, nachdem der Kennwort-Manager aktualisiert wurde.