Credential Manager API to zbiór interfejsów API wprowadzonych w Androidzie 14, które obsługują wielokrotnych metod logowania, takich jak nazwa użytkownika i hasło, klucze dostępu oraz sfederowane rozwiązania do logowania się (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. W tym dokumencie opisujemy zestaw interfejsów API, które udostępnić 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ść, używając 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
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>
Uprawnienie i filtr intencji widoczne powyżej są integralną częścią danych logowania. Proces menedżera działa zgodnie z oczekiwaniami. To uprawnienie jest potrzebne, aby z tą usługą można było powiązać tylko system Android. 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 uwierzytelniających integrują się z interfejsami API, takimi jak autouzupełnianie haseł i innych danych. Ci dostawcy mogą używać tej samej wewnętrznej infrastruktury do przechowywania istniejących typów danych logowania, a także rozszerzać ją o inne, w tym klucze dostępu.
Dwuetapowe podejście do interakcji z usługodawcą
Menedżer danych uwierzytelniających współpracuje z dostawcami danych uwierzytelniających w 2 etapach:
- Pierwszy etap to faza rozpoczęcia/zapytania, w której system łączy się
usługi i wywołania dostawcy danych uwierzytelniających
onBeginGetCredentialRequest()
,onBeginCreateCredentialRequest()
lub MetodyonClearCredentialStateRequest()
zBegin…
żądaniami. Dostawcy muszą przetwarzać te żądania i wysyłać odpowiedziBegin…
, wypełniając je wpisami, które reprezentują opcje wizualne wyświetlane w selektorze kont. Każdy wpis musi mieć ustawioną wartośćPendingIntent
. - 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. Ta odpowiedź jest następnie wysyłana do aplikacji klienta, która wywołała Menedżera danych logowania.
Uchwyt do tworzenia 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.
- Zastąp metodę
onBeginCreateCredentialRequest()
w usłudze rozszerzonej zCredentialProviderService
. - Wykonaj działanie
BeginCreateCredentialRequest
, tworząc odpowiadające muBeginCreateCredentialResponse
i przekazując go przez oddzwanianie. - Podczas tworzenia funkcji
BeginCreateCredentialResponse
dodaj wymaganą wartośćCreateEntries
. Każdy parametrCreateEntry
powinien odpowiadać na którym można zapisać dane logowania. Musi też miećPendingIntent
jest ustawiony wraz z innymi wymaganymi metadanymi.
Przykład poniżej pokazuje, jak wdrożyć te kroki.
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 tak, aby wyświetlać Wymagane jest potwierdzenie lub wybór biometrii.
- 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. - Wartość
PendingIntent
musi być skonstruowana z flagąPendingIntent.FLAG_MUTABLE
, aby system mógł dołączyć ostateczne żądanie do rozszerzenia intencji. - Funkcja
PendingIntent
nie może być zbudowana z flagąPendingIntent.FLAG_ONE_SHOT
, ponieważ użytkownik może wybrać wpis, wrócić i ponownie go wybrać, co spowoduje, że funkcjaPendingIntent
zostanie wywołana dwukrotnie. - Twoja
PendingIntent
musi być skonstruowana za pomocą unikalnego kodu żądania, że każdy wpis może mieć odpowiadającą mu właściwośćPendingIntent
.
Obsługa wyboru wpisu w przypadku próśb o utworzenie klucza dostępu
- Gdy użytkownik wybierze wypełnioną wcześniej wartość
CreateEntry
, wywoływana jest odpowiadająca jej wartośćPendingIntent
i tworzy się powiązany dostawcaActivity
. - Po wywołaniu metody
onCreate
w Twojej aktywności uzyskaj dostęp do powiązanego zamiaru i przekaż go do klasyPendingIntentHander
, aby uzyskaćProviderCreateCredentialRequest
. - Wyodrębnij
requestJson
,callingAppInfo
iclientDataHash
z użytkownika. - Wyodrębnij lokalny
accountId
z dodatkowych informacji o zamiarze. To przykładowa implementacja w aplikacji, która nie jest wymagana. Tego identyfikatora konta można użyć do przechowywania tych danych logowania dla tego konkretnego identyfikatora konta. - Zweryfikuj
requestJson
. Przykład poniżej używa lokalnych klas danych, takich jakPublicKeyCredentialCreationOptions
, do konwertowania wejściowego pliku JSON na klasę uporządkowaną zgodnie ze specyfikacją WebAuthn. Jako dostawca danych logowania możesz zastąpić tę klasę własnym parsowaniem. - Sprawdź asset-link aplikacji wywołującej, jeśli połączenie pochodzi z natywnej aplikacji na Androida.
- wyświetlić monit uwierzytelniania; W przykładzie poniżej użyto Androida Biometric API.
- Po pomyślnym uwierzytelnieniu wygeneruj
credentialId
i parę kluczy. - Zapisz klucz prywatny w lokalnej bazie danych przed
callingAppInfo.packageName
- 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 pomocniczych, takich jakAuthenticatorAttestationResponse
iFidoPublicKeyCredential
, które pomagają tworzyć dane JSON na podstawie wcześniej wspomnianej specyfikacji. Jako dostawca danych logowania możesz zastąpić te klasy własnymi konstruktorami. - Utwórz obiekt
CreatePublicKeyCredentialResponse
, korzystając z wygenerowanego powyżej pliku JSON. - Ustaw
CreatePublicKeyCredentialResponse
jako dodatkowe w okresieIntent
doPendingIntentHander.setCreateCredentialResponse()
i ustaw tę wartość w odniesieniu do wyniku Aktywności. - Zakończ aktywność.
Poniższy przykładowy kod 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łużyć zapytania dotyczące żądań utworzenia hasła:
- 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 wymaganeCreateEntries
. - Każdy identyfikator
CreateEntry
powinien odpowiadać kontu, na którym można użyć danych uwierzytelniających zapisane i musi mieć ustawiony atrybutPendingIntent
wraz z innymi metadanymi.
Poniższy przykład ilustruje, 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 żądań utworzenia 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
.
Przykład poniżej pokazuje, jak wdrożyć ten proces. Ten kod musi:
są obsługiwane 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żytkownika odbywa się w taki sposób:
- Gdy aplikacja kliencka próbuje zalogować użytkownika, przygotowuje
GetCredentialRequest
. - Platforma Androida przekazuje to żądanie wszystkim odpowiednim dostawcom danych logowania, łącząc się 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 logowania:
Przesłonij metodę
onBeginGetCredentialRequest()
, aby obsłużyć żądanie. Pamiętaj, że jeśli Twoje dane logowania są zablokowane, możesz natychmiast ustawić odpowiedźAuthenticationAction
i wywołać funkcję wywołania zwrotnego.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
credentialEntries
, muszą skonfigurować oczekujący zamiar, który przekieruje użytkownika do procesu odblokowywania aplikacji:private fun createUnlockPendingIntent(): PendingIntent { val intent = Intent(UNLOCK_INTENT).setPackage(PACKAGE_NAME) return PendingIntent.getActivity( applicationContext, UNIQUE_REQUEST_CODE, intent, ( PendingIntent.FLAG_MUTABLE or PendingIntent.FLAG_UPDATE_CURRENT ) ) }
Pobierz dane logowania z lokalnej bazy danych i skonfiguruj je za pomocą
CredentialEntries
, które będą wyświetlane na selektorze. W przypadku kluczy dostępu możesz ustawić dodatkowy parametrcredentialId
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) }
Wykonuj zapytania o dane logowania z bazy danych, twórz wpisy z kluczem dostępu i hasłem 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) ) }
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
- Za pomocą metody
onCreate
odpowiedniej aktywności pobierz powiązaną intencję i przekazywać doPendingIntentHandler.retrieveProviderGetCredentialRequest()
- Wyodrębnij z powyższego zapytania parametr
GetPublicKeyCredentialOption
. Następnie wyodrębnijrequestJson
iclientDataHash
tej opcji. - Wyodrębnianie
credentialId
z dodatkowej intencji, która została wypełniona przez dostawcy danych uwierzytelniających podczas konfigurowania odpowiedniej tabeliPendingIntent
. - Wyodrębnij klucz dostępu z lokalnej bazy danych przy użyciu parametrów żądania powyżej.
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 )
Aby zweryfikować użytkownika, użyj promptu dotyczącego biometrii (lub innego potwierdzenia) ). Fragment kodu poniżej korzysta z interfejsu Android Biometric API.
Gdy uwierzytelnianie się powiedzie, utwórz odpowiedź JSON na podstawie W3 Specyfikacja potwierdzenia uwierzytelniania internetowego. We fragmencie kodu poniżej, klasy danych pomocniczych, takich jak
AuthenticatorAssertionResponse
, są używane do pobierz uporządkowane parametry i przekonwertuj je na wymagany plik JSON . Odpowiedź zawiera podpis cyfrowy klucz prywatny danych logowania WebAuthn. Serwer strony uwierzytelniającej może zweryfikować to podpis, aby uwierzytelnić użytkownika przed zalogowaniem.Zbuduj
PublicKeyCredential
za pomocą kodu JSON wygenerowanego powyżej i ustaw go na końcowymGetCredentialResponse
. Ustaw tę odpowiedź końcową na w wyniku tych działań.
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)
Obsługa wyboru użytkowników na potrzeby uwierzytelnienia hasła
- W odpowiedniej czynności uzyskaj dostęp do intencji przekazanej do
onCreate
i wyodrębnijProviderGetCredentialRequest
za pomocąPendingIntentHandler
. 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 } }
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.
Wyczyść żądania 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 klienta wywołuje ten interfejs API i oczekuje, że ta trwała pozycja zostanie wyczyszczona. 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.
}
Dodaj możliwość linkowania do strony ustawień dostawcy
Aby umożliwić użytkownikom otwieranie ustawień dostawcy w sekcji Hasła,
klucze dostępu ekranu autouzupełniania, aplikacje dostawcy danych uwierzytelniających powinny implementować
credential-provider
Atrybut settingsActivity
w pliku manifestu
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 wartość tego atrybutu na
nazwę aktywności, która ma zostać uruchomiona z ekranu ustawień.
<credential-provider
xmlns:android="http://schemas.android.com/apk/res/android"
android:settingsSubtitle="Example settings provider name"
android:settingsActivity="com.example.SettingsActivity">
<capabilities>
<capability name="android.credentials.TYPE_PUBLIC_KEY_CREDENTIAL" />
</capabilities>
</credential-provider>

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

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

Uzyskiwanie listy dozwolonych aplikacji z przywilejami
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 uwierzytelniających musi przekazać listę
z zaufanych i uprzywilejowanych użytkowników
Interfejs API androidx.credentials.provider.CallingAppInfo's getOrigin()
. 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 uzyskaniu wartości origin
aplikacja dostawcy powinna uznać to za wywołanie z przywilejami i ustawić wartość origin
w danych klienta w AuthenticatorResponse
, zamiast obliczać wartość origin
za pomocą podpisu wywołującej aplikacji.
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 uwierzytelniających możesz użyć tej listy lub
podaj własną wartość w formacie JSON opisanym przez API. To zależy od
dostawcy, aby wybrać używaną listę. 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łączanie 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