साल 2024 की चौथी तिमाही में किया गया बदलाव: अपने Android ऐप्लिकेशन में क्रेडेंशियल मैनेजर एपीआई का इस्तेमाल करके, पुष्टि करने की प्रोसेस को आसान बनाने का तरीका जानें

1. शुरू करने से पहले

पुष्टि करने के पारंपरिक तरीकों से, सुरक्षा और इस्तेमाल से जुड़ी कई समस्याएं आती हैं.

पासवर्ड का इस्तेमाल ज़्यादातर किया जाता है, लेकिन...

• आसानी से भूल जाने वाले
• उपयोगकर्ताओं को मज़बूत पासवर्ड बनाने के लिए, पासवर्ड बनाने का तरीका पता होना चाहिए.
• हैकर आसानी से फ़िशिंग करते हैं, डेटा इकट्ठा करते हैं, और उसे फिर से चलाते हैं.

Android ने Credential Manager API बनाने के लिए काम किया है, ताकि साइन इन करने की प्रोसेस को आसान बनाया जा सके. साथ ही, बिना पासवर्ड के पुष्टि करने के लिए, इंडस्ट्री के नए स्टैंडर्ड पासकी का इस्तेमाल करके, सुरक्षा से जुड़े जोखिमों को कम किया जा सके.

Credential Manager में पासकी के साथ-साथ, पासवर्ड, 'Google से साइन इन करें' वगैरह जैसे पुष्टि करने के पारंपरिक तरीकों का इस्तेमाल किया जा सकता है.

उपयोगकर्ता पासकी बनाकर, उन्हें Google Password Manager में सेव कर पाएंगे. इसके बाद, ये पासकी उन सभी Android डिवाइसों पर सिंक हो जाएंगी जिन पर उपयोगकर्ता ने साइन इन किया हुआ है. उपयोगकर्ता खाते से जुड़ी पासकी बनाई जानी चाहिए. साथ ही, उपयोगकर्ता के पासकी से साइन इन करने से पहले, उसकी सार्वजनिक कुंजी को सर्वर पर सेव करना होगा.

ध्यान दें: तीसरे पक्ष के पासवर्ड मैनेजर की सुविधा, Android 14 या उसके बाद के वर्शन वाले डिवाइसों पर उपलब्ध है.

इस कोडलैब में, आपको Credential Manager API का इस्तेमाल करके पासकी और पासवर्ड से साइन अप करने का तरीका पता चलेगा. साथ ही, आने वाले समय में पुष्टि करने के लिए, इनका इस्तेमाल करने का तरीका भी पता चलेगा. इसमें दो फ़्लो शामिल हैं:

• साइन अप करना : पासकी और पासवर्ड का इस्तेमाल करके.
• साइन इन करना : पासकी और सेव किए गए पासवर्ड का इस्तेमाल करके.

ज़रूरी शर्तें

• Android Studio में ऐप्लिकेशन चलाने का बुनियादी तरीका.
• Android ऐप्लिकेशन में पुष्टि करने की प्रोसेस के बारे में बुनियादी जानकारी.
• पासकी के बारे में बुनियादी जानकारी.

आपको क्या सीखने को मिलेगा

• पासकी बनाने का तरीका.
• पासवर्ड मैनेजर में पासवर्ड सेव करने का तरीका.
• पासकी या सेव किए गए पासवर्ड की मदद से, उपयोगकर्ताओं की पुष्टि करने का तरीका.

आपको किन चीज़ों की ज़रूरत होगी

डिवाइसों के इनमें से कोई एक कॉम्बिनेशन:

• पासकी के लिए, Android 9 या इसके बाद का वर्शन और क्रेडेंशियल मैनेजर एपीआई की मदद से पासवर्ड की पुष्टि करने के लिए, Android 4.4 या इसके बाद का वर्शन वाला Android डिवाइस.
• डिवाइस में बायोमेट्रिक सेंसर होना चाहिए.
• बायोमेट्रिक (या स्क्रीन लॉक) क्रेडेंशियल ज़रूर रजिस्टर करें.
• Kotlin प्लगिन का वर्शन : 1.8.10

ध्यान दें: Credential Manager API, पासवर्ड और 'Google से साइन इन करें' विकल्पों के लिए, Android 4.4 से काम करता है. पासकी की सुविधा, सिर्फ़ Android 9 (एपीआई लेवल 28) वाले डिवाइसों पर काम करती है

या इसके बाद का वर्शन होना चाहिए.

