डिजिटल क्रेडेंशियल को ऑनलाइन स्वीकार करना

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

  1. दिए गए निर्देशों का पालन करके, ऐप्लिकेशन या वेब का इस्तेमाल करके इंटिग्रेट करें.
  2. Google Wallet के सैंडबॉक्स का इस्तेमाल करके, अपने फ़्लो की जांच करने के लिए टेस्ट आईडी का इस्तेमाल करें.
  3. लाइव होने के लिए, ऐक्सेस का अनुरोध करने के लिए यह फ़ॉर्म भरें. साथ ही, Google Wallet क्रेडेंशियल की सेवा की शर्तें स्वीकार करें. आपको अपनी हर कारोबारी इकाई के लिए यह फ़ॉर्म भरना होगा. फ़ॉर्म भरने के बाद, हमारी टीम आपसे संपर्क करेगी.
  4. अगर आपका कोई सवाल है, तोwallet-identity-rp-support@google.com से संपर्क करें.

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

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

  1. mdocs - ISO के मुताबिक तय किया गया.
  2. w3c Verifiable Credentials - इन्हें w3c ने तय किया है.

Android Credential Manager, दोनों फ़ॉर्मैट के साथ काम करता है. हालांकि, फ़िलहाल Google Wallet सिर्फ़ एमडॉक पर आधारित डिजिटल आईडी के साथ काम करता है.

इन क्रेडेंशियल का इस्तेमाल किया जा सकता है

Google Wallet में दो तरह के क्रेडेंशियल इस्तेमाल किए जा सकते हैं:

  1. मोबाइल ड्राइविंग लाइसेंस (एमडीएल)
  2. आईडी पास

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

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

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

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

अहम जानकारी

  1. ऐप्लिकेशन या वेबसाइट के पास, एपीआई के एंट्री पॉइंट को बनाने के तरीके में बदलाव करने का विकल्प होता है. पहले चरण में दिखाए गए तरीके के मुताबिक, हमारा सुझाव है कि "डिजिटल आईडी से पुष्टि करें" जैसा सामान्य बटन दिखाया जाए. ऐसा इसलिए, क्योंकि हमें उम्मीद है कि आने वाले समय में, Google Wallet के अलावा अन्य विकल्पों को भी API के ज़रिए उपलब्ध कराया जाएगा.
  2. दूसरे चरण में दिखने वाली सिलेक्टर स्क्रीन, Android की मदद से रेंडर की जाती है. ज़रूरी क्रेडेंशियल का पता, हर Wallet के लिए उपलब्ध कराए गए रजिस्ट्रेशन लॉजिक और पुष्टि करने वाली पार्टी के भेजे गए अनुरोध के मिलान से चलता है.
  3. तीसरा चरण, Google Wallet की मदद से पूरा किया जाता है. Google Wallet, इस स्क्रीन पर डेवलपर की ओर से दिए गए नाम, लोगो, और निजता नीति को दिखाएगा.

डिजिटल आईडी फ़्लो जोड़ना

अगर उपयोगकर्ता के पास क्रेडेंशियल नहीं है, तो हमारा सुझाव है कि "डिजिटल आईडी से पुष्टि करें" बटन के बगल में एक लिंक दें. यह लिंक, Google Wallet पर डीप-लिंक करेगा, ताकि उपयोगकर्ता डिजिटल आईडी जोड़ सके.

उपयोगकर्ता को ऐप्लिकेशन या वेबसाइट पर उम्र की पुष्टि करने के लिए कहा गया उपयोगकर्ता को डिजिटल आईडी पाने के लिए Google Wallet पर ले जाया जाता है
उपयोगकर्ता को ऐप्लिकेशन या वेबसाइट पर उम्र की पुष्टि करने के लिए कहा गया उपयोगकर्ता को डिजिटल आईडी पाने के लिए Google Wallet पर ले जाया जाता है

कोई डिजिटल आईडी उपलब्ध नहीं है

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

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

यह एपीआई, उपयोगकर्ता की निजता बनाए रखने के लिए, यह पता लगाने की सुविधा के साथ काम नहीं करता कि उपयोगकर्ता के पास कोई डिजिटल आईडी उपलब्ध है या नहीं. इसलिए, हमारा सुझाव है कि आप ऑनबोर्डिंग लिंक का विकल्प शामिल करें.

