Włącz klucze dostępu WebAuthn (API uwierzytelniania internetowego)

Hasła zapewniają nowoczesną, odporną na wyłudzanie informacji metodę uwierzytelniania opartą na standardach Web Authentication API (WebAuthn) i FIDO2 . Są one bezpieczną alternatywą dla haseł przy użyciu kryptografii klucza publicznego i uwierzytelniania opartego na urządzeniach. W tym artykule wyjaśniono, jak skonfigurować aplikację ASP.NET Core do używania kluczy dostępu do uwierzytelniania użytkowników.

Po przeczytaniu tego artykułu, aby uzyskać wskazówki dotyczące nowych i istniejących Blazor Web App, zapoznaj się z artykułem Implementacja kluczy dostępu w ASP.NET Core Blazor Web Apps.

Co to są klucze dostępu?

Klucze dostępu są zastępowane hasłami korzystającymi z par kluczy kryptograficznych. Klucz prywatny jest bezpiecznie przechowywany na urządzeniu użytkownika, na przykład w module zabezpieczeń sprzętu, wystawcy uwierzytelniania platformy (na przykład Windows Hello, Touch ID, Face ID) lub menedżera haseł, podczas gdy klucz publiczny jest przechowywany przez aplikację internetową. Podczas uwierzytelniania użytkownik okazuje posiadanie klucza prywatnego bez opuszczania urządzenia.

Najważniejsze korzyści z używania kluczy dostępu obejmują:

  • Odporność na wyłudzanie informacji: klucza dostępu są powiązane z określonymi witrynami internetowymi i nie mogą być używane w fałszywych witrynach.
  • Brak udostępnionych wpisów tajnych: serwer przechowuje tylko klucze publiczne, eliminując ryzyko naruszenia bazy danych haseł.
  • Wygoda użytkownika: Prosta weryfikacja biometryczna lub PIN zastępuje złożone wymagania dotyczące haseł.
  • Synchronizacja między urządzeniami: wielu dostawców kluczy dostępu synchronizuje poświadczenia między urządzeniami użytkownika.

Aby uzyskać więcej informacji, zobacz Internetowy interfejs API uwierzytelniania (dokumentacja MDN).

Klucze dostępu w ASP.NET Core Identity

ASP.NET Core Identity obejmuje wbudowaną obsługę rejestracji i uwierzytelniania klucza dostępu:

  • Bezproblemowa integracja z infrastrukturą Identity .
  • Obsługa uwierzytelniania użytkowników dla najbardziej typowych scenariuszy WebAuthn.
  • Wbudowane w szablon projektu Blazor Web App, więc wymagana jest tylko konfiguracja programisty.

Ważne

Implementacja klucza dostępu w ASP.NET Core Identity jest celowo ograniczona do scenariuszy uwierzytelniania. Nie jest ona przeznaczona jako biblioteka WebAuthn ogólnego przeznaczenia. Deweloperzy wymagający pełnej funkcjonalności WebAuthn powinni rozważyć biblioteki społeczności, które zapewniają kompleksową obsługę protokołów.

Obsługiwane scenariusze

Implementacja klucza dostępu ASP.NET Core Identity obsługuje następujące podstawowe scenariusze:

  • Dodawanie kluczy dostępu do istniejących kont: użytkownicy z kontami opartymi na hasłach mogą rejestrować hasła jako dodatkową metodę uwierzytelniania.
  • Tworzenie konta bez hasła: użytkownicy mogą tworzyć konta bez hasła, rejestrując klucz dostępu podczas tworzenia konta.
  • Logowanie bez hasła: użytkownicy mogą uwierzytelniać się tylko przy użyciu klucza dostępu bez wprowadzania hasła.

Ograniczenia

Bieżąca implementacja ma następujące ograniczenia:

  • Ograniczone do platformy ASP.NET Core Identity: interfejsy API zostały zaprojektowane specjalnie z myślą o scenariuszach uwierzytelniania Identity.
  • Brak domyślnej weryfikacji zaświadczania: implementacja domyślnie nie weryfikuje instrukcji zaświadczania.
  • Obsługa szablonów: tylko szablon Blazor Web App obsługuje klucze dostępu.
  • Brak wbudowanej obsługi uwierzytelniania 2FA: klucze dostępu są traktowane jako podstawowy czynnik uwierzytelniania, a nie jako drugi czynnik.

Podstawowe pojęcia

Dwa podstawowe procesy stanowią podstawę działania kluczy dostępu: poświadczanie i asercja.

Zaświadczanie (rejestracja)

Zaświadczanie to proces tworzenia i rejestrowania nowego klucza dostępu. Podczas zaświadczania serwer generuje unikatowe wyzwanie, które wystawca uwierzytelnienia musi uwzględnić w zwróconym poświadczeniu. Uwierzytelniacz tworzy nową parę kluczy i zwraca klucz publiczny wraz z danymi poświadczenia potwierdzającymi pochodzenie klucza. Następnie serwer weryfikuje to zaświadczanie i przechowuje klucz publiczny na potrzeby przyszłych prób uwierzytelniania.

