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

Gestore delle credenziali si riferisce a un insieme di API introdotte in Android 14 che supportano più metodi di accesso, come 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 provider di credenziali.

Configurazione

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

Dichiarazione di dipendenze

Aggiungi le seguenti dipendenze allo script di build del modulo dell'app per utilizzare l'ultima versione della libreria Gestore delle credenziali:

Kotlin

dependencies {
    implementation("androidx.credentials:credentials:1.7.0-alpha02")
}

Trendy

dependencies {
    implementation "androidx.credentials:credentials:1.7.0-alpha02"
}

Dichiara l'elemento del servizio nel file manifest

Nel file manifest dell'app AndroidManifest.xml, 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="@mipmap/ic_launcher"
    android:permission="android.permission.BIND_CREDENTIAL_PROVIDER_SERVICE"
    tools:targetApi="upside_down_cake">
    <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 nell'esempio precedente sono fondamentali per il funzionamento previsto del flusso di Gestore delle credenziali. L'autorizzazione è necessaria per consentire l'associazione a questo servizio solo al sistema Android. Il filtro per intent viene utilizzato per la rilevabilità di questo servizio come provider di credenziali da utilizzare con 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 tuo servizio tramite le costanti definite per ogni tipo di credenziale nella libreria. Nell'esempio seguente, il servizio supporta le password tradizionali e le passkey, le cui costanti sono definite come TYPE_PASSWORD_CREDENTIAL e TYPE_PUBLIC_KEY_CREDENTIAL:

<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 fornitori di credenziali si integrano con API come la compilazione automatica per password e altri dati. Questi provider possono utilizzare la stessa infrastruttura interna per archiviare i tipi di credenziali esistenti, espandendola al contempo per supportarne altri, incluse le passkey.

Approccio in due fasi all'interazione con i provider

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

  1. La prima fase è la fase di inizio/query in cui il sistema si associa ai servizi del provider di credenziali e richiama i metodi onBeginGetCredentialRequest(), onBeginCreateCredentialRequest() o onClearCredentialStateRequest() con le richieste Begin…. I provider devono elaborare queste richieste e rispondere con risposte Begin…, compilandole con voci che rappresentano le opzioni visive da mostrare nel selettore dell'account. Ogni voce deve avere un set PendingIntent.
  2. Una volta che l'utente seleziona una voce, inizia la fase di selezione e viene attivato l'PendingIntent associato alla voce, che richiama l'attività del provider corrispondente. Una volta che l'utente ha terminato di interagire con questa attività, il provider 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.

Gestisci la creazione delle passkey