वॉलेट से आईडी क्रेडेंशियल का अनुरोध करने के लिए फ़ॉर्मैट

यहां Android डिवाइस या वेब पर किसी भी वॉलेट से पहचान के क्रेडेंशियल पाने के लिए, एमडॉक requestJson के अनुरोध का एक सैंपल दिया गया है.

{
      "requests" : [
        {
          "protocol": "openid4vp-v1-unsigned", // openid4vp-v1-signed for signed request.
          "data": {<credential_request>} // This is an object, shouldn't be a string.
        }
      ]
}

एन्क्रिप्ट (सुरक्षित) करने का अनुरोध करना

client_metadata में, हर अनुरोध के लिए एन्क्रिप्शन की सार्वजनिक कुंजी होती है. आपको हर अनुरोध के लिए निजी कुंजियां सेव करनी होंगी. साथ ही, उनका इस्तेमाल Wallet ऐप्लिकेशन से मिले टोकन की पुष्टि करने और उसे अनुमति देने के लिए करना होगा.

requestJson में मौजूद credential_request पैरामीटर में ये फ़ील्ड शामिल होते हैं.

खास क्रेडेंशियल

{
  "response_type": "vp_token",
  "response_mode": "dc_api.jwt", // change this to dc_api if you want to demo with a non encrypted response.
  "nonce": "1234",
  "dcql_query": {
    "credentials": [
      {
        "id": "cred1",
        "format": "mso_mdoc",
        "meta": {
          "doctype_value": "org.iso.18013.5.1.mDL"  // this is for mDL. Use com.google.wallet.idcard.1 for ID pass
        },
        "claims": [
          {
            "path": [
              "org.iso.18013.5.1",
              "family_name"
            ],
            "intent_to_retain": false // set this to true if you are saving the value of the field
          },
          {
            "path": [
              "org.iso.18013.5.1",
              "given_name"
            ],
            "intent_to_retain": false
          },
          {
            "path": [
              "org.iso.18013.5.1",
              "age_over_18"
            ],
            "intent_to_retain": false
          }
        ]
      }
    ]
  },
  "client_metadata": {
    "jwks": {
      "keys": [ // sample request encryption key
        {
          "kty": "EC",
          "crv": "P-256",
          "x": "pDe667JupOe9pXc8xQyf_H03jsQu24r5qXI25x_n1Zs",
          "y": "w-g0OrRBN7WFLX3zsngfCWD3zfor5-NLHxJPmzsSvqQ",
          "use": "enc",
          "kid" : "1",  // This is required
          "alg" : "ECDH-ES",  // This is required
        }
      ]
    },
    "vp_formats_supported": {
      "mso_mdoc": {
        "deviceauth_alg_values": [
          -7
        ],
        "isserauth_alg_values": [
          -7
        ]
      }
    }
  }
}

ज़रूरी शर्तें पूरी करने वाला कोई भी क्रेडेंशियल

यहां mDL और आईडी पास, दोनों के लिए अनुरोध का उदाहरण दिया गया है. उपयोगकर्ता इनमें से किसी एक तरीके का इस्तेमाल करके आगे बढ़ सकता है.

{
  "response_type": "vp_token",
  "response_mode": "dc_api.jwt", // change this to dc_api if you want to demo with a non encrypted response.
  "nonce": "1234",
  "dcql_query": {
    "credentials": [
      {
        "id": "mdl-request",
        "format": "mso_mdoc",
        "meta": {
          "doctype_value": "org.iso.18013.5.1.mDL"
        },
        "claims": [
          {
            "path": [
              "org.iso.18013.5.1",
              "family_name"
            ],
            "intent_to_retain": false // set this to true if you are saving the value of the field
          },
          {
            "path": [
              "org.iso.18013.5.1",
              "given_name"
            ],
            "intent_to_retain": false
          },
          {
            "path": [
              "org.iso.18013.5.1",
              "age_over_18"
            ],
            "intent_to_retain": false
          }
        ]
      },
      {  // Credential type 2
        "id": "id_pass-request",
        "format": "mso_mdoc",
        "meta": {
          "doctype_value": "com.google.wallet.idcard.1"
        },
        "claims": [
          {
            "path": [
              "org.iso.18013.5.1",
              "family_name"
            ],
            "intent_to_retain": false // set this to true if you are saving the value of the field
          },
          {
            "path": [
              "org.iso.18013.5.1",
              "given_name"
            ],
            "intent_to_retain": false
          },
          {
            "path": [
              "org.iso.18013.5.1",
              "age_over_18"
            ],
            "intent_to_retain": false
          }
        ]
      }
    ]
    credential_sets : [
      {
        "options": [
          [ "mdl-request" ],
          [ "id_pass-request" ]
        ]
      }
    ]
  },
  "client_metadata": {
    "jwks": {
      "keys": [ // sample request encryption key
        {
          "kty": "EC",
          "crv": "P-256",
          "x": "pDe667JupOe9pXc8xQyf_H03jsQu24r5qXI25x_n1Zs",
          "y": "w-g0OrRBN7WFLX3zsngfCWD3zfor5-NLHxJPmzsSvqQ",
          "use": "enc",
          "kid" : "1",  // This is required
          "alg" : "ECDH-ES",  // This is required
        }
      ]
    },
    "vp_formats_supported": {
      "mso_mdoc": {
        "deviceauth_alg_values": [
          -7
        ],
        "isserauth_alg_values": [
          -7
        ]
      }
    }
  }
}

