Google Wallet से आईडी स्वीकार किए जा रहे हैं

ऑनलाइन

डिजिटल आईडी, इन-ऐप्लिकेशन और वेब, दोनों फ़्लो में स्वीकार किए जा सकते हैं. Google Wallet से क्रेडेंशियल स्वीकार करने के लिए, आपको:

1. दिए गए निर्देशों का पालन करके, ऐप्लिकेशन या वेब का इस्तेमाल करके इंटिग्रेट करें और
2. Google Wallet से क्रेडेंशियल स्वीकार करने का अनुरोध करने और सेवा की शर्तों से सहमत होने के लिए, यह फ़ॉर्म भरें.

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

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

• सेवा की शर्तों का लिंक
• लोगो
• वेबसाइट
• Play Store का पैकेज आईडी (Android ऐप्लिकेशन इंटिग्रेशन के लिए)
• वह Gmail आईडी जिसका इस्तेमाल सार्वजनिक बीटा वर्शन में शामिल होने के लिए किया गया था

क्रेडेंशियल के ऐसे फ़ॉर्मैट जिनका इस्तेमाल किया जा सकता है

डिजिटल पहचान दस्तावेज़ों के डेटा फ़ॉर्मैट के लिए, कई स्टैंडर्ड प्रस्तावित किए गए हैं. इनमें से दो स्टैंडर्ड, इंडस्ट्री में काफ़ी लोकप्रिय हैं:

1. mdocs - ISO ने तय किया है.
2. W3C के पुष्टि किए जा सकने वाले क्रेडेंशियल - W3C ने इनकी परिभाषा तय की है.

Android क्रेडेंशियल मैनेजर, दोनों फ़ॉर्मैट के साथ काम करता है. हालांकि, फ़िलहाल Google Wallet में सिर्फ़ एमडीओसी वाले डिजिटल आईडी इस्तेमाल किए जा सकते हैं.

उपयोगकर्ता अनुभव

जब कोई ऐप्लिकेशन पहचान से जुड़े एट्रिब्यूट का अनुरोध करता है, तो यह प्रोसेस होती है:

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

2. उपयोगकर्ता की ओर से चुना गया क्रेडेंशियल और Wallet ऐप्लिकेशन के साथ इंटरैक्शन: उपयोगकर्ता कोई क्रेडेंशियल चुनता है और Android, लेन-देन पूरा करने के लिए उससे जुड़े Wallet ऐप्लिकेशन को चालू करता है. Wallet ऐप्लिकेशन, सहमति लेने के लिए अपनी स्क्रीन दिखा सकता है या बायोमेट्रिक पुष्टि करने के लिए कह सकता है.

नतीजा: अगर उपयोगकर्ता सहमति देता है, तो चुनी गई पहचान के क्रेडेंशियल, अनुरोध करने वाले ऐप्लिकेशन के साथ शेयर किए जाते हैं. अगर उपयोगकर्ता अनुमति नहीं देता है, तो गड़बड़ी का मैसेज दिखता है.

ऐप्लिकेशन में

अपने Android ऐप्लिकेशन से पहचान की पुष्टि करने वाले क्रेडेंशियल का अनुरोध करने के लिए, यह तरीका अपनाएं:

डिपेंडेंसी अपडेट करना

अपने प्रोजेक्ट के build.gradle में, Credential Manager (बीटा वर्शन) का इस्तेमाल करने के लिए अपनी डिपेंडेंसी अपडेट करें:

dependencies {
    implementation("androidx.credentials:credentials:1.5.0-beta01")
    // 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-beta01")
}

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

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

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

पहचान बताने वाले एट्रिब्यूट का अनुरोध करना

पहचान की पुष्टि के अनुरोधों के लिए अलग-अलग पैरामीटर तय करने के बजाय, ऐप्लिकेशन उन्हें CredentialOption में JSON स्ट्रिंग के तौर पर एक साथ उपलब्ध कराता है. क्रेडेंशियल मैनेजर, इस JSON स्ट्रिंग को उपलब्ध डिजिटल वॉलेट पर भेजता है. हालांकि, वह इसके कॉन्टेंट की जांच नहीं करता. इसके बाद, हर वॉलेट की ये ज़िम्मेदारियां होती हैं: - पहचान की पुष्टि करने के अनुरोध को समझने के लिए, JSON स्ट्रिंग को पार्स करना. - यह तय करना कि सेव किए गए क्रेडेंशियल में से कौनसे क्रेडेंशियल, अनुरोध के मुताबिक हैं.

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