Asercja (uwierzytelnianie)

Asercja to proces uwierzytelniania przy użyciu istniejącego klucza dostępu. Serwer generuje unikatowe wyzwanie, które wystawca uwierzytelnienia podpisuje przy użyciu klucza prywatnego. Uwierzytelniacz odsyła tę podpisaną asercję do serwera, który weryfikuje podpis przy użyciu wcześniej przechowywanego klucza publicznego. Jeśli podpis jest prawidłowy, użytkownik jest uwierzytelniany.

Wymagania wstępne

  • .NET SDK (.NET 10 lub nowszy)
  • Nowoczesna przeglądarka internetowa, która obsługuje protokół WebAuthn.
  • Urządzenie wyposażone w uwierzytelniacz platformowy, taki jak Windows Hello lub Secure Enclave firmy Apple, albo klucz zabezpieczający.

Zagadnienia dotyczące zabezpieczeń

Podczas implementowania kluczy dostępu w usłudze ASP.NET Core Identityupewnij się, że aplikacja spełnia wymagania dotyczące zabezpieczeń opisane w tej sekcji.

Walidacja nagłówka hosta

Implementacja określa identyfikator Relying Party na podstawie nagłówka Host, gdy ServerDomain nie został jawnie skonfigurowany. Środowisko hostingu musi weryfikować nagłówki hostów, aby zapobiec atakom określania zakresu poświadczeń, które obejmują użycie naruszonych lub skradzionych poświadczeń użytkownika (nazw użytkowników, haseł, tokenów) w celu uzyskania nieautoryzowanego dostępu.

Środek zaradczy: Albo jawnie skonfiguruj ServerDomain w IdentityPasskeyOptions, albo upewnij się, że środowisko hostingu (Kestrel, IIS, odwrotny serwer proxy) weryfikuje nagłówki Host. Aby uzyskać szczegółowe informacje o konfiguracji, zobacz dokumentację platformy hostingu. Oprócz tego, jeśli używasz oprogramowania pośredniczącego Forwarded Headers, jawnie skonfiguruj AllowedHosts.

Zabezpieczenia poddomeny

Implementacja kluczy dostępu w ASP.NET Core obsługuje zabezpieczenia poddomen za pomocą opcji konfiguracji ServerDomain. Jeśli ServerDomain nie zostanie jawnie określony, implementacja używa nagłówka hosta do określenia domeny. Oznacza to, że strona, na której zarejestrowano klucz dostępu, kontroluje domenę dla tego poświadczenia.

Przykład:

  • Jeśli klucz dostępu jest zarejestrowany w systemie app.contoso.com, działa również w systemie *.app.contoso.com.
  • Jeśli jest on zarejestrowany w systemie contoso.com, działa również w systemie *.contoso.com.
  • Przeglądarka wymusza, aby z kluczy dostępu można było korzystać wyłącznie w domenie (i jej subdomenach), w której zostały zarejestrowane.

Wymaganie: Aplikacje wymagające ścisłej kontroli domeny powinny jawnie ustawić ServerDomain , a nie polegać na nagłówku hosta. Nie należy serwować niezaufanych treści w żadnej poddomenie objętej zakresem ServerDomain. Jeśli nie możesz tego zagwarantować, zaimplementuj niestandardową walidację pochodzenia , aby ograniczyć użycie klucza dostępu do określonych źródeł.

Wymaganie protokołu HTTPS

Wszystkie operacje klucza dostępu wymagają protokołu HTTPS. Implementacja przechowuje dane uwierzytelniania w zaszyfrowanych i podpisanych plikach cookie, które mogą być przechwytywane za pośrednictwem nieszyfrowanych połączeń.

Wymaganie: Zawsze używaj protokołu HTTPS w środowisku produkcyjnym. Skonfiguruj protokół HTTP Strict Transport Security (HSTS), aby zapobiec atakom polegającym na obniżeniu wersji protokołu.

Odzyskiwanie konta

Odzyskiwanie konta jest przede wszystkim problemem dla aplikacji, które zezwalają na używanie kluczy dostępu jako jedyny mechanizm uwierzytelniania. Domyślny Blazor Web App szablon projektu wymaga już od użytkowników skonfigurowania metody uwierzytelniania kopii zapasowej (hasła lub dostawcy zewnętrznego) podczas tworzenia konta, więc odzyskiwanie konta jest obsługiwane za pomocą tych istniejących mechanizmów.

Zalecenia:

W przypadku aplikacji wdrażających uwierzytelnianie tylko za pomocą klucza dostępu należy wziąć pod uwagę następujące kwestie:

  • Kody odzyskiwania generowane podczas tworzenia konta.
  • Procesy odzyskiwania konta za pomocą wiadomości e-mail.
  • Obowiązkowa rejestracja wielu kluczy dostępu.
  • Monitorowanie flagi IsBackedUp w UserPasskeyInfo, aby wyświetlić użytkownikom monit o dodanie dodatkowych poświadczeń.

Mechanizmy kontroli administracyjnej

Po wykryciu luki w zabezpieczeniach modelu wystawcy uwierzytelniania może być konieczne odwołanie poświadczeń, których dotyczy problem. Implementacja przechowuje kompletny obiekt atestacji dla każdego poświadczenia, w tym identyfikator GUID atestacji uwierzytelniającego (AAGUID), który jest 128-bitowym identyfikatorem wskazującym na typ klucza.

Implementacja: wyodrębnianie identyfikatorów AAGUID z przechowywanych obiektów zaświadczania, porównywanie ze znanymi modelami, których bezpieczeństwo zostało naruszone, i odwoływanie poświadczeń, których dotyczy problem. Wiarygodność identyfikatora AAGUID zależy od tego, czy aplikacja weryfikuje oświadczenia poświadczające. Aby podłączyć się do niestandardowej logiki weryfikacji instrukcji zaświadczania, zobacz Niestandardowe sprawdzanie poprawności instrukcji zaświadczania. Dostępne są biblioteki innych firm do weryfikacji atestacji, na przykład Passkeys - FIDO2 .NET Library (WebAuthn) (passwordless-lib/fido2-net-lib repozytorium GitHub)†.

Ostrzeżenie

† Biblioteki innych firm, w tym passwordless-lib/fido2-net-lib, nie są własnością ani nie są obsługiwane przez firmę Microsoft i nie są objęte żadną umową pomocy technicznej ani licencją firmy Microsoft. Należy zachować ostrożność podczas wdrażania biblioteki innej firmy, szczególnie w przypadku funkcji zabezpieczeń. Upewnij się, że biblioteka jest zgodna ze specyfikacjami oficjalnymi i przyjmuje najlepsze rozwiązania w zakresie zabezpieczeń. Zachowaj bieżącą wersję biblioteki, aby uzyskać najnowsze poprawki błędów.

Limity zasobów

Aby zapobiec atakom na wyczerpanie bazy danych, aplikacje powinny wymuszać limity rejestracji klucza dostępu, takie jak:

  • Maksymalna liczba kluczy dostępu na konto użytkownika.
  • Maksymalna długość wyświetlanych nazw kluczy dostępu.

Szablon Blazor Web App wymusza te limity domyślnie na poziomie aplikacji. Przykłady można znaleźć w następujących komponentach Razor w szablonie projektu Blazor Web App:

Uwaga / Notatka

Linki dokumentacyjne do źródła referencyjnego .NET zwykle ładują domyślną gałąź repozytorium, która odzwierciedla obecne prace rozwojowe nad nadchodzącą wersją .NET. Aby wybrać tag dla określonej wersji, użyj listy rozwijanej Przełącz gałęzie lub tagi.

Konfigurowanie opcji klucza dostępu

ASP.NET Core Identity udostępnia różne opcje konfigurowania zachowania klucza dostępu za pośrednictwem IdentityPasskeyOptions klasy, w tym:

  • AuthenticatorTimeout: pobiera lub ustawia czas, przez jaki przeglądarka powinna czekać, aż uwierzytelniacz udostępni klucz dostępu w postaci TimeSpan. Ta opcja dotyczy zarówno tworzenia nowego klucza dostępu, jak i żądania istniejącego klucza dostępu. Ta opcja jest traktowana jako wskazówka dla przeglądarki, a przeglądarka może zignorować tę opcję. Wartość domyślna to 5 minut.
  • ChallengeSize: pobiera lub ustawia rozmiar wyzwania w bajtach wysyłanych do klienta podczas zaświadczania i asercji. Ta opcja dotyczy zarówno tworzenia nowego klucza dostępu, jak i żądania istniejącego klucza dostępu. Wartość domyślna to 32 bajty.
  • ServerDomain: Pobiera lub ustawia efektywny identyfikator Relying Party (domenę) serwera. Powinno to być unikatowe i będzie używane jako tożsamość serwera. Ta opcja dotyczy zarówno tworzenia nowego klucza dostępu, jak i żądania istniejącego klucza dostępu. Jeśli użyto wartości null, co jest wartością domyślną, używany jest origin serwera. Aby uzyskać więcej informacji, zobacz Identyfikator strony ufającej (RP ID).

Przykładowa konfiguracja:

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

Aby uzyskać pełną listę opcji konfiguracji, zobacz IdentityPasskeyOptions. Aby uzyskać najbardziej aktualne domyślne ustawienia przeglądarki, zobacz specyfikację W3C WebAuthn.

