अपने उपयोगकर्ता को क्रेडेंशियल मैनेजर से साइन इन करें

क्रेडेंशियल मैनेजर एक Jetpack API है, जो एक से ज़्यादा साइन-इन की सुविधा देता है तरीके, जैसे कि उपयोगकर्ता नाम, पासवर्ड, पासकी, और फ़ेडरेटेड साइन-इन समाधान (जैसे कि 'Google से साइन-इन करें' सुविधा) को एक ही एपीआई में इस्तेमाल करते हैं. इससे, इंटिग्रेशन.

इसके अलावा, Credential Manager की मदद से, उपयोगकर्ताओं के लिए पुष्टि करने के सभी तरीकों के लिए एक ही साइन इन इंटरफ़ेस उपलब्ध होता है. इससे, उपयोगकर्ताओं को ऐप्लिकेशन में साइन इन करने में आसानी होती है. भले ही, उन्होंने साइन इन करने का कोई भी तरीका चुना हो.

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

क्रेडेंशियल मैनेजर एपीआई को बेहतर बनाने के लिए, आपके सुझाव, शिकायत या राय की अहम भूमिका होती है. शेयर करें अगर आपको कोई समस्या मिलती है या एपीआई को बेहतर बनाने के लिए कुछ आइडिया देते हैं, तो यहां दिए गए लिंक का इस्तेमाल करें:

सुझाव/राय दें या शिकायत करें

पासकी के बारे में जानकारी

पासवर्ड की जगह पासकी इस्तेमाल करना ज़्यादा सुरक्षित और आसान है. पासकी से, उपयोगकर्ता बायोमेट्रिक सेंसर (जैसे, फ़िंगरप्रिंट या चेहरे की पहचान), पिन या पैटर्न के बारे में जानकारी हो. इससे उपयोगकर्ताओं को जिससे आपके उपयोगकर्ताओं को उपयोगकर्ता नाम या उपयोगकर्ता नाम याद रखने से पासवर्ड.

पासकी, WebAuthn (वेब ऑथेंटिकेशन) पर निर्भर करती हैं. यह एक स्टैंडर्ड है, जिसे FIDO एलायंस और वर्ल्ड वाइड वेब कंसोर्टियम (W3C) ने मिलकर डेवलप किया है. WebAuthn, उपयोगकर्ता की पुष्टि करने के लिए, सार्वजनिक पासकोड क्रिप्टोग्राफ़ी का इस्तेमाल करता है. जिस वेबसाइट या ऐप्लिकेशन में उपयोगकर्ता साइन इन कर रहा है वह सार्वजनिक कुंजी देख सकता है और उसे सेव कर सकता है. हालांकि, वह निजी कुंजी कभी नहीं देख सकता. निजी कुंजी को गुप्त और सुरक्षित रखा जाता है. दरअसल, कुंजी बेहद खास है और पासकी से साइन इन करने पर, इन्हें फ़िशिंग नहीं किया जा सकता. इससे अतिरिक्त सुरक्षा मिलती है.

क्रेडेंशियल मैनेजर की मदद से लोग पासकी बना सकते हैं और उन्हें Google पर सेव कर सकते हैं Password Manager.

क्रेडेंशियल मैनेजर की मदद से, पासकी की मदद से पुष्टि करने के फ़्लो को आसानी से लागू करने का तरीका जानने के लिए, पासकी की मदद से उपयोगकर्ता की पुष्टि करना लेख पढ़ें.

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

क्रेडेंशियल मैनेजर का इस्तेमाल करने के लिए, इस सेक्शन में दिया गया तरीका अपनाएं.

प्लैटफ़ॉर्म का नया वर्शन इस्तेमाल करना

क्रेडेंशियल मैनेजर, Android 4.4 (एपीआई लेवल 19) और इसके बाद के वर्शन पर काम करता है.

अपने ऐप्लिकेशन पर डिपेंडेंसी जोड़ना

अपने ऐप्लिकेशन मॉड्यूल की बिल्ड स्क्रिप्ट में ये डिपेंडेंसी जोड़ें:

dependencies {
    implementation("androidx.credentials:credentials:1.5.0-alpha05")

    // optional - needed for credentials support from play services, for devices running
    // Android 13 and below.
    implementation("androidx.credentials:credentials-play-services-auth:1.5.0-alpha05")
}

dependencies {
    implementation "androidx.credentials:credentials:1.5.0-alpha05"

    // optional - needed for credentials support from play services, for devices running
    // Android 13 and below.
    implementation "androidx.credentials:credentials-play-services-auth:1.5.0-alpha05"
}

ProGuard फ़ाइल में क्लास को सुरक्षित रखना

अपने मॉड्यूल की proguard-rules.pro फ़ाइल में, ये निर्देश जोड़ें:

-if class androidx.credentials.CredentialManager
-keep class androidx.credentials.playservices.** {
  *;
}

अपने ऐप्लिकेशन को छोटा करने, अस्पष्ट बनाने, और उसे ऑप्टिमाइज़ करने के तरीके के बारे में ज़्यादा जानें.

डिजिटल ऐसेट लिंक के लिए सहायता जोड़ना

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

