Consenti l'accesso all'utente con Gestore credenziali

Gestore delle credenziali è un'API Jetpack che supporta più metodi di accesso, come nome utente e password, passkey e soluzioni di accesso federato (come Accedi con Google) in un'unica API, semplificando così l'integrazione per gli sviluppatori.

Inoltre, per gli utenti, Credential Manager unifica l'interfaccia di accesso per i metodi di autenticazione, rendendo più chiaro e semplice l'accesso alle app, indipendentemente dal metodo scelto.

Questa pagina spiega il concetto di passkey e i passaggi per implementare il supporto lato client per le soluzioni di autenticazione, incluse le passkey, utilizzando l'API Credential Manager. Esiste anche una pagina delle domande frequenti separata che fornisce risposte a domande più dettagliate e specifiche.

Informazioni sulle passkey

Le passkey sono un'alternativa più sicura e semplice rispetto alle password. Con le passkey, gli utenti possono accedere ad app e siti web utilizzando un sensore biometrico (ad esempio un sistema di riconoscimento delle impronte o del volto), un PIN o una sequenza. In questo modo, l'esperienza di accesso è fluida e gli utenti non devono ricordare nomi utente o password.

Le passkey si basano su WebAuthn (Web Authentication), uno standard sviluppato congiuntamente da FIDO Alliance e dal World Wide Web Consortium (W3C). WebAuthn utilizza la crittografia con chiave pubblica per autenticare l'utente. Il sito web o l'app a cui l'utente sta accedendo può visualizzare e archiviare la chiave pubblica, ma mai la chiave privata. La chiave privata viene mantenuta segreta e al sicuro. Poiché la chiave è univoca e collegata al sito web o all'app, le passkey non sono soggette a phishing, il che aumenta ulteriormente la sicurezza.

Gestore delle credenziali consente agli utenti di creare passkey e memorizzarle in Gestore delle password di Google.

Leggi Autenticazione utente con passkey per indicazioni su come implementare flussi di autenticazione con passkey senza problemi con Credential Manager.

Prerequisiti

Per utilizzare Credential Manager, completa i passaggi descritti in questa sezione.

Utilizzare una versione recente della piattaforma

Gestore delle credenziali è supportato su Android 4.4 (livello API 19) e versioni successive.

Aggiungere dipendenze alla tua app

Aggiungi le seguenti dipendenze allo script di build del modulo dell'app:

implementation(libs.androidx.credentials)

// optional - needed for credentials support from play services, for devices running
// Android 13 and below.
implementation(libs.androidx.credentials.play.services.auth)
build.gradle.kts

Scopri di più su come ridurre, offuscare e ottimizzare l'app.

Aggiunta del supporto per Digital Asset Links

