आपका पहला Android FIDO2 एपीआई

1. परिचय

FIDO2 एपीआई क्या है?

FIDO2 API, Android ऐप्लिकेशन को उपयोगकर्ताओं की पुष्टि करने के लिए, मज़बूत और पुष्टि किए गए सार्वजनिक पासकोड पर आधारित क्रेडेंशियल बनाने और इस्तेमाल करने की अनुमति देता है. एपीआई, WebAuthn Client को लागू करने की सुविधा देता है. इसमें BLE, एनएफ़सी, और यूएसबी रोमिंग की मदद से पुष्टि करने वाले टूल (सुरक्षा कुंजियां) इस्तेमाल किए जा सकते हैं. साथ ही, यह प्लैटफ़ॉर्म Authenticator की मदद से भी पुष्टि की जा सकती है. इसकी मदद से उपयोगकर्ता, फ़िंगरप्रिंट या स्क्रीन लॉक की मदद से अपनी पहचान की पुष्टि कर सकते हैं.

आपको क्या बनाना है...

इस कोडलैब में, फ़िंगरप्रिंट सेंसर की मदद से फिर से पुष्टि करने की आसान सुविधा वाला Android ऐप्लिकेशन बनाया जा रहा है. "फिर से पुष्टि करने का तरीका" तब होता है, जब कोई उपयोगकर्ता किसी ऐप्लिकेशन में साइन इन करता है और आपके ऐप्लिकेशन पर वापस स्विच करने पर या आपके ऐप्लिकेशन के किसी ज़रूरी सेक्शन को ऐक्सेस करने की कोशिश करते समय फिर से पुष्टि करता है. बाद वाले मामले को "चरण-अप ऑथेंटिकेशन" भी कहा जाता है.

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

इस गाइड में, आपको Android FIDO2 API को कॉल करने का तरीका पता चलेगा. साथ ही, आपको उन विकल्पों के बारे में भी जानकारी मिलेगी जो अलग-अलग मौकों के लिए उपलब्ध कराए जा सकते हैं. इसमें आपको दोबारा पुष्टि करने के सबसे सही तरीकों के बारे में भी जानकारी मिलेगी.

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

  • ऐसा Android डिवाइस जिसमें फ़िंगरप्रिंट सेंसर हो. स्क्रीन लॉक की मदद से, उपयोगकर्ता की पुष्टि करने की एक जैसी सुविधा उपलब्ध कराई जा सकती है. भले ही, फ़िंगरप्रिंट सेंसर मौजूद न हो
  • नए अपडेट के साथ Android OS 7.0 या इसके बाद का वर्शन. पक्का करें कि आपने फ़िंगरप्रिंट (या स्क्रीन लॉक) रजिस्टर किया हो.

2. सेट अप किया जा रहा है

डेटा स्टोर करने की जगह का क्लोन बनाएं

GitHub रिपॉज़िटरी देखें.

https://github.com/android/codelab-fido2

$ git clone https://github.com/android/codelab-fido2.git

हम क्या लागू करने जा रहे हैं?

  • उपयोगकर्ताओं को "उपयोगकर्ता के प्लैटफ़ॉर्म की पुष्टि करने वाले टूल" को रजिस्टर करने की सुविधा दें (फ़िंगरप्रिंट सेंसर वाला Android फ़ोन भी एक सुविधा की तरह काम करेगा).
  • उपयोगकर्ताओं को फ़िंगरप्रिंट का इस्तेमाल करके, ऐप्लिकेशन में अपनी फिर से पुष्टि करने की सुविधा दें.

आप क्या बनाने जा रहे हैं, इसकी झलक यहां से देख सकते हैं.

अपना कोडलैब प्रोजेक्ट शुरू करें

पूरा हो चुका ऐप्लिकेशन https://webauthn-codelab.glitch.me पर मौजूद सर्वर को अनुरोध भेजता है. वहां उसी ऐप्लिकेशन का वेब वर्शन आज़माया जा सकता है.

c2234c42ba8a6ef1.png