Google Wallet में सेव किए गए किसी भी पहचान पत्र से, इस्तेमाल किए जा सकने वाले किसी भी एट्रिब्यूट के लिए अनुरोध किया जा सकता है.

हस्ताक्षर किए गए अनुरोध

सुरक्षा को बेहतर बनाने और पुष्टि करने के अनुरोधों की अखंडता को बनाए रखने के लिए, आपको हस्ताक्षर किए गए अनुरोधों को लागू करना चाहिए. इन्हें JWT Secured Authorization Requests या JAR भी कहा जाता है. ज़्यादा जानकारी के लिए, openID4VP का दस्तावेज़ देखें.

बिना हस्ताक्षर वाले अनुरोधों में पैरामीटर को रॉ JSON के तौर पर भेजा जाता है. हालांकि, हस्ताक्षर वाले अनुरोध में, पुष्टि की जा सकने वाली आपकी प्रज़ेंटेशन के अनुरोध को क्रिप्टोग्राफ़िक तौर पर हस्ताक्षर किए गए JSON Web Token (JWT) में शामिल किया जाता है. इससे दो मुख्य फ़ायदे मिलते हैं:

  1. इंटीग्रिटी: इससे यह पक्का किया जाता है कि अनुरोध में कोई छेड़छाड़ नहीं की गई है.
  2. पुष्टि करने के अन्य तरीके (x509 पीकेआई): इससे Google Wallet को यह पता चलता है कि अनुरोध, पुष्टि करने वाले ऐसे व्यक्ति या कंपनी ने किया है जिसके पास Google Wallet में रजिस्टर की गई खास सार्वजनिक कुंजी है.

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

हस्ताक्षर किए गए अनुरोध के लिए कोड में बदलाव लागू करने से पहले, पक्का करें कि आपके पास ये चीज़ें हों:

  • निजी पासकोड: आपको एक निजी पासकोड की ज़रूरत होगी. उदाहरण के लिए, आपके सर्वर पर मैनेज किए जाने वाले अनुरोध पर हस्ताक्षर करने के लिए, Elliptic Curve ES256 या RSA) का इस्तेमाल किया जाता है.
  • सर्टिफ़िकेट: आपको अपने पासकोड पेयर से मिला एक स्टैंडर्ड X.509 सर्टिफ़िकेट चाहिए.
  • रजिस्ट्रेशन: पक्का करें कि आपका सार्वजनिक सर्टिफ़िकेट, Google Wallet में रजिस्टर हो. wallet-identity-rp-support@google.com पर हमारी सहायता टीम से संपर्क करें

अनुरोध बनाने का लॉजिक अपडेट करना

मुख्य बदलाव में, आपकी निजी कुंजी का इस्तेमाल करना और पेलोड को JWS में रैप करना शामिल है.