Uwaga / Notatka

Linki w dokumentacji do źródła referencyjnego platformy .NET zwykle prowadzą do domyślnej gałęzi repozytorium, która odzwierciedla bieżący stan rozwoju na potrzeby kolejnej wersji zapoznawczej platformy .NET. Aby wybrać tag dla określonej wersji, użyj listy rozwijanej Przełącz gałęzie lub tagi.

Walidacja niestandardowej instrukcji zaświadczania

Domyślnie ASP.NET Core Identity nie weryfikuje oświadczeń atestacyjnych. Jest to odpowiednie w przypadku większości scenariuszy uwierzytelniania użytkowników. Jeśli aplikacja wymaga weryfikacji właściwości wystawcy uwierzytelniania lub chcesz uniemożliwić użycie określonych wystawców uwierzytelnienia, na przykład w środowiskach przedsiębiorstwa, które wymagają wyższego poziomu zabezpieczeń, możesz zaimplementować niestandardową weryfikację zaświadczania:

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;
    };
});

Ostrzeżenie

Walidacja poświadczania jest złożona i wymaga utrzymywania repozytoriów zaufanych certyfikatów dla certyfikatów uwierzytelniacza. Zaimplementuj walidację niestandardową tylko wtedy, gdy aplikacja wymaga weryfikacji określonych właściwości wystawcy uwierzytelnienia.

Niestandardowa walidacja źródła

Domyślna walidacja źródła umożliwia żądania z poddomen i nie zezwala na elementy iframe między źródłami. Aby dostosować to zachowanie:

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;
    };
});

Dostosowywanie procedury obsługi klucza dostępu

IPasskeyHandler<TUser> to usługa, która generuje opcje kluczy dostępu i przeprowadza zaświadczanie oraz asercję. ASP.NET Core Identity rejestruje PasskeyHandler<TUser> jako implementację domyślną, a SignInManager<TUser> odwołuje się do niej. Interfejs ma cztery metody:

  • MakeCreationOptionsAsync: generuje opcje tworzenia i stan zaświadczania na potrzeby rejestrowania klucza dostępu.
  • MakeRequestOptionsAsync: generuje opcje żądania i stan asercji na potrzeby uwierzytelniania przy użyciu istniejącego klucza dostępu.
  • PerformAttestationAsync: weryfikuje poświadczenia zwracane przez przeglądarkę podczas rejestracji.
  • PerformAssertionAsync: weryfikuje poświadczenia zwracane przez przeglądarkę podczas uwierzytelniania.

Większość aplikacji powinna korzystać z metod SignInManager<TUser> przedstawionych w sekcjach Przepływ rejestracji i Przepływ uwierzytelniania, zamiast wywoływać bezpośrednio program obsługi. Metody te zarządzają stanem tymczasowym wymaganym przez dwuetapowe procesy rejestracji i uwierzytelniania oraz chronią ten stan na potrzeby aplikacji.

Kiedy należy zaimplementować IPasskeyHandler<TUser>

W przypadku większości dostosowań skorzystaj z IdentityPasskeyOptions wywołań zwrotnych opisanych w sekcjach Niestandardowa walidacja oświadczenia poświadczającego i Niestandardowa walidacja źródła. Zaimplementuj IPasskeyHandler<TUser> tylko w scenariuszach, których opcje nie mogą wyrazić, na przykład:

  • Różne opcje klucza dostępu dla każdego żądania lub dla każdej dzierżawy.
  • Rozpoznawanie użytkowników ze źródła innego niż UserManager<TUser>.
  • Dodawanie testów uruchamianych przed lub po wbudowanej weryfikacji webAuthn.

Zaimplementowanie interfejsu od podstaw oznacza ponowne wdrożenie kroków weryfikacji webAuthn, co jest podatne na błędy. Jeśli to możliwe, zaimplementuj interfejs jako opakowanie, które deleguje wywołania do wewnętrznej instancji PasskeyHandler<TUser> i dodaje tylko wymagane zachowanie.

Ostrzeżenie

Aplikacja, która wywołuje IPasskeyHandler<TUser> bezpośrednio, a nie za pośrednictwem SignInManager<TUser>, staje się odpowiedzialna za bezpieczne przechowywanie stanu poświadczenia. Aplikacja, która nie może to zrobić, umożliwia osobie atakującej zarejestrowanie klucza dostępu na koncie, które nie jest jego właścicielem.

Stan zaświadczania

Rejestrowanie klucza dostępu obejmuje dwa żądania. Pierwsze żądanie uzyskuje opcje tworzenia, a drugie żądanie przesyła nowe poświadczenia. Stan zaświadczania to informacje, które serwer zapamiętuje między dwoma żądaniami.

MakeCreationOptionsAsync zwraca element PasskeyCreationOptionsResult z dwiema częściami:

