Integra Gestore delle credenziali con la soluzione del tuo fornitore di credenziali

Con Gestore delle credenziali si intende un insieme di API introdotte in Android 14 che supportano più metodi di accesso, tra cui nome utente-password, passkey e soluzioni di accesso federato (come Accedi con Google). Quando viene richiamata l'API Credential Manager, il sistema Android aggrega le credenziali di tutti i provider di credenziali installati sul dispositivo. Questo documento descrive l'insieme di API che forniscono endpoint di integrazione per questi fornitori di credenziali.

Configurazione

Prima di implementare la funzionalità nel provider di credenziali, completa i passaggi di configurazione mostrati nelle sezioni seguenti.

Dichiarazione di dipendenze

Nel file build.gradle del modulo, dichiara una dipendenza utilizzando la versione più recente della libreria di Gestore delle credenziali:

implementation "androidx.credentials:credentials:1.2.0-{latest}"

Dichiara l'elemento del servizio nel file manifest

Nel file manifest AndroidManifest.xml della tua app, includi una dichiarazione <service> per una classe di servizio che estende la classe CredentialProviderService dalla libreria androidx.credentials, come mostrato nell'esempio seguente.

<service android:name=".MyCredentialProviderService"
         android:enabled="true"
         android:exported="true"
         android:label="My Credential Provider"
         android:icon="<any drawable icon>"
         android:permission="android.permission.BIND_CREDENTIAL_PROVIDER_SERVICE">
    <intent-filter>
        <action android:name="android.service.credentials.CredentialProviderService"/>
    </intent-filter>
    <meta-data
         android:name="android.credentials.provider"
         android:resource="@xml/provider"/>
</service>

L'autorizzazione e il filtro per intent mostrati sopra sono parte integrante del funzionamento del flusso di Gestore delle credenziali come previsto. Questa autorizzazione è necessaria affinché solo il sistema Android possa associarsi a questo servizio. Il filtro per intent viene utilizzato per scoprire questo servizio come provider di credenziali da utilizzare da Gestore delle credenziali.

Dichiara i tipi di credenziali supportati

Nella directory res/xml, crea un nuovo file denominato provider.xml. In questo file, dichiara i tipi di credenziali supportati dal servizio tramite le costanti definite per ogni tipo di credenziali nella libreria. Nel seguente esempio, il servizio supporta le password tradizionali e le passkey, costanti per le quali sono definite come TYPE_PASSWORD_CREDENTIAL e TYPE_PUBLIC_KEY_CREDENTIAL:

<?xml version="1.0" encoding="utf-8"?>
<credential-provider xmlns:android="http://schemas.android.com/apk/res/android">
   <capabilities>
       <capability name="android.credentials.TYPE_PASSWORD_CREDENTIAL" />
       <capability name="androidx.credentials.TYPE_PUBLIC_KEY_CREDENTIAL" />
   </capabilities>
</credential-provider>

Nei livelli API precedenti, i provider di credenziali si integrano con API come la compilazione automatica di password e altri dati. Questi provider possono utilizzare la stessa infrastruttura interna per archiviare i tipi di credenziali esistenti e estenderla al supporto di altri, incluse le passkey.

Approccio in due fasi all'interazione con il fornitore

Gestore delle credenziali interagisce con i fornitori di credenziali in due fasi:

  1. La prima fase è la fase di avvio/query in cui il sistema si vincola ai servizi del provider di credenziali e richiama i metodi onBeginGetCredentialRequest(), onBeginCreateCredentialRequest() o onClearCredentialStateRequest() con richieste Begin…. I provider devono elaborare queste richieste e rispondere con risposte Begin…, completandole con voci che rappresentano le opzioni visive da mostrare sul selettore di account. Per ogni voce deve essere impostato un valore PendingIntent.
  2. Una volta che l'utente seleziona una voce, inizia la fase di selezione e viene attivata la PendingIntent associata alla voce, attivando l'attività del provider corrispondente. Una volta che l'utente ha terminato di interagire con questa attività, il fornitore di credenziali deve impostare la risposta sul risultato dell'attività prima di terminarla. Questa risposta viene quindi inviata all'app client che ha richiamato Gestore delle credenziali.

