Google używa technologii AI do tłumaczenia treści na Twój preferowany język. Tłumaczenia wygenerowane przez AI mogą zawierać błędy.

Integrowanie Menedżera danych logowania z rozwiązaniem dostawcy danych uwierzytelniających

Credential Manager to zestaw interfejsów API wprowadzonych w Androidzie 14, które obsługują różne metody logowania, takie jak nazwa użytkownika i hasło, klucze dostępu i rozwiązania do logowania sfederowanego (np. Zaloguj się przez Google). Gdy wywoływany jest interfejs Credential Manager API, system Android agreguje dane logowania ze wszystkich dostawców danych logowania zainstalowanych na urządzeniu. W tym dokumencie opisano zestaw interfejsów API, które udostępniają punkty końcowe integracji dla tych dostawców danych logowania.

Konfiguracja

Zanim zaimplementujesz funkcje w dostawcy danych logowania, wykonaj czynności konfiguracyjne opisane w poniższych sekcjach.

Deklarowanie zależności

Aby używać najnowszej wersji biblioteki Credential Manager, dodaj do skryptu kompilacji modułu aplikacji te zależności:

Kotlin

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

Groovy

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

Zadeklaruj element usługi w pliku manifestu

W pliku manifestu aplikacji AndroidManifest.xml dodaj deklarację <service> dla klasy usługi, która rozszerza klasę CredentialProviderService z biblioteki androidx.credentials, jak pokazano w przykładzie poniżej.

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

Uprawnienia i filtr intencji pokazane w poprzednim przykładzie są niezbędne do prawidłowego działania przepływu Credential Manager. Uprawnienie jest wymagane, aby można było z nią powiązać tylko system Android. Filtr intencji służy do wykrywania tej usługi jako dostawcy danych logowania, który ma być używany przez Menedżera danych logowania.

Deklarowanie obsługiwanych typów danych logowania

W katalogu res/xml utwórz nowy plik o nazwie provider.xml. W tym pliku zadeklaruj typy danych logowania obsługiwane przez Twoją usługę, używając stałych zdefiniowanych dla każdego typu danych logowania w bibliotece. W tym przykładzie usługa obsługuje tradycyjne hasła oraz klucze dostępu, których stałe są zdefiniowane jako TYPE_PASSWORD_CREDENTIAL i 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>

Na poprzednich poziomach interfejsu API dostawcy danych logowania integrują się z interfejsami API, takimi jak autouzupełnianie haseł i innych danych. Dostawcy mogą używać tej samej infrastruktury wewnętrznej do przechowywania istniejących typów danych logowania, jednocześnie rozszerzając ją o obsługę innych typów, w tym kluczy dostępu.

Dwufazowe podejście do interakcji z dostawcą

Menedżer danych logowania wchodzi w interakcję z dostawcami danych logowania w 2 fazach:

Pierwsza faza to faza rozpoczęcia/zapytania, w której system wiąże się z usługami dostawcy danych logowania i wywołuje metody onBeginGetCredentialRequest(), onBeginCreateCredentialRequest() lub onClearCredentialStateRequest() z żądaniami Begin…. Dostawcy muszą przetworzyć te żądania i odpowiedzieć za pomocą odpowiedzi Begin…, wypełniając je wpisami, które reprezentują opcje wizualne do wyświetlenia w selektorze kont. Każdy wpis musi mieć ustawioną wartość PendingIntent.
Gdy użytkownik wybierze wpis, rozpocznie się faza wyboru i zostanie wywołany powiązany z nim obiekt PendingIntent, co spowoduje wyświetlenie odpowiedniej aktywności dostawcy. Gdy użytkownik zakończy interakcję z tą aktywnością, dostawca danych logowania musi ustawić odpowiedź na wynik aktywności, zanim ją zakończy. Ta odpowiedź jest następnie wysyłana do aplikacji klienta, która wywołała Credential Manager.

Obsługa tworzenia kluczy dostępu