Gestisci le query per la creazione di passkey

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

  1. Esegui l'override del metodo onBeginCreateCredentialRequest() nel servizio esteso da CredentialProviderService.
  2. Gestisci BeginCreateCredentialRequest creando un BeginCreateCredentialResponse corrispondente e passandolo tramite il callback.
  3. Durante la creazione di BeginCreateCredentialResponse, aggiungi l'elemento CreateEntries richiesto. Ogni CreateEntry deve corrispondere a un account in cui è possibile salvare la credenziale e deve avere un PendingIntent impostato insieme ad altri metadati obbligatori.

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 di autenticazione biometrica, conferma o selezione richiesta.
  • Tutti i dati richiesti dal provider quando viene richiamata l'attività corrispondente devono essere impostati come extra nell'intent utilizzato per creare il tuo PendingIntent, ad esempio un accountId nel flusso di creazione.
  • PendingIntent deve essere costruito con il flag PendingIntent.FLAG_MUTABLE in modo che il sistema possa aggiungere la richiesta finale all'extra dell'intent.
  • PendingIntent non deve essere creato con il flag PendingIntent.FLAG_ONE_SHOT, poiché l'utente potrebbe selezionare una voce, tornare indietro e selezionarla di nuovo, il che causerebbe l'attivazione di PendingIntent due volte.
  • PendingIntent deve essere costruito 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 CreateEntry compilato in precedenza, viene richiamato il PendingIntent corrispondente e viene creato il Activity del provider associato.
  2. Dopo aver richiamato il metodo onCreate della tua attività, accedi all'intent associato e passalo alla classe PendingIntentHander per ottenere ProviderCreateCredentialRequest.
  3. Estrai requestJson, callingAppInfo e clientDataHash dalla richiesta.
  4. Estrai il accountId locale dall'extra dell'intent. Si tratta di un'implementazione specifica dell'app di esempio e non è obbligatoria. Questo ID account può essere utilizzato per memorizzare questa credenziale in relazione a questo ID account specifico.
  5. Convalida il requestJson. L'esempio seguente utilizza classi di dati locali come PublicKeyCredentialCreationOptions per convertire il JSON di input in una classe strutturata in base alla specifica WebAuthn. In qualità di provider di credenziali, puoi sostituirlo con il tuo parser.
  6. Controlla l'asset-link dell'app di chiamate se la chiamata proviene da un'app per Android nativa.
  7. Mostra un prompt di autenticazione. L'esempio seguente utilizza l'API Biometric di Android.
  8. Quando l'autenticazione va a buon fine, genera un credentialId e una coppia di chiavi.
  9. Salva la chiave privata nel tuo database locale in corrispondenza di callingAppInfo.packageName.
  10. Crea una risposta JSON dell'API Web Authentication composta dalla chiave pubblica e da credentialId. L'esempio seguente utilizza classi di utilità locali come AuthenticatorAttestationResponse e FidoPublicKeyCredential che aiutano a creare un JSON basato sulla specifica menzionata in precedenza.In qualità di fornitore di credenziali, puoi sostituire queste classi con i tuoi builder.
  11. Crea un CreatePublicKeyCredentialResponse con il JSON generato sopra.
  12. Imposta CreatePublicKeyCredentialResponse come extra su un Intent tramite PendingIntentHander.setCreateCredentialResponse() e imposta l'intent sul risultato dell'attività.
  13. Termina l'attività.

L'esempio di codice riportato di seguito illustra questi passaggi. Questo codice deve essere gestito nella classe Activity una volta richiamato onCreate().

override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {
    super.onCreate(savedInstanceState, persistentState)
    // ...

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

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

    val biometricPrompt = BiometricPrompt(
        this,
        { }, // Pass in your own executor
        object : AuthenticationCallback() {
            override fun onAuthenticationError(errorCode: Int, errString: CharSequence) {
                super.onAuthenticationError(errorCode, errString)
                finish()
            }

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

            @RequiresApi(VERSION_CODES.P)
            override fun onAuthenticationSucceeded(
                result: 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,
                    authenticatorAttachment = "", // Add your authenticator attachment
                )
                val result = Intent()

                val createPublicKeyCredResponse =
                    CreatePublicKeyCredentialResponse(credential.json())

                // Set the CreateCredentialResponse as the result of the Activity
                PendingIntentHandler.setCreateCredentialResponse(
                    result,
                    createPublicKeyCredResponse
                )
                setResult(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)
}

@RequiresApi(VERSION_CODES.P)
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, segui questi passaggi:

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

Il seguente esempio 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
}

@RequiresApi(VERSION_CODES.M)
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 delle password

Quando l'utente seleziona un CreateEntry compilato, viene eseguito il PendingIntent corrispondente e viene visualizzata l'attività associata. Accedi all'intent associato passato in onCreate e passalo alla classe PendingIntentHander per ottenere il metodo ProviderCreateCredentialRequest.

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

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

if (createRequest == null) {
    return
}

val request: CreatePasswordRequest = createRequest.callingRequest as CreatePasswordRequest

// Fetch the ID and password from the request and save it in your database
mDatabase.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)
finish()

Gestisci l'accesso degli utenti