1. डिजिटल ऐसेट लिंक की JSON फ़ाइल बनाएं. उदाहरण के लिए, यह बताने के लिए कि वेबसाइट https://signin.example.com और पैकेज के नाम com.example वाला Android ऐप्लिकेशन, साइन इन क्रेडेंशियल शेयर कर सकता है, assetlinks.json नाम की फ़ाइल बनाएं. इसमें यह कॉन्टेंट शामिल करें:

   [
     {
       "relation" : [
         "delegate_permission/common.handle_all_urls",
         "delegate_permission/common.get_login_creds"
       ],
       "target" : {
         "namespace" : "android_app",
         "package_name" : "com.example.android",
         "sha256_cert_fingerprints" : [
           SHA_HEX_VALUE
         ]
       }
     }
   ]
   

   relation फ़ील्ड, एक या उससे ज़्यादा स्ट्रिंग का कलेक्शन होता है जो संबंध की घोषणा की जा रही है. यह बताने के लिए कि ऐप्लिकेशन और साइटें साइन इन करने के क्रेडेंशियल शेयर करती हैं, संबंधों को delegate_permission/handle_all_urls और delegate_permission/common.get_login_creds के तौर पर बताएं.

   target फ़ील्ड एक ऑब्जेक्ट है, जो उस एसेट के बारे में बताता है जिस पर एलान लागू होता है. ये फ़ील्ड किसी वेबसाइट की पहचान करते हैं:

   namespace

   web

   site

   वेबसाइट का यूआरएल, फ़ॉर्मैट https://domain[:optional_port]; इसके लिए उदाहरण, https://www.example.com. domain पूरी तरह क्वालिफ़ाइड होना चाहिए. और पोर्ट 443 का इस्तेमाल करते समय optional_port को हटाना ज़रूरी है एचटीटीपीएस. site टारगेट सिर्फ़ रूट डोमेन हो सकता है: नहीं किसी खास सबडायरेक्ट्री के लिए, ऐप्लिकेशन असोसिएशन को सीमित करना. वैल्यू को शामिल न करें पाथ, जैसे कि ट्रेलिंग स्लैश. सबडोमेन को मैच नहीं माना जाता है: इसका मतलब है कि अगर आपने www.example.com के तौर पर domain, डोमेन www.counter.example.com आपके ऐप्लिकेशन से नहीं जुड़ा है.

   ये फ़ील्ड किसी Android ऐप्लिकेशन की पहचान करते हैं:

   namespace	android_app
   package_name	ऐप्लिकेशन के मेनिफ़ेस्ट में बताया गया पैकेज का नाम. उदाहरण के लिए, com.example.android अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
   sha256_cert_fingerprints	आपके ऐप्लिकेशन के साइनिंग सर्टिफ़िकेट के SHA256 फ़िंगरप्रिंट.

2. डिजिटल ऐसेट लिंक JSON फ़ाइल को, साइन-इन डोमेन:

   https://domain[:optional_port]/.well-known/assetlinks.json
   

   उदाहरण के लिए, अगर आपका साइन-इन डोमेन signin.example.com है, तो JSON फ़ाइल को https://signin.example.com/.well-known/assetlinks.json पर होस्ट करें.

   डिजिटल ऐसेट लिंक फ़ाइल का MIME टाइप, JSON होना चाहिए. पक्का करें कि सर्वर, रिस्पॉन्स में Content-Type: application/json हेडर भेजता है.

3. पक्का करें कि आपके होस्ट ने Google को आपकी डिजिटल एसेट लिंक फ़ाइल को वापस पाने की अनुमति दी हो. अगर आपके पास robots.txt फ़ाइल है, तो उसमें Googlebot एजेंट को /.well-known/assetlinks.json को फिर से पाने की अनुमति होनी चाहिए. ज़्यादातर साइटें, किसी भी अपने-आप काम करने वाला एजेंट, जो /.well-known/ पाथ में फ़ाइलें वापस लाएगा, ताकि अन्य सेवाएं इन फ़ाइलों के मेटाडेटा को ऐक्सेस कर सकती हैं:

   User-agent: *
   Allow: /.well-known/
   

4. <application> में मौजूद मेनिफ़ेस्ट फ़ाइल में यह लाइन जोड़ें:

   <meta-data android:name="asset_statements" android:resource="@string/asset_statements" />
   

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

   Android ऐप्लिकेशन में, असोसिएशन का एलान करें. कोई ऐसा ऑब्जेक्ट जोड़ें जो लोड करने के लिए assetlinks.json फ़ाइलें. आपको किसी भी अपॉस्ट्रफ़ी से बचना होगा और आपके स्ट्रिंग में इस्तेमाल होने वाले कोटेशन मार्क. उदाहरण के लिए:

   <string name="asset_statements" translatable="false">
   [{
     \"include\": \"https://signin.example.com/.well-known/assetlinks.json\"
   }]
   </string>
   

   > GET /.well-known/assetlinks.json HTTP/1.1
   > User-Agent: curl/7.35.0
   > Host: signin.example.com
   
   < HTTP/1.1 200 OK
   < Content-Type: application/json
   

क्रेडेंशियल मैनेजर को कॉन्फ़िगर करें

CredentialManager ऑब्जेक्ट को कॉन्फ़िगर और शुरू करने के लिए, इसके जैसा लॉजिक जोड़ें निम्न:

// Use your app or activity context to instantiate a client instance of
// CredentialManager.
val credentialManager = CredentialManager.create(context)

// Use your app or activity context to instantiate a client instance of
// CredentialManager.
CredentialManager credentialManager = CredentialManager.create(context)