Obsługa zapytań dotyczących tworzenia kluczy dostępu

Gdy aplikacja kliencka chce utworzyć klucz dostępu i zapisać go u dostawcy danych logowania, wywołuje interfejs API createCredential. Aby obsłużyć to żądanie w usłudze dostawcy danych logowania i zapisać klucz dostępu w miejscu na dane, wykonaj czynności opisane w poniższych sekcjach.

Zastąp metodę onBeginCreateCredentialRequest() w usłudze rozszerzonej z CredentialProviderService.
Obsłuż BeginCreateCredentialRequest, tworząc odpowiedni obiekt BeginCreateCredentialResponse i przekazując go przez wywołanie zwrotne.
Podczas tworzenia obiektu BeginCreateCredentialResponse dodaj wymagany obiekt CreateEntries. Każdy element CreateEntry powinien odpowiadać kontu, na którym można zapisać dane logowania, i musi mieć ustawiony atrybut PendingIntent oraz inne wymagane metadane.

Poniższy przykład pokazuje, jak wykonać te czynności.

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

Konstrukcja PendingIntent powinna być zgodna z tymi wytycznymi:

Odpowiednia aktywność powinna być skonfigurowana tak, aby wyświetlać wymagane potwierdzenie lub wybór albo prośbę o uwierzytelnienie biometryczne.
Wszystkie wymagane dane, których dostawca potrzebuje, gdy wywoływana jest odpowiednia aktywność, powinny być ustawione jako dodatkowe w intencji używanej do utworzenia PendingIntent, np. accountId w procesie tworzenia.
Obiekt PendingIntent musi być utworzony z flagą PendingIntent.FLAG_MUTABLE, aby system mógł dołączyć ostateczne żądanie do dodatkowych danych intencji.
Obiekt PendingIntent nie może być tworzony z flagą PendingIntent.FLAG_ONE_SHOT, ponieważ użytkownik może wybrać wpis, wrócić i wybrać go ponownie, co spowoduje dwukrotne uruchomienie obiektu PendingIntent.
Obiekt PendingIntent musi być utworzony z unikalnym kodem żądania, aby każdy wpis miał odpowiadający mu obiekt PendingIntent.

Obsługa wyboru danych na potrzeby żądań utworzenia klucza dostępu

Gdy użytkownik wybierze wcześniej wypełniony element CreateEntry, wywoływany jest odpowiedni element PendingIntent i tworzony jest powiązany dostawca Activity.
Po wywołaniu metody onCreate aktywności uzyskaj dostęp do powiązanej intencji i przekaż ją do klasy PendingIntentHander, aby uzyskać ProviderCreateCredentialRequest.
Wyodrębnij z żądania requestJson, callingAppInfo i clientDataHash.
Wyodrębnij lokalne ustawienia accountId z dodatkowych danych intencji. Jest to implementacja specyficzna dla przykładowej aplikacji i nie jest wymagana. Ten identyfikator konta może służyć do przechowywania tych danych logowania na tym konkretnym koncie.
Sprawdź requestJson. W poniższym przykładzie użyto lokalnych klas danych, takich jak PublicKeyCredentialCreationOptions, aby przekonwertować wejściowy kod JSON na klasę uporządkowaną zgodnie ze specyfikacją WebAuthn. Jako dostawca danych logowania możesz zastąpić ten kod własnym parserem.
Jeśli połączenie pochodzi z natywnej aplikacji na Androida, sprawdź asset-link aplikacji do dzwonienia.
wyświetlić monit uwierzytelniania, W przykładzie poniżej użyto interfejsu API Biometric na Androidzie.
Po pomyślnym uwierzytelnieniu wygeneruj credentialId i parę kluczy.
Zapisz klucz prywatny w lokalnej bazie danych dla callingAppInfo.packageName.
Utwórz odpowiedź JSON interfejsu Web Authentication API, która składa się z klucza publicznego i credentialId. W poniższym przykładzie użyto lokalnych klas narzędziowych, takich jak AuthenticatorAttestationResponse i FidoPublicKeyCredential, które pomagają utworzyć obiekt JSON na podstawie wspomnianej wcześniej specyfikacji.Jako dostawca danych logowania możesz zastąpić te klasy własnymi kreatorami.
Utwórz obiekt CreatePublicKeyCredentialResponse z wygenerowanym powyżej kodem JSON.
Ustaw CreatePublicKeyCredentialResponse jako dodatkowy element w Intent za pomocą PendingIntentHander.setCreateCredentialResponse() i ustaw tę intencję jako wynik aktywności.
Zakończ aktywność.