आप ऐप्लिकेशन के अपने वर्शन पर काम करेंगे.

  1. https://glitch.com/edit/#!/webauthn-codelab पर वेबसाइट के बदलाव करें पेज पर जाएं
  2. "बदलाव करने के लिए रीमिक्स करें" ढूंढें बटन पर क्लिक करें. बटन दबाकर, आप "फ़ोर्क" कर सकते हैं कोड में बदलाव कर सकते हैं और नए प्रोजेक्ट यूआरएल के साथ अपने वर्शन के साथ आगे बढ़ सकते हैं. 9ef108869885e4ce.png अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
  3. सबसे ऊपर बाईं ओर, प्रोजेक्ट का नाम कॉपी करें. आपके पास इसमें अपने हिसाब से बदलाव करने का विकल्प है. c91d0d59c61021a4.png अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
  4. इसे .env फ़ाइल के HOSTNAME सेक्शन में ग्लिच में चिपकाएं. 889b55b1cf74b894.png

3. अपने ऐप्लिकेशन और वेबसाइट को डिजिटल ऐसेट लिंक से जोड़ना

किसी Android ऐप्लिकेशन पर FIDO2 API का इस्तेमाल करने के लिए, इसे किसी वेबसाइट से जोड़ें और उनके बीच क्रेडेंशियल शेयर करें. ऐसा करने के लिए, डिजिटल ऐसेट लिंक का इस्तेमाल करें. असोसिएशन का एलान करने के लिए, अपनी वेबसाइट पर डिजिटल ऐसेट लिंक JSON फ़ाइल होस्ट करें. साथ ही, अपने ऐप्लिकेशन के मेनिफ़ेस्ट में डिजिटल ऐसेट लिंक फ़ाइल का लिंक जोड़ें.

अपने डोमेन पर .well-known/assetlinks.json को होस्ट करें

अपने ऐप्लिकेशन और वेबसाइट के बीच असोसिएशन तय करने के लिए, JSON फ़ाइल बनाएं और उसे .well-known/assetlinks.json पर रखें. अच्छी बात यह है कि हमारे पास एक सर्वर कोड है, जो ग्लिच में .env फ़ाइल में बस इन एनवायरमेंट पैरामीटर को जोड़कर, assetlinks.json फ़ाइल को अपने-आप दिखाता है:

  • ANDROID_PACKAGENAME: आपके ऐप्लिकेशन का पैकेज नाम (com.example.android.fido2)
  • ANDROID_SHA256HASH: आपके साइनिंग सर्टिफ़िकेट में SHA256 की हैश

अपने डेवलपर साइनिंग सर्टिफ़िकेट का SHA256 हैश पाने के लिए, नीचे दिए गए निर्देश का इस्तेमाल करें. डीबग कीस्टोर का डिफ़ॉल्ट पासवर्ड "android" है.

$ keytool -exportcert -list -v -alias androiddebugkey -keystore ~/.android/debug.keystore

https://<your-project-name>.glitch.me/.well-known/assetlinks.json को ऐक्सेस करने पर , आपको इस तरह की JSON स्ट्रिंग दिखेगी:

[{
  "relation": ["delegate_permission/common.handle_all_urls", "delegate_permission/common.get_login_creds"],
  "target": {
    "namespace": "web",
    "site": "https://<your-project-name>.glitch.me"
  }
}, {
  "relation": ["delegate_permission/common.handle_all_urls", "delegate_permission/common.get_login_creds"],
  "target": {
    "namespace": "android_app",
    "package_name": "com.example.android.fido2",
    "sha256_cert_fingerprints": ["DE:AD:BE:EF:..."]
  }
}]

प्रोजेक्ट को Android Studio में खोलें

"मौजूदा Android Studio प्रोजेक्ट खोलें" पर क्लिक करें पर क्लिक करें.

"android" चुनें फ़ोल्डर में जाकर, रिपॉज़िटरी चेक आउट किया जा सकता है.

1062875cf11ffb95.png

ऐप्लिकेशन को रीमिक्स किए गए कॉन्टेंट से जोड़ें

gradle.properties फ़ाइल खोलें. फ़ाइल में सबसे नीचे, होस्ट के यूआरएल को उस Glitch रीमिक्स में बदलें जो आपने अभी-अभी बनाया है.