def construct_openid4vp_request(
    doctypes: list[str],
    requested_fields: list[dict],
    nonce_base64: str,
    jwe_encryption_public_jwk: jwk.JWK,
    is_zkp_request: bool,
    is_signed_request: bool,
    state: dict,
    origin: str
) -> dict:

    # ... [Existing logic to build 'presentation_definition' and basic 'request_payload'] ...

    # ------------------------------------------------------------------
    # SIGNED REQUEST IMPLEMENTATION (JAR)
    # ------------------------------------------------------------------
    if is_signed_request:
        try:
            # 1. Load the Verifier's Certificate
            # We must load the PEM string into a cryptography x509 object
            verifier_cert_obj = x509.load_pem_x509_certificate(
                CERTIFICATE.encode('utf-8'),
                backend=default_backend()
            )

            # 2. Calculate Client ID (x509_hash)
            # We calculate the SHA-256 hash of the DER-encoded certificate.
            cert_der = verifier_cert_obj.public_bytes(serialization.Encoding.DER)
            verifier_fingerprint_bytes = hashlib.sha256(cert_der).digest()

            # Create a URL-safe Base64 hash (removing padding '=')
            verifier_fingerprint_b64 = base64.urlsafe_b64encode(verifier_fingerprint_bytes).decode('utf-8').rstrip("=")

            # Format the client_id as required by the spec
            client_id = f'x509_hash:{verifier_fingerprint_b64}'

            # 3. Update Request Payload with JAR specific fields
            request_payload["client_id"] = client_id

            # Explicitly set expected origins to prevent relay attacks
            if origin:
                request_payload["expected_origins"] = [origin]

            # 4. Create Signed JWT (JWS)
            # Load the signing private key
            signing_key = jwk.JWK.from_pem(PRIVATE_KEY.encode('utf-8'))

            # Initialize JWS with the JSON payload
            jws_token = jws.JWS(json.dumps(request_payload).encode('utf-8'))

            # Construct the JOSE Header
            # 'x5c' (X.509 Certificate Chain) is critical: it allows the wallet
            # to validate your key against the one registered in the console.
            x5c_value = base64.b64encode(cert_der).decode('utf-8')

            protected_header = {
                "alg": "ES256",                 # Algorithm (e.g., ES256 or RS256)
                "typ": "oauth-authz-req+jwt",   # Standard type for JAR
                "kid": "1",                     # Key ID
                "x5c": [x5c_value]              # Embed the certificate
            }

            # Sign the token
            jws_token.add_signature(
                key=signing_key,
                alg=None,
                protected=json_encode(protected_header)
            )

            # 5. Return the Request Object
            # Instead of returning the raw JSON, we return the signed JWT string
            # under the 'request' key.
            return {"request": jws_token.serialize(compact=True)}

        except Exception as e:
            print(f"Error signing OpenID4VP request: {e}")
            return None

    # ... [Fallback for unsigned requests] ...
    return request_payload

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

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

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

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

dependencies {
    implementation("androidx.credentials:credentials:1.5.0-beta01")
    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 स्ट्रिंग को पार्स करना. - यह तय करना कि सेव किए गए क्रेडेंशियल में से कौनसे क्रेडेंशियल, अनुरोध को पूरा करते हैं.

हमारा सुझाव है कि पार्टनर, Android ऐप्लिकेशन इंटिग्रेशन के लिए भी सर्वर पर अनुरोध बनाएं.

GetDigitalCredentialOption() फ़ंक्शन कॉल में, अनुरोध फ़ॉर्मैट के requestJson का इस्तेमाल request के तौर पर किया जाएगा.

// 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)
    }
}

जवाब की पुष्टि करना

वॉलेट से जवाब मिलने के बाद, आपको यह पुष्टि करनी होगी कि जवाब सही है और इसमें credentialJson जवाब शामिल है.

// Handle the successfully returned credential.
fun verifyResult(result: GetCredentialResponse) {
    val credential = result.credential
    when (credential) {
        is DigitalCredential -> {
            val responseJson = credential.credentialJson
            validateResponseOnServer(responseJson) // make a server call to validate the response
        }
        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.
        }
        else -> Log.w(TAG, "Unexpected exception type ${e::class.java}")
    }
}

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

उदाहरण:

{
  "protocol" : "openid4vp-v1-unsigned",
  "data" : {
    <encrpted_response>
  }
}

आपको इस जवाब को वापस सर्वर पर भेजना होगा, ताकि यह पुष्टि की जा सके कि यह जवाब असली है. क्रेडेंशियल के जवाब की पुष्टि करने का तरीका जानें.

वेब

Chrome या अन्य ऐसे ब्राउज़र पर Digital Credentials API का इस्तेमाल करके, पहचान से जुड़े क्रेडेंशियल का अनुरोध करने के लिए, यह अनुरोध करें.