क्रेडेंशियल फ़ील्ड दिखाना

Android 14 और उसके बाद के वर्शन पर, isCredential एट्रिब्यूट का इस्तेमाल, क्रेडेंशियल फ़ील्ड के बारे में बताने के लिए किया जा सकता है. जैसे, उपयोगकर्ता नाम या पासवर्ड फ़ील्ड. इस एट्रिब्यूट से पता चलता है कि यह व्यू, क्रेडेंशियल फ़ील्ड है. इसका मकसद, क्रेडेंशियल मैनेजर और तीसरे पक्ष के क्रेडेंशियल देने वाले प्रोग्राम के साथ काम करना है. साथ ही, ऑटोमैटिक भरने की सेवाओं को ऑटोमैटिक भरने के बेहतर सुझाव देने में मदद करना है. जब ऐप्लिकेशन क्रेडेंशियल का इस्तेमाल करता है Manager API, उपलब्ध क्रेडेंशियल वाली क्रेडेंशियल मैनेजर की बॉटम शीट है दिखाया जाएगा. इसके लिए, ऑटोमैटिक भरने की सुविधा का डायलॉग बॉक्स दिखाने की ज़रूरत नहीं है उपयोगकर्ता नाम या पासवर्ड डालें. इसी तरह, पासवर्ड के लिए ऑटोमैटिक भरने की सुविधा का 'सेव करें' डायलॉग दिखाने की ज़रूरत नहीं है. ऐसा इसलिए, क्योंकि ऐप्लिकेशन क्रेडेंशियल सेव करने के लिए, क्रेडेंशियल मैनेजर API से अनुरोध करेगा.

isCredential एट्रिब्यूट का इस्तेमाल करने के लिए, उसे काम के व्यू में जोड़ें:

<TextView
   android:layout_width="match_parent"
   android:layout_height="wrap_content"
   android:isCredential="true"
...
 />

अपने उपयोगकर्ता के तौर पर साइन इन करना

उपयोगकर्ता के खाते से जुड़ी सभी पासकी और पासवर्ड के विकल्प वापस पाने के लिए, यह तरीका अपनाएं:

1. पासवर्ड और पासकी की पुष्टि करने के विकल्पों को शुरू करने के लिए:

   Kotlin

   // Retrieves the user's saved password for your app from their
   // password provider.
   val getPasswordOption = GetPasswordOption()
   
   // Get passkey from the user's public key credential provider.
   val getPublicKeyCredentialOption = GetPublicKeyCredentialOption(
       requestJson = requestJson
   )

   Java

   // Retrieves the user's saved password for your app from their
   // password provider.
   GetPasswordOption getPasswordOption = new GetPasswordOption();
   
   // Get passkey from the user's public key credential provider.
   GetPublicKeyCredentialOption getPublicKeyCredentialOption =
           new GetPublicKeyCredentialOption(requestJson);

2. पिछले चरण में मिले विकल्पों का इस्तेमाल करके, अपनी साइन-इन अनुरोध.

   Kotlin

   val getCredRequest = GetCredentialRequest(
       listOf(getPasswordOption, getPublicKeyCredentialOption)
   )

   Java

   GetCredentialRequest getCredRequest = new GetCredentialRequest.Builder()
       .addCredentialOption(getPasswordOption)
       .addCredentialOption(getPublicKeyCredentialOption)
       .build();

3. साइन-इन फ़्लो लॉन्च करने के लिए:

   Kotlin

   coroutineScope.launch {
       try {
           val result = credentialManager.getCredential(
               // Use an activity-based context to avoid undefined system UI
               // launching behavior.
               context = activityContext,
               request = getCredRequest
           )
           handleSignIn(result)
       } catch (e : GetCredentialException) {
           handleFailure(e)
       }
   }
   
   fun handleSignIn(result: GetCredentialResponse) {
       // Handle the successfully returned credential.
       val credential = result.credential
   
       when (credential) {
           is PublicKeyCredential -> {
               val responseJson = credential.authenticationResponseJson
               // Share responseJson i.e. a GetCredentialResponse on your server to
               // validate and  authenticate
           }
           is PasswordCredential -> {
               val username = credential.id
               val password = credential.password
               // Use id and password to send to your server to validate
               // and authenticate
           }
         is CustomCredential -> {
             // If you are also using any external sign-in libraries, parse them
             // here with the utility functions provided.
             if (credential.type == ExampleCustomCredential.TYPE)  {
             try {
                 val ExampleCustomCredential = ExampleCustomCredential.createFrom(credential.data)
                 // Extract the required credentials and complete the authentication as per
                 // the federated sign in or any external sign in library flow
                 } catch (e: ExampleCustomCredential.ExampleCustomCredentialParsingException) {
                     // Unlikely to happen. If it does, you likely need to update the dependency
                     // version of your external sign-in library.
                     Log.e(TAG, "Failed to parse an ExampleCustomCredential", e)
                 }
             } else {
               // Catch any unrecognized custom credential type here.
               Log.e(TAG, "Unexpected type of credential")
             }
           } else -> {
               // Catch any unrecognized credential type here.
               Log.e(TAG, "Unexpected type of credential")
           }
       }
   }

   Java

   credentialManager.getCredentialAsync(
       // Use activity based context to avoid undefined
       // system UI launching behavior
       activity,
       getCredRequest,
       cancellationSignal,
       <executor>,
       new CredentialManagerCallback<GetCredentialResponse, GetCredentialException>() {
           @Override
           public void onResult(GetCredentialResponse result) {
               handleSignIn(result);
           }
   
           @Override
           public void onError(GetCredentialException e) {
               handleFailure(e);
           }
       }
   );
   
   public void handleSignIn(GetCredentialResponse result) {
       // Handle the successfully returned credential.
       Credential credential = result.getCredential();
       if (credential instanceof PublicKeyCredential) {
           String responseJson = ((PublicKeyCredential) credential).getAuthenticationResponseJson();
           // Share responseJson i.e. a GetCredentialResponse on your server to validate and authenticate
       } else if (credential instanceof PasswordCredential) {
           String username = ((PasswordCredential) credential).getId();
           String password = ((PasswordCredential) credential).getPassword();
           // Use id and password to send to your server to validate and authenticate
       } else if (credential instanceof CustomCredential) {
           if (ExampleCustomCredential.TYPE.equals(credential.getType())) {
               try {
                   ExampleCustomCredential customCred = ExampleCustomCredential.createFrom(customCredential.getData());
                   // Extract the required credentials and complete the
                   // authentication as per the federated sign in or any external
                   // sign in library flow
               } catch (ExampleCustomCredential.ExampleCustomCredentialParsingException e) {
                   // Unlikely to happen. If it does, you likely need to update the
                   // dependency version of your external sign-in library.
                   Log.e(TAG, "Failed to parse an ExampleCustomCredential", e);
               }
           } else {
               // Catch any unrecognized custom credential type here.
               Log.e(TAG, "Unexpected type of credential");
           }
       } else {
           // Catch any unrecognized credential type here.
           Log.e(TAG, "Unexpected type of credential");
       }
   }

