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ą wiele metod logowania, takich jak nazwa użytkownika i hasło, klucze dostępu i rozwiązania logowania sfederowanego (np. Zaloguj się przez Google). W przypadku interfejsu Credential Manager API system Android agreguje dane logowania ze wszystkich danych logowania. z usług dostawcy oprogramowania zainstalowanego na urządzeniu. Ten dokument opisuje zestaw interfejsów API, które udostępniają punkty końcowe integracji dla tych dostawców danych logowania.

Konfiguracja

Zanim zaczniesz wdrażać funkcje w dostawcy danych logowania, wykonaj czynności konfiguracyjne opisane w następnych sekcjach.

Deklarowanie zależności

W pliku build.gradle modułu zadeklaruj zależność za pomocą atrybutu najnowsza biblioteki Credential Manager:

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

Zadeklaruj element usługi w pliku manifestu

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

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

Powyższe uprawnienia i filtr intencji są niezbędne, aby proces menedżera danych logowania działał zgodnie z oczekiwaniami. Te uprawnienia są potrzebne, aby tylko System Android może powiązać się z tą usługą. Filtr intencji służy do wykrywania tej usługi jako dostawcy poświadczeń, której będzie używać Menedżer poświadczeń.

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 uwierzytelniających obsługiwane przez usługę za pomocą stałych zdefiniowanych dla każdego typu danych uwierzytelniających w bibliotece. W następujących np. usługa obsługuje zarówno tradycyjne hasła, jak i klucze dostępu, stałe, które są 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 interfejsu API dostawcy danych logowania integrują się z interfejsami API, takimi jak autouzupełnianie haseł i innych danych. Ci dostawcy mogą używać tego samego wewnętrznego identyfikatora do przechowywania istniejących typów danych logowania i rozszerzania ich o infrastrukturę obsługiwać inne, w tym klucze dostępu.

Interakcja z dostawcą w 2 etapach

Menedżer danych uwierzytelniających wchodzi w interakcję z dostawcami danych uwierzytelniających w dwóch etapach:

  1. Pierwsza faza to faza rozpoczęcia/zapytania, w której system łączy się z usługami dostawcy danych logowania i wywołuje metody onBeginGetCredentialRequest(), onBeginCreateCredentialRequest() lub onClearCredentialStateRequest() z żądaniami Begin…. Dostawcy muszą przetwarzać te żądania i wysyłać odpowiedzi Begin…, wypełniając je wpisami, które reprezentują opcje wizualne wyświetlane w selektorze kont. Każdy wpis musi mieć ustawioną wartość PendingIntent.
  2. Gdy użytkownik wybierze pozycję, rozpoczyna się faza wyboru i wyzwala się PendingIntent powiązany z nią element, co powoduje wyświetlenie odpowiedniej aktywności dostawcy. Gdy użytkownik zakończy interakcję aktywność, dostawca danych uwierzytelniających musi ustawić odpowiedź na wynik funkcji przed zakończeniem. Odpowiedź jest następnie wysyłana do aplikacji klienckiej, która wywołał usługę Credential Manager.

Tworzenie klucza dostępu

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

Gdy aplikacja kliencka chce utworzyć klucz dostępu i zapisać go za pomocą jako dostawcę danych uwierzytelniających, wywołuje on interfejs API createCredential. Aby rozwiązać ten problem w usłudze dostawcy danych uwierzytelniających tak, aby klucz dostępu przechowywane na dysku, wykonaj czynności opisane w poniższych sekcjach.

  1. Zastąp metodę onBeginCreateCredentialRequest() w usłudze rozszerzonej z CredentialProviderService.
  2. Wykonaj działanie BeginCreateCredentialRequest, tworząc odpowiadające mu BeginCreateCredentialResponse i przekazując go przez oddzwanianie.
  3. Podczas tworzenia funkcji BeginCreateCredentialResponse dodaj wymaganą wartość CreateEntries. Każdy element CreateEntry powinien odpowiadać kontu, na którym można zapisać dane logowania. Musisz też podać wartość elementu PendingIntent wraz z innymi wymaganymi metadanymi.