const credentialResponse = await navigator.credentials.get({
          digital : {
          requests : [
            {
              protocol: "openid4vp-v1-unsigned",
              data: {<credential_request>} // This is an object, shouldn't be a string.
            }
          ]
        }
      })

इस एपीआई से मिले जवाब को वापस अपने सर्वर पर भेजें, ताकि क्रेडेंशियल के जवाब की पुष्टि की जा सके

क्रेडेंशियल के जवाब की पुष्टि करने का तरीका

आपके ऐप्लिकेशन या वेबसाइट से एन्क्रिप्ट (सुरक्षित) किया गया identityToken मिलने पर, आपको जवाब पर भरोसा करने से पहले कई तरह की पुष्टि करनी होगी.

  1. निजी पासकोड का इस्तेमाल करके जवाब को डिक्रिप्ट करना

    पहला चरण, सेव की गई निजी कुंजी का इस्तेमाल करके टोकन को डिक्रिप्ट करना और JSON फ़ॉर्मैट में जवाब पाना है.

    Python का उदाहरण:

    from jwcrypto import jwe, jwk

# Retrieve the Private Key from Datastore
reader_private_jwk = jwk.JWK.from_json(jwe_private_key_json_str)
# Save public key thumbprint for session transcript
encryption_public_jwk_thumbprint = reader_private_jwk.thumbprint()

# Decrypt the JWE encrypted response from Google Wallet
jwe_object = jwe.JWE()
jwe_object.deserialize(encrypted_jwe_response_from_wallet)
jwe_object.decrypt(reader_private_jwk)
decrypted_payload_bytes = jwe_object.payload
decrypted_data = json.loads(decrypted_payload_bytes)

    decrypted_data से, क्रेडेंशियल की जानकारी देने वाला vp_token JSON मिलेगा

    {
  "vp_token":
  {
    "cred1": ["<base64UrlNoPadding_encoded_credential>"] // This applies to OpenID4VP 1.0 spec.
  }
}

  2. सेशन की ट्रांसक्रिप्ट बनाना

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

    SessionTranscript = [
  null,                // DeviceEngagementBytes not available
  null,                // EReaderKeyBytes not available
  [
    "OpenID4VPDCAPIHandover",
    AndroidHandoverDataBytes   // BrowserHandoverDataBytes for Web
  ]
]

    Android और वेब, दोनों के लिए हैंडओवर करते समय, आपको उसी नॉनस का इस्तेमाल करना होगा जिसका इस्तेमाल आपने credential_request जनरेट करने के लिए किया था.

    Android हैंडओवर

        AndroidHandoverData = [
      origin,             // "android:apk-key-hash:<base64SHA256_ofAppSigningCert>",
      nonce,           // nonce that was used to generate credential request,
      encryption_public_jwk_thumbprint,  // Encryption public key (JWK) Thumbprint
    ]

    AndroidHandoverDataBytes = hashlib.sha256(cbor2.dumps(AndroidHandoverData)).digest()

    ब्राउज़र हैंडओवर

        BrowserHandoverData =[
      origin,               // Origin URL
      nonce,               //  nonce that was used to generate credential request
      encryption_public_jwk_thumbprint,  // Encryption public key (JWK) Thumbprint
    ]

    BrowserHandoverDataBytes = hashlib.sha256(cbor2.dumps(BrowserHandoverData)).digest()

    SessionTranscript का इस्तेमाल करके, DeviceResponse की पुष्टि ISO/IEC 18013-5:2021 के क्लॉज़ 9 के मुताबिक की जानी चाहिए. इसमें कई चरण शामिल हैं, जैसे:

  3. स्टेट इश्यूअर सर्टिफ़िकेट देखें. इस तरह की सेवा देने वाले बैंक/वित्तीय संस्थान के IACA सर्टिफ़िकेट देखें.

  4. एमएसओ के हस्ताक्षर की पुष्टि करना (18013-5 सेक्शन 9.1.2)

  5. डेटा एलिमेंट के लिए ValueDigests का हिसाब लगाना और उनकी जांच करना (18013-5 सेक्शन 9.1.2)

  6. deviceSignature के हस्ताक्षर की पुष्टि करना (18013-5 सेक्शन 9.1.3)

{
  "version": "1.0",
  "documents": [
    {
      "docType": "org.iso.18013.5.1.mDL",
      "issuerSigned": {
        "nameSpaces": {...}, // contains data elements
        "issuerAuth": [...]  // COSE_Sign1 w/ issuer PK, mso + sig
      },
      "deviceSigned": {
        "nameSpaces": 24(<< {} >>), // empty
        "deviceAuth": {
          "deviceSignature": [...] // COSE_Sign1 w/ device signature
        }
      }
    }
  ],
  "status": 0
}

अपना समाधान तैयार करना

अपना समाधान बनाने के लिए, GitHub पर पहचान की पुष्टि करने वालों के लिए उपलब्ध रेफ़रंस इंप्लीमेंटेशन देखें

ज़ीरो नॉलेज प्रूफ़ (जेडकेपी) के आधार पर पुष्टि करना

ज़ीरो-नॉलेज प्रूफ़ (जेडकेपी) एक क्रिप्टोग्राफ़िक तरीका है. इससे कोई व्यक्ति (प्रूवर), पुष्टि करने वाले व्यक्ति को यह साबित कर सकता है कि उसके पास पहचान से जुड़ी कोई जानकारी है या वह किसी खास शर्त को पूरा करता है. जैसे, उसकी उम्र 18 साल से ज़्यादा है या उसके पास मान्य क्रेडेंशियल है. हालांकि, इसमें असल डेटा का खुलासा नहीं किया जाता. असल में, यह किसी व्यक्ति की पहचान के बारे में दिए गए बयान की पुष्टि करने का एक तरीका है. इस दौरान, संवेदनशील जानकारी को निजी रखा जाता है.

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

डिजिटल पहचान में ZKP के मुख्य सिद्धांत:

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

ज़ीरो-नॉलेज प्रूफ़ की मुख्य प्रॉपर्टी:

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

Google Wallet से ज़ीरो नॉलेज प्रूफ़ वापस पाने के लिए, आपको अनुरोध का फ़ॉर्मैट बदलकर mso_mdoc_zk करना होगा. साथ ही, अपने अनुरोध में zk_system_type जोड़ना होगा

  ...
  "dcql_query": {
    "credentials": [{
      "id": "cred1",
      "format": "mso_mdoc_zk",
      "meta": {
        "doctype_value": "org.iso.18013.5.1.mDL"
        "zk_system_type": [
        {
          "system": "longfellow-libzk-v1",
          "circuit_hash": "f88a39e561ec0be02bb3dfe38fb609ad154e98decbbe632887d850fc612fea6f", // This will differ if you need more than 1 attribute.
          "num_attributes": 1, // number of attributes (in claims) this has can support
          "version": 5,
          "block_enc_hash": 4096,
          "block_enc_sig": 2945,
        }
        {
          "system": "longfellow-libzk-v1",
          "circuit_hash": "137e5a75ce72735a37c8a72da1a8a0a5df8d13365c2ae3d2c2bd6a0e7197c7c6", // This will differ if you need more than 1 attribute.
          "num_attributes": 1, // number of attributes (in claims) this has can support
          "version": 6,
          "block_enc_hash": 4096,
          "block_enc_sig": 2945,
        }
       ],
       "verifier_message": "challenge"
      },
     "claims": [{
         ...
      "client_metadata": {
        "jwks": {
          "keys": [ // sample request encryption key
            {
              ...

आपको वॉलेट से, एन्क्रिप्ट (सुरक्षित) किया गया ज़ीरो नॉलेज प्रूफ़ वापस मिलेगा. Google की longfellow-zk लाइब्रेरी का इस्तेमाल करके, इस सबूत की पुष्टि की जा सकती है. इसके लिए, आपको IACA सर्टिफ़िकेट जारी करने वालों के ख़िलाफ़ इसकी पुष्टि करनी होगी.

verifier-service में, डिप्लॉयमेंट के लिए तैयार, Docker पर आधारित सर्वर होता है. इससे, कुछ जारीकर्ता IACA सर्टिफ़िकेट के ख़िलाफ़ जवाब की पुष्टि की जा सकती है.

आपको जिन IACA जारी करने वाले सर्टिफ़िकेट पर भरोसा करना है उन्हें मैनेज करने के लिए, certs.pem में बदलाव किया जा सकता है.

ज़्यादा जानकारी के लिए, सहायता टीम से इस ईमेल पते पर संपर्क करें: wallet-identity-rp-support@google.com