// ...

# The URL of the server
host=https://<your-project-name>.glitch.me

अब आपके डिजिटल ऐसेट लिंक का कॉन्फ़िगरेशन पूरी तरह से सेट हो जाना चाहिए.

4. देखें कि अब यह ऐप्लिकेशन कैसे काम करता है

चलिए, यह देखते हैं कि अब यह ऐप्लिकेशन कैसे काम करता है. रन कॉन्फ़िगरेशन कॉम्बोबॉक्स में "app-start" ज़रूर चुनें. "Run" पर क्लिक करें (कॉम्बोबॉक्स के बगल में मौजूद हरे रंग के त्रिकोणीय) का इस्तेमाल करके, अपने कनेक्ट किए गए Android डिवाइस पर ऐप्लिकेशन लॉन्च करें.

29351fb97062b43c.png

ऐप्लिकेशन लॉन्च करने पर आपको स्क्रीन पर अपना उपयोगकर्ता नाम टाइप करने के लिए कहा जाएगा. यह UsernameFragment है। दिखाने के लिए, ऐप्लिकेशन और सर्वर किसी भी उपयोगकर्ता नाम को स्वीकार करते हैं. बस कुछ लिखें और "आगे बढ़ें" दबाएं.

bd9007614a9a3644.png

अगली स्क्रीन पर आपको AuthFragment दिखेगा. यहां उपयोगकर्ता, पासवर्ड डालकर साइन इन कर सकते हैं. बाद में, हम यहां FIDO2 प्रोटोकॉल से साइन इन करने के लिए एक सुविधा जोड़ेंगे. दोबारा जानने के लिए, ऐप्लिकेशन और सर्वर किसी भी पासवर्ड को स्वीकार करते हैं. बस कुछ लिखें और "साइन इन करें" दबाएं.

d9caba817a0a99bd.png

यह इस ऐप्लिकेशन की आखिरी स्क्रीन है, HomeFragment. फ़िलहाल, आपको यहां क्रेडेंशियल की सिर्फ़ एक खाली सूची दिखेगी. "फिर से पुष्टि करें" बटन दबाएं यह आपको AuthFragment पर वापस ले जाता है. "साइन आउट करें" बटन दबाएं यह आपको UsernameFragment पर वापस ले जाता है. "+" के साथ फ़्लोट करने वाला ऐक्शन बटन चिह्न अब कुछ नहीं करता, लेकिन यह

FIDO2 रजिस्ट्रेशन फ़्लो लागू करने के बाद, नया क्रेडेंशियल.

1cfcc6c884020e37.png

कोड करना शुरू करने से पहले, यहां इसकी एक उपयोगी तकनीक दी गई है. Android Studio में, "TODO" दबाएं सबसे नीचे. वह इस कोडलैब में सभी काम की सूची दिखाएगा. हम अगले सेक्शन में, पहले TODO से शुरुआत करेंगे.

e5a811bbc7cd7b30.png

5. फ़िंगरप्रिंट का इस्तेमाल करके क्रेडेंशियल रजिस्टर करना

फ़िंगरप्रिंट की मदद से पुष्टि करने की सुविधा चालू करने के लिए, आपको सबसे पहले उपयोगकर्ता के पुष्टि करने वाले प्लैटफ़ॉर्म से जनरेट किया गया क्रेडेंशियल रजिस्टर करना होगा. यह डिवाइस से जोड़ा गया पुष्टि करने वाला ऐप्लिकेशन होता है, जो फ़िंगरप्रिंट सेंसर जैसे बायोमेट्रिक्स का इस्तेमाल करके उपयोगकर्ता की पुष्टि करता है.

37ce78fdf2759832.png

जैसा कि हमने पिछले सेक्शन में देखा, फ़्लोट करने वाला कार्रवाई बटन अब कुछ नहीं करता. आइए देखते हैं कि हम नया क्रेडेंशियल कैसे रजिस्टर कर सकते हैं.

सर्वर एपीआई को कॉल करें: /auth/registerRequest

AuthRepository.kt खोलें और TODO(1) ढूंढें.