Sposób implementacji tych czynności ilustruje poniższy przykład.

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 spełniać te wymagania:

  • Odpowiednia aktywność powinna być skonfigurowana w taki sposób, aby wyświetlać wymagane prompty biometryczne, potwierdzenia lub wybory.
  • Wszelkie wymagane dane, których dostawca potrzebuje do wykonania odpowiedniej czynności, należy ustawić jako dodatkowe w intencji używanej do tworzenia PendingIntent, np. accountId w procesie tworzenia.
  • Pole PendingIntent musi być utworzone z użyciem flagi PendingIntent.FLAG_MUTABLE, aby system mógł dołączyć końcowy atrybut do intencji użytkownika.
  • Element PendingIntent nie może być utworzony za pomocą flagi PendingIntent.FLAG_ONE_SHOT, ponieważ użytkownik może wybrać wpis, wrócić i wybierz go ponownie. Spowoduje to dwukrotne uruchomienie elementu PendingIntent.
  • Wartość PendingIntent musi być tworzona za pomocą unikalnego kodu żądania, aby każdy wpis miał odpowiadającą mu wartość PendingIntent.

Obsługa wyboru wpisów w przypadku żądań utworzenia klucza dostępu

  1. Gdy użytkownik wybierze wypełnioną wcześniej wartość CreateEntry, wywoływana jest odpowiadająca jej wartość PendingIntent i tworzy się powiązany dostawca Activity.
  2. Po wywołaniu metody onCreate w Twojej aktywności uzyskaj dostęp do powiązanego zamiaru i przekaż go do klasy PendingIntentHander, aby uzyskać ProviderCreateCredentialRequest.
  3. Wyodrębnij z prośby wartości requestJson, callingAppInfo i clientDataHash.
  4. Wyodrębnij lokalny accountId z dodatkowych informacji o zamiarze. To przykładowa implementacja w aplikacji, która nie jest wymagana. Identyfikator tego konta może służyć do przechowywania tych danych logowania w związku z tym konkretnym identyfikatorem konta.
  5. Zweryfikuj requestJson. W przykładzie poniżej użyto lokalnych klas danych, takich jak PublicKeyCredentialCreationOptions, aby przekonwertować wejściowe dane JSON na klasa strukturalna zgodnie ze specyfikacją WebAuthn. Jako dostawca danych uwierzytelniających możesz zastąpić go własnym parserem.
  6. Sprawdź atrybut asset-link dotyczący aplikacji do połączeń, jeśli połączenie pochodzi z: natywną aplikację na Androida.
  7. wyświetlić monit uwierzytelniania; W przykładzie poniżej użyto Androida Biometric API.
  8. Po pomyślnym uwierzytelnieniu wygeneruj credentialId i parę kluczy.
  9. Zapisz klucz prywatny w lokalnej bazie danych przed callingAppInfo.packageName
  10. Utwórz odpowiedź JSON interfejsu Web Authentication API, która składa się z klucza publicznego i credentialId. Przykład poniżej używa lokalnych klas narzędzi, takich jak AuthenticatorAttestationResponse i FidoPublicKeyCredential, które pomagają utworzyć kod JSON na podstawie wcześniejszego wspomnianą specyfikację.Jako dostawca danych uwierzytelniających możesz zastąpić te klasy z budowlą.
  11. Utwórz obiekt CreatePublicKeyCredentialResponse, korzystając z wygenerowanego powyżej pliku JSON.
  12. Ustaw CreatePublicKeyCredentialResponse jako dodatek do Intent za pomocą PendingIntentHander.setCreateCredentialResponse() i ustaw ten zamiar jako wynik aktywności.
  13. Zakończ aktywność.

Przykładowy kod poniżej ilustruje te kroki. Ten kod musi być obsługiwany w Twojej klasy aktywności 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 żądań utworzenia hasła

Aby obsługiwać zapytania związane z prośbami o utworzenie hasła, wykonaj te czynności:

  • W metodie processCreateCredentialRequest(), o której mowa w poprzedniej sekcji, dodaj w bloku switch kolejny case do obsługi żądań hasła.
  • Podczas tworzenia BeginCreateCredentialResponse dodaj wymagane CreateEntries.
  • Każdy element CreateEntry powinien odpowiadać kontu, na którym można zapisać dane logowania, oraz musi mieć ustawiony element PendingIntent wraz z innymi metadanymi.

Ten przykład pokazuje, jak wdrożyć te kroki:

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

Obsługa wyboru wpisów w przypadku próśb o utworzenie hasła

Gdy użytkownik wybierze wypełnioną CreateEntry, zostanie uruchomiona odpowiadająca jej PendingIntent i wyświetlona powiązana aktywność. Uzyskaj dostęp do powiązana intencja jest przekazywana w funkcji onCreate i przekazywana do funkcji PendingIntentHander, aby pobrać 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)

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