Per attivare il supporto delle passkey per la tua app per Android, associa l'app a un sito web di tua proprietà. Per dichiarare questa associazione, segui i passaggi riportati di seguito:

  1. Crea un file JSON Digital Asset Links. Ad esempio, per dichiarare che il sito web https://signin.example.com e un'app per Android con il nome del pacchetto com.example possono condividere le credenziali di accesso, crea un file denominato assetlinks.json con il seguente contenuto:

    [
  {
    "relation" : [
      "delegate_permission/common.handle_all_urls",
      "delegate_permission/common.get_login_creds"
    ],
    "target" : {
      "namespace" : "android_app",
      "package_name" : "com.example.android",
      "sha256_cert_fingerprints" : [
        SHA_HEX_VALUE
      ]
    }
  }
]
    assetlinks.json

    Il campo relation è un array di una o più stringhe che descrivono la relazione dichiarata. Per dichiarare che app e siti condividono le credenziali di accesso, specifica le relazioni come delegate_permission/handle_all_urls e delegate_permission/common.get_login_creds.

    Il campo target è un oggetto che specifica la risorsa a cui si applica la dichiarazione. I seguenti campi identificano un sito web:

    namespace web
    site

    L'URL del sito web, nel formato https://domain[:optional_port]; ad esempio, https://www.example.com.

    domain deve essere completo e optional_port deve essere omesso quando si utilizza la porta 443 per HTTPS.

    Una destinazione site può essere solo un dominio principale: non puoi limitare l'associazione di un'app a una sottodirectory specifica. Non includere un percorso nell'URL, ad esempio una barra finale.

    I sottodomini non sono considerati corrispondenze, ovvero se specifichi domain come www.example.com, il dominio www.counter.example.com non è associato alla tua app.

    I seguenti campi identificano un'app per Android:

    namespace android_app
    package_name Il nome del pacchetto dichiarato nel manifest dell'app. Ad esempio, com.example.android
    sha256_cert_fingerprints Le impronte SHA256 del certificato di firma della tua app.

  2. Ospita il file JSON Digital Asset Links nel seguente percorso del dominio di accesso:

    https://domain[:optional_port]/.well-known/assetlinks.json

    Ad esempio, se il dominio di accesso è signin.example.com, ospita il file JSON all'indirizzo https://signin.example.com/.well-known/assetlinks.json.

    Il tipo MIME per il file Digital Assets Link deve essere JSON. Verifica che il server invii un'intestazione Content-Type: application/json nella risposta.

  3. Verifica che il tuo host consenta a Google di recuperare il file Digital Asset Links. Se hai un file robots.txt, deve consentire all'agente Googlebot di recuperare /.well-known/assetlinks.json. La maggior parte dei siti può consentire a qualsiasi agente automatizzato di recuperare i file nel percorso /.well-known/ in modo che altri servizi possano accedere ai metadati in questi file:

    User-agent: *
Allow: /.well-known/

  4. Aggiungi la seguente riga al file manifest in <application>:

    <meta-data android:name="asset_statements" android:resource="@string/asset_statements" />

  5. Se utilizzi l'accesso con password tramite Credential Manager, segui questo passaggio per configurare il collegamento degli asset digitali nel manifest. Questo passaggio non è obbligatorio se utilizzi solo passkey.

    Dichiara l'associazione nell'app per Android. Aggiungi un oggetto che specifichi i file assetlinks.jsonda caricare. Devi eseguire l'escape di tutti gli apostrofi e virgolette che utilizzi nella stringa. Ad esempio:

    <string name="asset_statements" translatable="false">
[{
  \"include\": \"https://signin.example.com/.well-known/assetlinks.json\"
}]
</string>

    > GET /.well-known/assetlinks.json HTTP/1.1
> User-Agent: curl/7.35.0
> Host: signin.example.com

< HTTP/1.1 200 OK
< Content-Type: application/json

Configurare Credential Manager

Per configurare e inizializzare un oggetto CredentialManager, aggiungi una logica simile a quella riportata di seguito:

// Use your app or activity context to instantiate a client instance of
// CredentialManager.
private val credentialManager = CredentialManager.create(context)
PasskeyAndPasswordFunctions.kt

Indicare i campi delle credenziali

Su Android 14 e versioni successive, l'attributo isCredential può essere utilizzato per indicare i campi delle credenziali, ad esempio i campi del nome utente o della password. Questo attributo indica che questa visualizzazione è un campo delle credenziali progettato per funzionare con Credential Manager e fornitori di credenziali di terze parti, contribuendo al contempo a fornire suggerimenti migliori per i servizi di compilazione automatica. Quando l'app utilizza l'API Credential Manager, viene visualizzato il foglio inferiore di Credential Manager con le credenziali disponibili e non è più necessario mostrare la finestra di dialogo di compilazione automatica per il nome utente o la password. Allo stesso modo, non è necessario mostrare la finestra di dialogo di salvataggio del riempimento automatico per le password, poiché l'app richiederà all'API Credential Manager di salvare le credenziali.

Per utilizzare l'attributo isCredential, aggiungilo alle viste pertinenti:

<TextView
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:isCredential="true" />
xmlsnippets.xml

Accedi all'utente

Per recuperare tutte le opzioni di passkey e password associate all'account dell'utente, completa questi passaggi:

  1. Inizializza le opzioni di autenticazione con password e passkey:

    // Retrieves the user's saved password for your app from their