Te kroki ilustruje poniższy przykład kodu. Ten kod musi zostać obsłużony w klasie Activity po wywołaniu metody 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)}"
}

Obsługa zapytań dotyczących próśb o utworzenie hasła

Aby obsługiwać zapytania dotyczące żądań utworzenia hasła, wykonaj te czynności:

W metodzie processCreateCredentialRequest() wspomnianej w poprzedniej sekcji dodaj kolejny przypadek w bloku przełącznika, aby obsługiwać żądania haseł.
Podczas tworzenia BeginCreateCredentialResponse dodaj wymagane CreateEntries.
Każdy element CreateEntry powinien odpowiadać kontu, na którym można zapisać dane logowania, i musi mieć ustawiony element PendingIntent oraz inne metadane.

Poniższy przykład pokazuje, jak wykonać te czynności:

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

Obsługa wyboru danych logowania w przypadku żądań utworzenia hasła

Gdy użytkownik wybierze wypełniony element CreateEntry, zostanie wykonany odpowiedni element PendingIntent i wyświetli się powiązana aktywność. Uzyskaj dostęp do powiązanej intencji przekazanej w onCreate i przekaż ją do klasy PendingIntentHander, aby uzyskać metodę ProviderCreateCredentialRequest.

Poniższy przykład pokazuje, jak wdrożyć ten proces. Ten kod musi być obsługiwany w metodzie onCreate() aktywności.

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

Logowanie użytkownika odbywa się w następujący sposób:

Gdy aplikacja kliencka próbuje zalogować użytkownika, przygotowuje instancję GetCredentialRequest.
Platforma Androida przekazuje to żądanie do wszystkich odpowiednich dostawców danych logowania, łącząc się z tymi usługami.
Usługa dostawcy otrzymuje wtedy obiekt BeginGetCredentialRequest, który zawiera listę obiektów BeginGetCredentialOption. Każdy z nich zawiera parametry, których można użyć do pobrania pasujących danych logowania.

Aby obsłużyć to żądanie w usłudze dostawcy danych logowania, wykonaj te czynności:

Zastąp metodę onBeginGetCredentialRequest(), aby obsłużyć żądanie. Pamiętaj, że jeśli dane logowania są zablokowane, możesz natychmiast ustawić AuthenticationAction w odpowiedzi i wywołać wywołanie zwrotne.

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

Dostawcy, którzy wymagają odblokowania danych logowania przed zwróceniem jakichkolwiek danych credentialEntries, muszą skonfigurować intencję oczekującą, która przekieruje użytkownika do procesu odblokowywania aplikacji:

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

Pobierz dane logowania z lokalnej bazy danych i skonfiguruj je za pomocą CredentialEntries, aby były wyświetlane w selektorze. W przypadku kluczy dostępu możesz ustawić credentialId jako dodatkowy element intencji, aby wiedzieć, do jakich danych logowania jest on mapowany, gdy użytkownik wybierze ten wpis.

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

Pobierz dane logowania z bazy danych, utwórz wpisy kluczy dostępu i haseł do wypełnienia.

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

Po wysłaniu zapytania i wypełnieniu danych logowania musisz obsłużyć etap wyboru danych logowania przez użytkownika, niezależnie od tego, czy jest to klucz dostępu, czy hasło.

Obsługa wyboru użytkownika w przypadku kluczy dostępu