यहां दिए गए उदाहरण में, JSON अनुरोध को फ़ॉर्मैट करने का तरीका बताया गया है. ऐसा करते समय, जब आपको पासकी मिलती है, तो:

{
  "challenge": "T1xCsnxM2DNL2KdK5CLa6fMhD7OBqho6syzInk_n-Uo",
  "allowCredentials": [],
  "timeout": 1800000,
  "userVerification": "required",
  "rpId": "credential-manager-app-test.glitch.me"
}

नीचे दिए गए उदाहरण में बताया गया है कि सार्वजनिक कुंजी वाला क्रेडेंशियल मिलने के बाद, JSON रिस्पॉन्स कैसा दिख सकता है:

{
  "id": "KEDetxZcUfinhVi6Za5nZQ",
  "type": "public-key",
  "rawId": "KEDetxZcUfinhVi6Za5nZQ",
  "response": {
    "clientDataJSON": "eyJ0eXBlIjoid2ViYXV0aG4uZ2V0IiwiY2hhbGxlbmdlIjoiVDF4Q3NueE0yRE5MMktkSzVDTGE2Zk1oRDdPQnFobzZzeXpJbmtfbi1VbyIsIm9yaWdpbiI6ImFuZHJvaWQ6YXBrLWtleS1oYXNoOk1MTHpEdll4UTRFS1R3QzZVNlpWVnJGUXRIOEdjVi0xZDQ0NEZLOUh2YUkiLCJhbmRyb2lkUGFja2FnZU5hbWUiOiJjb20uZ29vZ2xlLmNyZWRlbnRpYWxtYW5hZ2VyLnNhbXBsZSJ9",
    "authenticatorData": "j5r_fLFhV-qdmGEwiukwD5E_5ama9g0hzXgN8thcFGQdAAAAAA",
    "signature": "MEUCIQCO1Cm4SA2xiG5FdKDHCJorueiS04wCsqHhiRDbbgITYAIgMKMFirgC2SSFmxrh7z9PzUqr0bK1HZ6Zn8vZVhETnyQ",
    "userHandle": "2HzoHm_hY0CjuEESY9tY6-3SdjmNHOoNqaPDcZGzsr0"
  }
}

क्रेडेंशियल उपलब्ध न होने पर, अपवादों को हैंडल करें

कुछ मामलों में, हो सकता है कि उपयोगकर्ता के पास कोई क्रेडेंशियल उपलब्ध न हो या वह उपलब्ध क्रेडेंशियल का इस्तेमाल करने की सहमति न दे. अगर getCredential() को शुरू किया जाता है और कोई क्रेडेंशियल नहीं मिलता है, तो NoCredentialException दिखाया जाता है. अगर ऐसा होता है, तो आपके कोड को NoCredentialException को संभालना चाहिए इंस्टेंस.

try {
  val credential = credentialManager.getCredential(credentialRequest)
} catch (e: NoCredentialException) {
  Log.e("CredentialManager", "No credential available", e)
}

try {
  Credential credential = credentialManager.getCredential(credentialRequest);
} catch (NoCredentialException e) {
  Log.e("CredentialManager", "No credential available", e);
}

Android 14 या इसके बाद वाले वर्शन पर, खाता दिखाते समय, इंतज़ार का समय कम किया जा सकता है कॉल करने से पहले, prepareGetCredential() तरीके का इस्तेमाल करके सिलेक्टर को चुनें getCredential().

val response = credentialManager.prepareGetCredential(
  GetCredentialRequest(
    listOf(
      <getPublicKeyCredentialOption>,
      <getPasswordOption>
    )
  )
}