Zarządzanie logowaniem użytkowników

Logowanie użytkowników przebiega w ten sposób:

  • Gdy aplikacja kliencka próbuje zalogować użytkownika, przygotowuje GetCredentialRequest.
  • Platforma Androida przekazuje to żądanie do wszystkich odpowiednich danych logowania przez powiązanie z tymi usługami.
  • Usługa dostawcy otrzymuje wtedy BeginGetCredentialRequest, która zawiera listę BeginGetCredentialOption, z których każda 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 uwierzytelniających, wykonaj następujące kroki:

  1. Zastąp metodę onBeginGetCredentialRequest() do obsługi żądania. Pamiętaj, że jeśli dane logowania są zablokowane, możesz od razu ustawić AuthenticationAction w odpowiedzi i wywołaj 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())
    }
}

    Usługodawcy, którzy wymagają odblokowania danych logowania przed powrotem dowolne credentialEntries, musi skonfigurować intencję oczekującą, która umożliwia nawigację do procesu odblokowywania w 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, które będą wyświetlane na selektorze. W przypadku kluczy dostępu możesz ustawić dodatkowy parametr credentialId w intencji, aby wiedzieć, do których danych logowania odwołuje się klucz, 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. Wysyłanie zapytań dotyczących danych logowania z bazy danych, tworzenie wpisów kluczy i haseł w .

    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 i wypełnieniu danych logowania musisz teraz obsłużyć fazę wyboru danych logowania wybranych przez użytkownika, niezależnie od tego, czy są to klucze dostępu czy hasła.

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

  1. W metodzie onCreate odpowiedniej aktywności pobierz powiązany zamiar i przekaż go do PendingIntentHandler.retrieveProviderGetCredentialRequest().
  2. Wyodrębnij GetPublicKeyCredentialOption z pobranego żądania powyżej. Następnie wyodrębnij requestJson i clientDataHash tej opcji.
  3. Wyodrębnianie credentialId z dodatkowej intencji, która została wypełniona przez dostawcy danych uwierzytelniających podczas konfigurowania odpowiedniej tabeli PendingIntent.
  4. Wyodrębnij klucz dostępu z lokalnej bazy danych przy użyciu parametrów żądania powyżej.

  5. Potwierdź, że klucz dostępu z wyodrębnionymi metadanymi jest prawidłowy, a użytkownik weryfikacji.

    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, użyj promptu dotyczącego biometrii (lub innego potwierdzenia) ). Fragment kodu poniżej korzysta z interfejsu API Android Biometric.

  7. Po pomyślnym uwierzytelnieniu ułóż odpowiedź JSON na podstawie specyfikacji W3 Web Authentication Assertion. W poniżej zamieszczonym fragmencie kodu klasy danych pomocniczych, takie jak AuthenticatorAssertionResponse, służą do przyjmowania parametrów strukturalnych i konwertowania ich do wymaganego formatu JSON. Odpowiedź zawiera podpis cyfrowy klucz prywatny danych logowania WebAuthn. Serwer podmiotu uzależnionego może przeprowadzić weryfikację ten podpis, aby uwierzytelnić użytkownika przed zalogowaniem się.

  8. Zbuduj PublicKeyCredential za pomocą kodu JSON wygenerowanego powyżej i ustaw go na końcowym GetCredentialResponse. Ustaw tę odpowiedź końcową na w wyniku tych działań.

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

Obsługa wyboru użytkowników na potrzeby uwierzytelnienia hasła

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

  2. Użyj parametru GetPasswordOption w żądaniu, aby pobrać poświadczenia logowania z hasłem dla nazwy przychodzącego pakietu.

    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.

    // 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 logowania są zablokowane. Jeśli użytkownik wybierze tę opcję działanie odpowiadające wybranemu działaniu intencji w polu Metoda PendingIntent jest wywoływana. Dostawcy danych uwierzytelniających mogą następnie wyświetlać dane biometryczne procesu uwierzytelniania lub podobnego mechanizmu do odblokowywania danych logowania. W przypadku powodzenia dostawca danych logowania musi utworzyć BeginGetCredentialResponse, podobnie jak w przypadku obsługi logowania użytkownika opisanej powyżej, ponieważ dane logowania są teraz odblokowane. Następnie należy ustawić tę odpowiedź za pomocą metody PendingIntentHandler.setBeginGetCredentialResponse(), zanim przygotowany zamiar zostanie ustawiony jako wynik, a działanie zostanie zakończone.

