„Credential Manager“ bezieht sich auf eine Reihe von APIs, die mit Android 14 eingeführt wurden und Mehrfachanmeldung, z. B. Nutzername und Passwort, Passkeys und föderiertes Lernen Anmeldelösungen (z. B. „Über Google anmelden“). Wenn die Credential Manager API aufgerufen wird, fasst das Android-System Anmeldedaten aus allen Anmeldedaten zusammen. die auf dem Gerät installiert sind. In diesem Dokument werden die APIs beschrieben, Integrationsendpunkte für diese Anmeldeinformationsanbieter bereitstellen.
Einrichten
Bevor Sie Funktionen bei Ihrem Anmeldedatenanbieter implementieren, führen Sie die folgenden Schritte aus: die in den folgenden Abschnitten beschrieben werden.
Abhängigkeiten deklarieren
Deklarieren Sie in der Datei build.gradle
Ihres Moduls eine Abhängigkeit mithilfe der neuesten Version
Version der Anmeldedaten-Manager-Bibliothek:
implementation "androidx.credentials:credentials:1.2.0-{latest}"
Dienstelement in Manifestdatei deklarieren
Fügen Sie in der Manifestdatei AndroidManifest.xml
Ihrer App eine <service>
-Deklaration für eine Dienstklasse ein, die die Klasse CredentialProviderService
aus der androidx.credentials-Bibliothek erweitert, wie im folgenden Beispiel gezeigt.
<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>
Die oben genannten Berechtigungs- und Intent-Filter sind entscheidend, damit der Ablauf des Anmeldedaten-Managers wie erwartet funktioniert. Die Berechtigung ist erforderlich, damit nur das Android-System eine Bindung an diesen Dienst vornehmen kann. Der Intent-Filter wird für die Sichtbarkeit dieses Dienstes als Anmeldedatenanbieter, der von Anmeldedaten-Manager
Unterstützte Anmeldedatentypen deklarieren
Erstellen Sie im Verzeichnis res/xml
eine neue Datei mit dem Namen provider.xml
. In dieser
Datei können Sie die von Ihrem Dienst unterstützten Anmeldedatentypen mithilfe von Konstanten
die für jeden Anmeldedatentyp in der Bibliothek definiert sind. Im Folgenden
Der Dienst unterstützt beispielsweise
herkömmliche Passwörter und Passkeys.
Konstanten, für die
TYPE_PASSWORD_CREDENTIAL
und 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>
Auf vorherigen API-Ebenen können Anmeldedatenanbieter APIs wie Autofill einbinden. für Passwörter und andere Daten. Diese Anbieter können die vorhandene interne Infrastruktur zum Speichern der vorhandenen Anmeldedatentypen verwenden und gleichzeitig erweitern, um andere zu unterstützen, einschließlich Passkeys.
Zweistufiger Ansatz für die Interaktion mit Dienstleistern
Der Anmeldedaten-Manager interagiert in zwei Phasen mit Anmeldedatenanbietern:
- Die erste Phase ist die Beginn-/Abfragephase, in der das System an Anmeldedatenanbieterdienste gebunden wird und die Methoden
onBeginGetCredentialRequest()
,onBeginCreateCredentialRequest()
oderonClearCredentialStateRequest()
mitBegin…
-Anfragen aufruft. Anbieter müssen diese Anfragen verarbeiten und mitBegin…
-Antworten antworten. Sie müssen dabei Einträge mit visuellen Optionen angeben, die in der Kontoauswahl angezeigt werden sollen. Für jeden Eintrag mussPendingIntent
festgelegt sein. - Sobald der Nutzer einen Eintrag auswählt, beginnt die Auswahlphase und der
PendingIntent
, die mit dem Eintrag verknüpft sind, wird ausgelöst. entsprechenden Anbieteraktivität. Sobald der Nutzer mit dieser Aktivität fertig ist, muss der Anmeldedatenanbieter die Antwort auf das Ergebnis der Aktivität festlegen, bevor er sie beendet. Diese Antwort wird dann an die Client-App gesendet, die den Anmeldedaten-Manager aufgerufen hat.
Passkey-Erstellung verarbeiten
Abfragen beim Erstellen von Passkeys verarbeiten
Wenn eine Client-App einen Passkey erstellen und mit einem
Anmeldedatenanbieter verwendet er die createCredential
API. Um das Problem zu beheben
Ihres Anmeldedatenanbieters an, sodass der Passkey tatsächlich
die im Speicher abgelegt sind, führen Sie die in den folgenden Abschnitten beschriebenen Schritte aus.
- Methode
onBeginCreateCredentialRequest()
in Ihrem Dienst überschreiben verlängert vonCredentialProviderService
. - Verarbeiten Sie den
BeginCreateCredentialRequest
, indem Sie eine die entsprechendeBeginCreateCredentialResponse
-Datei den Callback. - Fügen Sie beim Erstellen der
BeginCreateCredentialResponse
den Parameter erforderlich:CreateEntries
. JedesCreateEntry
sollte einem Konto, in dem die Anmeldedaten gespeichert werden können, und ein KontoPendingIntent
wird zusammen mit anderen erforderlichen Metadaten festgelegt.
Das folgende Beispiel zeigt, wie diese Schritte implementiert werden.
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
)
)
}
Die PendingIntent
-Konstruktion muss Folgendes erfüllen:
- Die entsprechende Aktivität sollte so eingerichtet sein, dass alle erforderlichen biometrischen Aufforderungen, Bestätigungen oder Auswahlen angezeigt werden.
- Alle erforderlichen Daten, die der Anbieter beim Aufrufen der entsprechenden Aktivität benötigt, sollten als Extra für den Intent festgelegt werden, mit dem Ihre
PendingIntent
erstellt wird, z. B. einaccountId
im Erstellungsvorgang. - Dein
PendingIntent
muss mit dem Flag erstellt werdenPendingIntent.FLAG_MUTABLE
, damit das System die letzte zusätzliche Anfrage an den Intent. - Dein
PendingIntent
darf nicht mit dem Flag erstellt werdenPendingIntent.FLAG_ONE_SHOT
, da der Nutzer einen Eintrag auswählen kann, zurückgehen und wählen Sie sie noch einmal aus. Dadurch wirdPendingIntent
zweimal ausgelöst. - Ihre
PendingIntent
muss mit einem eindeutigen Anfragecode erstellt werden, damit jeder Eintrag eine eigene entsprechendePendingIntent
haben kann.
Auswahl von Einträgen für Anfragen zum Erstellen von Passkeys verarbeiten
- Wenn der Nutzer eine zuvor ausgefüllte
CreateEntry
auswählt, wird das Feld entsprechendePendingIntent
aufgerufen und der zugehörige AnbieterActivity
wird erstellt. - Nachdem die
onCreate
-Methode Ihrer Aktivität aufgerufen wurde, greifen Sie auf den zugehörigen Intent zu und übergeben Sie ihn an diePendingIntentHander
-Klasse, um dieProviderCreateCredentialRequest
zu erhalten. - Extrahieren Sie
requestJson
,callingAppInfo
undclientDataHash
aus dem - Extrahieren Sie die lokale
accountId
aus dem Intent-Extra. Dies ist eine Beispiel-App Implementierung und ist nicht erforderlich. Diese Konto-ID kann verwendet werden um diese Anmeldedaten für diese bestimmte Konto-ID zu speichern. - Validiere
requestJson
. Im folgenden Beispiel werden lokale Datenklassen wiePublicKeyCredentialCreationOptions
verwendet, um die Eingabe-JSON-Datei in eine strukturierte Klasse gemäß der WebAuthn-Spezifikation umzuwandeln. Als Anmeldedatenanbieter können Sie dies durch Ihren eigenen Parser ersetzen. - Prüfe den Asset-Link der anrufenden App, wenn der Anruf von einer nativen Android-App ausgeht.
- Eine Authentifizierungsaufforderung anzeigen. Im folgenden Beispiel wird die Biometric API von Android verwendet.
- Wenn die Authentifizierung erfolgreich ist, generieren Sie
credentialId
und einen Schlüsselpaar. - Speichern Sie den privaten Schlüssel in Ihrer lokalen Datenbank unter
callingAppInfo.packageName
. - Erstelle eine JSON-Antwort der Web Authentication API, die aus dem öffentlichen Schlüssel und der
credentialId
besteht. Im Beispiel unten werden lokale Dienstprogrammklassen wieAuthenticatorAttestationResponse
undFidoPublicKeyCredential
verwendet, die beim Erstellen einer JSON-Datei auf der Grundlage der oben genannten Spezifikation helfen. Als Anmeldedatenanbieter können Sie diese Klassen durch eigene Builder ersetzen. - Erstellen Sie eine
CreatePublicKeyCredentialResponse
mit dem oben generierten JSON. - Legen Sie
CreatePublicKeyCredentialResponse
überPendingIntentHander.setCreateCredentialResponse()
als Extra für eineIntent
fest und legen Sie diese Absicht als Ergebnis der Aktivität fest. - Schließen Sie die Aktivität ab.
Das Codebeispiel unten veranschaulicht diese Schritte. Dieser Code muss in Ihrer Aktivitätsklasse verarbeitet werden, sobald onCreate()
aufgerufen wird.
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)}"
}
Abfragen für Anfragen zum Erstellen von Passwörtern verarbeiten
So beantwortest du Anfragen zum Erstellen von Passwörtern:
- Informationen zur
processCreateCredentialRequest()
-Methode, die in den Im vorherigen Abschnitt ein weiteres Case in das Schalterblock einfügen Passwortanforderungen. - Fügen Sie beim Erstellen der
BeginCreateCredentialResponse
die erforderlichenCreateEntries
hinzu. - Jede
CreateEntry
sollte einem Konto entsprechen, in dem die Anmeldedaten gespeichert werden können. und es muss einPendingIntent
zusammen mit anderen Metadaten festgelegt sein.
Das folgende Beispiel veranschaulicht die Implementierung dieser Schritte:
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)
}
Eintragsauswahl für Anfragen zur Passworterstellung verarbeiten
Wenn der Nutzer eine ausgefüllte CreateEntry
auswählt, wird die entsprechende PendingIntent
ausgeführt und die zugehörige Aktivität wird angezeigt. Rufen Sie die zugehörige Absicht auf, die in onCreate
übergeben wurde, und übergeben Sie sie an die Klasse PendingIntentHander
, um die Methode ProviderCreateCredentialRequest
zu erhalten.
Das folgende Beispiel zeigt, wie dieser Prozess implementiert wird. Dieser Code muss
werden in der onCreate()
-Methode deiner Aktivität verarbeitet.
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()
Nutzeranmeldung verarbeiten
So funktioniert die Nutzeranmeldung:
- Wenn eine Client-App versucht, einen Nutzer anzumelden, wird eine
GetCredentialRequest
-Instanz. - Das Android-Framework leitet diese Anfrage an alle anwendbaren Anmeldedatenanbieter weiter, indem es eine Bindung an diese Dienste herstellt.
- Der Anbieterdienst erhält dann eine
BeginGetCredentialRequest
mit einer Liste vonBeginGetCredentialOption
, die jeweils Parameter enthalten, mit denen übereinstimmende Anmeldedaten abgerufen werden können.
So verarbeiten Sie diese Anfrage in Ihrem Anmeldedatenanbieterdienst:
Überschreibe die Methode
onBeginGetCredentialRequest()
, um die Anfrage zu verarbeiten. Hinweis: Wenn Ihre Anmeldedaten gesperrt sind, können Sie sofort eineAuthenticationAction
für die Antwort und ruft den Callback auf.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()) } }
Anbieter, die das Entsperren der Anmeldedaten vor der Rückgabe von
credentialEntries
erfordern, müssen einen ausstehenden Intent einrichten, der den Nutzer zum Entsperren der App weiterleitet: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 ) ) }
Rufen Sie Anmeldedaten aus Ihrer lokalen Datenbank ab und richten Sie sie mit
CredentialEntries
so ein, dass sie in der Auswahl angezeigt werden. Für Passkeys können SiecredentialId
als zusätzliches Attribut für den Intent festlegen, damit Sie wissen, auf welche Anmeldedaten er verweist, wenn der Nutzer diesen Eintrag auswählt.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) }
Fragen Sie Anmeldedaten aus Ihrer Datenbank ab, erstellen Sie Passkey- und Passworteinträge für dargestellt wird.
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) ) }
Nachdem du die Anmeldedaten abgefragt und eingefügt hast, musst du die Auswahlphase für die vom Nutzer ausgewählten Anmeldedaten verarbeiten, unabhängig davon, ob es sich um einen Passkey oder ein Passwort handelt.
Nutzerauswahl für Passkeys verarbeiten
- Rufe in der
onCreate
-Methode der entsprechenden Activity-Klasse den verknüpfter Intent und übergeben SiePendingIntentHandler.retrieveProviderGetCredentialRequest()
GetPublicKeyCredentialOption
aus der abgerufenen Anfrage extrahieren oben. Extrahieren Sie anschließendrequestJson
undclientDataHash
von dieser Option aus.- Extrahieren Sie die
credentialId
aus dem Intent-Extra, das vom Anmeldedatenanbieter beim Einrichten der entsprechendenPendingIntent
ausgefüllt wurde. - Extrahieren Sie den Passkey mithilfe der Anfrageparameter aus Ihrer lokalen Datenbank wie oben beschrieben.
Mit extrahierten Metadaten und dem Nutzer bestätigen, dass der Passkey gültig ist Überprüfung.
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 )
Um den Nutzer zu bestätigen, können Sie eine biometrische Aufforderung oder eine andere Bestätigungsmethode anzeigen. Im folgenden Code-Snippet wird die Android Biometric API verwendet.
Nach erfolgreicher Authentifizierung erstellen Sie eine JSON-Antwort auf Basis des W3- Web Authentication Assertion-Spezifikation Im Code-Snippet unten werden Hilfsdatenklassen wie
AuthenticatorAssertionResponse
verwendet, um Sie können strukturierte Parameter in das erforderliche JSON-Format konvertieren Format. Die Antwort enthält eine digitale Signatur aus dem privaten Schlüssel eines WebAuthn-Anmeldedatensatzes. Der Server der vertrauenden Partei kann diese Signatur überprüfen, um einen Nutzer vor der Anmeldung zu authentifizieren.Erstelle mithilfe der oben generierten JSON-Datei ein
PublicKeyCredential
und setze es auf ein endgültigesGetCredentialResponse
. Legen Sie diese endgültige Antwort auf das Ergebnis dieser Aktivität fest.
Das folgende Beispiel veranschaulicht, wie diese Schritte implementiert werden können:
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)
Nutzerauswahl für die Passwortauthentifizierung
- Greifen Sie in der entsprechenden Aktivität auf den Intent zu, der an
onCreate
übergeben wurde, und extrahieren Sie dieProviderGetCredentialRequest
mitPendingIntentHandler
. Verwende
GetPasswordOption
in der Anfrage, um Passwort-Anmeldedaten für den Namen des eingehenden Pakets abzurufen.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 } }
Nachdem Sie die Antwort abgerufen haben, legen Sie sie für die ausgewählten Anmeldedaten fest.
// Set the response back val result = Intent() val passwordCredential = PasswordCredential(username, password) PendingIntentHandler.setGetCredentialResponse( result, GetCredentialResponse(passwordCredential) ) setResult(Activity.RESULT_OK, result) finish()
Auswahl eines Eintrags für eine Authentifizierungsaktion verarbeiten
Wie bereits erwähnt, kann ein Anmeldedatenanbieter eine AuthenticationAction
festlegen, wenn die Anmeldedaten gesperrt sind. Wenn der Nutzer diesen Eintrag auswählt, wird die Aktivität aufgerufen, die der Intent-Aktion entspricht, die in PendingIntent
festgelegt ist. Anmeldedatenanbieter können dann eine biometrische
oder einen ähnlichen Mechanismus zum Entsperren der Anmeldedaten. Bei Erfolg
muss der Anmeldedatenanbieter eine BeginGetCredentialResponse
erstellen, ähnlich
wie oben beschrieben wird, da die Anmeldedaten jetzt
entriegelt. Diese Antwort muss dann über die Methode PendingIntentHandler.setBeginGetCredentialResponse()
festgelegt werden, bevor die vorbereitete Absicht als Ergebnis festgelegt und die Aktivität beendet wird.
Anmeldedatenanfragen löschen
Eine Client-App kann anfordern, dass alle für die Anmeldedatenauswahl gespeicherten Status gelöscht werden. Ein Anmeldedatenanbieter kann beispielsweise die zuvor ausgewählten Anmeldedaten speichern und beim nächsten Mal nur diese zurückgeben. Eine Clientanwendung ruft diese API auf und erwartet, dass die angepinnte Auswahl gelöscht wird. Der Anmeldeinformationsanbieterdienst kann diese Anfrage bearbeiten, indem er die Methode onClearCredentialStateRequest()
überschreibt:
override fun onClearCredentialStateRequest(
request: android.service.credentials.ClearCredentialStateRequest,
cancellationSignal: CancellationSignal,
callback: OutcomeReceiver<Void?, ClearCredentialException>,
) {
// Delete any maintained state as appropriate.
}
Möglichkeit zum Verknüpfen mit der Seite „Einstellungen“ des Anbieters hinzufügen
Damit Ihre Nutzer die Einstellungen Ihres Anbieters im Bereich Passwörter,
Passkeys und Autofill-Bildschirm angezeigt wird, sollten die Apps des Anmeldedatenanbieters die
credential-provider
settingsActivity
-Manifestattribut in
res/xml/provider.xml
Mit diesem Attribut können Sie einen Intent zum Öffnen des
Bildschirm mit den Einstellungen, wenn ein Nutzer auf einen Anbieternamen in der Spalte Passwörter,
Passkeys und Liste der Dienste automatisch ausfüllen. Legen Sie für den Wert dieses Attributs die
Name der Aktivität, die über den Einstellungsbildschirm gestartet werden soll.
<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>