GetCredentialResponse response = credentialManager.prepareGetCredential(
  new GetCredentialRequest(
    Arrays.asList(
      new PublicKeyCredentialOption(),
      new PasswordOption()
    )
  )
);

prepareGetCredential() तरीका, यूज़र इंटरफ़ेस (यूआई) एलिमेंट को ट्रिगर नहीं करता. यह सिर्फ़ तैयारी करने में आपकी मदद करता है, ताकि बाद में getCredential() एपीआई की मदद से, बाकी क्रेडेंशियल पाने की कार्रवाई (जिसमें यूज़र इंटरफ़ेस शामिल हैं) शुरू की जा सके.

कैश मेमोरी में सेव किया गया डेटा, PrepareGetCredentialResponse ऑब्जेक्ट में दिखाया जाता है. अगर आपने पहले से क्रेडेंशियल मौजूद हैं, तो नतीजों को कैश मेमोरी में सेव किया जाएगा और फिर बाद में, खाते को चालू करने के लिए, बचे हुए getCredential() एपीआई को लॉन्च करेंगे कैश मेमोरी में सेव किए गए डेटा को चुनने वाला टूल.

रजिस्ट्रेशन फ़्लो

पुष्टि करने के लिए, इनमें से किसी एक का इस्तेमाल करके उपयोगकर्ता को रजिस्टर किया जा सकता है पासकी या पासवर्ड डालें.

पासकी बनाना

लोगों को पासकी रजिस्टर करने और फिर से पुष्टि करने के लिए उसका इस्तेमाल करने का विकल्प देने के लिए, CreatePublicKeyCredentialRequest ऑब्जेक्ट का इस्तेमाल करके, उपयोगकर्ता क्रेडेंशियल रजिस्टर करें.

fun createPasskey(requestJson: String, preferImmediatelyAvailableCredentials: Boolean) {
    val createPublicKeyCredentialRequest = CreatePublicKeyCredentialRequest(
        // Contains the request in JSON format. Uses the standard WebAuthn
        // web JSON spec.
        requestJson = requestJson,
        // Defines whether you prefer to use only immediately available
        // credentials, not hybrid credentials, to fulfill this request.
        // This value is false by default.
        preferImmediatelyAvailableCredentials = preferImmediatelyAvailableCredentials,
    )

    // Execute CreateCredentialRequest asynchronously to register credentials
    // for a user account. Handle success and failure cases with the result and
    // exceptions, respectively.
    coroutineScope.launch {
        try {
            val result = credentialManager.createCredential(
                // Use an activity-based context to avoid undefined system
                // UI launching behavior
                context = activityContext,
                request = createPublicKeyCredentialRequest,
            )
            handlePasskeyRegistrationResult(result)
        } catch (e : CreateCredentialException){
            handleFailure(e)
        }
    }
}

fun handleFailure(e: CreateCredentialException) {
    when (e) {
        is CreatePublicKeyCredentialDomException -> {
            // Handle the passkey DOM errors thrown according to the
            // WebAuthn spec.
            handlePasskeyError(e.domError)
        }
        is CreateCredentialCancellationException -> {
            // The user intentionally canceled the operation and chose not
            // to register the credential.
        }
        is CreateCredentialInterruptedException -> {
            // Retry-able error. Consider retrying the call.
        }
        is CreateCredentialProviderConfigurationException -> {
            // Your app is missing the provider configuration dependency.
            // Most likely, you're missing the
            // "credentials-play-services-auth" module.
        }
        is CreateCredentialUnknownException -> ...
        is CreateCredentialCustomException -> {
            // You have encountered an error from a 3rd-party SDK. If you
            // make the API call with a request object that's a subclass of
            // CreateCustomCredentialRequest using a 3rd-party SDK, then you
            // should check for any custom exception type constants within
            // that SDK to match with e.type. Otherwise, drop or log the
            // exception.
        }
        else -> Log.w(TAG, "Unexpected exception type ${e::class.java.name}")
    }
}

public void createPasskey(String requestJson, boolean preferImmediatelyAvailableCredentials) {
    CreatePublicKeyCredentialRequest createPublicKeyCredentialRequest =
            // `requestJson` contains the request in JSON format. Uses the standard
            // WebAuthn web JSON spec.
            // `preferImmediatelyAvailableCredentials` defines whether you prefer
            // to only use immediately available credentials, not  hybrid credentials,
            // to fulfill this request. This value is false by default.
            new CreatePublicKeyCredentialRequest(
                requestJson, preferImmediatelyAvailableCredentials);

    // Execute CreateCredentialRequest asynchronously to register credentials
    // for a user account. Handle success and failure cases with the result and
    // exceptions, respectively.
    credentialManager.createCredentialAsync(
        // Use an activity-based context to avoid undefined system
        // UI launching behavior
        requireActivity(),
        createPublicKeyCredentialRequest,
        cancellationSignal,
        executor,
        new CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException>() {
            @Override
            public void onResult(CreateCredentialResponse result) {
                handleSuccessfulCreatePasskeyResult(result);
            }

            @Override
            public void onError(CreateCredentialException e) {
                if (e instanceof CreatePublicKeyCredentialDomException) {
                    // Handle the passkey DOM errors thrown according to the
                    // WebAuthn spec.
                    handlePasskeyError(((CreatePublicKeyCredentialDomException)e).getDomError());
                } else if (e instanceof CreateCredentialCancellationException) {
                    // The user intentionally canceled the operation and chose not
                    // to register the credential.
                } else if (e instanceof CreateCredentialInterruptedException) {
                    // Retry-able error. Consider retrying the call.
                } else if (e instanceof CreateCredentialProviderConfigurationException) {
                    // Your app is missing the provider configuration dependency.
                    // Most likely, you're missing the
                    // "credentials-play-services-auth" module.
                } else if (e instanceof CreateCredentialUnknownException) {
                } else if (e instanceof CreateCredentialCustomException) {
                    // You have encountered an error from a 3rd-party SDK. If
                    // you make the API call with a request object that's a
                    // subclass of
                    // CreateCustomCredentialRequest using a 3rd-party SDK,
                    // then you should check for any custom exception type
                    // constants within that SDK to match with e.type.
                    // Otherwise, drop or log the exception.
                } else {
                  Log.w(TAG, "Unexpected exception type "
                          + e.getClass().getName());
                }
            }
        }
    );
}