Wyczyszczenie żądań dotyczących danych logowania

Aplikacja kliencka może wymagać, aby każdy stan utrzymywany na potrzeby wyboru danych logowania musiał być może zostać wyczyszczona, np. dostawca danych uwierzytelniających może zapamiętać poprzednio wybrany i zwrócą go następnym razem. Aplikacja kliencka wywołuje ten interfejs API i oczekuje, że zaznaczenie przyklejone zostanie usunięte. Usługa dostawcy danych uwierzytelniających może obsłużyć to żądanie, zastępując Metoda onClearCredentialStateRequest():

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

Aby umożliwić użytkownikom otwieranie ustawień dostawcy na ekranie Hasła, klucze dostępu i autouzupełnianie, aplikacje dostawców danych logowania powinny zaimplementować atrybut manifestu credential-provider settingsActivity w res/xml/provider.xml. Ten atrybut umożliwia użycie intencji, by otworzyć własnego ekranu ustawień, gdy użytkownik kliknie nazwę dostawcy w sekcji Hasła, klucze dostępu autouzupełnianialisty usług. Ustaw dla tego atrybutu nazwę aktywności, która ma być uruchamiana na ekranie 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>
Schemat przedstawiający funkcje zmiany i otwierania przycisku
Rys. 1. Przycisk Zmień otwiera okno wyboru umożliwiające użytkownikowi wybranie preferowanych danych logowania dostawcy usług. Przycisk Otwórz powoduje uruchomienie działania ustawień zdefiniowanego w w pliku manifestu i otwiera stronę ustawień dostawcy usług.

Zamiary dotyczące ustawień

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

Ekran ustawień haseł, kluczy dostępu i autouzupełniania
Rysunek 2. Ustawienia haseł, kluczy dostępu i autouzupełniania ekranu.

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

Schemat przedstawiający funkcje zmiany i otwierania przycisku
Rysunek 3. Preferowana usługa haseł, kluczy dostępu i ekran ustawień autouzupełniania.

Uzyskiwanie listy dozwolonych aplikacji z podwyższonymi uprawnieniami

Aplikacje z uprawnieniami, takie jak przeglądarki internetowe, wykonują wywołania do Menedżera danych logowania w imieniu innych stron zaufanych, ustawiając parametr origin w metodach CredentialManager GetCredentialRequest() i CreatePublicKeyCredentialRequest(). Aby je przetworzyć, dostawca danych logowania pobiera origin za pomocą getOrigin() API.

Aby pobrać origin, aplikacja dostawcy danych logowania musi przekazać do interfejsu androidx.credentials.provider.CallingAppInfo's getOrigin() listę uprzywilejowanych i zaufanych wywołujących. Ta lista dozwolonych musi być prawidłowym obiektem JSON. Wartość origin jest zwracana, jeśli packageName i odcisk cyfrowy certyfikatu uzyskany z signingInfo są zgodne z odciskiem cyfrowym aplikacji znalezionej w privilegedAllowlist przekazanej do interfejsu API getOrigin(). Po Wartość origin została uzyskana, aplikacja dostawcy powinna traktować to jako uprzywilejowane wywołaj i ustaw ten element origin w danych klienta w AuthenticatorResponse, zamiast obliczać origin przy użyciu podpisu aplikacji do połączeń.

Jeśli pobierasz żądanie origin, użyj clientDataHash podanego bezpośrednio w CreatePublicKeyCredentialRequest() lub GetPublicKeyCredentialOption() zamiast haszowania i szyfrowania. clientDataJSON w trakcie prośby o podpisanie. Aby uniknąć problemów z analizowaniem pliku JSON, w odpowiedzi na żądanie dotyczące potwierdzenia i oświadczenia ustaw wartość zastępczą dla clientDataJSON. Menedżer haseł Google używa publicznie dostępnej listy dozwolonych w przypadku wywołań funkcji getOrigin(). Jako dostawca danych logowania możesz użyć tej listy lub podać własną w formacie JSON opisanym przez interfejs API. Dostawca sam wybiera, której listy używać. Aby uzyskać uprzywilejowany dostęp dzięki aplikacji lub usłudze innej firmy dostawców danych uwierzytelniających można znaleźć w dokumentacji dostarczonej przez firmę zewnętrzną.

Włącz dostawców na urządzeniu

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

fun createSettingsPendingIntent(): PendingIntent