2. सेट अप करें

ध्यान दें: अपने Android ऐप्लिकेशन के लिए पासकी की सुविधा चालू करने के लिए, सबसे पहले अपने ऐप्लिकेशन और वेबसाइट को जोड़ना होगा.

इस सैंपल ऐप्लिकेशन के लिए, किसी वेबसाइट से डिजिटल एसेट लिंक करना ज़रूरी है, ताकि क्रेडेंशियल मैनेजर लिंक करने की पुष्टि कर सके और आगे की कार्रवाई कर सके. इसलिए, मॉक रिस्पॉन्स में इस्तेमाल किया गया आरपी आईडी, तीसरे पक्ष के मॉक किए गए सर्वर(Glitch.me) से लिया गया है. अगर आपको अपना मॉक रिस्पॉन्स आज़माना है, तो अपने ऐप्लिकेशन का डोमेन जोड़ें. साथ ही, यहां बताए गए तरीके से डिजिटल एसेट लिंक करना न भूलें.

अपने मॉक सर्वर पर पैकेज के नाम और SHA की डिजिटल एसेट लिंकिंग की पुष्टि करने के लिए, डीबग और रिलीज़ वैरिएंट बनाने के लिए, प्रोजेक्ट में बताए गए उसी debug.keystore का इस्तेमाल करें. (build.gradle में सैंपल ऐप्लिकेशन के लिए, यह काम आपके लिए पहले से ही किया जा रहा है).

1. अपने लैपटॉप पर, credman_codelab शाखा से इस डेटा स्टोर करने की जगह को क्लोन करें : https://github.com/android/identity-samples/tree/credman_codelab

git clone -b credman_codelab https://github.com/android/identity-samples.git

2. CredentialManager मॉड्यूल पर जाएं और Android Studio में प्रोजेक्ट खोलें.

ऐप्लिकेशन की शुरुआती स्थिति देखें

ऐप्लिकेशन की शुरुआती स्थिति कैसे काम करती है, यह देखने के लिए यह तरीका अपनाएं:

1. ऐप्लिकेशन लॉन्च करें.
2. आपको साइन अप और साइन इन बटन वाली मुख्य स्क्रीन दिखेगी. फ़िलहाल, ये बटन कुछ नहीं करते. हालांकि, हम आने वाले सेक्शन में इनका फ़ंक्शन चालू करेंगे.

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> को भी यूनीक होना चाहिए, ताकि आपको एक यूनीक चैलेंज जनरेट हो. यह तरीका आपके कोड में पहले से मौजूद है.

ध्यान दें: userId और challenge को Base64 का इस्तेमाल करके कोड में बदलना होगा. getEncodedUserId() और getEncodedChallenge() की जांच करके पक्का करें कि उन्हें सही तरीके से कोड में बदला गया है.

असल सर्वर 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 ऑब्जेक्ट के कुछ अहम पैरामीटर के बारे में बताया गया है:

पैरामीटर	जानकारी
challenge	सर्वर से जनरेट की गई रैंडम स्ट्रिंग, जिसमें इतना एन्ट्रापी होता है कि उसका अनुमान लगाना मुश्किल हो जाता है. यह कम से कम 16 बाइट का होना चाहिए. यह ज़रूरी है, लेकिन रजिस्ट्रेशन के दौरान इसका इस्तेमाल नहीं किया जाता. इसका इस्तेमाल सिर्फ़ पुष्टि के लिए किया जाता है.
user.id	उपयोगकर्ता का यूनीक आईडी. इस वैल्यू में, व्यक्तिगत पहचान से जुड़ी जानकारी शामिल नहीं होनी चाहिए. जैसे, ईमेल पते या उपयोगकर्ता नाम. हर खाते के लिए, 16-बाइट की कोई भी वैल्यू जनरेट की जा सकती है.
user.name	इस फ़ील्ड में, उस खाते का यूनीक आइडेंटिफ़ायर होना चाहिए जिसे उपयोगकर्ता पहचान सके. जैसे, उसका ईमेल पता या उपयोगकर्ता नाम. यह नाम, खाता चुनने वाले टूल में दिखेगा. (अगर उपयोगकर्ता नाम का इस्तेमाल किया जा रहा है, तो पासवर्ड की पुष्टि करने के लिए इस्तेमाल की गई वैल्यू का इस्तेमाल करें.)
user.displayName	यह फ़ील्ड भरना ज़रूरी नहीं है. इसमें खाते के लिए, उपयोगकर्ता के हिसाब से आसान नाम दिया जा सकता है.
rp.id	भरोसा करने वाली पार्टी की इकाई, आपके आवेदन की जानकारी से मेल खाती है. इसमें ये एट्रिब्यूट शामिल हैं: name (ज़रूरी है): आपके ऐप्लिकेशन का नाम ID (ज़रूरी नहीं): यह डोमेन या सबडोमेन से जुड़ा होता है. अगर यह एट्रिब्यूट मौजूद नहीं है, तो मौजूदा डोमेन का इस्तेमाल किया जाता है. icon (ज़रूरी नहीं).
pubKeyCredParams	इस्तेमाल किए जा सकने वाले एल्गोरिदम और कुंजी के टाइप की सूची. इस सूची में कम से कम एक एलिमेंट होना चाहिए.
excludeCredentials	हो सकता है कि डिवाइस रजिस्टर करने वाले उपयोगकर्ता ने पहले ही अन्य डिवाइसों को रजिस्टर कर लिया हो. अगर आपको किसी एक Authenticator ऐप्लिकेशन पर, एक ही खाते के लिए कई क्रेडेंशियल बनाने की सुविधा को सीमित करना है, तो इन डिवाइसों को अनदेखा किया जा सकता है. अगर transports सदस्य मौजूद है, तो हर क्रेडेंशियल के रजिस्ट्रेशन के दौरान, getTransports() को कॉल करने का नतीजा दिखना चाहिए.
authenticatorSelection.authenticatorAttachment	इससे पता चलता है कि डिवाइस को प्लैटफ़ॉर्म से अटैच करना है या नहीं या ऐसा करने की ज़रूरत नहीं है. इस वैल्यू को platform पर सेट करें. इससे पता चलता है कि आपको ऐसा पुष्टि करने वाला टूल चाहिए जो प्लैटफ़ॉर्म डिवाइस में एम्बेड हो. साथ ही, उपयोगकर्ता को यूएसबी सुरक्षा कुंजी जैसी चीज़ डालने के लिए कहा नहीं जाएगा.
residentKey	पासकी बनाने के लिए, वैल्यू required डालें.

क्रेडेंशियल बनाना

1. 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 कमांड की मदद से, गड़बड़ी के पूरे लॉग देखे जा सकते हैं.

आपका डेटा सुरक्षित है: भले ही, उपयोगकर्ता पासकी बनाने के लिए बायोमेट्रिक सेंसर का इस्तेमाल करता हो, लेकिन सर्वर को बायोमेट्रिक डेटा कभी नहीं दिखता. डिवाइस सिर्फ़ इस बात की पुष्टि करता है कि सेव की गई बायोमेट्रिक जानकारी, उपयोगकर्ता की स्थानीय जानकारी से मेल खाती है. ऐसा, पासकी बनाने या उससे साइन इन करने के लिए किया जाता है. बायोमेट्रिक जानकारी, डिवाइस में ही सेव रहती है.

ध्यान दें: createCredential() कॉल एक सस्पेंड फ़ंक्शन है. इसलिए, इसे coroutineScope/किसी दूसरे सस्पेंड फ़ंक्शन से कॉल किया जाना चाहिए.

2. आखिर में, आपको रजिस्ट्रेशन की प्रोसेस पूरी करनी होगी. ऐप्लिकेशन, सर्वर को सार्वजनिक कुंजी का क्रेडेंशियल भेजता है. इसके बाद, सर्वर उसे मौजूदा उपयोगकर्ता के साथ रजिस्टर करता है.

यहां हमने मॉक सर्वर का इस्तेमाल किया है. इसलिए, हम सिर्फ़ 'सही' दिखाते हैं. इससे पता चलता है कि सर्वर ने आने वाले समय में पुष्टि और पुष्टि करने के लिए, रजिस्टर की गई सार्वजनिक कुंजी सेव कर ली है. सर्वर-साइड पासकी रजिस्ट्रेशन के बारे में ज़्यादा पढ़कर, इसे खुद लागू किया जा सकता है.

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 ऑब्जेक्ट के कुछ अहम पैरामीटर के बारे में बताया गया है:

पैरामीटर	जानकारी
id	बनाई गई पासकी का Base64URL कोड में बदला गया आईडी. इस आईडी से ब्राउज़र को यह पता चलता है कि पुष्टि करने के बाद, डिवाइस में मिलती-जुलती पासकी मौजूद है या नहीं. यह वैल्यू, बैकएंड पर डेटाबेस में सेव होनी चाहिए.
rawId	क्रेडेंशियल आईडी का ArrayBuffer ऑब्जेक्ट वर्शन.
response.clientDataJSON	क्लाइंट का एन्क्रिप्ट किया गया डेटा, ArrayBuffer ऑब्जेक्ट में होता है.
response.attestationObject	कोड में बदला गया ArrayBuffer ऑब्जेक्ट. इसमें अहम जानकारी शामिल होती है, जैसे कि आरपी आईडी, फ़्लैग, और सार्वजनिक पासकोड.

ऐप्लिकेशन चलाएं. इसके बाद, पासकी से साइन अप करें बटन पर क्लिक करके पासकी बनाएं.

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 ऑब्जेक्ट के कुछ अहम पैरामीटर के बारे में बताया गया है:

पैरामीटर	जानकारी
challenge	ArrayBuffer ऑब्जेक्ट में, सर्वर से जनरेट किया गया चैलेंज. रीप्ले अटैक को रोकने के लिए, ऐसा करना ज़रूरी है. एक ही जवाब में, एक ही चैलेंज को दो बार स्वीकार न करें. इसे सीएसआरएफ़ टोकन मानें.
rpId	आरपी आईडी एक डोमेन होता है. वेबसाइट, अपना डोमेन या रजिस्टर किया जा सकने वाला कोई सफ़िक्स बता सकती है. यह वैल्यू, पासकी बनाने के दौरान इस्तेमाल किए गए rp.id पैरामीटर से मेल खानी चाहिए.

• इसके बाद, आपको इस उपयोगकर्ता खाते के लिए 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 ऑब्जेक्ट के ज़रूरी पैरामीटर शामिल हैं:

पैरामीटर	जानकारी
id	पुष्टि किए गए पासकी क्रेडेंशियल का Base64URL कोड में बदला गया आईडी.
rawId	क्रेडेंशियल आईडी का ArrayBuffer ऑब्जेक्ट वर्शन.
response.clientDataJSON	क्लाइंट डेटा का ArrayBuffer ऑब्जेक्ट. इस फ़ील्ड में जानकारी होती है, जैसे कि चैलेंज और ऑरिजिन, जिसकी पुष्टि आरपी सर्वर को करनी होती है.
response.authenticatorData	पुष्टि करने वाले ऐप्लिकेशन के डेटा का ArrayBuffer ऑब्जेक्ट. इस फ़ील्ड में आरपी आईडी जैसी जानकारी होती है.
response.signature	हस्ताक्षर का ArrayBuffer ऑब्जेक्ट. यह वैल्यू, क्रेडेंशियल का मुख्य हिस्सा होती है. इसकी पुष्टि सर्वर पर की जानी चाहिए.
response.userHandle	ArrayBuffer ऑब्जेक्ट, जिसमें बनाने के समय सेट किया गया यूज़र आईडी होता है. अगर सर्वर को अपनी पसंद के आईडी की वैल्यू चुननी है या बैकएंड को क्रेडेंशियल आईडी पर इंडेक्स बनाने से बचना है, तो इस वैल्यू का इस्तेमाल क्रेडेंशियल आईडी के बजाय किया जा सकता है.

ध्यान दें: getCredential() कॉल एक सस्पेंड फ़ंक्शन है. इसलिए, इसे coroutineScope/किसी दूसरे सस्पेंड फ़ंक्शन से कॉल करना होगा.

• आखिर में, आपको पुष्टि की प्रक्रिया पूरी करनी होगी. आम तौर पर, उपयोगकर्ता पासकी की मदद से पुष्टि करने के बाद, ऐप्लिकेशन सर्वर को एक सार्वजनिक कुंजी क्रेडेंशियल भेजता है. इसमें पुष्टि करने का एश्योरेशन होता है. सर्वर, एश्योरेशन की पुष्टि करता है और उपयोगकर्ता की पुष्टि करता है.

यहां हमने मॉक सर्वर का इस्तेमाल किया है, इसलिए हम सिर्फ़ 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 पर पूछें.

ज़्यादा जानें

• Credential Manager की मदद से अपने उपयोगकर्ता को साइन इन कराना
• Credential Manager API का इस्तेमाल करके, पासकी की मदद से अपने ऐप्लिकेशन में आसानी से पुष्टि करना
• Android और Chrome पर पासकी की सुविधा