JSON अनुरोध को फ़ॉर्मैट करना

पासकी बनाने के बाद, आपको उसे उपयोगकर्ता के खाते से जोड़ना होगा. साथ ही, पासकी की सार्वजनिक कुंजी को अपने सर्वर पर सेव करना होगा. पासकी बनाते समय, JSON अनुरोध को फ़ॉर्मैट करने का तरीका जानने के लिए, नीचे दिया गया कोड उदाहरण देखें.

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

{
  "challenge": "abc123",
  "rp": {
    "name": "Credential Manager example",
    "id": "credential-manager-test.example.com"
  },
  "user": {
    "id": "def456",
    "name": "helloandroid@gmail.com",
    "displayName": "helloandroid@gmail.com"
  },
  "pubKeyCredParams": [
    {
      "type": "public-key",
      "alg": -7
    },
    {
      "type": "public-key",
      "alg": -257
    }
  ],
  "timeout": 1800000,
  "attestation": "none",
  "excludeCredentials": [
    {"id": "ghi789", "type": "public-key"},
    {"id": "jkl012", "type": "public-key"}
  ],
  "authenticatorSelection": {
    "authenticatorAttachment": "platform",
    "requireResidentKey": true,
    "residentKey": "required",
    "userVerification": "required"
  }
}

authenticatorAttachment के लिए वैल्यू सेट करना

authenticatorAttachment पैरामीटर को सिर्फ़ क्रेडेंशियल बनाते समय सेट किया जा सकता है समय. इसके लिए, platform, cross-platform या कोई वैल्यू सबमिट की जा सकती है. ज़्यादातर मामलों में, वैल्यू सबमिट करने का सुझाव नहीं दिया जाता.

• platform: उपयोगकर्ता के मौजूदा डिवाइस को रजिस्टर करने या साइन इन करने के बाद, पासवर्ड का इस्तेमाल करने वाले उपयोगकर्ता को पासकी पर अपग्रेड करने के लिए कहने के लिए, authenticatorAttachment को platform पर सेट करें.
• cross-platform: इस वैल्यू का इस्तेमाल आम तौर पर, कई तरीकों से पुष्टि करने वाले क्रेडेंशियल रजिस्टर करते समय किया जाता है. इसका इस्तेमाल पासकी के संदर्भ में नहीं किया जाता.
• कोई वैल्यू नहीं: उपयोगकर्ताओं को अपने पसंदीदा डिवाइसों (जैसे, खाता सेटिंग में) पर पासकी बनाने की सुविधा देने के लिए, जब कोई उपयोगकर्ता पासकी जोड़ने का विकल्प चुनता है, तो authenticatorAttachment पैरामीटर की वैल्यू नहीं दी जानी चाहिए. ज़्यादातर मामलों में, पैरामीटर को अनिर्दिष्ट छोड़ देना सबसे अच्छा होता है का विकल्प शामिल है.

डुप्लीकेट पासकी बनाने से रोकें

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

JSON के जवाब को मैनेज करना

नीचे दिया गया कोड स्निपेट, सार्वजनिक पासकोड क्रेडेंशियल बनाने के लिए JSON रिस्पॉन्स का उदाहरण दिखाता है. लौटाए गए सार्वजनिक पासकोड को मैनेज करने के तरीके के बारे में ज़्यादा जानें क्रेडेंशियल.

{
  "id": "KEDetxZcUfinhVi6Za5nZQ",
  "type": "public-key",
  "rawId": "KEDetxZcUfinhVi6Za5nZQ",
  "response": {
    "clientDataJSON": "eyJ0eXBlIjoid2ViYXV0aG4uY3JlYXRlIiwiY2hhbGxlbmdlIjoibmhrUVhmRTU5SmI5N1Z5eU5Ka3ZEaVh1Y01Fdmx0ZHV2Y3JEbUdyT0RIWSIsIm9yaWdpbiI6ImFuZHJvaWQ6YXBrLWtleS1oYXNoOk1MTHpEdll4UTRFS1R3QzZVNlpWVnJGUXRIOEdjVi0xZDQ0NEZLOUh2YUkiLCJhbmRyb2lkUGFja2FnZU5hbWUiOiJjb20uZ29vZ2xlLmNyZWRlbnRpYWxtYW5hZ2VyLnNhbXBsZSJ9",
    "attestationObject": "o2NmbXRkbm9uZWdhdHRTdG10oGhhdXRoRGF0YViUj5r_fLFhV-qdmGEwiukwD5E_5ama9g0hzXgN8thcFGRdAAAAAAAAAAAAAAAAAAAAAAAAAAAAEChA3rcWXFH4p4VYumWuZ2WlAQIDJiABIVgg4RqZaJyaC24Pf4tT-8ONIZ5_Elddf3dNotGOx81jj3siWCAWXS6Lz70hvC2g8hwoLllOwlsbYatNkO2uYFO-eJID6A"
  }
}