शुरुआत में, हम Google Wallet से आईडी पाने के लिए, झलक दिखाने वाले प्रोटोकॉल का इस्तेमाल करेंगे. इससे, वेब एपीआई स्पेसिफ़िकेशन के फ़ाइनल होने के दौरान, इंटिग्रेशन और टेस्टिंग शुरू की जा सकती है.

झलक दिखाने वाले प्रोटोकॉल के लिए, mdoc requestJson का सैंपल यहां दिया गया है:

{
  identity: {
    providers: [{
      holder: {
        selector: {
          format: ['mdoc'],
          type: 'org.iso.18013.5.1.mDL',
          fields: [
            'org.iso.18013.5.1.family_name',
            'org.iso.18013.5.1.portrait',
          ]
        },
        params: {
          nonce: '1234',
          readerPublicKey: '<public_key>',
          extraParamAsNeededByWallets: true,
        },
      },
    }]
  }
}

// The request in the JSON format to conform with
// the JSON-ified Digital Credentials API request definition.
val requestJson = generateRequestFromServer()
val digitalCredentialOption =
    GetDigitalCredentialOption(requestJson = requestJson)

// Use the option from the previous step to build the `GetCredentialRequest`.
val getCredRequest = GetCredentialRequest(
    listOf(digitalCredentialOption)
)

coroutineScope.launch {
    try {
        val result = credentialManager.getCredential(
            context = activityContext,
            request = getCredRequest
        )
        verifyResult(result)
    } catch (e : GetCredentialException) {
        handleFailure(e)
    }
}

// Handle the successfully returned credential.
fun verifyResult(result: GetCredentialResponse) {
    val credential = result.credential
    when (credential) {
        is DigitalCredential -> {
            val responseJson = credential.credentialJson
            validateResponseOnServer(responseJson)
        }
        else -> {
            // Catch any unrecognized credential type here.
            Log.e(TAG, "Unexpected type of credential ${credential.type}")
        }
    }
}

// Handle failure.
fun handleFailure(e: GetCredentialException) {
  when (e) {
        is GetCredentialCancellationException -> {
            // The user intentionally canceled the operation and chose not
            // to share the credential.
        }
        is GetCredentialInterruptedException -> {
            // Retry-able error. Consider retrying the call.
        }
        is NoCredentialException -> {
            // No credential was available.
        }
        is CreateCredentialUnknownException -> {
            // An unknown, usually unexpected, error has occurred. Check the
            // message error for any additional debugging information.
        }
        is CreateCredentialCustomException -> {
            // You have encountered a custom error thrown by the wallet.
            // If you made 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}")
    }
}

रिस्पॉन्स में, W3C की ओर से तय की गई identityToken (JSON स्ट्रिंग) दिखती है. इस जवाब को तैयार करने की ज़िम्मेदारी Wallet ऐप्लिकेशन की है.

उदाहरण:

{
    "token": "<base64 encoded response>"
}

टोकन भेजना और सर्वर पर प्रोसेस करना

identityToken मिलने के बाद, आपके ऐप्लिकेशन को पुष्टि के लिए, उसे अपने ऐप्लिकेशन सर्वर पर भेजना चाहिए. पहले चरण में, टोकन को base64 फ़ॉर्मैट से डिकोड किया जाता है. इससे मिलने वाला बाइट कलेक्शन, CBOR डेटा दिखाता है. यह डेटा, नीचे दिए गए CDDL का पालन करता है.

CredentialDocument = {
  "version": tstr,       // Set to "ANDROID-HPKE-v1"
  "pkEm": bstr,          // Public key, in uncompressed form
  "cipherText": bstr     // The encrypted data
}

अगला चरण, Android के हिसाब से हैंडओवर स्ट्रक्चर का इस्तेमाल करके, ISO/IEC 18013-5:2021 से SessionTranscript का हिसाब लगाना है:

SessionTranscript = [
  null,                // DeviceEngagementBytes not available
  null,                // EReaderKeyBytes not available
  AndroidHandover      // Defined below
]

AndroidHandover = [
  "AndroidHandoverv1", // Version number
  nonce,               // nonce that comes from request
  appId,               // RP package name
  pkRHash,             // The SHA256 hash of the recipient public key
]

cipherText को HPKE एन्क्रिप्शन का इस्तेमाल करके एन्क्रिप्ट किया जाता है. इसे डिक्रिप्ट करने के लिए, पहले से जनरेट की गई ईसी निजी कुंजी के साथ-साथ, पुष्टि किए गए अतिरिक्त डेटा के तौर पर SessionTranscript का इस्तेमाल करें. साथ ही, इन सेटिंग का इस्तेमाल करें:

• केएम: DHKEM(P-256, HKDF-SHA256)
• केडीएफ़: HKDF-SHA256
• AEAD: AES-128-GCM

इससे मिलने वाला क्लियरटेक्स्ट, डिवाइस रिस्पॉन्स का CBOR बाइट होता है, जैसा कि ISO/IEC 18013-5:2021 में बताया गया है. DeviceResponse की पुष्टि, ISO/IEC 18013-5:2021 के क्लॉज़ 9 के मुताबिक की जानी चाहिए. इसमें कई चरण शामिल होते हैं. जैसे, यह पुष्टि करना कि एमडीओसी, भरोसेमंद जारीकर्ता से मिला है और रिस्पॉन्स पर, टारगेट किए गए डिवाइस से हस्ताक्षर किया गया है. पुष्टि करने की इस प्रोसेस के कुछ हिस्से के लिए, OpenWallet Foundation के आइडेंटिटी क्रेडेंशियल प्रोजेक्ट की DeviceResponseParser क्लास का इस्तेमाल किया जा सकता है.

वेब

Chrome पर Digital Credentials API का इस्तेमाल करके, पहचान की पुष्टि करने वाले क्रेडेंशियल का अनुरोध करने के लिए, आपको Digital Credentials API के ऑरिजिन ट्रायल के लिए साइन अप करना होगा.

आमने-सामने

Google Wallet से आईडी स्वीकार करने के लिए, यह तरीका अपनाएं:

• ISO 18013-5 के मुताबिक आईडी स्वीकार करने के लिए, रीडर बनाएं या खरीदें
• स्वीकार किए गए आईडी की पुष्टि करने के लिए, रीडर में IACA सर्टिफ़िकेट लोड करें
• अपने समाधान को टेस्ट करना
• Google Wallet के साथ अपना ऐप्लिकेशन रजिस्टर करना

ISO 18013-5 के मुताबिक आईडी स्वीकार करने के लिए, रीडर बनाएं या खरीदें

Wallet में आईडी, मोबाइल ड्राइविंग लाइसेंस के लिए ISO 18013-5 स्टैंडर्ड के मुताबिक लागू किए जाते हैं. ये डिवाइस, डेटा ट्रांसफ़र करने के लिए BLE के साथ-साथ एनएफ़सी या क्यूआर कोड का इस्तेमाल करते हैं. इसलिए, कोई भी डिवाइस जो स्टैंडर्ड के उन पहलुओं को लागू कर सकता है, वह रीडर के तौर पर काम कर सकता है. यहां तक कि मोबाइल ऐप्लिकेशन भी. यह स्टैंडर्ड ओपन है, इसलिए मार्केट में तीसरे पक्ष के कई लागू करने वाले उपलब्ध हैं. साथ ही, ज़रूरत पड़ने पर, सीधे तौर पर भी यह सुविधा लागू की जा सकती है.

इस सुविधा को खुद लागू करने के तरीके के बारे में जानने के लिए, हमारे ओपन सोर्स रेफ़रंस रीडर Android ऐप्लिकेशन देखें. यह ऐप्लिकेशन, ISO स्टैंडर्ड को लागू करता है और Google Wallet से एमडीएल स्वीकार कर सकता है.

रेफ़रंस रीडर ऐप्लिकेशन बनाकर और उसे चलाकर, इस सुविधा का इस्तेमाल शुरू किया जा सकता है:

• रेफ़रंस ऐप्लिकेशन के रिपॉज़िटरी को क्लोन करना
• Android Studio पर प्रोजेक्ट खोलें
• अपने Android डिवाइस या एमुलेटर पर appverifier टारगेट बनाएं और चलाएं.

स्वीकार किए गए आईडी की पुष्टि करने के लिए, रीडर में IACA सर्टिफ़िकेट लोड करें

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

• ऐरिज़ोना
• कैलिफ़ोर्निया
• कोलरैडो
• जॉर्जिया
• मैरीलैंड

अपने समाधान को टेस्ट करना

अपने समाधान की जांच करने के लिए, हमारे ओपन सोर्स रेफ़रंस होल्डर Android ऐप्लिकेशन बनाएं और चलाएं. रेफ़रंस होल्डर ऐप्लिकेशन बनाने और उसे चलाने का तरीका यहां बताया गया है:

• रेफ़रंस ऐप्लिकेशन के रिपॉज़िटरी को क्लोन करना
• Android Studio पर प्रोजेक्ट खोलें
• अपने Android डिवाइस या एमुलेटर पर appholder टारगेट बनाएं और चलाएं.

(ज़रूरी नहीं) Google Wallet पर अपना ऐप्लिकेशन रजिस्टर करना

इस फ़ॉर्म को भरकर, Google Wallet के साथ अपना ऐप्लिकेशन रजिस्टर करें.