क्रेडेंशियल मैनेजर का मतलब, Android 14 में लॉन्च किए गए ऐसे एपीआई के सेट से है जो साइन-इन करने के कई तरीके, जैसे कि उपयोगकर्ता नाम-पासवर्ड, पासकी, और फ़ेडरेटेड साइन-इन करने के तरीके, जैसे कि 'Google से साइन-इन करें' सुविधा. क्रेडेंशियल मैनेजर एपीआई कब इस्तेमाल किया जाएगा का अनुरोध किया जाता है, तो Android सिस्टम सभी क्रेडेंशियल से क्रेडेंशियल एग्रीगेट करता है मोबाइल और इंटरनेट सेवा देने वाली कंपनियां जो डिवाइस पर इंस्टॉल की गई हैं. इस दस्तावेज़ में उन एपीआई के सेट के बारे में बताया गया है जो इन क्रेडेंशियल की सेवा देने वाली कंपनियों के लिए इंटिग्रेशन एंडपॉइंट उपलब्ध कराते हैं.
सेटअप
क्रेडेंशियल देने वाली सेवा की सुविधाओं को लागू करने से पहले, सेटअप के चरणों के बारे में नीचे बताया गया है.
डिपेंडेंसी का एलान करना
अपने मॉड्यूल की build.gradle फ़ाइल में, नया
क्रेडेंशियल मैनेजर लाइब्रेरी का वर्शन:
implementation "androidx.credentials:credentials:1.2.0-{latest}"
मेनिफ़ेस्ट फ़ाइल में सेवा एलिमेंट की जानकारी दें
अपने ऐप्लिकेशन की मेनिफ़ेस्ट फ़ाइल AndroidManifest.xml में, <service> शामिल करें
सेवा श्रेणी के लिए घोषणा जो
CredentialProviderService क्लास, androidx.क्रेडेंशियल लाइब्रेरी से ली गई,
जैसा कि नीचे उदाहरण में दिखाया गया है.
<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>
ऊपर दिखाई गई अनुमति और इंटेंट फ़िल्टर, क्रेडेंशियल के लिए ज़रूरी हैं मैनेजर फ़्लो, उम्मीद के मुताबिक काम करे. अनुमति की ज़रूरत इसलिए है, ताकि सिर्फ़ Android सिस्टम इस सेवा से बाइंड कर सकता है. इंटेंट फ़िल्टर का इस्तेमाल, इस सेवा को क्रेडेंशियल मैनेजर के ज़रिए इस्तेमाल किए जाने वाले क्रेडेंशियल प्रोवाइडर के तौर पर खोजने के लिए किया जाता है.
बताएं कि आप किस तरह के क्रेडेंशियल का इस्तेमाल कर सकते हैं
अपनी res/xml डायरेक्ट्री में, provider.xml नाम की नई फ़ाइल बनाएं. इस फ़ाइल में, उन क्रेडेंशियल टाइप के बारे में बताएं जिनका इस्तेमाल आपकी सेवा के साथ किया जा सकता है. इसके लिए, लाइब्रेरी में हर क्रेडेंशियल टाइप के लिए तय की गई स्थिर वैल्यू का इस्तेमाल करें. यहां दिए गए उदाहरण में, यह सेवा सामान्य पासवर्ड के साथ-साथ पासकी के साथ भी काम करती है. इन पासकी के लिए, TYPE_PASSWORD_CREDENTIAL और 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>
पिछले एपीआई लेवल पर, क्रेडेंशियल देने वाली कंपनियां, ऑटोमैटिक भरने की सुविधा जैसे एपीआई के साथ इंटिग्रेट करती हैं पासवर्ड और अन्य डेटा के लिए. ये सेवा देने वाली कंपनियां, मौजूदा क्रेडेंशियल टाइप को सेव करने के लिए, उसी इंटरनल इन्फ़्रास्ट्रक्चर का इस्तेमाल कर सकती हैं. साथ ही, इसे पासकी के साथ-साथ अन्य क्रेडेंशियल टाइप के साथ काम करने के लिए भी बढ़ाया जा सकता है.
सेवा देने वाली कंपनी के साथ इंटरैक्शन के लिए दो चरणों वाला तरीका
क्रेडेंशियल मैनेजर, क्रेडेंशियल देने वाली सेवाओं के साथ दो चरणों में इंटरैक्ट करता है:
- पहला चरण शुरुआत/क्वेरी का चरण है, जिसमें सिस्टम
क्रेडेंशियल देने वाली सेवाएं और चालू करना
onBeginGetCredentialRequest(),onBeginCreateCredentialRequest(), याonClearCredentialStateRequest()तरीकों का इस्तेमाल करने की अनुमति है. इन तरीकों मेंBegin…अनुरोध शामिल हैं. सेवा देने वाली कंपनियों को इन अनुरोधों को प्रोसेस करना होगा औरBegin…जवाबों के साथ जवाब देना होगा. साथ ही, उन्हें उन एंट्री से भरना होगा जो खाता चुनने वाले टूल पर दिखाए जाने वाले विज़ुअल विकल्पों को दिखाती हैं. हर एंट्री मेंPendingIntentसेट होना चाहिए. - उपयोगकर्ता के किसी एंट्री को चुनने के बाद, चुनने का चरण शुरू होता है और
एंट्री से जुड़ा
PendingIntentट्रिगर हो जाता है. इससे, सेवा देने वाली कंपनी की गतिविधि. जब उपयोगकर्ता इस गतिविधि के साथ इंटरैक्ट करना बंद कर दे, तो क्रेडेंशियल देने वाली कंपनी को गतिविधि को खत्म करने से पहले, गतिविधि के नतीजे के लिए जवाब सेट करना होगा. इसके बाद, यह जवाब उस क्लाइंट ऐप्लिकेशन को भेजा जाता है जिसने क्रेडेंशियल मैनेजर को शुरू किया था.
पासकी बनाने का काम मैनेज करना
पासकी बनाने से जुड़ी क्वेरी मैनेज करना
जब कोई क्लाइंट ऐप्लिकेशन, पासकी बनाना चाहता है और उसे
क्रेडेंशियल देने के लिए, वे createCredential एपीआई को कॉल करते हैं. मैनेज करने के लिए
ऐसा अनुरोध करें कि पासकी
जो आपके खाते के स्टोरेज में सेव है, तो नीचे दिए गए चरणों को पूरा करें.
- अपनी सेवा में
onBeginCreateCredentialRequest()तरीके को बदलेंCredentialProviderServiceसे बढ़ाया गया. BeginCreateCredentialRequestको हैंडल करने के लिए, उससे मिलता-जुलताBeginCreateCredentialResponseबनाएं और उसे कॉलबैक में पास करें.BeginCreateCredentialResponseबनाते समय, ज़रूरीCreateEntriesजोड़ें. हरCreateEntry, उस खाते से जुड़ा होना चाहिए जहां क्रेडेंशियल सेव किए जा सकते हैं. साथ ही, उसमें ज़रूरी मेटाडेटा के साथPendingIntentसेट होना चाहिए.
इस उदाहरण में, इन चरणों को लागू करने का तरीका बताया गया है.
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
)
)
}
PendingIntent ऐसेट में इन बातों का पालन किया जाना चाहिए:
- गतिविधि को इस तरह से सेट अप किया जाना चाहिए कि ज़रूरी होने पर, बायोमेट्रिक पुष्टि करने के लिए कहा जा सके, पुष्टि करने के लिए कहा जा सके या कोई विकल्प चुना जा सके.
- जब संबंधित गतिविधि शुरू की जाती है, तब सेवा देने वाली कंपनी को जो भी ज़रूरी डेटा चाहिए उसे उस इंटेंट पर एक्स्ट्रा के तौर पर सेट किया जाना चाहिए जिसका इस्तेमाल आपके
PendingIntentको बनाने के लिए किया जाता है. जैसे, बनाने के फ़्लो मेंaccountId. - आपका
PendingIntent, झंडे के साथ बनाया जाना चाहिएPendingIntent.FLAG_MUTABLEताकि सिस्टम आखिरी नतीजे को जोड़ सके इंटेंट एक्स्ट्रा के लिए अनुरोध करें. - आपके
PendingIntentको फ़्लैगPendingIntent.FLAG_ONE_SHOTके साथ नहीं बनाया जाना चाहिए, क्योंकि उपयोगकर्ता किसी एंट्री को चुन सकता है, वापस जा सकता है, और उसे फिर से चुन सकता है. इससेPendingIntentदो बार ट्रिगर होगा. - आपका
PendingIntent, एक यूनीक अनुरोध कोड के साथ बनाया जाना चाहिए, ताकि हर एंट्री का अपनाPendingIntentहो.
पासकी बनाने के अनुरोधों के लिए, एंट्री चुनने की सुविधा को मैनेज करना
- जब उपयोगकर्ता पहले से भरा हुआ
CreateEntryचुनता है, तो संबंधितPendingIntentका इस्तेमाल किया जाता है और उससे जुड़ी सेवा देने वाली कंपनीActivityबनाया गया. - आपकी गतिविधि के
onCreateतरीके को शुरू करने के बाद, उससे जुड़ा इंटेंट ऐक्सेस करें औरProviderCreateCredentialRequestपाने के लिए, उसेPendingIntentHanderक्लास में पास करें. - अनुरोध से
requestJson,callingAppInfo, औरclientDataHashको निकालें. - इंटेंट एक्सट्रा से स्थानीय
accountIdनिकालें. यह किसी ऐप्लिकेशन के लिए लागू करने का सैंपल है. इसे लागू करना ज़रूरी नहीं है. इस खाता आईडी का इस्तेमाल, इस क्रेडेंशियल को इस खाता आईडी के साथ सेव करने के लिए किया जा सकता है. requestJsonकी पुष्टि करें. यहां दिए गए उदाहरण में,PublicKeyCredentialCreationOptionsजैसी लोकल डेटा क्लास का इस्तेमाल किया गया है. इससे, इनपुट जेएसओएन को WebAuthn स्पेसिफ़िकेशन के मुताबिक स्ट्रक्चर्ड क्लास में बदला जा सकता है. क्रेडेंशियल उपलब्ध कराने वाले के तौर पर, इसे अपने पार्सर से बदला जा सकता है.- कॉल करने वाले ऐप्लिकेशन का asset-link देखें, अगर कॉल किसी इस्तेमाल करने के लिए बनाया गया है.
- पुष्टि करने का अनुरोध दिखाएं. नीचे दिए गए उदाहरण में Android का बायोमेट्रिक एपीआई.
- पुष्टि हो जाने के बाद,
credentialIdऔर एक कुंजी जोड़ी जनरेट करें. - निजी कुंजी को अपने स्थानीय डेटाबेस में
callingAppInfo.packageNameके लिए सेव करें. - ऐसा Web Authentication API JSON रिस्पॉन्स बनाएं जो
इसमें सार्वजनिक पासकोड और
credentialIdशामिल होते हैं. उदाहरण के लिए नीचे स्थानीय यूटिलिटी क्लास का इस्तेमाल किया गया है, जैसे किAuthenticatorAttestationResponseऔरFidoPublicKeyCredentialपुराने डेटा के आधार पर JSON बनाने में मदद करता है. दस्तावेज़ में बताया गया है.क्रेडेंशियल देने वाले के तौर पर, इन क्लास को इनसे बदला जा सकता है: खुद बनाएं. - जनरेट किए गए JSON का इस्तेमाल करके
CreatePublicKeyCredentialResponseबनाएं पढ़ें. PendingIntentHander.setCreateCredentialResponse()की मदद से,IntentपरCreatePublicKeyCredentialResponseको एक्सट्रा के तौर पर सेट करें. साथ ही, उस इंटेंट को गतिविधि के नतीजे पर सेट करें.- गतिविधि पूरी करें.
नीचे दिए गए उदाहरण में, इन चरणों को दिखाया गया है. इस कोड को इसमें हैंडल किया जाना चाहिए
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)}"
}
पासवर्ड बनाने के अनुरोधों से जुड़ी क्वेरी मैनेज करना
पासवर्ड बनाने के अनुरोधों से जुड़ी क्वेरी को मैनेज करने के लिए, यह तरीका अपनाएं:
- आपके
processCreateCredentialRequest()तरीके में बताए गए इसमें बताए गए तरीके पिछले सेक्शन में, हैंडलिंग के लिए स्विच ब्लॉक में कोई अन्य केस जोड़ें पासवर्ड के अनुरोध शामिल हैं. BeginCreateCredentialResponseबनाते समय, ज़रूरीCreateEntriesजोड़ें.- हर
CreateEntry, किसी ऐसे खाते से जुड़ा होना चाहिए जहां क्रेडेंशियल सेव किया जा सकता हो. साथ ही, उस पर अन्य मेटाडेटा के साथPendingIntentसेट होना चाहिए.
नीचे दिए गए उदाहरण में, इन चरणों को लागू करने का तरीका बताया गया है:
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)
}
पासवर्ड बनाने के अनुरोधों के लिए, एंट्री चुनने का विकल्प मैनेज करना
जब उपयोगकर्ता, जानकारी से भरा हुआ कोई CreateEntry चुनता है, तो उससे जुड़ा PendingIntent लागू हो जाता है और उससे जुड़ी गतिविधि दिखने लगती है.
संबद्ध इंटेंट, onCreate में पास किया गया और उसे
ProviderCreateCredentialRequest तरीका पाने के लिए, PendingIntentHander क्लास.
नीचे दिए गए उदाहरण में इस प्रोसेस को लागू करने का तरीका बताया गया है. इस कोड को आपकी गतिविधि के onCreate() मेथड में मैनेज करना होगा.
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()
उपयोगकर्ता के साइन-इन को मैनेज करना
उपयोगकर्ता के साइन इन को मैनेज करने के लिए, यह तरीका अपनाएं:
- जब कोई क्लाइंट ऐप्लिकेशन उपयोगकर्ता को साइन इन करने की कोशिश करता है, तो यह
GetCredentialRequestइंस्टेंस. - Android फ़्रेमवर्क, इस अनुरोध को लागू होने वाले सभी क्रेडेंशियल पर लागू करता है इन सेवाओं के लिए बाध्य करना होगा.
- इसके बाद, सेवा देने वाली कंपनी को एक
BeginGetCredentialRequestमिलता है. इसमेंBeginGetCredentialOptionकी सूची होती है. हरBeginGetCredentialOptionमें ऐसे पैरामीटर होते हैं जिनका इस्तेमाल, मैच होने वाले क्रेडेंशियल वापस पाने के लिए किया जा सकता है.
क्रेडेंशियल की सेवा देने वाली अपनी कंपनी में इस अनुरोध को मैनेज करने के लिए, यह तरीका अपनाएं:
अनुरोध को मैनेज करने के लिए,
onBeginGetCredentialRequest()तरीके को बदलें. ध्यान दें कि अगर आपके क्रेडेंशियल लॉक हैं, तो जवाब परAuthenticationActionऔर कॉलबैक शुरू करें.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()) } }सेवा देने वाली ऐसी कंपनियां जिन्हें वापस लौटने से पहले क्रेडेंशियल को अनलॉक करना ज़रूरी है किसी भी
credentialEntriesको, नेविगेट करने वाला ऐसा इंटेंट सेट अप करना होगा उपयोगकर्ता को ऐप्लिकेशन के अनलॉक फ़्लो पर ले जाने के लिए: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 ) ) }अपने लोकल डेटाबेस से क्रेडेंशियल पाएं और इनका इस्तेमाल करके उन्हें सेट अप करें
CredentialEntriesको सिलेक्टर पर दिखाने के लिए. पासकी के लिए, इसे सेट किया जा सकता है इंटेंट पर एक अतिरिक्त के रूप मेंcredentialId, ताकि यह पता चल सके कि वह कौनसा क्रेडेंशियल है उपयोगकर्ता के इस एंट्री को चुनने पर मैप करता है.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) }अपने डेटाबेस के क्रेडेंशियल के बारे में क्वेरी करें. इसके बाद, पासकी और पासवर्ड डालें अपने-आप जानकारी भर जाए.
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) ) }जब आप क्वेरी करें और क्रेडेंशियल को पॉप्युलेट करें, तो अब आपको उपयोगकर्ता जिन क्रेडेंशियल को चुन रहा है उन्हें चुनने का चरण यह एक पासकी या पासवर्ड है.
पासकी के लिए उपयोगकर्ता के चुने गए विकल्प को मैनेज करना
- उससे जुड़ी गतिविधि के
onCreateतरीके में, उससे जुड़ा इंटेंट पाएं औरPendingIntentHandler.retrieveProviderGetCredentialRequest()को पास करें. - ऊपर दिए गए अनुरोध से
GetPublicKeyCredentialOptionनिकालें. इसके बाद, इस विकल्प सेrequestJsonऔरclientDataHashको अलग करें. - इंटेंट एक्सट्रा से
credentialIdनिकालें. इसे क्रेडेंशियल उपलब्ध कराने वाली कंपनी ने,PendingIntentसेट अप करते समय भरा था. - ऊपर ऐक्सेस किए गए अनुरोध पैरामीटर का इस्तेमाल करके, अपने लोकल डेटाबेस से पासकी निकालें.
एक्सट्रैक्ट किए गए मेटाडेटा के साथ पासकी को मान्य होने का दावा करें. साथ ही, पुष्टि करने के लिए.
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 )उपयोगकर्ता की पुष्टि करने के लिए, बायोमेट्रिक प्रॉम्प्ट (या पुष्टि करने का कोई दूसरा तरीका) दिखाएं. नीचे दिया गया कोड स्निपेट, Android Biometric API का इस्तेमाल करता है.
पुष्टि हो जाने के बाद, W3 Web Authentication Assertion spec के आधार पर JSON रिस्पॉन्स बनाएं. नीचे दिए गए कोड स्निपेट में,
AuthenticatorAssertionResponseजैसी हेल्पर डेटा क्लास का इस्तेमाल, स्ट्रक्चर्ड पैरामीटर को शामिल करने और उन्हें ज़रूरी JSON फ़ॉर्मैट में बदलने के लिए किया जाता है. रिस्पॉन्स में, WebAuthn क्रेडेंशियल की निजी कुंजी से मिला डिजिटल हस्ताक्षर शामिल होता है. भरोसेमंद पक्ष का सर्वर पुष्टि कर सकता है साइन इन करने से पहले उपयोगकर्ता को प्रमाणित करने के लिए इस हस्ताक्षर का इस्तेमाल करें.ऊपर जनरेट किए गए JSON का इस्तेमाल करके
PublicKeyCredentialबनाएं और इसे फ़ाइनलGetCredentialResponseपर सेट करें. इस गतिविधि के नतीजे के आधार पर, यह आखिरी जवाब सेट करें.
नीचे दिए गए उदाहरण में, इन चरणों को लागू करने का तरीका बताया गया है:
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)
पासवर्ड की पुष्टि करने के लिए, उपयोगकर्ता के चुने गए तरीके को मैनेज करना
- अपनी गतिविधि में,
onCreateमें पास किए गए इंटेंट को ऐक्सेस करें औरPendingIntentHandlerका इस्तेमाल करकेProviderGetCredentialRequestको निकालें. आने वाले पैकेज के नाम के लिए पासवर्ड के क्रेडेंशियल वापस पाने के लिए, अनुरोध में
GetPasswordOptionका इस्तेमाल करें.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 } }पासवर्ड वापस पाने के बाद, चुने गए पासवर्ड क्रेडेंशियल के लिए जवाब सेट करें.
// Set the response back val result = Intent() val passwordCredential = PasswordCredential(username, password) PendingIntentHandler.setGetCredentialResponse( result, GetCredentialResponse(passwordCredential) ) setResult(Activity.RESULT_OK, result) finish()
पुष्टि करने की कार्रवाई की एंट्री का चुनाव मैनेज करना
जैसा कि पहले बताया गया है, अगर क्रेडेंशियल लॉक हैं, तो क्रेडेंशियल देने वाली कंपनी AuthenticationAction सेट कर सकती है. अगर उपयोगकर्ता इस एंट्री को चुनता है, तो PendingIntent में सेट की गई इंटेंट ऐक्शन से जुड़ी ऐक्टिविटी शुरू हो जाती है. इसके बाद, क्रेडेंशियल देने वाली कंपनियां, क्रेडेंशियल अनलॉक करने के लिए, बायोमेट्रिक पुष्टि करने का तरीका या मिलता-जुलता तरीका दिखा सकती हैं. पुष्टि हो जाने के बाद, क्रेडेंशियल उपलब्ध कराने वाली कंपनी को BeginGetCredentialResponse बनाना होगा. यह BeginGetCredentialResponse, उपयोगकर्ता के साइन इन करने के तरीके के बारे में ऊपर बताए गए तरीके से मिलता-जुलता होना चाहिए. ऐसा इसलिए, क्योंकि क्रेडेंशियल अब अनलॉक हो गए हैं. इसके बाद, इस जवाब को PendingIntentHandler.setBeginGetCredentialResponse() तरीके से सेट करना होगा. इसके बाद ही, तैयार किए गए इंटेंट को नतीजे के तौर पर सेट किया जाएगा और गतिविधि पूरी हो जाएगी.
क्रेडेंशियल के अनुरोध मिटाना
क्लाइंट ऐप्लिकेशन यह अनुरोध कर सकता है कि क्रेडेंशियल चुनने के लिए किसी भी राज्य को बनाए रखना ज़रूरी है
साफ़ नहीं किए जाते, जैसे कि क्रेडेंशियल देने वाला, आपके चुने गए विकल्प को याद रख सकता है
क्रेडेंशियल डालें और उसे अगली बार ही वापस करें. कोई क्लाइंट ऐप्लिकेशन इस एपीआई को कॉल करता है और उम्मीद करता है कि स्टिक सिलेक्शन हट जाए. क्रेडेंशियल देने वाली सेवा, onClearCredentialStateRequest() तरीके को बदलकर, इस अनुरोध को मैनेज कर सकती है:
override fun onClearCredentialStateRequest(
request: android.service.credentials.ClearCredentialStateRequest,
cancellationSignal: CancellationSignal,
callback: OutcomeReceiver<Void?, ClearCredentialException>,
) {
// Delete any maintained state as appropriate.
}
सेवा देने वाली कंपनी के सेटिंग पेज से लिंक करने के लिए सुविधा जोड़ें
उपयोगकर्ताओं को पासवर्ड, पासकी, और ऑटोमैटिक भरने की सुविधा वाली स्क्रीन से, क्रेडेंशियल की सेवा देने वाली कंपनी की सेटिंग खोलने की अनुमति देने के लिए, क्रेडेंशियल की सेवा देने वाले ऐप्लिकेशन को res/xml/provider.xml में credential-provider settingsActivity मेनिफ़ेस्ट एट्रिब्यूट लागू करना चाहिए. इस एट्रिब्यूट की मदद से, अपने ऐप्लिकेशन की
अगर कोई उपयोगकर्ता, पासवर्ड,
पासकी और सेवाओं की सूची अपने-आप भरने की सुविधा. इस एट्रिब्यूट का मान
सेटिंग स्क्रीन से लॉन्च की जाने वाली गतिविधि का नाम.
<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>
सेटिंग के इंटेंट
सेटिंग खोलें: android.settings.CREDENTIAL_PROVIDER के ज़रिए, सेटिंग स्क्रीन खुलती है. यहां उपयोगकर्ता, अपने पसंदीदा और अन्य क्रेडेंशियल प्रोवाइडर चुन सकता है.
पसंदीदा क्रेडेंशियल सेवा: ACTION_REQUEST_SET_AUTOFILL_SERVICE इंटेंट, उपयोगकर्ता को सेवा देने वाली पसंदीदा कंपनी चुनने की स्क्रीन पर रीडायरेक्ट करता है. इस स्क्रीन पर चुने गए क्रेडेंशियल और ऑटोमैटिक भरने की सुविधा देने वाली कंपनी, आपके लिए प्राथमिकता बन जाती है.
खास अधिकारों वाले ऐप्लिकेशन की अनुमति वाली सूची पाना
वेब ब्राउज़र जैसे ऐप्लिकेशन, क्रेडेंशियल मैनेजर GetCredentialRequest() और CreatePublicKeyCredentialRequest() तरीकों में origin पैरामीटर सेट करके, भरोसेमंद अन्य पक्षों की ओर से क्रेडेंशियल मैनेजर कॉल करते हैं. इन अनुरोधों को प्रोसेस करने के लिए,
क्रेडेंशियल देने वाला, getOrigin() का इस्तेमाल करके origin को फिर से हासिल करता है
एपीआई.
origin को वापस पाने के लिए, क्रेडेंशियल उपलब्ध कराने वाले ऐप्लिकेशन को androidx.credentials.provider.CallingAppInfo's getOrigin() एपीआई को, विशेषाधिकार वाले और भरोसेमंद कॉलर की सूची भेजनी होगी. अनुमति वाली सूची
एक मान्य JSON ऑब्जेक्ट होना चाहिए. origin तब दिखाया जाता है, जब packageName और signingInfo से मिले सर्टिफ़िकेट के फ़िंगरप्रिंट, getOrigin() एपीआई को पास किए गए privilegedAllowlist में मौजूद ऐप्लिकेशन के फ़िंगरप्रिंट से मेल खाते हों. origin वैल्यू मिलने के बाद, सेवा देने वाले ऐप्लिकेशन को इसे एक खास कॉल माना जाना चाहिए. साथ ही, कॉल करने वाले ऐप्लिकेशन के हस्ताक्षर का इस्तेमाल करके origin का हिसाब लगाने के बजाय, AuthenticatorResponse में origin को क्लाइंट डेटा पर सेट करना चाहिए.
origin को वापस पाने पर, सीधे तौर पर दिए गए clientDataHash का इस्तेमाल करें
CreatePublicKeyCredentialRequest() में या
असेंबल और हैश करने के बजाय GetPublicKeyCredentialOption() से मैच किया जाएगा
clientDataJSON. JSON को पार्स करने से जुड़ी समस्याओं से बचने के लिए, पुष्टि और एश्योरेशन के जवाब में clientDataJSON के लिए प्लेसहोल्डर वैल्यू सेट करें.
Google Password Manager, getOrigin() को कॉल करने के लिए, सार्वजनिक तौर पर उपलब्ध अनुमति वाली सूची का इस्तेमाल करता है. क्रेडेंशियल उपलब्ध कराने वाली कंपनी के तौर पर, इस सूची का इस्तेमाल किया जा सकता है या एपीआई के बताए गए JSON फ़ॉर्मैट में अपनी सूची दी जा सकती है. यह तय करना सेवा देने वाली कंपनी के हाथ में है कि किस सूची का इस्तेमाल किया जाए. तीसरे पक्ष की मदद से खास अधिकार पाने के लिए
क्रेडेंशियल देने वाली कंपनियां, तीसरे पक्ष की ओर से दिए गए दस्तावेज़ देखें.
डिवाइस पर इंटरनेट सेवा देने वाली कंपनियों के नाम उपलब्ध कराएं
उपयोगकर्ताओं को इसके ज़रिए प्रोवाइडर को चालू करना होगा डिवाइस की सेटिंग > पासवर्ड और खाते > आपको सेवा देने वाली कंपनी > चालू या बंद करें.
fun createSettingsPendingIntent(): PendingIntent