Stan tworzony przez domyślny program obsługi zawiera wyzwanie oraz element PasskeyUserEntity, który identyfikuje konto, dla którego zarejestrowano klucz dostępu. Stan jest serializowany jako JSON bez podpisu lub szyfrowania, więc nie zapewnia żadnej ochrony integralności.

Stan to jedyne miejsce, które rejestruje konto. Odpowiedź poświadczenia z przeglądarki zawiera nowy klucz publiczny i podpisane wyzwanie, ale nic, co identyfikuje użytkownika, dlatego PerformAttestationAsync podaje użytkownika pobranego ze stanu w UserEntity. Jeśli stan zostanie zmodyfikowany przed przesłaniem poświadczenia, klucz dostępu zostanie zarejestrowany dla konta wskazanego przez zmodyfikowany stan.

Weryfikowanie integralności i własności

Aplikacja, która zarządza stanem zaświadczania, musi spełniać następujące trzy wymagania.

Integralność: klient nie może modyfikować stanu. Nie umieszczaj stanu w ukrytym polu formularza, treści żądania ani niechronionej pamięci przeglądarki. Osoba atakująca, która zmienia identyfikator użytkownika w parametrze state, pomyślnie przechodzi proces rejestracji, a jej uwierzytelniacz zostaje zapisany na koncie wskazanym przez zmodyfikowany parametr state, co daje jej możliwość zalogowania się na to konto. Zachowaj stan na serwerze lub chroń go za pomocą interfejsów API ochrony danych ASP.NET Core przed wysłaniem go do przeglądarki.

Przynależność: stan musi być powiązany z sesją, która zażądała opcji utworzenia, a to powiązanie musi zostać sprawdzone w momencie przesłania poświadczenia. Porównaj UserEntity z aktualnie zalogowanym użytkownikiem przed zapisaniem klucza dostępu. Moduł obsługi nie wykonuje tego sprawdzenia, ponieważ nie ma oddzielnego rekordu użytkownika, z którym mógłby go porównać.

Pojedyncze użycie i wygaśnięcie: odrzuć stan po jego przeczytaniu i nadaj mu krótki okres istnienia. Można odtworzyć stan, który pozostaje prawidłowy.

Dla odniesienia, SignInManager<TUser> spełnia te wymagania w następujący sposób:

  • Przechowywanie stanu w mechanizmie uwierzytelniania cookie, chronionym przez interfejsy API ochrony danych, tak aby przeglądarka nie mogła go odczytać ani zmodyfikować.
  • Wylogowywanie stanu natychmiast po jego odczytaniu, co ogranicza stan do pojedynczego użycia.
  • Rejestrowanie, czy stan został utworzony na potrzeby poświadczenia czy asercji, oraz odrzucanie przypadków niezgodności.

Przykład rejestracji

Poniższy przykład bezpośrednio wywołuje IPasskeyHandler<TUser> i przechowuje stan poświadczenia w elemencie cookie chronionym przez mechanizmy ochrony danych. Oba punkty końcowe wymagają uwierzytelnionego użytkownika, ponieważ klucz dostępu jest dodawany do zalogowanego konta:

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();

Poprzedni kod:

  • Chroni stan zaświadczania za pomocą interfejsów API ochrony danych przed dotarciem stanu do przeglądarki, aby klient nie mógł go odczytać ani zmodyfikować.
  • cookie Ogranicza okres istnienia do pięciu minut, co ogranicza czas otwarcia rejestracji.

Po nadejściu poświadczeń aplikacja przywraca stan, sprawdza, czy zaświadczenie należy do zalogowanego użytkownika, a następnie przechowuje klucz dostępu:

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();

Poprzedni kod:

  • Usuwa stan cookie, zanim zostanie użyty, dzięki czemu nadaje się on do pojedynczej rejestracji.
  • Odrzuca żądanie, gdy nie można wyłączyć ochrony stanu, co ma miejsce, gdy wartość została naruszona lub była chroniona za pomocą innego klucza.
  • Potwierdza, że wynik poświadczenia wskazuje zalogowanego użytkownika przed zapisaniem klucza dostępu. Moduł obsługi pobiera konto ze stanu atestacji, więc to sprawdzenie uniemożliwia przypisanie klucza dostępu do innego konta.

Typ PasskeyRegistrationRequest zawiera serializowane poświadczenie z przeglądarki:

public record PasskeyRegistrationRequest(string CredentialJson);

Zarejestruj niestandardową procedurę obsługi

AddSignInManager rejestruje domyślny program obsługi w AddScoped, a nie w TryAddScoped, więc niestandardowy program obsługi musi zostać zarejestrowany po usługach Identity, aby to on był implementacją, która zostanie rozpoznana:

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

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

Przepływ rejestracji

W tej sekcji opisano każdy krok procesu rejestracji klucza dostępu, wyjaśniając, jak ASP.NET Core Identity ułatwia tworzenie i przechowywanie poświadczeń klucza dostępu.

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

