1. शुरू करने से पहले
पुष्टि करने के पारंपरिक तरीकों से, सुरक्षा और इस्तेमाल से जुड़ी कई समस्याएं आती हैं.
पासवर्ड का इस्तेमाल ज़्यादातर किया जाता है, लेकिन...
- आसानी से भूल जाने वाले
- उपयोगकर्ताओं को मज़बूत पासवर्ड बनाने के लिए, पासवर्ड बनाने का तरीका पता होना चाहिए.
- हैकर आसानी से फ़िशिंग करते हैं, डेटा इकट्ठा करते हैं, और उसे फिर से चलाते हैं.
Android ने Credential Manager API बनाने के लिए काम किया है, ताकि साइन इन करने की प्रोसेस को आसान बनाया जा सके. साथ ही, बिना पासवर्ड के पुष्टि करने के लिए, इंडस्ट्री के नए स्टैंडर्ड पासकी का इस्तेमाल करके, सुरक्षा से जुड़े जोखिमों को कम किया जा सके.
Credential Manager में पासकी के साथ-साथ, पासवर्ड, 'Google से साइन इन करें' वगैरह जैसे पुष्टि करने के पारंपरिक तरीकों का इस्तेमाल किया जा सकता है.
उपयोगकर्ता पासकी बनाकर, उन्हें Google Password Manager में सेव कर पाएंगे. इसके बाद, ये पासकी उन सभी Android डिवाइसों पर सिंक हो जाएंगी जिन पर उपयोगकर्ता ने साइन इन किया हुआ है. उपयोगकर्ता खाते से जुड़ी पासकी बनाई जानी चाहिए. साथ ही, उपयोगकर्ता के पासकी से साइन इन करने से पहले, उसकी सार्वजनिक कुंजी को सर्वर पर सेव करना होगा.
इस कोडलैब में, आपको Credential Manager API का इस्तेमाल करके पासकी और पासवर्ड से साइन अप करने का तरीका पता चलेगा. साथ ही, आने वाले समय में पुष्टि करने के लिए, इनका इस्तेमाल करने का तरीका भी पता चलेगा. इसमें दो फ़्लो शामिल हैं:
- साइन अप करना : पासकी और पासवर्ड का इस्तेमाल करके.
- साइन इन करना : पासकी और सेव किए गए पासवर्ड का इस्तेमाल करके.
ज़रूरी शर्तें
- Android Studio में ऐप्लिकेशन चलाने का बुनियादी तरीका.
- Android ऐप्लिकेशन में पुष्टि करने की प्रोसेस के बारे में बुनियादी जानकारी.
- पासकी के बारे में बुनियादी जानकारी.
आपको क्या सीखने को मिलेगा
- पासकी बनाने का तरीका.
- पासवर्ड मैनेजर में पासवर्ड सेव करने का तरीका.
- पासकी या सेव किए गए पासवर्ड की मदद से, उपयोगकर्ताओं की पुष्टि करने का तरीका.
आपको किन चीज़ों की ज़रूरत होगी
डिवाइसों के इनमें से कोई एक कॉम्बिनेशन:
- पासकी के लिए, Android 9 या इसके बाद का वर्शन और क्रेडेंशियल मैनेजर एपीआई की मदद से पासवर्ड की पुष्टि करने के लिए, Android 4.4 या इसके बाद का वर्शन वाला Android डिवाइस.
- डिवाइस में बायोमेट्रिक सेंसर होना चाहिए.
- बायोमेट्रिक (या स्क्रीन लॉक) क्रेडेंशियल ज़रूर रजिस्टर करें.
- Kotlin प्लगिन का वर्शन : 1.8.10
2. सेट अप करें
- अपने लैपटॉप पर, credman_codelab शाखा से इस डेटा स्टोर करने की जगह को क्लोन करें : https://github.com/android/identity-samples/tree/credman_codelab
git clone -b credman_codelab https://github.com/android/identity-samples.git
- CredentialManager मॉड्यूल पर जाएं और Android Studio में प्रोजेक्ट खोलें.
ऐप्लिकेशन की शुरुआती स्थिति देखें
ऐप्लिकेशन की शुरुआती स्थिति कैसे काम करती है, यह देखने के लिए यह तरीका अपनाएं:
- ऐप्लिकेशन लॉन्च करें.
- आपको साइन अप और साइन इन बटन वाली मुख्य स्क्रीन दिखेगी. फ़िलहाल, ये बटन कुछ नहीं करते. हालांकि, हम आने वाले सेक्शन में इनका फ़ंक्शन चालू करेंगे.
3. पासकी का इस्तेमाल करके साइन अप करने की सुविधा जोड़ना
Credential Manager API का इस्तेमाल करने वाले किसी Android ऐप्लिकेशन पर नया खाता बनाते समय, उपयोगकर्ता अपने खाते के लिए पासकी बना सकते हैं. यह पासकी, उपयोगकर्ता के चुने गए क्रेडेंशियल प्रोवाइडर पर सुरक्षित रूप से सेव की जाएगी. साथ ही, आने वाले समय में साइन इन करने के लिए इसका इस्तेमाल किया जाएगा. इसके लिए, उपयोगकर्ता को हर बार अपना पासवर्ड डालने की ज़रूरत नहीं होगी.
अब आपको पासकी बनानी होगी और बायोमेट्रिक्स/स्क्रीन लॉक का इस्तेमाल करके, उपयोगकर्ता के क्रेडेंशियल रजिस्टर करने होंगे.
पासकी से साइन अप करना
Credential Manager/app/main/java/SignUpFragment.kt में मौजूद कोड, एक टेक्स्ट फ़ील्ड "username" और पासकी से साइन अप करने के लिए बटन तय करता है.
createPasskey() कॉल में चैलेंज और अन्य JSON रिस्पॉन्स पास करें
पासकी बनाने से पहले, आपको सर्वर से ज़रूरी जानकारी का अनुरोध करना होगा. यह जानकारी, createCredential() कॉल के दौरान, क्रेडेंशियल मैनेजर एपीआई को भेजी जाएगी.
आपके प्रोजेक्ट की एसेट में पहले से ही एक मॉक रिस्पॉन्स मौजूद है. इसे RegFromServer.txt कहा जाता है. यह इस कोडलैब में ज़रूरी पैरामीटर दिखाता है.
- अपने ऐप्लिकेशन में, SignUpFragment.kt पर जाएं. इसके बाद, signUpWithPasskeys तरीका ढूंढें. यहां आपको पासकी बनाने और उपयोगकर्ता को ऐप्लिकेशन में शामिल करने का लॉजिक लिखना होगा. आपको यह तरीका उसी क्लास में मिल सकता है.
createPasskey()को कॉल करने के लिए, टिप्पणी वाले else ब्लॉक की जांच करें और उसे इस कोड से बदलें:
SignUpFragment.kt
//TODO : Call createPasskey() to signup with passkey
val data = createPasskey()
स्क्रीन पर मान्य उपयोगकर्ता नाम भरने के बाद, इस तरीके को कॉल किया जाएगा.
createPasskey()तरीके में, आपको ज़रूरी पैरामीटर के साथCreatePublicKeyCredentialRequest()बनाना होगा.
SignUpFragment.kt
//TODO create a CreatePublicKeyCredentialRequest() with necessary registration json from server
val request = CreatePublicKeyCredentialRequest(fetchRegistrationJsonFromServer())
fetchRegistrationJsonFromServer() तरीका, ऐसेट से एमुलेट किए गए सर्वर PublicKeyCredentialCreationOptions के JSON रिस्पॉन्स को पढ़ता है. साथ ही, पासकी बनाते समय पास किए जाने वाले रजिस्ट्रेशन JSON को दिखाता है.
fetchRegistrationJsonFromServer()तरीका ढूंढें और JSON दिखाने के लिए, TODO को नीचे दिए गए कोड से बदलें. साथ ही, खाली स्ट्रिंग दिखाने वाले स्टेटमेंट को हटाएं :
SignUpFragment.kt
//TODO fetch registration mock response
val response = requireContext().readFromAsset("RegFromServer")
//Update userId,challenge, name and Display name in the mock
return response.replace("<userId>", getEncodedUserId())
.replace("<userName>", binding.username.text.toString())
.replace("<userDisplayName>", binding.username.text.toString())
.replace("<challenge>", getEncodedChallenge())
- यह JSON अधूरा है और इसमें चार फ़ील्ड ऐसे हैं जिन्हें बदलना होगा.
- UserId को यूनीक होना चाहिए, ताकि उपयोगकर्ता ज़रूरत पड़ने पर एक से ज़्यादा पासकी बना सके.
<userId>को जनरेट की गईuserIdवैल्यू से बदलें. <challenge>को भी यूनीक होना चाहिए, ताकि आपको एक यूनीक चैलेंज जनरेट हो. यह तरीका आपके कोड में पहले से मौजूद है.
असल सर्वर PublicKeyCredentialCreationOptions के रिस्पॉन्स में ज़्यादा विकल्प दिख सकते हैं. इनमें से कुछ फ़ील्ड का उदाहरण यहां दिया गया है:
{
"challenge": String,
"rp": {
"name": String,
"id": String
},
"user": {
"id": String,
"name": String,
"displayName": String
},
"pubKeyCredParams": [
{
"type": "public-key",
"alg": -7
},
{
"type": "public-key",
"alg": -257
}
],
"timeout": 1800000,
"attestation": "none",
"excludeCredentials": [],
"authenticatorSelection": {
"authenticatorAttachment": "platform",
"requireResidentKey": true,
"residentKey": "required",
"userVerification": "required"
}
}
इस टेबल में, PublicKeyCredentialCreationOptions ऑब्जेक्ट के कुछ अहम पैरामीटर के बारे में बताया गया है:
पैरामीटर | जानकारी |
सर्वर से जनरेट की गई रैंडम स्ट्रिंग, जिसमें इतना एन्ट्रापी होता है कि उसका अनुमान लगाना मुश्किल हो जाता है. यह कम से कम 16 बाइट का होना चाहिए. यह ज़रूरी है, लेकिन रजिस्ट्रेशन के दौरान इसका इस्तेमाल नहीं किया जाता. इसका इस्तेमाल सिर्फ़ पुष्टि के लिए किया जाता है. | |
उपयोगकर्ता का यूनीक आईडी. इस वैल्यू में, व्यक्तिगत पहचान से जुड़ी जानकारी शामिल नहीं होनी चाहिए. जैसे, ईमेल पते या उपयोगकर्ता नाम. हर खाते के लिए, 16-बाइट की कोई भी वैल्यू जनरेट की जा सकती है. | |
इस फ़ील्ड में, उस खाते का यूनीक आइडेंटिफ़ायर होना चाहिए जिसे उपयोगकर्ता पहचान सके. जैसे, उसका ईमेल पता या उपयोगकर्ता नाम. यह नाम, खाता चुनने वाले टूल में दिखेगा. (अगर उपयोगकर्ता नाम का इस्तेमाल किया जा रहा है, तो पासवर्ड की पुष्टि करने के लिए इस्तेमाल की गई वैल्यू का इस्तेमाल करें.) | |
यह फ़ील्ड भरना ज़रूरी नहीं है. इसमें खाते के लिए, उपयोगकर्ता के हिसाब से आसान नाम दिया जा सकता है. | |
भरोसा करने वाली पार्टी की इकाई, आपके आवेदन की जानकारी से मेल खाती है. इसमें ये एट्रिब्यूट शामिल हैं:
| |
इस्तेमाल किए जा सकने वाले एल्गोरिदम और कुंजी के टाइप की सूची. इस सूची में कम से कम एक एलिमेंट होना चाहिए. | |
हो सकता है कि डिवाइस रजिस्टर करने वाले उपयोगकर्ता ने पहले ही अन्य डिवाइसों को रजिस्टर कर लिया हो. अगर आपको किसी एक Authenticator ऐप्लिकेशन पर, एक ही खाते के लिए कई क्रेडेंशियल बनाने की सुविधा को सीमित करना है, तो इन डिवाइसों को अनदेखा किया जा सकता है. अगर | |
इससे पता चलता है कि डिवाइस को प्लैटफ़ॉर्म से अटैच करना है या नहीं या ऐसा करने की ज़रूरत नहीं है. इस वैल्यू को | |
| पासकी बनाने के लिए, वैल्यू |
क्रेडेंशियल बनाना
CreatePublicKeyCredentialRequest()बनाने के बाद, आपको बनाए गए अनुरोध के साथcreateCredential()कॉल को कॉल करना होगा.
SignUpFragment.kt
//TODO call createCredential() with createPublicKeyCredentialRequest
try {
response = credentialManager.createCredential(
requireActivity(),
request
) as CreatePublicKeyCredentialResponse
} catch (e: CreateCredentialException) {
configureProgress(View.INVISIBLE)
handlePasskeyFailure(e)
}
- आपने
createCredential()को ज़रूरी जानकारी दी है. - अनुरोध पूरा होने के बाद, आपको स्क्रीन पर एक बॉटमशीट दिखेगी. इसमें आपको पासकी बनाने के लिए कहा जाएगा.
- अब उपयोगकर्ता, बायोमेट्रिक्स या स्क्रीन लॉक वगैरह की मदद से अपनी पहचान की पुष्टि कर सकते हैं.
- रेंडर किए गए व्यू को दिखाने की सुविधा को मैनेज किया जाता है. साथ ही, अगर किसी वजह से अनुरोध पूरा नहीं होता है, तो अपवादों को मैनेज किया जाता है. यहां गड़बड़ी के मैसेज लॉग किए जाते हैं और ऐप्लिकेशन पर गड़बड़ी के डायलॉग बॉक्स में दिखाए जाते हैं. Android Studio या
adb debugकमांड की मदद से, गड़बड़ी के पूरे लॉग देखे जा सकते हैं.
- आखिर में, आपको रजिस्ट्रेशन की प्रोसेस पूरी करनी होगी. ऐप्लिकेशन, सर्वर को सार्वजनिक कुंजी का क्रेडेंशियल भेजता है. इसके बाद, सर्वर उसे मौजूदा उपयोगकर्ता के साथ रजिस्टर करता है.
यहां हमने मॉक सर्वर का इस्तेमाल किया है. इसलिए, हम सिर्फ़ 'सही' दिखाते हैं. इससे पता चलता है कि सर्वर ने आने वाले समय में पुष्टि और पुष्टि करने के लिए, रजिस्टर की गई सार्वजनिक कुंजी सेव कर ली है. सर्वर-साइड पासकी रजिस्ट्रेशन के बारे में ज़्यादा पढ़कर, इसे खुद लागू किया जा सकता है.
signUpWithPasskeys() तरीके में, काम की टिप्पणी ढूंढें और उसे इस कोड से बदलें:
SignUpFragment.kt
//TODO : complete the registration process after sending public key credential to your server and let the user in
data?.let {
registerResponse()
DataProvider.setSignedInThroughPasskeys(true)
listener.showHome()
}
registerResponse()trueदिखाता है, जिससे पता चलता है कि मॉक सर्वर ने सार्वजनिक कुंजी को आने वाले समय में इस्तेमाल करने के लिए सेव कर लिया है.setSignedInThroughPasskeysफ़्लैग कोtrueपर सेट करें.- लॉग इन करने के बाद, उपयोगकर्ता को होम स्क्रीन पर रीडायरेक्ट करें.
किसी असल PublicKeyCredential में ज़्यादा फ़ील्ड हो सकते हैं. इन फ़ील्ड का उदाहरण यहां दिया गया है:
{
"id": String,
"rawId": String,
"type": "public-key",
"response": {
"clientDataJSON": String,
"attestationObject": String,
}
}
इस टेबल में, PublicKeyCredential ऑब्जेक्ट के कुछ अहम पैरामीटर के बारे में बताया गया है:
पैरामीटर | जानकारी |
बनाई गई पासकी का Base64URL कोड में बदला गया आईडी. इस आईडी से ब्राउज़र को यह पता चलता है कि पुष्टि करने के बाद, डिवाइस में मिलती-जुलती पासकी मौजूद है या नहीं. यह वैल्यू, बैकएंड पर डेटाबेस में सेव होनी चाहिए. | |
क्रेडेंशियल आईडी का | |
क्लाइंट का एन्क्रिप्ट किया गया डेटा, | |
कोड में बदला गया |
ऐप्लिकेशन चलाएं. इसके बाद, पासकी से साइन अप करें बटन पर क्लिक करके पासकी बनाएं.
4. क्रेडेंशियल प्रोवाइडर में पासवर्ड सेव करना
इस ऐप्लिकेशन में, साइन अप स्क्रीन में, आपके पास पहले से ही उपयोगकर्ता नाम और पासवर्ड है. इसे डेमो के मकसद से लागू किया गया है.
उपयोगकर्ता के पासवर्ड क्रेडेंशियल को पासवर्ड प्रोवाइडर के साथ सेव करने के लिए, आपको पासवर्ड सेव करने के लिए createCredential() को पास करने के लिए CreatePasswordRequest लागू करना होगा.
signUpWithPassword()का तरीका ढूंढें, TODO कोcreatePasswordकॉल से बदलें:
SignUpFragment.kt
//TODO : Save the user credential password with their password provider
createPassword()
createPassword()तरीके में, आपको पासवर्ड का अनुरोध इस तरह से बनाना होगा. इसके लिए, TODO को नीचे दिए गए कोड से बदलें:
SignUpFragment.kt
//TODO : CreatePasswordRequest with entered username and password
val request = CreatePasswordRequest(
binding.username.text.toString(),
binding.password.text.toString()
)
- इसके बाद,
createPassword()तरीके में, पासवर्ड बनाने के अनुरोध के साथ क्रेडेंशियल बनाएं और उपयोगकर्ता के पासवर्ड क्रेडेंशियल को पासवर्ड प्रोवाइडर के साथ सेव करें. TODO को इस कोड से बदलें:
SignUpFragment.kt
//TODO : Create credential with created password request
try {
credentialManager.createCredential(requireActivity(), request) as CreatePasswordResponse
} catch (e: Exception) {
Log.e("Auth", " Exception Message : " + e.message)
}
- अब आपने उपयोगकर्ता के पासवर्ड प्रोवाइडर के पास, पासवर्ड क्रेडेंशियल सेव कर लिया है. इससे, सिर्फ़ एक टैप में पासवर्ड की मदद से पुष्टि की जा सकती है.
5. पासकी या पासवर्ड से पुष्टि करने की सुविधा जोड़ना
अब आपके पास अपने ऐप्लिकेशन में सुरक्षित तरीके से पुष्टि करने के लिए, इस पासकोड का इस्तेमाल करने का विकल्प है.
getPasskey() कॉल को पास करने के लिए, चैलेंज और अन्य विकल्प पाना
उपयोगकर्ता से पुष्टि करने के लिए कहने से पहले, आपको सर्वर से WebAuthn JSON में पास करने के लिए पैरामीटर का अनुरोध करना होगा. इसमें चैलेंज भी शामिल है.
आपके पास अपनी एसेट (AuthFromServer.txt) में पहले से ही एक मॉक रिस्पॉन्स है, जो इस कोडलैब में ऐसे पैरामीटर दिखाता है.
- अपने ऐप्लिकेशन में, SignInFragment.kt पर जाएं. इसके बाद,
signInWithSavedCredentialsवह तरीका ढूंढें जिसमें सेव की गई पासकी या पासवर्ड की मदद से पुष्टि करने का लॉजिक लिखा जाएगा. साथ ही, उपयोगकर्ता को ऐप्लिकेशन में जाने की अनुमति दी जाएगी: createPasskey()को कॉल करने के लिए, टिप्पणी वाले else ब्लॉक की जांच करें और इसे नीचे दिए गए कोड से बदलें:
SignInFragment.kt
//TODO : Call getSavedCredentials() method to signin using passkey/password
val data = getSavedCredentials()
- getSavedCredentials() तरीके में, आपको क्रेडेंशियल देने वाली कंपनी से क्रेडेंशियल पाने के लिए ज़रूरी पैरामीटर के साथ
GetPublicKeyCredentialOption()बनाना होगा.
SigninFragment.kt
//TODO create a GetPublicKeyCredentialOption() with necessary registration json from server
val getPublicKeyCredentialOption =
GetPublicKeyCredentialOption(fetchAuthJsonFromServer(), null)
fetchAuthJsonFromServer() तरीका, ऐसेट से पुष्टि करने वाले JSON रिस्पॉन्स को पढ़ता है और इस उपयोगकर्ता खाते से जुड़ी सभी पासकी को वापस पाने के लिए, पुष्टि करने वाला JSON दिखाता है.
GetPublicKeyCredentialOption() का दूसरा पैरामीटर clientDataHash है - यह एक हैश है, जिसका इस्तेमाल भरोसेमंद पक्ष की पहचान की पुष्टि करने के लिए किया जाता है. इसे सिर्फ़ तब सेट करें, जब आपने GetCredentialRequest.origin सेट किया हो. सैंपल ऐप्लिकेशन के लिए, यह null पर सेट है.
- fetchAuthJsonFromServer() मेथड ढूंढें और JSON दिखाने के लिए, TODO को नीचे दिए गए कोड से बदलें. साथ ही, खाली स्ट्रिंग दिखाने वाले स्टेटमेंट को हटाएं:
SignInFragment.kt
//TODO fetch authentication mock json
return requireContext().readFromAsset("AuthFromServer")
ध्यान दें : इस कोडलैब के सर्वर को ऐसा JSON दिखाने के लिए डिज़ाइन किया गया है जो एपीआई के getCredential() कॉल में पास की गई PublicKeyCredentialRequestOptions डिक्शनरी से ज़्यादा से ज़्यादा मिलता-जुलता हो. नीचे दिए गए कोड स्निपेट में, कुछ उदाहरण के तौर पर ऐसे विकल्प शामिल हैं जो आपको असल जवाब में मिल सकते हैं:
{
"challenge": String,
"rpId": String,
"userVerification": "",
"timeout": 1800000
}
इस टेबल में, PublicKeyCredentialRequestOptions ऑब्जेक्ट के कुछ अहम पैरामीटर के बारे में बताया गया है:
पैरामीटर | जानकारी |
| |
आरपी आईडी एक डोमेन होता है. वेबसाइट, अपना डोमेन या रजिस्टर किया जा सकने वाला कोई सफ़िक्स बता सकती है. यह वैल्यू, पासकी बनाने के दौरान इस्तेमाल किए गए |
- इसके बाद, आपको इस उपयोगकर्ता खाते के लिए Credential Manager API की मदद से, पासवर्ड प्रोवाइडर में सेव किए गए सभी पासवर्ड वापस पाने के लिए,
PasswordOption()ऑब्जेक्ट बनाना होगा.getSavedCredentials()तरीके में, TODO ढूंढें और इसे इनके साथ बदलें:
SigninFragment.kt
//TODO create a PasswordOption to retrieve all the associated user's password
val getPasswordOption = GetPasswordOption()
क्रेडेंशियल पाएं
- इसके बाद, आपको ऊपर दिए गए सभी विकल्पों के साथ
getCredential()अनुरोध को कॉल करके, उससे जुड़े क्रेडेंशियल वापस पाने होंगे:
SignInFragment.kt
//TODO call getCredential() with required credential options
val result = try {
credentialManager.getCredential(
requireActivity(),
GetCredentialRequest(
listOf(
getPublicKeyCredentialOption,
getPasswordOption
)
)
)
} catch (e: Exception) {
configureViews(View.INVISIBLE, true)
Log.e("Auth", "getCredential failed with exception: " + e.message.toString())
activity?.showErrorAlert(
"An error occurred while authenticating through saved credentials. Check logs for additional details"
)
return null
}
if (result.credential is PublicKeyCredential) {
val cred = result.credential as PublicKeyCredential
DataProvider.setSignedInThroughPasskeys(true)
return "Passkey: ${cred.authenticationResponseJson}"
}
if (result.credential is PasswordCredential) {
val cred = result.credential as PasswordCredential
DataProvider.setSignedInThroughPasskeys(false)
return "Got Password - User:${cred.id} Password: ${cred.password}"
}
if (result.credential is CustomCredential) {
//If you are also using any external sign-in libraries, parse them here with the utility functions provided.
}
- आपने
getCredential()को ज़रूरी जानकारी दी है. यह क्रेडेंशियल के विकल्पों की सूची और गतिविधि के संदर्भ को लेता है, ताकि उस संदर्भ में बॉटमशीट में विकल्पों को रेंडर किया जा सके. - अनुरोध पूरा होने के बाद, आपको स्क्रीन पर एक बॉटमशीट दिखेगी. इसमें, उस खाते के लिए बनाए गए सभी क्रेडेंशियल की सूची होगी.
- अब उपयोगकर्ता, चुने गए क्रेडेंशियल की पुष्टि करने के लिए, बायोमेट्रिक्स या स्क्रीन लॉक वगैरह की मदद से अपनी पहचान की पुष्टि कर सकते हैं.
- अगर चुना गया क्रेडेंशियल
PublicKeyCredentialहै, तोsetSignedInThroughPasskeysफ़्लैग कोtrueके तौर पर सेट करें. अगर ऐसा नहीं है, तो इसेfalseपर सेट करें.
नीचे दिए गए कोड स्निपेट में, PublicKeyCredential ऑब्जेक्ट का एक उदाहरण शामिल है:
{
"id": String
"rawId": String
"type": "public-key",
"response": {
"clientDataJSON": String
"authenticatorData": String
"signature": String
"userHandle": String
}
}
यहां दी गई टेबल में सभी पैरामीटर शामिल नहीं हैं. हालांकि, इसमें PublicKeyCredential ऑब्जेक्ट के ज़रूरी पैरामीटर शामिल हैं:
पैरामीटर | जानकारी |
पुष्टि किए गए पासकी क्रेडेंशियल का Base64URL कोड में बदला गया आईडी. | |
क्रेडेंशियल आईडी का | |
क्लाइंट डेटा का | |
पुष्टि करने वाले ऐप्लिकेशन के डेटा का | |
हस्ताक्षर का | |
|
- आखिर में, आपको पुष्टि की प्रक्रिया पूरी करनी होगी. आम तौर पर, उपयोगकर्ता पासकी की मदद से पुष्टि करने के बाद, ऐप्लिकेशन सर्वर को एक सार्वजनिक कुंजी क्रेडेंशियल भेजता है. इसमें पुष्टि करने का एश्योरेशन होता है. सर्वर, एश्योरेशन की पुष्टि करता है और उपयोगकर्ता की पुष्टि करता है.
यहां हमने मॉक सर्वर का इस्तेमाल किया है, इसलिए हम सिर्फ़ true दिखाते हैं. इससे पता चलता है कि सर्वर ने एश्योरेशन की पुष्टि कर ली है. सर्वर-साइड पासकी की पुष्टि के बारे में ज़्यादा पढ़ें, ताकि आप इसे खुद लागू कर सकें.
signInWithSavedCredentials() तरीके में, काम की टिप्पणी ढूंढें और उसे इस कोड से बदलें:
SignInFragment.kt
//TODO : complete the authentication process after validating the public key credential to your server and let the user in.
data?.let {
sendSignInResponseToServer()
listener.showHome()
}
sendSigninResponseToServer()true दिखाता है, जिससे पता चलता है कि (मॉक) सर्वर ने आने वाले समय में इस्तेमाल करने के लिए, सार्वजनिक पासकोड की पुष्टि कर ली है.- लॉग इन करने के बाद, उपयोगकर्ता को होम स्क्रीन पर रीडायरेक्ट करें.
ऐप्लिकेशन चलाएं और साइन इन करें > पासकी/सेव किए गए पासवर्ड से साइन इन करें पर जाएं. इसके बाद,सेव किए गए क्रेडेंशियल का इस्तेमाल करके साइन इन करें.
इसे आज़माएं
आपने अपने Android ऐप्लिकेशन पर, पासकी बनाने, क्रेडेंशियल मैनेजर में पासवर्ड सेव करने, और पासकी या सेव किए गए पासवर्ड की मदद से पुष्टि करने की सुविधा लागू की है. इसके लिए, आपने Credential Manager API का इस्तेमाल किया है.
6. बधाई हो!
आपने यह कोडलैब पूरा कर लिया है! अगर आपको फ़ाइनल समाधान देखना है, तो https://github.com/android/identity-samples/tree/main/CredentialManager पर जाएं
अगर आपका कोई सवाल है, तो passkey टैग के साथ StackOverflow पर पूछें.