Einstellungs-Intents
Einstellungen öffnen: Das android.settings.CREDENTIAL_PROVIDER
.
öffnet sich ein Einstellungsbildschirm,
auf dem die Nutzenden ihre bevorzugten
zusätzliche Anbieter von Anmeldedaten.

Bevorzugter Anmeldedatendienst: Die ACTION_REQUEST_SET_AUTOFILL_SERVICE
-Intent leitet den Nutzer zum Bildschirm zur Auswahl des bevorzugten Anbieters weiter. Der auf diesem Bildschirm ausgewählte Anbieter wird zum bevorzugten Anmeldedaten- und Autofill-Anbieter.

Zulassungsliste für privilegierte Apps abrufen
Privilegierte Apps wie Webbrowser führen Credential Manager-Aufrufe im Namen von
durch Festlegen des origin
-Parameters in den Anmeldedaten
Administrator GetCredentialRequest()
und
CreatePublicKeyCredentialRequest()
-Methoden. Um diese Anfragen zu verarbeiten, ruft der Anmeldedatenanbieter die origin
mithilfe der getOrigin()
API ab.
Zum Abrufen der origin
muss die Anwendung des Anmeldeinformationsanbieters eine Liste von
privilegierten und vertrauenswürdigen Anrufern des
androidx.credentials.provider.CallingAppInfo's getOrigin()
API verwenden. Diese Zulassungsliste muss ein gültiges JSON-Objekt sein. origin
wird zurückgegeben, wenn die packageName
und
Die von signingInfo
abgerufenen Zertifikatfingerabdrücke stimmen mit denen einer App überein
finden Sie in der privilegedAllowlist
, die an die getOrigin()
API übergeben wurde. Nach dem
origin
-Wert erhalten, sollte die Anbieter-App dies als privilegiert einstufen
rufen Sie diese Datei auf und legen Sie origin
für die Kundendaten fest.
in der AuthenticatorResponse
, anstatt die
origin
durch die Signatur der aufrufenden App.
Wenn du eine origin
abrufen möchtest, verwende die clientDataHash
, die direkt in CreatePublicKeyCredentialRequest()
oder GetPublicKeyCredentialOption()
angegeben ist, anstatt clientDataJSON
während der Signaturanfrage zusammenzustellen und zu hashen. Legen Sie in der Attestierungs- und Bestätigungsantwort einen Platzhalterwert für clientDataJSON
fest, um Probleme beim JSON-Parsen zu vermeiden.
Der Google Passwortmanager verwendet eine frei verfügbare Zulassungsliste für
getOrigin()
-Aufrufe Als Anmeldedatenanbieter können Sie diese Liste oder
eigene Daten im von der API beschriebenen JSON-Format bereitstellen. Es liegt an der
Anbieter auswählen, welche Liste verwendet werden soll. Informationen zum Erhalt von Berechtigungen bei Anmeldedatenanbietern von Drittanbietern finden Sie in der Dokumentation des jeweiligen Anbieters.
Anbieter auf einem Gerät aktivieren
Nutzer müssen den Anbieter über Geräteeinstellungen > Passwörter und Konten > Ihr Anbieter > Aktivieren oder deaktivieren aktivieren.
fun createSettingsPendingIntent(): PendingIntent