Krok 1. Inicjowanie rejestracji

Proces rejestracji rozpoczyna się, gdy użytkownik zdecyduje się dodać klucz dostępu do swojego konta. Zwykle odbywa się to za pośrednictwem przycisku lub linku w interfejsie użytkownika aplikacji. Po wybraniu tego elementu ten element wyzwala kod JavaScript w celu organizowania przepływu rejestracji.

Implementacja po stronie klienta różni się znacznie między aplikacjami. W szablonie Blazor Web App znajdziesz kompletny przykład w pliku PasskeySubmit.razor.js, który pokazuje, jak niestandardowy komponent internetowy obsługuje inicjowanie rejestracji i zarządza następującymi po niej wywołaniami interfejsu API WebAuthn.

Krok 2. Żądanie opcji tworzenia

Po zainicjowaniu rejestracji przeglądarka musi uzyskać opcje tworzenia z serwera. Te opcje informują przeglądarkę, jaki rodzaj poświadczenia należy utworzyć, i obejmują ważne parametry bezpieczeństwa, takie jak wyzwanie, które musi zostać podpisane.

Z perspektywy przeglądarki ten krok obejmuje wysyłanie żądania HTTP do serwera:

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 });
}

Aplikacja powinna zdefiniować punkt końcowy, który generuje następujące opcje:

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");
});

Metoda MakePasskeyCreationOptionsAsync ma kluczowe znaczenie w tym procesie. Metoda akceptuje element opisujący PasskeyUserEntity użytkownika, dla którego jest tworzony klucz dostępu. Ta jednostka zawiera identyfikator użytkownika, nazwę użytkownika (zazwyczaj adres e-mail) oraz czytelną dla człowieka nazwę wyświetlaną. Metoda zwraca ciąg JSON zgodny ze schematem WebAuthn PublicKeyCredentialCreationOptions , którego przeglądarka używa w następnym kroku. W tle ta metoda przechowuje również stan tymczasowy w uwierzytelnianiu cookie , aby upewnić się, że odpowiedź z przeglądarki odpowiada tym konkretnym opcjom. Aplikacje, które zarządzają tym stanem, muszą je chronić zgodnie z opisem w sekcji Dostosowywanie procedury obsługi kluczy dostępu .

Krok 3. Serwer generuje opcje

Gdy wykonywana jest operacja MakePasskeyCreationOptionsAsync, używa ona konfiguracji IdentityPasskeyOptions aplikacji do określenia konkretnych parametrów tworzenia poświadczeń. Te opcje kontrolują różne aspekty procesu tworzenia klucza dostępu.

Te opcje można dostosować podczas uruchamiania aplikacji. Przykład:

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

Opcja UserVerificationRequirement określa, czy wystawca uwierzytelnienia musi zweryfikować tożsamość użytkownika (za pomocą metod biometrycznych lub PIN), a jednocześnie ResidentKeyRequirement wskazuje, czy poświadczenie powinno być wykrywalne, zezwalając na uwierzytelnianie bez uprzedniego podania nazwy użytkownika. Aby uzyskać więcej informacji, zobacz IdentityPasskeyOptions.

Krok 4: Klient żąda danych uwierzytelniających

Po udostępnieniu opcji tworzenia język JavaScript po stronie klienta przekazuje opcje do interfejsu API WebAuthn w celu utworzenia nowego poświadczenia:

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 });
}

Funkcja parseCreationOptionsFromJSON konwertuje odpowiedź JSON na format oczekiwany przez interfejs API WebAuthn i navigator.credentials.create() inicjuje proces tworzenia poświadczeń za pomocą wystawcy uwierzytelnienia.

Krok 5. Interakcja aplikacji Authenticator

Na tym etapie przeglądarka komunikuje się z uwierzytelniaczem w celu utworzenia poświadczenia. Wystawca uwierzytelnienia monituje użytkownika o weryfikację, co może obejmować skanowanie odcisku palca, wprowadzenie numeru PIN lub użycie rozpoznawania twarzy. Ta interakcja odbywa się całkowicie po stronie przeglądarki i uwierzytelniacza, bez konieczności użycia kodu aplikacji. Środowisko użytkownika różni się w zależności od typu wystawcy uwierzytelnienia i możliwości platformy.

Krok 6. Przesyłanie poświadczeń

Po utworzeniu poświadczenia przez wystawcę uwierzytelniania przeglądarka musi wysłać poświadczenie z powrotem do serwera w celu weryfikacji i przechowywania. Przed przesłaniem poświadczenie musi być serializowane do formatu JSON:

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);
}

W szablonie Blazor Web App zwrócone poświadczenie jest automatycznie serializowane i przesyłane za pośrednictwem formularza, ale dokładny sposób przesyłania różni się w zależności od aplikacji.

Krok 7: Weryfikacja serwera i przechowywanie