// password provider.
val getPasswordOption = GetPasswordOption()

// Get passkey from the user's public key credential provider.
val getPublicKeyCredentialOption = GetPublicKeyCredentialOption(
  requestJson = requestJson
)
    PasskeyAndPasswordFunctions.kt

  2. Utilizza le opzioni recuperate dal passaggio precedente per creare la richiesta di accesso.

    val credentialRequest = GetCredentialRequest(
  listOf(getPasswordOption, getPublicKeyCredentialOption),
)
    PasskeyAndPasswordFunctions.kt

  3. Avvia il flusso di accesso:

    coroutineScope {
  try {
    result = credentialManager.getCredential(
      // Use an activity-based context to avoid undefined system UI
      // launching behavior.
      context = activityContext,
      request = credentialRequest
    )
    handleSignIn(result)
  } catch (e: GetCredentialException) {
    // Handle failure
  }
}
    PasskeyAndPasswordFunctions.kt
    
    
    fun handleSignIn(result: GetCredentialResponse) {
  // Handle the successfully returned credential.
  val credential = result.credential

  when (credential) {
    is PublicKeyCredential -> {
      val responseJson = credential.authenticationResponseJson
      // Share responseJson i.e. a GetCredentialResponse on your server to
      // validate and  authenticate
    }

    is PasswordCredential -> {
      val username = credential.id
      val password = credential.password
      // Use id and password to send to your server to validate
      // and authenticate
    }

    is CustomCredential -> {
      // If you are also using any external sign-in libraries, parse them
      // here with the utility functions provided.
      if (credential.type == ExampleCustomCredential.TYPE) {
        try {
          val ExampleCustomCredential =
            ExampleCustomCredential.createFrom(credential.data)
          // Extract the required credentials and complete the authentication as per
          // the federated sign in or any external sign in library flow
        } catch (e: ExampleCustomCredential.ExampleCustomCredentialParsingException) {
          // Unlikely to happen. If it does, you likely need to update the dependency
          // version of your external sign-in library.
          Log.e(TAG, "Failed to parse an ExampleCustomCredential", e)
        }
      } else {
        // Catch any unrecognized custom credential type here.
        Log.e(TAG, "Unexpected type of credential")
      }
    }
    else -> {
      // Catch any unrecognized credential type here.
      Log.e(TAG, "Unexpected type of credential")
    }
  }
}
    PasskeyAndPasswordFunctions.kt

L'esempio seguente mostra come formattare la richiesta JSON quando ricevi una passkey:

{
  "challenge": "T1xCsnxM2DNL2KdK5CLa6fMhD7OBqho6syzInk_n-Uo",
  "allowCredentials": [],
  "timeout": 1800000,
  "userVerification": "required",
  "rpId": "https://passkeys-codelab.glitch.me/"
}

Il seguente esempio mostra l'aspetto di una risposta JSON dopo aver ottenuto una credenziale di chiave pubblica:

{
  "id": "KEDetxZcUfinhVi6Za5nZQ",
  "type": "public-key",
  "rawId": "KEDetxZcUfinhVi6Za5nZQ",
  "response": {
    "clientDataJSON": "eyJ0eXBlIjoid2ViYXV0aG4uZ2V0IiwiY2hhbGxlbmdlIjoiVDF4Q3NueE0yRE5MMktkSzVDTGE2Zk1oRDdPQnFobzZzeXpJbmtfbi1VbyIsIm9yaWdpbiI6ImFuZHJvaWQ6YXBrLWtleS1oYXNoOk1MTHpEdll4UTRFS1R3QzZVNlpWVnJGUXRIOEdjVi0xZDQ0NEZLOUh2YUkiLCJhbmRyb2lkUGFja2FnZU5hbWUiOiJjb20uZ29vZ2xlLmNyZWRlbnRpYWxtYW5hZ2VyLnNhbXBsZSJ9",
    "authenticatorData": "j5r_fLFhV-qdmGEwiukwD5E_5ama9g0hzXgN8thcFGQdAAAAAA",
    "signature": "MEUCIQCO1Cm4SA2xiG5FdKDHCJorueiS04wCsqHhiRDbbgITYAIgMKMFirgC2SSFmxrh7z9PzUqr0bK1HZ6Zn8vZVhETnyQ",
    "userHandle": "2HzoHm_hY0CjuEESY9tY6-3SdjmNHOoNqaPDcZGzsr0"
  }
}

