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

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

Skonfiguruj

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

Deklarowanie zależności

W pliku build.gradle modułu zadeklaruj zależność przy użyciu najnowszej wersji biblioteki Menedżera danych logowania:

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

Zadeklaruj element usługi w pliku manifestu

W pliku manifestu aplikacji AndroidManifest.xml umieść deklarację <service> klasy usługi, która rozszerza klasę CredentialProviderService z biblioteki androidx.credentials zgodnie z przykładem poniżej.

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

Uprawnienia i filtr intencji wymienione powyżej stanowią integralną część procesu Menedżera danych logowania, aby działać zgodnie z oczekiwaniami. Te uprawnienia są potrzebne, by można było powiązać z nią tylko system Android. Filtr intencji służy do wykrywania tej usługi jako dostawcy danych logowania do użycia przez menedżera danych uwierzytelniających.

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ę. W tym celu użyj stałych określonych dla poszczególnych typów danych logowania w bibliotece. W poniższym przykładzie usługa obsługuje tradycyjne hasła, a także klucze dostępu – stałe zdefiniowane jako TYPE_PASSWORD_CREDENTIAL i 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>

Na poprzednich poziomach dostawcy danych logowania dostawcy danych logowania integrują się z interfejsami API takimi jak autouzupełnianie haseł i inne dane. Ci dostawcy mogą używać tej samej infrastruktury wewnętrznej do przechowywania istniejących typów danych logowania, a jednocześnie rozszerzać tę bazę na inne, w tym klucze dostępu.

Dwuetapowe podejście do interakcji z usługodawcą

Menedżer danych logowania współpracuje z dostawcami danych logowania w 2 etapach:

  1. Pierwszy etap 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ą przetwarzać te żądania i odpowiadać za pomocą odpowiedzi Begin…, wypełniając je wpisami przedstawiającymi opcje wizualne, które mają się wyświetlać w selektorze kont. Każda pozycja musi mieć ustawiony atrybut PendingIntent.
  2. Gdy użytkownik wybierze wpis, rozpocznie się etap wyboru i uruchomi się powiązany z nim obiekt PendingIntent, co spowoduje rozpoczęcie odpowiedniej aktywności dostawcy. Gdy użytkownik zakończy interakcję z tym działaniem, dostawca danych logowania musi ustawić odpowiedź na wynik działania przed jego zakończeniem. Ta odpowiedź jest następnie wysyłana do aplikacji klienckiej, która wywołała Menedżera danych logowania.

Utwórz klucz dostępu

Obsługa zapytań o tworzenie klucza 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 w taki sposób, że klucz jest rzeczywiście przechowywany w pamięci, wykonaj czynności opisane w poniższych sekcjach.

  1. Zastąp metodę onBeginCreateCredentialRequest() w usłudze rozszerzonej z CredentialProviderService.
  2. Wykonaj obsługę BeginCreateCredentialRequest, tworząc odpowiedni element BeginCreateCredentialResponse i przekazując go w wywołaniu zwrotnym.
  3. Podczas tworzenia BeginCreateCredentialResponse dodaj wymagane CreateEntries. Każdy element CreateEntry powinien odpowiadać kontu, na którym dane logowania mogą zostać zapisane, i musi mieć zestaw PendingIntent wraz z innymi wymaganymi metadanymi.

Poniższy przykład pokazuje, jak to zrobić.

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:

  • Należy skonfigurować odpowiednie działanie, aby wyświetlać wszelkie wymagane powiadomienia biometryczne, potwierdzenia lub wyboru.
  • Wszystkie wymagane dane, których dostawca potrzebuje przy wywoływaniu danego działania, powinny być ustawione jako dodatkowe w intencji używanej do utworzenia elementu PendingIntent, np. accountId w procesie tworzenia.
  • PendingIntent musi być skonstruowany z flagą PendingIntent.FLAG_MUTABLE, aby system mógł dołączyć ostateczne żądanie do dodatkowej intencji.
  • Element PendingIntent nie może być utworzony z flagą PendingIntent.FLAG_ONE_SHOT, ponieważ użytkownik może wybrać wpis, wrócić i ponownie wybrać go, co spowoduje 2 uruchomienia elementu PendingIntent.
  • Element PendingIntent musi być utworzony z unikalnym kodem żądania, tak aby każdy wpis miał własny, odpowiadający mu kod PendingIntent.