यहां, एफ़एबी को दबाने पर registerRequest को कॉल किया जाता है. हम चाहते हैं कि इस तरीके को सर्वर एपीआई /auth/registerRequest को कॉल किया जाए. एपीआई, उन सभी PublicKeyCredentialCreationOptions के साथ ApiResult दिखाता है जिनकी ज़रूरत क्लाइंट को नया क्रेडेंशियल जनरेट करने के लिए होती है.

इसके बाद, हम इन विकल्पों के बारे में बताने के लिए getRegisterPendingIntent पर कॉल कर सकते हैं. यह FIDO2 एपीआई, फ़िंगरप्रिंट वाला डायलॉग खोलने और नया क्रेडेंशियल जनरेट करने के लिए, Android PendingIntent की सुविधा देता है. साथ ही, हम कॉलर को वह PendingIntent वापस कर सकते हैं.

इसके बाद, यह तरीका नीचे दिखेगा.

suspend fun registerRequest(): PendingIntent? {
  fido2ApiClient?.let { client ->
    try {
      val sessionId = dataStore.read(SESSION_ID)!!
      when (val apiResult = api.registerRequest(sessionId)) {
        ApiResult.SignedOutFromServer -> forceSignOut()
        is ApiResult.Success -> {
          if (apiResult.sessionId != null) {
            dataStore.edit { prefs ->
              prefs[SESSION_ID] = apiResult.sessionId
            }
          }
          val task = client.getRegisterPendingIntent(apiResult.data)
          return task.await()
        }
      }
    } catch (e: Exception) {
      Log.e(TAG, "Cannot call registerRequest", e)
    }
  }
  return null
}

रजिस्ट्रेशन के लिए, फ़िंगरप्रिंट वाला डायलॉग खोलें

HomeFragment.kt खोलें और TODO(2) ढूंढें.

यहां यूज़र इंटरफ़ेस (यूआई) को हमारे AuthRepository से इंटेंट वापस मिलता है. यहां हम पिछले चरण की वजह से मिले PendingIntent को लॉन्च करने के लिए, createCredentialIntentLauncher सदस्य का इस्तेमाल करेंगे. इससे क्रेडेंशियल जनरेट करने के लिए एक डायलॉग बॉक्स खुलेगा.

binding.add.setOnClickListener {
  lifecycleScope.launch {
    val intent = viewModel.registerRequest()
    if (intent != null) {
      createCredentialIntentLauncher.launch(
        IntentSenderRequest.Builder(intent).build()
      )
    }
  }
}

नए क्रेडेंशियल से ऐक्टिविटी का नतीजा पाएं

HomeFragment.kt खोलें और TODO(3) ढूंढें.

फ़िंगरप्रिंट वाला डायलॉग बंद होने के बाद, handleCreateCredentialResult वाले तरीके को कॉल किया जाता है. क्रेडेंशियल जनरेट होने के बाद, Activityनतीजे के data सदस्य में क्रेडेंशियल की जानकारी शामिल हो जाएगी.

सबसे पहले, हमें data से PublicKeyCredential निकालना होगा. डेटा इंटेंट में, Fido.FIDO2_KEY_CREDENTIAL_EXTRA कुंजी के साथ बाइट अरे का एक और फ़ील्ड होता है. बाइट अरे को PublicKeyCredential ऑब्जेक्ट में बदलने के लिए, PublicKeyCredential में deserializeFromBytes नाम के स्टैटिक तरीके का इस्तेमाल किया जा सकता है.

इसके बाद, यह देखें कि इस क्रेडेंशियल ऑब्जेक्ट का response सदस्य, AuthenticationErrorResponse है या नहीं. अगर ऐसा है, तो इसका मतलब है कि क्रेडेंशियल जनरेट करने में कोई गड़बड़ी हुई थी; अगर ऐसा नहीं है, तो हम बैकएंड पर क्रेडेंशियल भेज सकते हैं.

पूरा हो चुका तरीका कुछ ऐसा दिखेगा:

private fun handleCreateCredentialResult(activityResult: ActivityResult) {
  val bytes = activityResult.data?.getByteArrayExtra(Fido.FIDO2_KEY_CREDENTIAL_EXTRA)
  when {
    activityResult.resultCode != Activity.RESULT_OK ->
      Toast.makeText(requireContext(), R.string.cancelled, Toast.LENGTH_LONG).show()
    bytes == null ->
      Toast.makeText(requireContext(), R.string.credential_error, Toast.LENGTH_LONG)
        .show()
    else -> {
      val credential = PublicKeyCredential.deserializeFromBytes(bytes)
      val response = credential.response
      if (response is AuthenticatorErrorResponse) {
        Toast.makeText(requireContext(), response.errorMessage, Toast.LENGTH_LONG)
          .show()
      } else {
        viewModel.registerResponse(credential)
      }
    }
  }
}

सर्वर एपीआई को कॉल करें: /auth/registerResponse

AuthRepository.kt खोलें और TODO(4) ढूंढें.

यह registerResponse तरीका, यूज़र इंटरफ़ेस (यूआई) से नया क्रेडेंशियल जनरेट होने के बाद कॉल किया जाता है और हमें इसे सर्वर पर वापस भेजना है.

PublicKeyCredential ऑब्जेक्ट में, जनरेट किए गए नए क्रेडेंशियल के बारे में जानकारी होती है. अब हम अपनी लोकल पासकोड का आईडी याद रखना चाहते हैं, ताकि हम उसे सर्वर पर रजिस्टर की गई अन्य कुंजियों से अलग कर सकें. PublicKeyCredential ऑब्जेक्ट में, उसकी rawId प्रॉपर्टी लें और toBase64 का इस्तेमाल करके उसे लोकल स्ट्रिंग वैरिएबल में रखें.

अब हम सर्वर पर जानकारी भेजने के लिए तैयार हैं. सर्वर एपीआई को कॉल करने और जवाब भेजने के लिए, api.registerResponse का इस्तेमाल करें. दिखाई गई वैल्यू में, सर्वर पर रजिस्टर किए गए सभी क्रेडेंशियल की सूची होती है. इसमें नया क्रेडेंशियल भी शामिल होता है.

आखिर में, हम अपने DataStore में नतीजे सेव कर सकते हैं. क्रेडेंशियल की सूची को CREDENTIALS कुंजी के साथ StringSet के तौर पर सेव करना चाहिए. क्रेडेंशियल की सूची को StringSet में बदलने के लिए, toStringSet का इस्तेमाल किया जा सकता है.

इसके अलावा, हम क्रेडेंशियल आईडी को LOCAL_CREDENTIAL_ID कुंजी के साथ सेव करते हैं.

suspend fun registerResponse(credential: PublicKeyCredential) {
  try {
    val sessionId = dataStore.read(SESSION_ID)!!
    val credentialId = credential.rawId.toBase64()
    when (val result = api.registerResponse(sessionId, credential)) {
      ApiResult.SignedOutFromServer -> forceSignOut()
      is ApiResult.Success -> {
        dataStore.edit { prefs ->
          result.sessionId?.let { prefs[SESSION_ID] = it }
          prefs[CREDENTIALS] = result.data.toStringSet()
          prefs[LOCAL_CREDENTIAL_ID] = credentialId
        }
      }
    }
  } catch (e: ApiException) {
    Log.e(TAG, "Cannot call registerResponse", e)
  }
}

ऐप्लिकेशन चलाएं. इससे आपको एफ़एबी पर क्लिक करके, नया क्रेडेंशियल रजिस्टर करने का विकल्प मिलेगा.

7d64d9289c5a3cbc.png

6. फ़िंगरप्रिंट से उपयोगकर्ता की पुष्टि करें

अब हमारा क्रेडेंशियल ऐप्लिकेशन और सर्वर पर रजिस्टर हो गया है. अब हम उपयोगकर्ता को साइन इन करने की अनुमति देने के लिए, इसका इस्तेमाल कर सकते हैं. हम AuthFragment में, फ़िंगरप्रिंट से साइन इन करने की सुविधा जोड़ रहे हैं. जब कोई उपयोगकर्ता इस स्क्रीन पर पहुंचता है, तो उसे फ़िंगरप्रिंट वाला डायलॉग दिखता है. पुष्टि हो जाने पर, उपयोगकर्ता को HomeFragment पर रीडायरेक्ट कर दिया जाता है.

सर्वर एपीआई को कॉल करें: /auth/signinRequest

AuthRepository.kt खोलें और TODO(5) ढूंढें.

signinRequest वाला तरीका तब लागू किया जाता है, जब AuthFragment खोला जाता है. यहां, हमें सर्वर का अनुरोध करना है और देखना है कि क्या उपयोगकर्ता को FIDO2 प्रोटोकॉल पर साइन इन करने की अनुमति दी जा सकती है.

सबसे पहले, हमें सर्वर से PublicKeyCredentialRequestOptions को वापस लाना होगा. सर्वर एपीआई को कॉल करने के लिए, api.signInRequest का इस्तेमाल करें. दिए गए ApiResult में PublicKeyCredentialRequestOptions शामिल है.

PublicKeyCredentialRequestOptions की मदद से, हम FIDO2 एपीआई getSignIntent का इस्तेमाल करके फ़िंगरप्रिंट वाला डायलॉग खोलने के लिए, PendingIntent बना सकते हैं.

आखिर में, हम PendingIntent को वापस यूज़र इंटरफ़ेस (यूआई) पर वापस भेज सकते हैं.

suspend fun signinRequest(): PendingIntent? {
  fido2ApiClient?.let { client ->
    val sessionId = dataStore.read(SESSION_ID)!!
    val credentialId = dataStore.read(LOCAL_CREDENTIAL_ID)
    if (credentialId != null) {
      when (val apiResult = api.signinRequest(sessionId, credentialId)) {
        ApiResult.SignedOutFromServer -> forceSignOut()
        is ApiResult.Success -> {
          val task = client.getSignPendingIntent(apiResult.data)
          return task.await()
        }
      }
    }
  }
  return null
}

दावा करने के लिए, फ़िंगरप्रिंट वाला डायलॉग बॉक्स खोलें

AuthFragment.kt खोलें और TODO(6) ढूंढें.

यह बिलकुल वैसा ही है जैसा हमने रजिस्ट्रेशन के लिए किया था. हम signIntentLauncher के सदस्य के साथ, फ़िंगरप्रिंट वाला डायलॉग लॉन्च कर सकते हैं.

viewLifecycleOwner.lifecycleScope.launchWhenStarted {
  launch {
    viewModel.signinRequests.collect { intent ->
      signIntentLauncher.launch(
        IntentSenderRequest.Builder(intent).build()
      )
    }
  }
  launch {
    ...
  }
}

ऐक्टिविटी के नतीजे को मैनेज करें

Authफ़्रैगमेंट.kt खोलें और TODO(7) ढूंढें.

यह वही तरीका है जो हमने रजिस्ट्रेशन के लिए किया था. हम PublicKeyCredential एक्सट्रैक्ट कर सकते हैं, गड़बड़ी का पता लगा सकते हैं, और उसे ViewModel को पास कर सकते हैं.

private fun handleSignResult(activityResult: ActivityResult) {
  val bytes = activityResult.data?.getByteArrayExtra(Fido.FIDO2_KEY_CREDENTIAL_EXTRA)
  when {
    activityResult.resultCode != Activity.RESULT_OK ->
      Toast.makeText(requireContext(), R.string.cancelled, Toast.LENGTH_SHORT).show()
    bytes == null ->
      Toast.makeText(requireContext(), R.string.auth_error, Toast.LENGTH_SHORT)
        .show()
    else -> {
      val credential = PublicKeyCredential.deserializeFromBytes(bytes)
      val response = credential.response
      if (response is AuthenticatorErrorResponse) {
        Toast.makeText(requireContext(), response.errorMessage, Toast.LENGTH_SHORT)
          .show()
      } else {
        viewModel.signinResponse(credential)
      }
    }
  }
}

सर्वर एपीआई को कॉल करें: /auth/signinResponse

AuthRepository.kt खोलें और TODO(8) ढूंढें.

PublicKeyक्रेडेंशियल ऑब्जेक्ट में keyHandle के रूप में एक क्रेडेंशियल आईडी है. जैसा कि हमने रजिस्ट्रेशन फ़्लो में किया था, चलिए इसे लोकल स्ट्रिंग वैरिएबल में सेव करते हैं, ताकि हम इसे बाद में सेव कर सकें.

अब हम api.signinResponse का इस्तेमाल करके, सर्वर एपीआई को कॉल करने के लिए तैयार हैं. दिखाई गई वैल्यू में क्रेडेंशियल की सूची शामिल है.

इस स्थिति में, साइन इन हो जाता है. हमें सभी नतीजे अपने DataStore में सेव करने होंगे. क्रेडेंशियल की सूची को CREDENTIALS कुंजी के साथ StringSet फ़ॉर्मैट में सेव करना चाहिए. हमने ऊपर जो लोकल क्रेडेंशियल आईडी सेव किया है उसे LOCAL_CREDENTIAL_ID कुंजी के साथ स्ट्रिंग के तौर पर सेव किया जाना चाहिए.

आखिर में, हमें साइन इन की स्थिति को अपडेट करना होगा, ताकि यूज़र इंटरफ़ेस (यूआई) उपयोगकर्ता को Homeफ़्रैगमेंट पर रीडायरेक्ट कर सके. ऐसा करने के लिए, signInStateMutable नाम के SharedFlow में SignInState.SignedIn ऑब्जेक्ट छोड़ें. हम refreshCredentials को कॉल करके, उपयोगकर्ता के क्रेडेंशियल फ़ेच करना चाहते हैं, ताकि वे यूज़र इंटरफ़ेस (यूआई) में दिख सकें.

suspend fun signinResponse(credential: PublicKeyCredential) {
  try {
    val username = dataStore.read(USERNAME)!!
    val sessionId = dataStore.read(SESSION_ID)!!
    val credentialId = credential.rawId.toBase64()
    when (val result = api.signinResponse(sessionId, credential)) {
      ApiResult.SignedOutFromServer -> forceSignOut()
      is ApiResult.Success -> {
        dataStore.edit { prefs ->
          result.sessionId?.let { prefs[SESSION_ID] = it }
          prefs[CREDENTIALS] = result.data.toStringSet()
          prefs[LOCAL_CREDENTIAL_ID] = credentialId
        }
        signInStateMutable.emit(SignInState.SignedIn(username))
        refreshCredentials()
      }
    }
  } catch (e: ApiException) {
    Log.e(TAG, "Cannot call registerResponse", e)
  }
}

ऐप्लिकेशन चलाएं और "फिर से पुष्टि करें" पर क्लिक करें AuthFragment खोलने के लिए. अब आपको फ़िंगरप्रिंट का एक डायलॉग बॉक्स दिखेगा. इसमें आपसे अपने फ़िंगरप्रिंट से साइन इन करने के लिए कहा जाएगा.

45f81419f84952c8.png

बधाई हो! अब आपने रजिस्ट्रेशन और साइन-इन करने के लिए, Android पर FIDO2 API को इस्तेमाल करने का तरीका जान लिया है.

7. बधाई हो!

आपने कोडलैब (कोड बनाना सीखना) पूरा कर लिया है - आपका पहला Android FIDO2 API.

आपने क्या सीखा

  • उपयोगकर्ता की पुष्टि करने वाले प्लैटफ़ॉर्म की मदद से, क्रेडेंशियल को रजिस्टर करने का तरीका.
  • रजिस्टर किए गए Authenticator का इस्तेमाल करके, उपयोगकर्ता की पुष्टि करने का तरीका.
  • नए पुष्टि करने वाले को रजिस्टर करने के लिए उपलब्ध विकल्प.
  • बायोमेट्रिक सेंसर की मदद से, फिर से पुष्टि करने के लिए उपयोगकर्ता अनुभव के सबसे सही तरीके.

अगला चरण

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

आप आपका पहला WebAuthn कोडलैब आज़माकर, इस बारे में जान सकते हैं!

संसाधन

मदद के लिए, FIDO Alliance से यूरी एकरमैन को खास धन्यवाद.