W metodzie onCreate odpowiedniej aktywności pobierz powiązaną intencję i przekaż ją do PendingIntentHandler.retrieveProviderGetCredentialRequest().
Wyodrębnij GetPublicKeyCredentialOption z pobranego powyżej żądania. Następnie wyodrębnij z tej opcji requestJson i clientDataHash.
Wyodrębnij credentialId z dodatkowych danych intencji, które zostały wypełnione przez dostawcę danych logowania podczas konfigurowania odpowiedniego PendingIntent.
Wyodrębnij klucz dostępu z lokalnej bazy danych, używając parametrów żądania, do których uzyskano dostęp powyżej.

Potwierdź, że klucz dostępu jest prawidłowy, korzystając z wyodrębnionych metadanych i weryfikacji użytkownika.

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
)

Aby zweryfikować użytkownika, wyświetl prośbę o dane biometryczne (lub inną metodę potwierdzenia). Poniższy fragment kodu korzysta z interfejsu Android Biometric API.
Po pomyślnym uwierzytelnieniu utwórz odpowiedź JSON na podstawie specyfikacji asercji uwierzytelniania internetowego W3. We fragmencie kodu poniżej klasy danych pomocniczych, takie jak AuthenticatorAssertionResponse, są używane do pobierania uporządkowanych parametrów i konwertowania ich na wymagany format JSON. Odpowiedź zawiera podpis cyfrowy z klucza prywatnego danych logowania WebAuthn. Serwer strony uzależnionej może zweryfikować ten podpis, aby uwierzytelnić użytkownika przed zalogowaniem.
Utwórz obiekt PublicKeyCredential, używając wygenerowanego powyżej kodu JSON, i ustaw go w obiekcie GetCredentialResponse. Ustaw tę ostateczną odpowiedź na wynik tego działania.

Poniższy przykład pokazuje, jak można wykonać te czynności:

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)

Obsługa wyboru użytkownika na potrzeby uwierzytelniania za pomocą hasła

W odpowiedniej aktywności uzyskaj dostęp do intencji przekazanej do onCreate i wyodrębnij ProviderGetCredentialRequest za pomocą PendingIntentHandler.

Aby pobrać dane logowania za pomocą hasła dla nazwy pakietu przychodzącego, użyj w żądaniu GetPasswordOption.

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

Po pobraniu ustaw odpowiedź dla wybranego hasła.

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

Obsługa wyboru wpisu działania uwierzytelniania

Jak wspomnieliśmy wcześniej, dostawca danych uwierzytelniających może ustawić AuthenticationAction, jeśli dane uwierzytelniające są zablokowane. Jeśli użytkownik wybierze ten wpis, zostanie wywołana aktywność odpowiadająca działaniu intencji ustawionemu w PendingIntent. Dostawcy danych logowania mogą następnie wyświetlić proces uwierzytelniania biometrycznego lub podobny mechanizm, aby odblokować dane logowania. W przypadku powodzenia dostawca danych logowania musi utworzyć obiekt BeginGetCredentialResponse, podobnie jak w przypadku obsługi logowania użytkownika opisanej powyżej, ponieważ dane logowania są teraz odblokowane. Odpowiedź należy następnie ustawić za pomocą metody PendingIntentHandler.setBeginGetCredentialResponse(), zanim przygotowana intencja zostanie ustawiona jako wynik, a aktywność zostanie zakończona.

Wyczyść żądania danych logowania

Aplikacja kliencka może zażądać wyczyszczenia stanu zapisanego na potrzeby wyboru danych logowania, np. dostawca danych logowania może zapamiętać wcześniej wybrane dane logowania i zwrócić je tylko następnym razem. Aplikacja kliencka wywołuje ten interfejs API i oczekuje, że wybór zostanie wyczyszczony. Usługa dostawcy danych logowania może obsłużyć to żądanie, zastępując metodę onClearCredentialStateRequest():

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

Dodanie możliwości linkowania do strony ustawień dostawcy

Aby umożliwić użytkownikom otwieranie ustawień dostawcy na ekranie Hasła, klucze i autouzupełnianie, aplikacje dostawcy danych logowania powinny implementować atrybut manifestu credential-provider settingsActivity w res/xml/provider.xml. Ten atrybut umożliwia użycie intencji do otwarcia ekranu ustawień aplikacji, gdy użytkownik kliknie nazwę dostawcy na liście usług Hasła, klucze dostępu i autouzupełnianie. Dla tego atrybutu ustaw wartość odpowiadającą nazwie aktywności, która ma być uruchamiana z ekranu ustawień.

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

Diagram przedstawiający funkcje przycisków zmiany i otwierania — **Rysunek 1.** Przycisk **Zmień** otwiera okno wyboru, w którym użytkownik może wybrać preferowanego dostawcę danych logowania. Przycisk **Otwórz** uruchamia aktywność ustawień zdefiniowaną w zmianie pliku manifestu i otwiera stronę ustawień konkretnego dostawcy.

Intencje dotyczące ustawień

Otwórz ustawienia: intencja android.settings.CREDENTIAL_PROVIDER wyświetla ekran ustawień, na którym użytkownik może wybrać preferowanych i dodatkowych dostawców danych logowania.

**Ilustracja 2.** Ekran ustawień haseł, kluczy dostępu i autouzupełniania.

Preferowana usługa danych logowania: intencja ACTION_REQUEST_SET_AUTOFILL_SERVICE przekierowuje użytkownika do ekranu wyboru preferowanego dostawcy. Dostawca wybrany na tym ekranie stanie się preferowanym dostawcą danych logowania i autouzupełniania.

Uzyskiwanie listy dozwolonych aplikacji uprzywilejowanych

Aplikacje z podwyższonymi uprawnieniami, takie jak przeglądarki, wywołują Credential Manager w imieniu innych stron zależnych, ustawiając parametr origin w metodach GetCredentialRequest() i CreatePublicKeyCredentialRequest() Credential Manager. Aby przetworzyć te żądania, dostawca danych logowania pobiera origin za pomocą interfejsu API getOrigin().

Aby pobrać origin, aplikacja dostawcy danych logowania musi przekazać listę uprzywilejowanych i zaufanych rozmówców do interfejsu API androidx.credentials.provider.CallingAppInfo's getOrigin(). Ta lista dozwolonych musi być prawidłowym obiektem JSON. origin jest zwracany, jeśli packageName i odciski cyfrowe certyfikatu uzyskane z signingInfo pasują do odcisków cyfrowych aplikacji znalezionej w privilegedAllowlist przekazanym do interfejsu API getOrigin(). Po uzyskaniu wartości origin aplikacja dostawcy powinna uznać to za połączenie uprzywilejowane i ustawić tę wartość origin w danych klienta w AuthenticatorResponse, zamiast obliczać origin przy użyciu podpisu aplikacji wywołującej.

Jeśli pobierzesz origin, użyj clientDataHash podanego bezpośrednio w CreatePublicKeyCredentialRequest() lub GetPublicKeyCredentialOption() zamiast składania i haszowania clientDataJSON podczas podpisanego żądania. Aby uniknąć problemów z analizą kodu JSON, ustaw wartość zmiennej dla clientDataJSON w odpowiedzi na atest i asercję. Menedżer haseł Google używa publicznie dostępnej listy dozwolonych do wywołań getOrigin(). Jako dostawca danych logowania możesz użyć tej listy lub podać własną w formacie JSON opisanym przez interfejs API. To dostawca decyduje, która lista zostanie użyta. Aby uzyskać uprzywilejowany dostęp u zewnętrznych dostawców danych logowania, zapoznaj się z dokumentacją dostarczoną przez daną firmę.

Włączanie dostawców na urządzeniu

Użytkownicy muszą włączyć dostawcę w ustawieniach urządzenia > Hasła i konta > Twój dostawca > Włącz lub wyłącz.

fun createSettingsPendingIntent(): PendingIntent