Zarządzanie wybieraniem wpisów na potrzeby żądań utworzenia klucza dostępu

  1. Gdy użytkownik wybierze wypełnioną wcześniej CreateEntry, wywoływany jest odpowiedni dostawca PendingIntent i tworzony jest powiązany dostawca Activity.
  2. Po wywołaniu metody onCreate aktywności otwórz powiązaną intencję i przekaż ją do klasy PendingIntentHander, aby pobrać ProviderCreateCredentialRequest.
  3. Wyodrębnij z żądania requestJson, callingAppInfo i clientDataHash.
  4. Wyodrębnij lokalny plik accountId z dodatkowego intencji. Jest to przykładowa implementacja aplikacji, która nie jest wymagana. Za pomocą tego identyfikatora konta można przechowywać te dane logowania wraz z konkretnym identyfikatorem konta.
  5. Zweryfikuj requestJson. W przykładzie poniżej użyto lokalnych klas danych, takich jak PublicKeyCredentialCreationOptions, do przekonwertowania wejściowego kodu JSON na uporządkowaną klasę zgodnie ze specyfikacją WebAuthn. Jako dostawca danych logowania możesz zastąpić go własnym parserem.
  6. Jeśli wywołanie pochodzi z natywnej aplikacji na Androida, sprawdź link do zasobu aplikacji wywołującej.
  7. wyświetlanie prośby o uwierzytelnienie, W przykładzie poniżej użyto interfejsu API Biometric w Androidzie.
  8. Jeśli uwierzytelnianie się powiedzie, wygeneruj credentialId i parę kluczy.
  9. Zapisz klucz prywatny w lokalnej bazie danych pod kątem callingAppInfo.packageName.
  10. Utwórz odpowiedź w formacie JSON interfejsu Web Authentication API, która składa się z klucza publicznego i credentialId. W przykładzie poniżej używane są lokalne klasy narzędzi, takie jak AuthenticatorAttestationResponse i FidoPublicKeyCredential, które pomagają utworzyć plik JSON na podstawie wspomnianej wcześniej specyfikacji.Jako dostawca danych logowania możesz zastąpić te klasy własnymi.
  11. Utwórz CreatePublicKeyCredentialResponse za pomocą kodu JSON wygenerowanego powyżej.
  12. Ustaw CreatePublicKeyCredentialResponse jako dodatek w Intent do PendingIntentHander.setCreateCredentialResponse() i ustaw tę intencję na wynik aktywności.
  13. Dokończ aktywność.

Ilustruje to poniższy kod. Ten kod należy zastosować w klasie Activity po wywołaniu funkcji 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)}"
}

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

Aby obsługiwać zapytania o prośby o utworzenie hasła:

  • W metodzie processCreateCredentialRequest() omówionej w poprzedniej sekcji dodaj kolejny przypadek w bloku przełączania do obsługi żądań hasła.
  • Podczas tworzenia obiektu BeginCreateCredentialResponse dodaj wymagane CreateEntries.
  • Każdy element CreateEntry powinien odpowiadać kontu, na którym można zapisać dane logowania. Musi mieć ustawiony atrybut PendingIntent wraz z innymi metadanymi.

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
}

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

Wybór obsługi wpisów na potrzeby żądań utworzenia hasła

Gdy użytkownik wybierze wypełnione pole CreateEntry, odpowiednie PendingIntent uruchomi się i wyświetli powiązane działanie. Uzyskaj dostęp do powiązanej intencji przekazywanej w onCreate i przekaż ją do klasy PendingIntentHander, aby uzyskać metodę ProviderCreateCredentialRequest.