क्लाइंट डेटा JSON से ऑरिजिन की पुष्टि करें

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

वेब मामले में, origin समान साइट के ऑरिजिन को दिखाता है, जहां क्रेडेंशियल में साइन इन किया गया था. उदाहरण के लिए, https://www.example.com:8443/store?category=shoes#athletic का यूआरएल दिया गया है, तो origin का यूआरएल https://www.example.com:8443 होगा.

Android ऐप्लिकेशन के लिए, उपयोगकर्ता एजेंट, कॉल करने वाले ऐप्लिकेशन के हस्ताक्षर में origin को अपने-आप सेट करता है. पासकी एपीआई के कॉलर की पुष्टि करने के लिए, इस हस्ताक्षर की पुष्टि आपके सर्वर पर की जानी चाहिए. Android origin, एक यूआरआई है APK साइनिंग सर्टिफ़िकेट के SHA-256 हैश से लिया जाता है, जैसे कि:

android:apk-key-hash:<sha256_hash-of-apk-signing-cert>

कीस्टोर से साइनिंग सर्टिफ़िकेट के SHA-256 हैश इन तरीकों से ढूंढे जा सकते हैं: निम्न टर्मिनल आदेश चला रहा है:

keytool -list -keystore <path-to-apk-signing-keystore>

SHA-256 हैश, कोलन से अलग किए गए हेक्साडेसिमल फ़ॉर्मैट (91:F7:CB:F9:D6:81…) में होते हैं. साथ ही, Android origin वैल्यू, base64url में एन्कोड की जाती हैं. Python के इस उदाहरण में, हैश फ़ॉर्मैट को कंपेटिबल फ़ॉर्मैट में बदलने का तरीका बताया गया है. कोलन से अलग किया गया हेक्साडेसिमल फ़ॉर्मैट:

import binascii
import base64
fingerprint = '91:F7:CB:F9:D6:81:53:1B:C7:A5:8F:B8:33:CC:A1:4D:AB:ED:E5:09:C5'
print("android:apk-key-hash:" + base64.urlsafe_b64encode(binascii.a2b_hex(fingerprint.replace(':', ''))).decode('utf8').replace('=', ''))

fingerprint की वैल्यू को अपनी वैल्यू से बदलें. यहां एक उदाहरण दिया गया है result:

android:apk-key-hash:kffL-daBUxvHpY-4M8yhTavt5QnFEI2LsexohxrGPYU

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

किसी उपयोगकर्ता का पासवर्ड सेव करना

अगर उपयोगकर्ता आपके ऐप्लिकेशन में पुष्टि करने के फ़्लो के लिए उपयोगकर्ता नाम और पासवर्ड डालता है, तो उपयोगकर्ता का क्रेडेंशियल रजिस्टर किया जा सकता है. इसका इस्तेमाल, उपयोगकर्ता की पुष्टि करने के लिए किया जा सकता है. ऐसा करने के लिए, CreatePasswordRequest ऑब्जेक्ट बनाएं:

fun registerPassword(username: String, password: String) {
    // Initialize a CreatePasswordRequest object.
    val createPasswordRequest =
            CreatePasswordRequest(id = username, password = password)

    // Create credential and handle result.
    coroutineScope.launch {
        try {
            val result =
                credentialManager.createCredential(
                    // Use an activity based context to avoid undefined
                    // system UI launching behavior.
                    activityContext,
                    createPasswordRequest
                  )
            handleRegisterPasswordResult(result)
        } catch (e: CreateCredentialException) {
            handleFailure(e)
        }
    }
}

void registerPassword(String username, String password) {
    // Initialize a CreatePasswordRequest object.
    CreatePasswordRequest createPasswordRequest =
        new CreatePasswordRequest(username, password);

    // Register the username and password.
    credentialManager.createCredentialAsync(
        // Use an activity-based context to avoid undefined
        // system UI launching behavior
        requireActivity(),
        createPasswordRequest,
        cancellationSignal,
        executor,
        new CredentialManagerCallback<CreateCredentialResponse, CreateCredentialException>() {
            @Override
            public void onResult(CreateCredentialResponse result) {
                handleResult(result);
            }

            @Override
            public void onError(CreateCredentialException e) {
                handleFailure(e);
            }
        }
    );
}

क्रेडेंशियल वापस पाने में मदद करना

अगर उपयोगकर्ता के पास अब ऐसे डिवाइस का ऐक्सेस नहीं है जिसमें उसने अपना कॉन्टेंट सेव किया था क्रेडेंशियल नहीं दिए हैं, तो उन्हें एक सुरक्षित ऑनलाइन बैकअप से डेटा वापस पाने की ज़रूरत पड़ सकती है. क्रेडेंशियल वापस पाने की इस प्रोसेस में मदद करने के तरीके के बारे में ज़्यादा जानने के लिए, इस ब्लॉग पोस्ट में "ऐक्सेस वापस पाना या नए डिवाइस जोड़ना" सेक्शन पढ़ें: Google Password Manager में पासकी की सुरक्षा.