Gestire le eccezioni quando non sono disponibili credenziali

In alcuni casi, l'utente potrebbe non disporre di credenziali disponibili o potrebbe non concedere il consenso all'utilizzo di una credenziale disponibile. Se viene richiamato getCredential() e non vengono trovate credenziali, viene restituito un NoCredentialException. In questo caso, il codice deve gestire le istanze NoCredentialException.

coroutineScope {
  try {
    result = credentialManager.getCredential(
      context = activityContext,
      request = credentialRequest
    )
  } catch (e: GetCredentialException) {
    Log.e("CredentialManager", "No credential available", e)
  }
}
PasskeyAndPasswordFunctions.kt

Su Android 14 o versioni successive, puoi ridurre la latenza quando mostri il selettore dell'account utilizzando il metodo prepareGetCredential() prima di chiamare getCredential().

coroutineScope {
  val response = credentialManager.prepareGetCredential(
    GetCredentialRequest(
      listOf(
        getPublicKeyCredentialOption,
        getPasswordOption
      )
    )
  )
}
PasskeyAndPasswordFunctions.kt

Il metodo prepareGetCredential() non richiama elementi dell'interfaccia utente. Ti aiuta solo a eseguire il lavoro di preparazione in modo da poter avviare in un secondo momento l'operazione get-credential rimanente (che coinvolge le UI) tramite l'API getCredential().

I dati memorizzati nella cache vengono restituiti in un oggetto PrepareGetCredentialResponse. Se esistono credenziali, i risultati verranno memorizzati nella cache e potrai avviare in un secondo momento l'API getCredential() rimanente per visualizzare il selettore dell'account con i dati memorizzati nella cache.

Flussi di registrazione

Puoi registrare un utente per l'autenticazione utilizzando una passkey o una password.

Crea una passkey

Per dare agli utenti la possibilità di registrare una passkey e utilizzarla per la riautenticazione, registra una credenziale utente utilizzando un oggetto CreatePublicKeyCredentialRequest.

suspend fun createPasskey(requestJson: String, preferImmediatelyAvailableCredentials: Boolean) {
  val createPublicKeyCredentialRequest = CreatePublicKeyCredentialRequest(
    // Contains the request in JSON format. Uses the standard WebAuthn
    // web JSON spec.
    requestJson = requestJson,
    // Defines whether you prefer to use only immediately available
    // credentials, not hybrid credentials, to fulfill this request.
    // This value is false by default.
    preferImmediatelyAvailableCredentials = preferImmediatelyAvailableCredentials,
  )

  // Execute CreateCredentialRequest asynchronously to register credentials
  // for a user account. Handle success and failure cases with the result and
  // exceptions, respectively.
  coroutineScope {
    try {
      val result = credentialManager.createCredential(
        // Use an activity-based context to avoid undefined system
        // UI launching behavior
        context = activityContext,
        request = createPublicKeyCredentialRequest,
      )
      //  Handle passkey creation result
    } catch (e : CreateCredentialException){
      handleFailure(e)
    }
  }
}
PasskeyAndPasswordFunctions.kt


fun handleFailure(e: CreateCredentialException) {
  when (e) {
    is CreatePublicKeyCredentialDomException -> {
      // Handle the passkey DOM errors thrown according to the
      // WebAuthn spec.
    }
    is CreateCredentialCancellationException -> {
      // The user intentionally canceled the operation and chose not
      // to register the credential.
    }
    is CreateCredentialInterruptedException -> {
      // Retry-able error. Consider retrying the call.
    }
    is CreateCredentialProviderConfigurationException -> {
      // Your app is missing the provider configuration dependency.
      // Most likely, you're missing the
      // "credentials-play-services-auth" module.
    }
    is CreateCredentialCustomException -> {
      // You have encountered an error from a 3rd-party SDK. If you
      // make the API call with a request object that's a subclass of
      // CreateCustomCredentialRequest using a 3rd-party SDK, then you
      // should check for any custom exception type constants within
      // that SDK to match with e.type. Otherwise, drop or log the
      // exception.
    }
    else -> Log.w(TAG, "Unexpected exception type ${e::class.java.name}")
  }
}
PasskeyAndPasswordFunctions.kt