Poniższy przykład pokazuje, jak wdrożyć ten proces. Musisz go wykonać w metodzie onCreate() aktywności.

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

Obsługa logowania użytkowników

Logowanie użytkowników odbywa się w ten sposób:

  • Gdy aplikacja kliencka próbuje zalogować użytkownika, przygotowuje instancję GetCredentialRequest.
  • Platforma Android rozpowszechnia to żądanie do wszystkich odpowiednich dostawców danych logowania przez powiązanie z tymi usługami.
  • Usługa dostawcy otrzymuje następnie BeginGetCredentialRequest zawierający listę BeginGetCredentialOption, z których każdy zawiera parametry, które mogą służyć do pobierania pasujących danych logowania.

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

  1. Aby obsługiwać żądanie, zastąp metodę onBeginGetCredentialRequest(). 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 obiektu credentialEntries, muszą skonfigurować oczekującą intencję, 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
        )
    )
}

  2. 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 w intencji, aby dowiedzieć się, na jakie dane logowania jest zmapowany, 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 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. Zapytanie o dane logowania z bazy danych oraz wpisy klucza i hasła 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
              ),
              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. Po wysłaniu zapytania dotyczącego danych logowania i wypełnieniu tych danych musisz przejść do etapu wyboru danych logowania wybranych przez użytkownika – niezależnie od tego, czy jest to klucz dostępu czy hasło.

Obsługa wyboru użytkowników na potrzeby kluczy dostępu

  1. W metodzie onCreate odpowiedniej aktywności pobierz powiązaną intencję i przekaż ją do PendingIntentHandler.retrieveProviderGetCredentialRequest().
  2. Wyodrębnij GetPublicKeyCredentialOption z żądania pobranego powyżej. Następnie wyodrębnij wartości requestJson i clientDataHash z tej opcji.
  3. Wyodrębnij z dodatkowego intencji parametr credentialId, który został uzupełniony przez dostawcę danych logowania podczas konfigurowania odpowiedniego PendingIntent.
  4. Wyodrębnij klucz dostępu z lokalnej bazy danych za pomocą parametrów żądania dostępnych powyżej.

  5. Potwierdzanie, że klucz dostępu jest prawidłowy w przypadku wyodrębnionych metadanych i weryfikacji użytkownika.

    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. Aby zweryfikować użytkownika, wyświetlaj prompt biometryczny (lub inną metodę asercji). Poniższy fragment kodu korzysta z interfejsu Android Bimetric API.

  7. Gdy uwierzytelnianie się powiedzie, utwórz odpowiedź JSON na podstawie specyfikacji potwierdzenia uwierzytelniania internetowego W3. We fragmencie kodu poniżej podane są pomocnicze klasy danych, takie jak AuthenticatorAssertionResponse, służą do przyjmowania 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 się.

  8. Utwórz PublicKeyCredential przy użyciu wygenerowanego powyżej kodu JSON i ustaw go na końcowym elemencie GetCredentialResponse. Ustaw odpowiedź końcową na wynik tego działania.

Poniższy przykład pokazuje, jak można wdrożyć te kroki:

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)

Wybór użytkownika na potrzeby uwierzytelniania hasła

  1. W odpowiednim działaniu otwórz intencję przekazaną do funkcji onCreate i wyodrębnij ProviderGetCredentialRequest za pomocą metody PendingIntentHandler.

  2. Użyj w żądaniu GetPasswordOption, aby pobrać dane logowania do nazwy pakietu przychodzącego.

    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. Po pobraniu ustaw odpowiedź dla wybranych danych logowania do 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()

Wybór wpisu działania uwierzytelniania