L'accesso dell'utente viene gestito con i seguenti passaggi:

  • Quando un'app client tenta di eseguire l'accesso di un utente, prepara un'istanza GetCredentialRequest.
  • Il framework Android propaga questa richiesta a tutti i provider di credenziali applicabili associandosi a questi servizi.
  • Il servizio del provider riceve quindi un BeginGetCredentialRequest che contiene un elenco di BeginGetCredentialOption, ognuno dei quali contiene parametri che possono essere utilizzati 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 sulla 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 pending intent 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 database locale e configurale utilizzando CredentialEntries per visualizzarle nel selettore. Per le passkey, puoi impostare credentialId come extra nell'intent in modo da sapere a quale credenziale viene mappata 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 processGetCredentialRequest(
    request: BeginGetCredentialRequest
): BeginGetCredentialResponse {
    val callingPackageInfo = request.callingAppInfo
    val callingPackageName = callingPackageInfo?.packageName.orEmpty()
    val credentialEntries: MutableList<CredentialEntry> = mutableListOf()

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

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

    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
                ),
                beginGetPublicKeyCredentialOption = 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 compilato le credenziali, devi gestire la fase di selezione delle credenziali selezionate dall'utente, che si tratti di una passkey o di una password.

Gestione della selezione effettuata dall'utente per le passkey

  1. Nel metodo onCreate dell'attività corrispondente, recupera l'intent associato e passalo a PendingIntentHandler.retrieveProviderGetCredentialRequest().
  2. Estrai GetPublicKeyCredentialOption dalla richiesta recuperata in precedenza. Successivamente, estrai requestJson e clientDataHash da questa opzione.
  3. Estrai credentialId dall'extra dell'intent, che è stato compilato dal provider di credenziali durante la configurazione di PendingIntent corrispondente.
  4. Estrai la passkey dal database locale utilizzando i parametri della richiesta a cui hai eseguito l'accesso in precedenza.

  5. Verifica che la passkey sia valida con i metadati estratti e la verifica dell'utente.

    val getRequest = PendingIntentHandler.retrieveProviderGetCredentialRequest(intent)
val publicKeyRequest = getRequest?.credentialOptions?.first() as GetPublicKeyCredentialOption

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

// Get the saved passkey from your database based on the credential ID from the PublicKeyRequest
val passkey = mDatabase.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, mostra un prompt biometrico (o un altro metodo di asserzione). Lo snippet di codice riportato di seguito utilizza l'API Android Biometric.

  7. Una volta completata l'autenticazione, crea una risposta JSON basata sulla specifica W3 Web Authentication Assertion. Nello snippet di codice 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 della chiave privata di una credenziale WebAuthn. Il server della relying party può verificare questa firma per autenticare un utente prima dell'accesso.

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

L'esempio seguente illustra come implementare questi passaggi:

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

val biometricPrompt = BiometricPrompt(
    this,
    { }, // Pass in your own 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,
                authenticatorAttachment = "", // Add your authenticator attachment
            )
            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 dell'utente per l'autenticazione con password

  1. Nell'attività corrispondente, accedi all'intent passato 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?.credentialOptions?.first() as GetPasswordOption