Gestire la creazione di passkey

Gestire le query per la creazione di passkey

Quando un'app client vuole creare una passkey e memorizzarla con un fornitore di credenziali, chiama l'API createCredential. Per gestire questa richiesta nel servizio del fornitore di credenziali in modo che la passkey venga effettivamente archiviata nel tuo spazio di archiviazione, completa i passaggi riportati nelle sezioni seguenti.

  1. Esegui l'override del metodo onBeginCreateCredentialRequest() nel servizio esteso da CredentialProviderService.
  2. Per gestire BeginCreateCredentialRequest, crea un BeginCreateCredentialResponse corrispondente e passalo attraverso il callback.
  3. Durante la creazione della BeginCreateCredentialResponse, aggiungi il CreateEntries obbligatorio. Ogni elemento CreateEntry deve corrispondere a un account in cui è possibile salvare la credenziale e deve avere impostato un elemento PendingIntent e altri metadati richiesti.

L'esempio seguente illustra come implementare questi passaggi.

override fun onBeginCreateCredentialRequest(
  request: BeginCreateCredentialRequest,
  cancellationSignal: CancellationSignal,
  callback: OutcomeReceiver<BeginCreateCredentialResponse, CreateCredentialException>,
) {
  val response: BeginCreateCredentialResponse? = processCreateCredentialRequest(request)
  if (response != null) {
    callback.onResult(response)
  } else {
    callback.onError(CreateCredentialUnknownException())
  }
}

fun processCreateCredentialRequest(request: BeginCreateCredentialRequest): BeginCreateCredentialResponse? {
  when (request) {
    is BeginCreatePublicKeyCredentialRequest -> {
      // Request is passkey type
      return handleCreatePasskeyQuery(request)
    }
  }
  // Request not supported
  return null
}

private fun handleCreatePasskeyQuery(
    request: BeginCreatePublicKeyCredentialRequest
    ): BeginCreateCredentialResponse {

    // Adding two create entries - one for storing credentials to the 'Personal'
    // account, and one for storing them to the 'Family' account. These
    // accounts are local to this sample app only.
    val createEntries: MutableList<CreateEntry> = mutableListOf()
    createEntries.add( CreateEntry(
        PERSONAL_ACCOUNT_ID,
        createNewPendingIntent(PERSONAL_ACCOUNT_ID, CREATE_PASSKEY_INTENT)
    ))

    createEntries.add( CreateEntry(
        FAMILY_ACCOUNT_ID,
        createNewPendingIntent(FAMILY_ACCOUNT_ID, CREATE_PASSKEY_INTENT)
    ))

    return BeginCreateCredentialResponse(createEntries)
}

private fun createNewPendingIntent(accountId: String, action: String): PendingIntent {
    val intent = Intent(action).setPackage(PACKAGE_NAME)

    // Add your local account ID as an extra to the intent, so that when
    // user selects this entry, the credential can be saved to this
    // account
    intent.putExtra(EXTRA_KEY_ACCOUNT_ID, accountId)

    return PendingIntent.getActivity(
        applicationContext, UNIQUE_REQ_CODE,
        intent, (
            PendingIntent.FLAG_MUTABLE
            or PendingIntent.FLAG_UPDATE_CURRENT
        )
    )
}

La costruzione di PendingIntent deve rispettare quanto segue:

  • L'attività corrispondente deve essere configurata in modo da mostrare qualsiasi richiesta biometrica, conferma o selezione obbligatoria.
  • Tutti i dati obbligatori necessari al provider quando viene richiamata l'attività corrispondente devono essere impostati come extra nell'intent utilizzato per creare il tuo PendingIntent, ad esempio accountId nel flusso di creazione.
  • PendingIntent deve essere creato con il flag PendingIntent.FLAG_MUTABLE in modo che il sistema possa aggiungere la richiesta finale all'elemento aggiuntivo sull'intent.
  • Il tuo PendingIntent non deve essere creato con il flag PendingIntent.FLAG_ONE_SHOT poiché l'utente può selezionare una voce, tornare indietro e riselezionarla. Di conseguenza, PendingIntent si attiverà due volte.
  • PendingIntent deve essere creato con un codice di richiesta univoco in modo che ogni voce possa avere il proprio PendingIntent corrispondente.

Gestisci la selezione delle voci per le richieste di creazione di passkey

  1. Quando l'utente seleziona un valore CreateEntry compilato in precedenza, viene richiamato il PendingIntent corrispondente e viene creato il provider associato Activity.
  2. Una volta richiamato il metodo onCreate dell'attività, accedi all'intent associato e passalo alla classe PendingIntentHander per ottenere ProviderCreateCredentialRequest.
  3. Estrai requestJson, callingAppInfo e clientDataHash dalla richiesta.
  4. Estrai l'elemento accountId locale dall'elemento aggiuntivo sull'intent. Questa è un'implementazione specifica dell'app di esempio e non è obbligatoria. Questo ID account può essere utilizzato per memorizzare la credenziale in questo specifico ID account.
  5. Convalida l'elemento requestJson. L'esempio seguente utilizza classi di dati locali come PublicKeyCredentialCreationOptions per convertire il JSON di input in una classe strutturata secondo le specifiche WebAuthn. In qualità di provider di credenziali, puoi sostituirlo con il tuo analizzatore sintattico.
  6. Controlla l'asset-link per l'app di chiamata se la chiamata proviene da un'app Android nativa.
  7. Mostra un prompt di autenticazione. L'esempio seguente utilizza l'API Biometric di Android.
  8. Se l'autenticazione ha esito positivo, genera un credentialId e una coppia di chiavi.
  9. Salva la chiave privata nel database locale utilizzando callingAppInfo.packageName.
  10. Crea una risposta JSON dell'API Web Authentication composta dalla chiave pubblica e dalla credentialId. L'esempio che segue utilizza classi di utilità locali come AuthenticatorAttestationResponse e FidoPublicKeyCredential che aiutano a creare un JSON in base alla specifica menzionata in precedenza.In qualità di provider di credenziali, puoi sostituire queste classi con i tuoi builder.
  11. Crea un elemento CreatePublicKeyCredentialResponse con il JSON generato in precedenza.
  12. Imposta CreatePublicKeyCredentialResponse come extra su Intent fino a PendingIntentHander.setCreateCredentialResponse() e imposta tale intento sul risultato dell'attività.
  13. Termina l'attività.

Il codice di esempio riportato di seguito illustra questi passaggi. Questo codice deve essere gestito nella classe Attività dopo la chiamata a onCreate().

val request =
  PendingIntentHandler.retrieveProviderCreateCredentialRequest(intent)

val accountId = intent.getStringExtra(CredentialsRepo.EXTRA_KEY_ACCOUNT_ID)
if (request != null && request.callingRequest is CreatePublicKeyCredentialRequest) {
  val publicKeyRequest: CreatePublicKeyCredentialRequest =
    request.callingRequest as CreatePublicKeyCredentialRequest
  createPasskey(
    publicKeyRequest.requestJson,
    request.callingAppInfo,
    publicKeyRequest.clientDataHash,
    accountId
  )
}

fun createPasskey(
  requestJson: String,
  callingAppInfo: CallingAppInfo?,
  clientDataHash: ByteArray?,
  accountId: String?
) {
  val request = PublicKeyCredentialCreationOptions(requestJson)

  val biometricPrompt = BiometricPrompt(
    this,
    <executor>,
    object : BiometricPrompt.AuthenticationCallback() {
      override fun onAuthenticationError(
        errorCode: Int, errString: CharSequence
      ) {
        super.onAuthenticationError(errorCode, errString)
        finish()
      }

      override fun onAuthenticationFailed() {
        super.onAuthenticationFailed()
        finish()
      }

      override fun onAuthenticationSucceeded(
        result: BiometricPrompt.AuthenticationResult
      ) {
        super.onAuthenticationSucceeded(result)

        // Generate a credentialId
        val credentialId = ByteArray(32)
        SecureRandom().nextBytes(credentialId)

        // Generate a credential key pair
        val spec = ECGenParameterSpec("secp256r1")
        val keyPairGen = KeyPairGenerator.getInstance("EC");
        keyPairGen.initialize(spec)
        val keyPair = keyPairGen.genKeyPair()

        // Save passkey in your database as per your own implementation

        // Create AuthenticatorAttestationResponse object to pass to
        // FidoPublicKeyCredential

        val response = AuthenticatorAttestationResponse(
          requestOptions = request,
          credentialId = credentialId,
          credentialPublicKey = getPublicKeyFromKeyPair(keyPair),
          origin = appInfoToOrigin(callingAppInfo),
          up = true,
          uv = true,
          be = true,
          bs = true,
          packageName = callingAppInfo.packageName
        )

        val credential = FidoPublicKeyCredential(
          rawId = credentialId, response = response
        )
        val result = Intent()

        val createPublicKeyCredResponse =
          CreatePublicKeyCredentialResponse(credential.json())

        // Set the CreateCredentialResponse as the result of the Activity
        PendingIntentHandler.setCreateCredentialResponse(
          result, createPublicKeyCredResponse
        )
        setResult(Activity.RESULT_OK, result)
        finish()
      }
    }
  )

  val promptInfo = BiometricPrompt.PromptInfo.Builder()
    .setTitle("Use your screen lock")
    .setSubtitle("Create passkey for ${request.rp.name}")
    .setAllowedAuthenticators(
        BiometricManager.Authenticators.BIOMETRIC_STRONG
        /* or BiometricManager.Authenticators.DEVICE_CREDENTIAL */
      )
    .build()
  biometricPrompt.authenticate(promptInfo)
}

fun appInfoToOrigin(info: CallingAppInfo): String {
  val cert = info.signingInfo.apkContentsSigners[0].toByteArray()
  val md = MessageDigest.getInstance("SHA-256");
  val certHash = md.digest(cert)
  // This is the format for origin
  return "android:apk-key-hash:${b64Encode(certHash)}"
}

Gestisci le query per le richieste di creazione di password

Per gestire le query per le richieste di creazione di password:

  • All'interno del metodo processCreateCredentialRequest() menzionato nella sezione precedente, aggiungi un'altra richiesta all'interno del blocco di switch per gestire le richieste di password.
  • Durante la creazione di BeginCreateCredentialResponse, aggiungi gli CreateEntries richiesti.
  • Ogni CreateEntry deve corrispondere a un account in cui è possibile salvare la credenziale e deve avere un valore PendingIntent impostato insieme ad altri metadati.

L'esempio seguente illustra come implementare questi passaggi:

fun processCreateCredentialRequest(
    request: BeginCreateCredentialRequest
  ): BeginCreateCredentialResponse? {
  when (request) {
    is BeginCreatePublicKeyCredentialRequest -> {
      // Request is passkey type
      return handleCreatePasskeyQuery(request)
    }

    is BeginCreatePasswordCredentialRequest -> {
    // Request is password type
      return handleCreatePasswordQuery(request)
    }
  }
  return null
}

private fun handleCreatePasswordQuery(
    request: BeginCreatePasswordCredentialRequest
  ): BeginCreateCredentialResponse {
  val createEntries: MutableList<CreateEntry> = mutableListOf()

  // Adding two create entries - one for storing credentials to the 'Personal'
  // account, and one for storing them to the 'Family' account. These
  // accounts are local to this sample app only.
  createEntries.add(
    CreateEntry(
      PERSONAL_ACCOUNT_ID,
      createNewPendingIntent(PERSONAL_ACCOUNT_ID, CREATE_PASSWORD_INTENT)
    )
  )
  createEntries.add(
    CreateEntry(
      FAMILY_ACCOUNT_ID,
      createNewPendingIntent(FAMILY_ACCOUNT_ID, CREATE_PASSWORD_INTENT)
    )
  )

  return BeginCreateCredentialResponse(createEntries)
}

Gestisci la selezione delle voci per le richieste di creazione della password

Quando l'utente seleziona un elemento CreateEntry completato, viene eseguito il PendingIntent corrispondente e visualizza l'attività associata. Accedere all'intent associato passato a onCreate e passarlo alla classe PendingIntentHander per ottenere il metodo ProviderCreateCredentialRequest.

L'esempio seguente illustra come implementare questa procedura. Questo codice deve essere gestito nel metodo onCreate() dell'attività.

val createRequest = PendingIntentHandler.retrieveProviderCreateCredentialRequest(intent)
val accountId = intent.getStringExtra(CredentialsRepo.EXTRA_KEY_ACCOUNT_ID)

val request: CreatePasswordRequest = createRequest.callingRequest as CreatePasswordRequest

// Fetch the ID and password from the request and save it in your database
<your_database>.addNewPassword(
    PasswordInfo(
        request.id,
        request.password,
        createRequest.callingAppInfo.packageName
    )
)

//Set the final response back
val result = Intent()
val response = CreatePasswordResponse()
PendingIntentHandler.setCreateCredentialResponse(result, response)
setResult(Activity.RESULT_OK, result)
this@<activity>.finish()

Gestire l'accesso degli utenti

L'accesso utente viene gestito nei seguenti passaggi:

  • Quando un'app client tenta di accedere a un utente, prepara un'istanza di GetCredentialRequest.
  • Il framework Android propaga questa richiesta a tutti i provider di credenziali applicabili associandoli a questi servizi.
  • Il servizio del provider riceve quindi un elemento BeginGetCredentialRequest che contiene un elenco di BeginGetCredentialOption, ciascuno dei quali contiene parametri utilizzabili per recuperare le credenziali corrispondenti.

Per gestire questa richiesta nel servizio del provider di credenziali, completa i seguenti passaggi:

  1. Esegui l'override del metodo onBeginGetCredentialRequest() per gestire la richiesta. Tieni presente che se le tue credenziali sono bloccate, puoi impostare immediatamente un AuthenticationAction nella risposta e richiamare il callback.

    private val unlockEntryTitle = "Authenticate to continue"

override fun onBeginGetCredentialRequest(
    request: BeginGetCredentialRequest,
    cancellationSignal: CancellationSignal,
    callback: OutcomeReceiver<BeginGetCredentialResponse, GetCredentialException>,
) {
    if (isAppLocked()) {
        callback.onResult(BeginGetCredentialResponse(
            authenticationActions = mutableListOf(AuthenticationAction(
                unlockEntryTitle, createUnlockPendingIntent())
                )
            )
        )
        return
    }
    try {
        response = processGetCredentialRequest(request)
        callback.onResult(response)
    } catch (e: GetCredentialException) {
        callback.onError(GetCredentialUnknownException())
    }
}

    I provider che richiedono lo sblocco delle credenziali prima di restituire qualsiasi credentialEntries devono configurare un intent in attesa che indirizzi l'utente al flusso di sblocco dell'app:

    private fun createUnlockPendingIntent(): PendingIntent {
    val intent = Intent(UNLOCK_INTENT).setPackage(PACKAGE_NAME)
    return PendingIntent.getActivity(
    applicationContext, UNIQUE_REQUEST_CODE, intent, (
        PendingIntent.FLAG_MUTABLE
        or PendingIntent.FLAG_UPDATE_CURRENT
        )
    )
}

  2. Recupera le credenziali dal tuo database locale e configurale utilizzando CredentialEntries da visualizzare sul selettore. Per le passkey, puoi impostare credentialId come extra nell'intent in modo da sapere a quale credenziale viene mappato quando l'utente seleziona questa voce.

    companion object {
    // These intent actions are specified for corresponding activities
    // that are to be invoked through the PendingIntent(s)
    private const val GET_PASSKEY_INTENT_ACTION = "PACKAGE_NAME.GET_PASSKEY"
    private const val GET_PASSWORD_INTENT_ACTION = "PACKAGE_NAME.GET_PASSWORD"

}

fun processGetCredentialsRequest(
request: BeginGetCredentialRequest
): BeginGetCredentialResponse {
    val callingPackage = request.callingAppInfo?.packageName
    val credentialEntries: MutableList<CredentialEntry> = mutableListOf()

    for (option in request.beginGetCredentialOptions) {
        when (option) {
            is BeginGetPasswordOption -> {
                credentialEntries.addAll(
                        populatePasswordData(
                            callingPackage,
                            option
                        )
                    )
                }
                is BeginGetPublicKeyCredentialOption -> {
                    credentialEntries.addAll(
                        populatePasskeyData(
                            callingPackage,
                            option
                        )
                    )
                )
            } else -> {
                Log.i(TAG, "Request not supported")
            }
        }
    }
    return BeginGetCredentialResponse(credentialEntries)
}

  3. Esegui una query sulle credenziali dal tuo database e crea voci di passkey e password da completare.

    private fun populatePasskeyData(
    callingAppInfo: CallingAppInfo,
    option: BeginGetPublicKeyCredentialOption
): List<CredentialEntry> {
  val passkeyEntries: MutableList<CredentialEntry> = mutableListOf()
  val request = PublicKeyCredentialRequestOptions(option.requestJson)
  // Get your credentials from database where you saved during creation flow
  val creds = <getCredentialsFromInternalDb(request.rpId)>
  val passkeys = creds.passkeys
  for (passkey in passkeys) {
      val data = Bundle()
      data.putString("credId", passkey.credId)
      passkeyEntries.add(
          PublicKeyCredentialEntry(
              context = applicationContext,
              username = passkey.username,
              pendingIntent = createNewPendingIntent(
                  GET_PASSKEY_INTENT_ACTION,
                  data
              ),
              beginPublicKeyCredentialOption = option,
              displayName = passkey.displayName,
              icon = passkey.icon
          )
      )
  }
  return passkeyEntries
}

// Fetch password credentials and create password entries to populate to
// the user
private fun populatePasswordData(
callingPackage: String,
option: BeginGetPasswordOption
): List<CredentialEntry> {
    val passwordEntries: MutableList<CredentialEntry> = mutableListOf()

    // Get your password credentials from database where you saved during
    // creation flow
    val creds = <getCredentialsFromInternalDb(callingPackage)>
    val passwords = creds.passwords
    for (password in passwords) {
        passwordEntries.add(
            PasswordCredentialEntry(
                context = applicationContext,
                username = password.username,
                pendingIntent = createNewPendingIntent(
                GET_PASSWORD_INTENT
                ),
                beginGetPasswordOption = option
                    displayName = password.username,
                icon = password.icon
            )
        )
    }
    return passwordEntries
}

private fun createNewPendingIntent(
    action: String,
    extra: Bundle? = null
): PendingIntent {
    val intent = Intent(action).setPackage(PACKAGE_NAME)
    if (extra != null) {
        intent.putExtra("CREDENTIAL_DATA", extra)
    }

    return PendingIntent.getActivity(
        applicationContext, UNIQUE_REQUEST_CODE, intent,
        (PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT)
    )
}

  4. Dopo aver eseguito la query e aver inserito le credenziali, ora devi gestire la fase di selezione delle credenziali selezionate dall'utente, che si tratti di una passkey o una password.

Gestione della selezione degli utenti per le passkey

  1. Nel metodo onCreate dell'attività corrispondente, recupera l'intent associato e passa a PendingIntentHandler.retrieveProviderGetCredentialRequest().
  2. Estrai GetPublicKeyCredentialOption dalla richiesta recuperata sopra. Successivamente, estrai requestJson e clientDataHash da questa opzione.
  3. Estrai il campo credentialId dall'intent aggiuntivo, che è stato completato dal provider di credenziali al momento della configurazione dell'elemento PendingIntent corrispondente.
  4. Estrai la passkey dal database locale utilizzando i parametri della richiesta di cui sopra.

  5. Dichiara che la passkey è valida con i metadati estratti e la verifica dell'utente.

    val getRequest =
    PendingIntentHandler.retrieveProviderGetCredentialRequest(intent)
val publicKeyRequest =
getRequest.credentialOption as GetPublicKeyCredentialOption

val requestInfo = intent.getBundleExtra("CREDENTIAL_DATA")
val credIdEnc = requestInfo.getString("credId")

// Get the saved passkey from your database based on the credential ID
// from the publickeyRequest
val passkey = <your database>.getPasskey(credIdEnc)

// Decode the credential ID, private key and user ID
val credId = b64Decode(credIdEnc)
val privateKey = b64Decode(passkey.credPrivateKey)
val uid = b64Decode(passkey.uid)

val origin = appInfoToOrigin(getRequest.callingAppInfo)
val packageName = getRequest.callingAppInfo.packageName

validatePasskey(
    publicKeyRequest.requestJson,
    origin,
    packageName,
    uid,
    passkey.username,
    credId,
    privateKey
)

  6. Per convalidare l'utente, visualizza un prompt biometrico (o un altro metodo di asserzione). Lo snippet di codice riportato di seguito utilizza l'API biometrica di Android.

  7. Una volta completata l'autenticazione, crea una risposta JSON basata sulle specifiche W3 Web Authentication Assertion. Nello snippet di codice riportato di seguito, vengono utilizzate classi di dati helper come AuthenticatorAssertionResponse per acquisire parametri strutturati e convertirli nel formato JSON richiesto. La risposta contiene una firma digitale dalla chiave privata di una credenziale WebAuthn. Il server della parte affidabile può verificare questa firma per autenticare un utente prima di accedere.

  8. Crea un elemento PublicKeyCredential utilizzando il JSON generato in precedenza e impostalo su una GetCredentialResponse finale. Imposta questa risposta finale sul risultato di questa attività.

L'esempio seguente illustra come è possibile implementare questi passaggi:

val request = PublicKeyCredentialRequestOptions(requestJson)
val privateKey: ECPrivateKey = convertPrivateKey(privateKeyBytes)

val biometricPrompt = BiometricPrompt(
    this,
    <executor>,
    object : BiometricPrompt.AuthenticationCallback() {
        override fun onAuthenticationError(
        errorCode: Int, errString: CharSequence
        ) {
            super.onAuthenticationError(errorCode, errString)
            finish()
        }

        override fun onAuthenticationFailed() {
            super.onAuthenticationFailed()
            finish()
        }

        override fun onAuthenticationSucceeded(
        result: BiometricPrompt.AuthenticationResult
        ) {
        super.onAuthenticationSucceeded(result)
        val response = AuthenticatorAssertionResponse(
            requestOptions = request,
            credentialId = credId,
            origin = origin,
            up = true,
            uv = true,
            be = true,
            bs = true,
            userHandle = uid,
            packageName = packageName
        )

        val sig = Signature.getInstance("SHA256withECDSA");
        sig.initSign(privateKey)
        sig.update(response.dataToSign())
        response.signature = sig.sign()

        val credential = FidoPublicKeyCredential(
            rawId = credId, response = response
        )
        val result = Intent()
        val passkeyCredential = PublicKeyCredential(credential.json)
        PendingIntentHandler.setGetCredentialResponse(
            result, GetCredentialResponse(passkeyCredential)
        )
        setResult(RESULT_OK, result)
        finish()
        }
    }
)

val promptInfo = BiometricPrompt.PromptInfo.Builder()
    .setTitle("Use your screen lock")
    .setSubtitle("Use passkey for ${request.rpId}")
    .setAllowedAuthenticators(
            BiometricManager.Authenticators.BIOMETRIC_STRONG
            /* or BiometricManager.Authenticators.DEVICE_CREDENTIAL */
        )
    .build()
biometricPrompt.authenticate(promptInfo)

Gestione della selezione degli utenti per l'autenticazione della password

  1. Nell'attività corrispondente, accedi all'intent trasmesso a onCreate ed estrai ProviderGetCredentialRequest utilizzando PendingIntentHandler.

  2. Utilizza GetPasswordOption nella richiesta per recuperare le credenziali della password per il nome del pacchetto in entrata.

    val getRequest =
PendingIntentHandler.retrieveProviderGetCredentialRequest(intent)

val passwordOption = getRequest.credentialOption as GetPasswordCredentialOption

val username = passwordOption.username
// Fetch the credentials for the calling app package name
val creds = <your_database>.getCredentials(callingAppInfo.packageName)
val passwords = creds.passwords
val it = passwords.iterator()
var password = ""
while (it.hasNext() == true) {
    val passwordItemCurrent = it.next()
    if (passwordItemCurrent.username == username) {
       password = passwordItemCurrent.password
       break
    }
}

  3. Una volta recuperata, imposta la risposta per la credenziale della password selezionata.

    // Set the response back
val result = Intent()
val passwordCredential = PasswordCredential(username, password)
PendingIntentHandler.setGetCredentialResponse(
result, GetCredentialResponse(passwordCredential)
)
setResult(Activity.RESULT_OK, result)
finish()

Gestisci la selezione di una voce di azione di autenticazione

Come menzionato in precedenza, un fornitore di credenziali può impostare un valore AuthenticationAction se le credenziali sono bloccate. Se l'utente seleziona questa voce, viene richiamata l'attività corrispondente all'azione per intent impostata in PendingIntent. I fornitori di credenziali possono quindi mostrare un flusso di autenticazione biometrica o un meccanismo simile per sbloccare le credenziali. Se l'operazione ha esito positivo, il fornitore di credenziali deve creare un BeginGetCredentialResponse, in modo simile alla gestione dell'accesso utente descritta sopra, poiché le credenziali sono ora sbloccate. Questa risposta deve essere impostata tramite il metodo PendingIntentHandler.setBeginGetCredentialResponse() prima che l'intent preparato venga impostato come risultato e l'attività sia terminata.

Cancella le richieste di credenziali

Un'app client può richiedere che qualsiasi stato mantenuto per la selezione delle credenziali debba essere cancellato, ad esempio un fornitore di credenziali può ricordare le credenziali selezionate in precedenza e restituirle solo la volta successiva. Un'app client chiama questa API e si aspetta che la selezione fissa venga cancellata. Il tuo servizio del provider di credenziali può gestire questa richiesta sostituendo il metodo onClearCredentialStateRequest():

override fun onClearCredentialStateRequest(
    request: android.service.credentials.ClearCredentialStateRequest,
    cancellationSignal: CancellationSignal,
    callback: OutcomeReceiver<Void?, ClearCredentialException>,
  ) {
    // Delete any maintained state as appropriate.
}

Ottieni una lista consentita di app con privilegi

Le app con privilegi, come i browser web, effettuano chiamate a Gestore delle credenziali per conto di altre parti attendibili impostando il parametro origin nei metodi Gestore delle credenziali GetCredentialRequest() e CreatePublicKeyCredentialRequest(). Per elaborare queste richieste, il provider di credenziali recupera origin utilizzando l'API getOrigin().

Per recuperare origin, l'app del provider di credenziali deve passare all'API androidx.credentials.provider.CallingAppInfo's getOrigin() un elenco di chiamanti con privilegi e attendibili. Questa lista consentita deve essere un oggetto JSON valido. Il valore origin viene restituito se packageName e le fingerprint del certificato ottenute da signingInfo corrispondono a quelle di un'app trovata in privilegedAllowlist passata all'API getOrigin(). Una volta ottenuto il valore origin, l'app del provider dovrebbe considerarla una chiamata con privilegi e impostare questo origin sui dati del client in AuthenticatorResponse, invece di calcolare origin utilizzando la firma dell'app chiamante.

Se recuperi un origin, utilizza il valore clientDataHash fornito direttamente in CreatePublicKeyCredentialRequest() o GetPublicKeyCredentialOption() anziché eseguire l'assemblaggio e l'hashing clientDataJSON durante la richiesta di firma. Per evitare problemi di analisi JSON, imposta un valore segnaposto per clientDataJSON nella risposta dell'attestazione e dell'asserzione.

Gestore delle password di Google utilizza una lista consentita aperta per le chiamate a getOrigin(). In qualità di fornitore di credenziali, puoi utilizzare questo elenco o fornirne uno nel formato JSON descritto dall'API. Spetta al provider scegliere quale elenco utilizzare. Per ottenere l'accesso privilegiato con provider di credenziali di terze parti, consulta la documentazione fornita dalla terza parte.

Abilitare i fornitori su un dispositivo

Gli utenti devono attivare il provider tramite impostazioni del dispositivo > Password e account > Il tuo provider > Attiva o Disattiva.

Su Android 14 o versioni successive, chiama l'API createSettingsPendingIntent() per restituire un intent in attesa quando viene richiamato. Viene visualizzata una schermata che consente a un utente di attivare il provider di Gestore delle credenziali.

fun createSettingsPendingIntent(): PendingIntent