Jak wspomniano wcześniej, dostawca danych logowania może ustawić AuthenticationAction, jeśli dane logowania są zablokowane. Jeśli użytkownik wybierze ten wpis, wywołana jest aktywność odpowiadająca zestawowi działań intencji w PendingIntent. Dostawcy danych logowania mogą następnie udostępniać proces uwierzytelniania biometrycznego lub podobny mechanizm do odblokowywania danych logowania. Po pomyślnym zakończeniu dostawca danych logowania musi utworzyć BeginGetCredentialResponse, podobną do opisanej powyżej obsługi logowania przez użytkowników, ponieważ dane logowania są teraz odblokowane. Następnie trzeba ustawić tę odpowiedź za pomocą metody PendingIntentHandler.setBeginGetCredentialResponse(), zanim przygotowana intencja zostanie ustawiona jako wynik i działanie zostanie zakończone.

Wyczyść żądania danych logowania

Aplikacja kliencka może poprosić o usunięcie dowolnego stanu utrzymywanego na potrzeby wyboru danych logowania, np. dostawca danych logowania może zapamiętać wybrane wcześniej dane logowania i zwrócić je tylko następnym razem. Aplikacja kliencka wywołuje ten interfejs API i oczekuje, że zapamiętany 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: android.service.credentials.ClearCredentialStateRequest,
    cancellationSignal: CancellationSignal,
    callback: OutcomeReceiver<Void?, ClearCredentialException>,
  ) {
    // Delete any maintained state as appropriate.
}

Uzyskiwanie listy dozwolonych aplikacji z podwyższonymi uprawnieniami

Aplikacje z uprawnieniami dostępu, takie jak przeglądarki, wykonują wywołania Menedżera danych logowania w imieniu innych podmiotów uzależnionych, ustawiając parametr origin w metodach Menedżera danych logowania GetCredentialRequest() i CreatePublicKeyCredentialRequest(). Aby przetworzyć te żądania, dostawca danych logowania pobiera origin za pomocą interfejsu API getOrigin().

Aby pobrać origin, aplikacja dostawcy danych logowania musi przekazać do interfejsu API androidx.credentials.provider.CallingAppInfo's getOrigin() listę zaufanych i upoważnionych obiektów wywołujących. Ta lista dozwolonych musi być prawidłowym obiektem JSON. origin jest zwracany, jeśli odciski cyfrowe packageName i odciski cyfrowe certyfikatów uzyskane z signingInfo odpowiadają odciskom cyfrowym aplikacji znajdującym się w elemencie privilegedAllowlist przekazanym do interfejsu getOrigin() API. Po uzyskaniu wartości origin aplikacja dostawcy powinna uznać to wywołanie uprzywilejowane i ustawić ten element origin w danych klienta w AuthenticatorResponse, zamiast obliczać origin za pomocą podpisu aplikacji wywołującej.

Jeśli pobierasz origin, użyj metody clientDataHash dostarczonej bezpośrednio w CreatePublicKeyCredentialRequest() lub GetPublicKeyCredentialOption(), zamiast tworzyć i haszować clientDataJSON podczas żądania podpisu. Aby uniknąć problemów z analizą JSON, ustaw wartość zmiennej dla clientDataJSON w atestacji i odpowiedzi na potwierdzenie.

Menedżer haseł Google używa otwartej listy dozwolonych w przypadku wywołań adresu getOrigin(). Jako dostawca danych logowania możesz użyć tej listy lub podać własną w formacie JSON opisanym w interfejsie API. To dostawca decyduje, która lista ma być używana. Informacje o tym, jak uzyskać uprzywilejowany dostęp w przypadku zewnętrznych dostawców danych logowania, znajdziesz w ich dokumentacji.

Włączanie dostawców na urządzeniu

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

Na Androidzie 14 lub nowszym wywołaj interfejs createSettingsPendingIntent() API, aby po wywołaniu zwrócić oczekującą intencję. Wyświetli się ekran, na którym użytkownik może włączyć dostawcę Menedżera danych logowania.

fun createSettingsPendingIntent(): PendingIntent