Gdy serwer otrzyma poświadczenie, musi zweryfikować jego ważność i zapisać klucz publiczny na potrzeby przyszłego uwierzytelniania. To tutaj kluczowe stają się interfejsy API kluczy dostępu w ASP.NET Core Identity.

Metoda PerformPasskeyAttestationAsync weryfikuje odpowiedź poświadczenia przesłaną przez klienta. Ten kompleksowy proces weryfikacji:

  • Sprawdza, czy typ poświadczeń jest zgodny z oczekiwaniami.
  • Weryfikuje dane klienta w formacie JSON, w tym źródło i wyzwanie.
  • Sprawdza flagi danych uwierzytelniacza pod kątem obecności użytkownika i jego weryfikacji
  • Wyodrębnia i weryfikuje klucz publiczny.

Jeśli wszystkie kontrole zakończą się pomyślnie, metoda zwraca PasskeyAttestationResult zawierający zweryfikowane informacje o kluczu uwierzytelniającym.

Gdy poświadczenie zostanie zweryfikowane, aplikacja używa AddOrUpdatePasskeyAsync, aby przechowywać klucz dostępu w bazie danych:

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");
}

Przechowywany UserPasskeyInfo zawiera wszystkie niezbędne informacje potrzebne do przyszłego uwierzytelniania, w tym identyfikator poświadczenia, klucz publiczny, licznik podpisów do ochrony przed atakami powtórzeniowymi oraz flagi wskazujące, czy klucz dostępu ma kopię zapasową lub czy kwalifikuje się do utworzenia kopii zapasowej.

Krok 8. Zadania po rejestracji

Po pomyślnym zarejestrowaniu klucza dostępu aplikacje często wykonują dodatkowe zadania w celu ulepszenia środowiska użytkownika. Typowym wzorcem jest monitowanie użytkowników o podanie przyjaznej nazwy dla swojego klucza dostępu, co ułatwia identyfikowanie wielu poświadczeń. Właściwość UserPasskeyInfo.Name przechowuje tę przyjazną nazwę, którą można zaktualizować przy użyciu tej samej AddOrUpdatePasskeyAsync metody:

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

Przepływ uwierzytelniania

W tej sekcji wyjaśniono, jak użytkownicy uwierzytelniają się przy użyciu swoich kluczy dostępu, od inicjowania procesu logowania w celu ustanowienia uwierzytelnionej sesji.

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

Krok 1. Inicjowanie uwierzytelniania

Użytkownicy zazwyczaj inicjują uwierzytelnianie za pomocą dedykowanego przycisku lub linku na stronie logowania. Niektóre aplikacje obsługują również warunkowy interfejs użytkownika, w którym klucze dostępu pojawiają się jako sugestie autouzupełniania w polu nazwy użytkownika. Metoda inicjowania wyzwala kod JavaScript, który zarządza przepływem uwierzytelniania, podobnie jak w procesie rejestracji.

Krok 2. Żądanie opcji uwierzytelniania

Przeglądarka żąda opcji uwierzytelniania z serwera, aby rozpocząć proces uwierzytelniania. Te opcje obejmują listę dopuszczalnych poświadczeń i nowe wyzwanie do podpisania:

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 });
}

Metoda MakePasskeyRequestOptionsAsync generuje te opcje. W przypadku podania określonego użytkownika na liście dozwolonych uwzględniane są tylko poświadczenia tego użytkownika. Po wywołaniu bez użytkownika generuje opcje odpowiednie dla warunkowego interfejsu użytkownika lub uwierzytelniania bez nazwy użytkownika:

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");
});

Krok 3. Serwer generuje opcje

Serwer generuje opcje uwierzytelniania przy użyciu tej samej IdentityPasskeyOptions konfiguracji używanej podczas rejestracji. Musi być zgodna ServerDomain z domeną, w której klucz dostępu został pierwotnie zarejestrowany, lub uwierzytelnianie kończy się niepowodzeniem. UserVerificationRequirement określa, czy moduł uwierzytelniający musi zweryfikować tożsamość użytkownika podczas uwierzytelniania.

Krok 4. Aseracja żądań klientów

Język JavaScript po stronie klienta przekazuje opcje uwierzytelniania do interfejsu API WebAuthn w celu żądania potwierdzenia od wystawcy uwierzytelnienia:

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 });
}

Wywołanie navigator.credentials.get() inicjuje proces uwierzytelniania za pomocą wystawcy uwierzytelnienia, który monituje użytkownika o weryfikację.

Krok 5: Weryfikacja uwierzytelniacza

Uwierzytelniacz weryfikuje tożsamość użytkownika i podpisuje żądanie przy użyciu klucza prywatnego. Proces ten jest obsługiwany w całości przez przeglądarkę i uwierzytelniacz, podobnie jak etap weryfikacji podczas rejestracji. Środowisko użytkownika zależy od typu wystawcy uwierzytelnienia i może obejmować weryfikację biometryczną lub wpis numeru PIN.

Krok 6. Przesyłanie asercji

Po utworzeniu podpisanej asercji przez uwierzytelniacz przeglądarka serializuje ją do formatu JSON i przesyła do serwera:

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);
}

Mechanizm przesyłania różni się w zależności od aplikacji, ale zazwyczaj obejmuje przesyłanie formularza lub wywołanie interfejsu API.

Krok 7. Weryfikacja serwera

Serwer weryfikuje asercji w celu uwierzytelnienia użytkownika. ASP.NET Core Identity udostępnia metodę PasskeySignInAsync , która wykonuje pełny przepływ uwierzytelniania w jednym wywołaniu:

var result = await signInManager.PasskeySignInAsync(credentialJson);

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

return Results.Unauthorized();

Metoda PasskeySignInAsync wywołuje wewnętrznie PerformPasskeyAssertionAsync, aby:

  • Zweryfikuj podpis asercji przy użyciu przechowywanego klucza publicznego.
  • Sprawdź, czy wyzwanie jest zgodne z tym, które zostało pierwotnie wysłane.
  • Sprawdź flagi autentykatora pod kątem obecności użytkownika i jego weryfikacji.
  • Zaktualizuj licznik podpisów, aby zapobiec atakom powtórzeniowym.

Jeśli wszystkie sprawdzenia zakończą się pomyślnie, metoda loguje użytkownika i zwraca SignInResult, wskazując powodzenie.

Metoda rozróżnia akcję użytkownika możliwego do odzyskania i błąd aplikacji. Jeśli brakuje stanu sesji dla klucza dostępu lub stan ten wygasł, na przykład ponieważ użytkownik zbyt długo zwlekał z odpowiedzią do uwierzytelniacza, metoda zwraca SignInResult.Failed. Wywołanie metody bez wcześniejszego wywołania MakePasskeyRequestOptionsAsync zgłasza InvalidOperationException, ponieważ wskazuje to na problem w aplikacji, a nie na coś, czego użytkownik może spróbować ponownie.

W przypadku scenariuszy wymagających większej kontroli można użyć PerformPasskeyAssertionAsync bezpośrednio do zweryfikowania potwierdzenia bez natychmiastowego zalogowania się użytkownika:

Krok 8. Ustanowienie sesji

Po pomyślnym uwierzytelnieniu ASP.NET Core Identity ustanawia uwierzytelnianą sesję dla użytkownika. Metoda PasskeySignInAsync obsługuje to automatycznie, tworząc niezbędne pliki cookie i oświadczenia uwierzytelniania. Następnie aplikacja przekierowuje użytkownika do chronionych zasobów lub wyświetla spersonalizowaną zawartość.

Łagodzenie PublicKeyCredential.toJSON błędu (TypeError: Illegal invocation)

MetodaPublicKeyCredential.toJSON zwraca reprezentację JSON obiektu PublicKeyCredential. Metoda jest wywoływana przez menedżera haseł, gdy aplikacja próbuje zserializować PublicKeyCredential przez wywołanie JSON.stringify podczas rejestrowania lub uwierzytelniania użytkownika.

Niektóre menedżery haseł nie implementują poprawnie metody PublicKeyCredential.toJSON, która jest wymagana do prawidłowego działania JSON.stringify podczas serializacji poświadczeń klucza dostępu. Podczas rejestrowania lub uwierzytelniania użytkownika za pomocą aplikacji na Blazor Web App podstawie szablonu projektu podczas próby dodania klucza dostępu zgłaszany jest następujący błąd przez niektórych menedżerów haseł:

Error: Could not add a passkey: Illegal invocation

Dopóki twój wybrany menedżer haseł nie zostanie zaktualizowany do poprawnego zaimplementowania metody PublicKeyCredential.toJSON, wprowadź następujące zmiany w aplikacji. Poniższy kod ręcznie serializuje PublicKeyCredential do formatu JSON.

Components/Account/Shared/PasskeySubmit.razor.js W pliku znajdź blok kodu definicji elementu niestandardowegopasskey-submit:

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

Dodaj następującą convertToBase64 funkcję do bloku kodu:

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;
}

obtainAndSubmitCredential W funkcji bloku kodu znajdź wiersz wywołujący JSON.stringify poświadczenie użytkownika i usuń wiersz:

- const credentialJson = JSON.stringify(credential);

Zastąp poprzedni wiersz następującym kodem:

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,
});

Poprzednie obejście jest wymagane tylko do czasu aktualizacji menedżera haseł, aby poprawnie wdrożyć metodę PublicKeyCredential.toJSON. Zalecamy śledzenie informacji o wersji menedżera haseł i przywrócenie wcześniejszych zmian po zaktualizowaniu menedżera haseł.