Formatta la richiesta JSON

Dopo aver creato una passkey, devi associarla all'account di un utente e memorizzare la chiave pubblica della passkey sul tuo server. Il seguente esempio di codice mostra come formattare la richiesta JSON quando crei una passkey.

Questo post del blog sull'introduzione dell'autenticazione senza problemi nelle tue app mostra come formattare la richiesta JSON quando crei passkey e quando ti autentichi utilizzando le passkey. Spiega anche perché le password non sono una soluzione di autenticazione efficace, come sfruttare le credenziali biometriche esistenti, come associare la tua app a un sito web di tua proprietà, come creare passkey e come autenticarsi utilizzando le passkey.

{
  "challenge": "abc123",
  "rp": {
    "name": "Credential Manager example",
    "id": "credential-manager-test.example.com"
  },
  "user": {
    "id": "def456",
    "name": "helloandroid@gmail.com",
    "displayName": "helloandroid@gmail.com"
  },
  "pubKeyCredParams": [
    {
      "type": "public-key",
      "alg": -7
    },
    {
      "type": "public-key",
      "alg": -257
    }
  ],
  "timeout": 1800000,
  "attestation": "none",
  "excludeCredentials": [
    {
      "id": "ghi789",
      "type": "public-key"
    },
    {
      "id": "jkl012",
      "type": "public-key"
    }
  ],
  "authenticatorSelection": {
    "authenticatorAttachment": "platform",
    "requireResidentKey": true,
    "residentKey": "required",
    "userVerification": "required"
  }
}

Imposta i valori per authenticatorAttachment