पासकी एंडपॉइंट के लोकप्रिय यूआरएल वाले पासवर्ड मैनेजमेंट टूल के लिए सहायता जोड़ना

हमारा सुझाव है कि पासकी के एंडपॉइंट के लिए, जाने-पहचाने यूआरएल के साथ काम करने की सुविधा जोड़ें. इससे, पासवर्ड और क्रेडेंशियल मैनेजमेंट टूल के साथ आसानी से इंटिग्रेट किया जा सकेगा और आने वाले समय में इन टूल के साथ काम किया जा सकेगा. यह एक ओपन प्रोटोकॉल है, ताकि पार्टनर, पासकी के साथ काम करने की सुविधा का आधिकारिक तौर पर विज्ञापन कर सकें. साथ ही, पासकी को रजिस्टर करने और मैनेज करने के लिए सीधे लिंक उपलब्ध करा सकें.

1. https://example.com पर भरोसा करने वाले पक्ष के लिए, जिसकी वेबसाइट प्लस है तो लोकप्रिय URL https://example.com/.well-known/passkey-endpoints.

2. यूआरएल के बारे में क्वेरी करने पर, रिस्पॉन्स में इस स्कीमा का इस्तेमाल किया जाना चाहिए

   {
     "enroll": "https://example.com/account/manage/passkeys/create"
     "manage": "https://example.com/account/manage/passkeys"
   }
   

3. इस लिंक को वेब के बजाय सीधे अपने ऐप्लिकेशन में खोलने के लिए, इसका इस्तेमाल करें Android ऐप्लिकेशन के लिंक.

4. ज़्यादा जानकारी के लिए, यहां जाएं: GitHub पर पासकी एंडपॉइंट जाने-पहचाने यूआरएल के बारे में जानकारी देता है.

पासकी मैनेज करने में लोगों की मदद करें. इसके लिए, उन्हें बताएं कि पासकी किस कंपनी ने बनाई हैं

किसी ऐप्लिकेशन से जुड़ी कई पासकी मैनेज करते समय, उपयोगकर्ताओं को एक समस्या का सामना करना पड़ता है. यह समस्या, बदलाव करने या मिटाने के लिए सही पासकी की पहचान करने से जुड़ी होती है. इसके साथ सहायता करने के लिए तो हमारा सुझाव है कि ऐप्लिकेशन और वेबसाइटों में ज़्यादा जानकारी जानकारी, जैसे क्रेडेंशियल बनाने वाले का नाम, दस्तावेज़ बनाने की तारीख और आपके ऐप्लिकेशन की सेटिंग स्क्रीन पर मौजूद पासकी की सूची में वह तारीख जब आपने पिछली बार इस्तेमाल किया था.इसके लिए, आपको सेवा देने वाली कंपनी यह जानकारी, Google से जुड़े AAGUID की जांच करके मिलती है और पासवर्ड से जुड़ी पासकी डालें. AAGUID, पासकी के पुष्टि करने वाले डेटा के हिस्से के तौर पर मिल सकता है.

उदाहरण के लिए, अगर कोई उपयोगकर्ता Android डिवाइस पर, Google Password Manager का इस्तेमाल करके पासकी बनाता है, तो आरपी को एक AAGUID मिलता है. यह कुछ ऐसा दिखता है: "ea9b8d66-4d01-1d21-3ce4-b6b48cb575d4". भरोसेमंद पक्ष यह कर सकता है: पासकी सूची में मौजूद पासकी के बारे में जानकारी दें, ताकि यह पता चल सके कि इसे इसका इस्तेमाल करके बनाया गया है Google Password Manager.

पासकी की सेवा देने वाली किसी कंपनी के साथ AAGUID को मैप करने के लिए, आरपी कम्यूनिटी सोर्स से मिली जानकारी का इस्तेमाल कर सकते हैं AAGUID का डेटा स्टोर करने की जगह. AAGUID को सूची में जाकर, पासकी की सेवा देने वाली कंपनी का नाम और आइकॉन देखें.

AAGUID इंटिग्रेशन के बारे में ज़्यादा पढ़ें.

सामान्य गड़बड़ियां हल करना

नीचे दी गई टेबल में, आम तौर पर होने वाली गड़बड़ियों के कोड और उनके बारे में जानकारी दी गई है. इस समस्या की वजह के बारे में कुछ जानकारी देता है:

अन्य संसाधन

क्रेडेंशियल मैनेजर एपीआई और पासकी के बारे में ज़्यादा जानने के लिए, यहां जाएं इन संसाधनों की मदद से:

• पासकी के यूज़र एक्सपीरियंस (यूएक्स) से जुड़ी गाइड
• वीडियो: पासकी की मदद से Android ऐप्लिकेशन में पासवर्ड का इस्तेमाल कम करने का तरीका सहायता
• कोडलैब: Credential Manager API का इस्तेमाल करके, पुष्टि करने की प्रोसेस को आसान बनाने का तरीका जानें Android ऐप्लिकेशन में
• सैंपल ऐप्लिकेशन: CredentialManager