val username = passwordOption.allowedUserIds.first()
// Fetch the credentials for the calling app package name
val creds = mDatabase.getCredentials(callingAppInfo.packageName)
val passwords = creds.passwords
val it = passwords.iterator()
var password = ""
while (it.hasNext()) {
    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 accennato in precedenza, un provider di credenziali può impostare un AuthenticationAction se le credenziali sono bloccate. Se l'utente seleziona questa voce, viene richiamata l'attività corrispondente all'azione dell'intent impostata in PendingIntent. I provider di credenziali possono quindi mostrare un flusso di autenticazione biometrica o un meccanismo simile per sbloccare le credenziali. In caso di esito positivo, il provider di credenziali deve creare un BeginGetCredentialResponse, in modo simile a come viene descritta sopra la gestione dell'accesso degli utenti, poiché le credenziali sono ora sbloccate. Questa risposta deve poi essere impostata tramite il metodo PendingIntentHandler.setBeginGetCredentialResponse() prima che l'intent preparato venga impostato come risultato e l'attività venga completata.

Cancella le richieste di credenziali

Un'app client può richiedere la cancellazione di qualsiasi stato mantenuto per la selezione delle credenziali, ad esempio un provider di credenziali potrebbe ricordare la credenziale selezionata in precedenza e restituire solo quella la volta successiva. Un'app client chiama questa API e si aspetta che la selezione fissa venga cancellata. Il servizio del provider di credenziali può gestire questa richiesta eseguendo l'override del metodo onClearCredentialStateRequest():

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

Per consentire agli utenti di aprire le impostazioni del tuo provider dalla schermata Password, passkey e compilazione automatica, le app del provider di credenziali devono implementare l'attributo manifest credential-provider settingsActivity in res/xml/provider.xml. Questo attributo ti consente di utilizzare un intent per aprire la schermata delle impostazioni della tua app se un utente fa clic sul nome di un provider nell'elenco di servizi Password, passkey e compilazione automatica. Imposta il valore di questo attributo sul nome dell'attività da avviare dalla schermata delle impostazioni.

<credential-provider
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:settingsSubtitle="Example settings provider name"
    android:settingsActivity="com.example.SettingsActivity">
    <capabilities>
        <capability name="android.credentials.TYPE_PUBLIC_KEY_CREDENTIAL" />
    </capabilities>
</credential-provider>
Diagramma che mostra le funzioni dei pulsanti Modifica e Apri
Figura 1: il pulsante Cambia apre la finestra di dialogo di selezione esistente, consentendo all'utente di selezionare il provider di credenziali preferito. Il pulsante Apri avvia l'attività delle impostazioni definita nella modifica del manifest e apre una pagina delle impostazioni specifica per quel provider.

Intent delle impostazioni

Apri le impostazioni: l'intent android.settings.CREDENTIAL_PROVIDER visualizza una schermata delle impostazioni in cui l'utente può selezionare i provider di credenziali preferiti e aggiuntivi.

La schermata delle impostazioni di password, passkey e compilazione automatica
Figura 2: la schermata delle impostazioni di password, passkey e compilazione automatica.

Servizio di credenziali preferito: l'intent ACTION_REQUEST_SET_AUTOFILL_SERVICE reindirizza l'utente alla schermata di selezione del provider preferito. Il fornitore selezionato in questa schermata diventa il fornitore preferito di credenziali e compilazione automatica.

Diagramma che mostra le funzioni dei pulsanti Modifica e Apri
Figura 3: la schermata delle impostazioni Servizio preferito per password, passkey e compilazione automatica.

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 relying party impostando il parametro origin nei metodi GetCredentialRequest() e CreatePublicKeyCredentialRequest() di Gestore delle credenziali. Per elaborare queste richieste, il provider di credenziali recupera il origin utilizzando l'API getOrigin().

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

Se recuperi un origin, utilizza il clientDataHash fornito direttamente in CreatePublicKeyCredentialRequest() o GetPublicKeyCredentialOption() anziché assemblare ed eseguire l'hashing di clientDataJSON durante la richiesta firmata. Per evitare problemi di analisi JSON, imposta un valore segnaposto per clientDataJSON nella risposta di attestazione e asserzione. Gestore delle password di Google utilizza una lista consentita disponibile pubblicamente per le chiamate a getOrigin(). In qualità di provider di credenziali, puoi utilizzare questo elenco o fornirne uno tuo nel formato JSON descritto dall'API. Spetta al fornitore selezionare l'elenco da utilizzare. Per ottenere l'accesso con privilegi con provider di credenziali di terze parti, consulta la documentazione fornita dalla terza parte.

Abilita i provider su un dispositivo

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

fun createSettingsPendingIntent(): PendingIntent