Il parametro authenticatorAttachment può essere impostato solo al momento della creazione delle credenziali. Puoi specificare platform, cross-platform o nessun valore. Nella maggior parte dei casi, non è consigliato alcun valore.

  • platform: per registrare il dispositivo attuale dell'utente o chiedere a un utente con password di eseguire l'upgrade alle passkey dopo l'accesso, imposta authenticatorAttachment su platform.
  • cross-platform: questo valore viene comunemente utilizzato durante la registrazione di credenziali multifattore e non viene utilizzato nel contesto di una passkey.
  • Nessun valore: per consentire agli utenti di creare passkey sui propri dispositivi preferiti (ad esempio nelle impostazioni dell'account), il parametro authenticatorAttachment non deve essere specificato quando un utente sceglie di aggiungere una passkey. Nella maggior parte dei casi, lasciare il parametro non specificato è l'opzione migliore.

Impedire la creazione di passkey duplicate

Elenca gli ID credenziali nell'array facoltativo excludeCredentials per impedire la creazione di una nuova passkey se ne esiste già una con lo stesso provider di passkey.

Gestire la risposta JSON

Il seguente snippet di codice mostra un esempio di risposta JSON per la creazione di una credenziale di chiave pubblica. Scopri di più su come gestire la credenziale della chiave pubblica restituita.

{
  "id": "KEDetxZcUfinhVi6Za5nZQ",
  "type": "public-key",
  "rawId": "KEDetxZcUfinhVi6Za5nZQ",
  "response": {
    "clientDataJSON": "eyJ0eXBlIjoid2ViYXV0aG4uY3JlYXRlIiwiY2hhbGxlbmdlIjoibmhrUVhmRTU5SmI5N1Z5eU5Ka3ZEaVh1Y01Fdmx0ZHV2Y3JEbUdyT0RIWSIsIm9yaWdpbiI6ImFuZHJvaWQ6YXBrLWtleS1oYXNoOk1MTHpEdll4UTRFS1R3QzZVNlpWVnJGUXRIOEdjVi0xZDQ0NEZLOUh2YUkiLCJhbmRyb2lkUGFja2FnZU5hbWUiOiJjb20uZ29vZ2xlLmNyZWRlbnRpYWxtYW5hZ2VyLnNhbXBsZSJ9",
    "attestationObject": "o2NmbXRkbm9uZWdhdHRTdG10oGhhdXRoRGF0YViUj5r_fLFhV-qdmGEwiukwD5E_5ama9g0hzXgN8thcFGRdAAAAAAAAAAAAAAAAAAAAAAAAAAAAEChA3rcWXFH4p4VYumWuZ2WlAQIDJiABIVgg4RqZaJyaC24Pf4tT-8ONIZ5_Elddf3dNotGOx81jj3siWCAWXS6Lz70hvC2g8hwoLllOwlsbYatNkO2uYFO-eJID6A"
  }
}

Verifica l'origine dal file JSON dei dati del client

origin rappresenta l'applicazione o il sito web da cui proviene una richiesta e viene utilizzato dalle passkey per proteggere dagli attacchi di phishing. Il server della tua app deve controllare l'origine dei dati del client rispetto a una lista consentita di app e siti web approvati. Se il server riceve una richiesta da un'app o un sito web di un'origine non riconosciuta, la richiesta deve essere rifiutata.

Nel caso del web, origin riflette l'origine dello stesso sito in cui è stata eseguita l'autenticazione della credenziale. Ad esempio, dato un URL di https://www.example.com:8443/store?category=shoes#athletic , il origin è https://www.example.com:8443.

Per le app per Android, lo user agent imposta automaticamente origin sulla firma dell'app chiamante. Questa firma deve essere verificata come corrispondenza sul tuo server per convalidare il chiamante dell'API passkey. L'origin Android è un URI derivato dall'hash SHA-256 del certificato di firma dell'APK, ad esempio:

android:apk-key-hash:<sha256_hash-of-apk-signing-cert>

Gli hash SHA-256 dei certificati di firma di un keystore possono essere trovati eseguendo il seguente comando del terminale:

keytool -list -keystore <path-to-apk-signing-keystore>

Gli hash SHA-256 sono in formato esadecimale delimitato da due punti (91:F7:CB:F9:D6:81…) e i valori origin di Android sono codificati in base64url. Questo esempio in Python mostra come convertire il formato hash in un formato esadecimale compatibile separato da due punti:

import binascii
import base64
fingerprint = '91:F7:CB:F9:D6:81:53:1B:C7:A5:8F:B8:33:CC:A1:4D:AB:ED:E5:09:C5'
print("android:apk-key-hash:" + base64.urlsafe_b64encode(binascii.a2b_hex(fingerprint.replace(':', ''))).decode('utf8').replace('=', ''))

Sostituisci il valore di fingerprint con il tuo valore. Ecco un esempio di risultato:

android:apk-key-hash:kffL-daBUxvHpY-4M8yhTavt5QnFEI2LsexohxrGPYU

Puoi quindi abbinare questa stringa a un'origine consentita sul tuo server. Se hai più certificati di firma, ad esempio certificati per il debug e il rilascio, o più app, ripeti la procedura e accetta tutte queste origini come valide sul server.

Salvare la password di un utente

Se l'utente fornisce un nome utente e una password per un flusso di autenticazione nella tua app, puoi registrare una credenziale utente che può essere utilizzata per autenticare l'utente. Per farlo, crea un oggetto CreatePasswordRequest:

suspend fun registerPassword(username: String, password: String) {
  // Initialize a CreatePasswordRequest object.
  val createPasswordRequest =
    CreatePasswordRequest(id = username, password = password)

  // Create credential and handle result.
  coroutineScope {
    try {
      val result =
        credentialManager.createCredential(
          // Use an activity based context to avoid undefined
          // system UI launching behavior.
          activityContext,
          createPasswordRequest
        )
      // Handle register password result
    } catch (e: CreateCredentialException) {
      handleFailure(e)
    }
  }
}
PasskeyAndPasswordFunctions.kt

Supporto per il recupero delle credenziali

Se un utente non ha più accesso a un dispositivo su cui aveva memorizzato le proprie credenziali, potrebbe dover eseguire il ripristino da un backup online sicuro. Per scoprire di più su come supportare questa procedura di recupero delle credenziali, leggi la sezione "Recupero dell'accesso o aggiunta di nuovi dispositivi" di questo post del blog: Sicurezza delle passkey nel Gestore delle password di Google.

Creare automaticamente passkey per gli utenti

Se un utente non ha una passkey, puoi crearne una automaticamente per suo conto al successivo accesso utilizzando una password salvata nel suo gestore delle password. Per farlo, imposta il campo isConditionalCreateRequest quando richiedi le credenziali pubbliche:

CreatePublicKeyCredentialRequest(
    // other parameters
    isConditionalCreateRequest: Boolean = true
)

Quando l'utente accede, viene creata e memorizzata automaticamente una passkey nel gestore delle password selezionato dall'utente. Se utilizzi Gestore delle password di Google, l'utente deve aver utilizzato (tramite Credential Manager o compilazione automatica) la password salvata nel gestore delle password. L'utente riceve una notifica al momento della creazione di questa passkey e può accedere al gestore delle password per gestirla.

Questa funzionalità richiede la versione 1.6.0-alpha01 o successive.

Aggiungere il supporto per gli strumenti di gestione delle password con URL noti degli endpoint passkey

Per un'integrazione perfetta e la compatibilità futura con gli strumenti di gestione di password e credenziali, ti consigliamo di aggiungere il supporto per gli endpoint passkey e gli URL noti. Si tratta di un protocollo aperto che consente alle parti allineate di pubblicizzare formalmente il proprio supporto per le passkey e fornire link diretti per la registrazione e la gestione delle passkey.

  1. Per una relying party all'indirizzo https://example.com, che ha un sito web più app per Android e iOS, l'URL noto sarebbe https://example.com/.well-known/passkey-endpoints.

  2. Quando viene eseguita una query sull'URL, la risposta deve utilizzare lo schema seguente

    {
  "enroll": "https://example.com/account/manage/passkeys/create"
  "manage": "https://example.com/account/manage/passkeys"
}

  3. Per fare in modo che questo link si apra direttamente nella tua app anziché sul web, utilizza i link per app Android.

  4. Per ulteriori dettagli, consulta la spiegazione dell'URL noto degli endpoint passkey su GitHub.

Aiuta gli utenti a gestire le proprie passkey mostrando il provider che le ha create

Una delle sfide che gli utenti devono affrontare quando gestiscono più passkey associate a una determinata app è l'identificazione della passkey corretta per la modifica o l'eliminazione. Per risolvere questo problema, è consigliabile che app e siti web includano ulteriori informazioni, come il fornitore che ha creato la credenziale, la data di creazione e la data dell'ultimo utilizzo in un elenco di passkey nella schermata delle impostazioni dell'app.Le informazioni sul fornitore vengono ottenute esaminando l'AAGUID associato alla passkey corrispondente. L'AAGUID si trova nei dati dell'autenticatore di una passkey.

Ad esempio, se un utente crea una passkey su un dispositivo Android utilizzando Google Password Manager, il RP riceve un AAGUID simile a questo: "ea9b8d66-4d01-1d21-3ce4-b6b48cb575d4". La relying party può annotare la passkey nell'elenco delle passkey per indicare che è stata creata utilizzando Gestore delle password di Google.

Per mappare un AAGUID a un fornitore di passkey, le RP possono utilizzare un repository di AAGUID di origine comunitaria. Cerca l'AAGUID nell'elenco per trovare il nome e l'icona del fornitore di passkey.

Scopri di più sull'integrazione di AAGUID.

Risolvere gli errori più comuni

Consulta la guida alla risoluzione dei problemi di Credential Manager per i codici di errore comuni, le descrizioni e le informazioni sulle cause.

Risorse aggiuntive

Per scoprire di più sull'API Credential Manager e sulle passkey, consulta le seguenti risorse: