3. adım: Güvenen taraf olarak entegre edin

Bu kılavuzda, Doğrudan Güvenen Tarafların (RP'ler) (bireysel satıcılar, işletmeler ve uygulama geliştiriciler) Android uygulamaları ve web'de dijital kimlik bilgileri istemek ve doğrulamak için Digital Credentials API'yi nasıl entegre ettiği açıklanmaktadır.

Başlat

Yolunuzu seçin RP, Doğrulayıcı Kayıt Sorumlusu veya Yüz Yüze

1
Korumalı alanı ayarlama Hesabı izin verilenler listesine ekleme ve cihazı değiştirme
2
Test kimliği oluşturma Cüzdan'a test dijital kimlik ekleme
3Burada
Entegre edin Kendi yolunuzu oluşturun:
Güvenen Taraf✓ Doğrulayıcı Kayıt Sorumlusu→
4
Entegrasyonu test etme Uçtan uca yapılacaklar listesini çalıştırma ve video kaydetme
5
Canlı kullanıma geçme Kendi yolunuzu seçerek başlayın:
Relying Party→ Verifier Registrar→

Güvenen taraf entegrasyonunun işleyiş şekli

Her Güvenen Taraf entegrasyonu dört adımdan oluşur. A ve C adımları sunucunuzda çalışır; B adımı Android uygulamanızda veya tarayıcınızda çalışır. Uygulama ayrıntılarına gitmek için herhangi bir adımı seçin:

A İsteği biçimlendirme ve imzalamaSunucu: OpenID4VP JSON oluşturma ve JWS imzalama B API'yi tetiklemeİstemci: Kimlik Bilgisi Yöneticisi'ni veya Web API'yi çağırma C Şifre çözme ve doğrulamaSunucu: JWE şifresini çözme ve IACA zincirini kontrol etme D ZKP ekleme (isteğe bağlı)Sıfır bilgi kanıtları ile yaş doğrulama

Üretim kimlik bilgilerini istemeden önce korumalı alanda derleme ve test yapma

A-D adımlarını uygularken Google'ın önceden güvenilen korumalı alan öğelerini kullanarak hemen derleme ve test yapabilirsiniz:

İstek imzalama

Google'ın Korumalı Alan Test Anahtarları ve Meta Verileri'ni kullanarak OpenID4VP isteklerini imzalayın.

Test Kimlik Bilgisi

Utopia Test ID Pass ile korumalı alan modundaki bir Android cihazda test edin.

Yanıt Doğrulama

issuerAuth değerini Utopia Sandbox sertifikasına göre doğrulayın.

Online doğrulama için arka uç sunucunuz, istemci uygulamanız veya tarayıcınız ile Google Cüzdan arasındaki uçtan uca sıra

Desteklenen biçimler, kimlik bilgileri ve özellikler

Google Cüzdan, Android 9 (API düzeyi 28) ve sonraki sürümlerde ve desteklenen tarayıcılarda OpenID4VP (Sürüm 1.0) üzerinden ISO mdoc tabanlı dijital kimlikleri destekler.

Desteklenen Kimlik Bilgileri ve Özellikler

Google Cüzdan'dan talep edebileceğiniz doctype_value tanımlayıcıları (mDL, dijital kimlik, fotoğraflı kimlik) ve özellik talep yollarını inceleyin.

Desteklenen Kart Sağlayıcı Kuruluşlar ve IACA Sertifikaları

issuerAuth doğrulaması için ABD eyaletleri, uluslararası yayıncılar ve Sandbox Utopia yayıncısı için resmi IACA kök sertifikalarını indirin.

A Adımı: İsteği Biçimlendirme ve İmzalama (Sunucu Tarafı)

Herhangi bir cüzdandan kimlik bilgisi istemek için sunucunuzda OpenID4VP kullanarak isteğinizi biçimlendirmeniz gerekir. Tek bir dcql_query nesnesinde belirli bir kimlik bilgisi veya birden fazla kimlik bilgisi isteyebilirsiniz.

JSON isteği örneği

Android cihazdaki veya web'deki herhangi bir cüzdandan kimlik bilgilerini almak için gönderilen mdoc requestJson isteği örneğini aşağıda bulabilirsiniz.

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

Şifreleme isteğinde bulunma

client_metadata, her istek için şifreleme ortak anahtarını içerir. Her istek için özel anahtarları saklamanız ve bunları, cüzdan uygulamasından aldığınız jetonun kimliğini doğrulamak ve yetkilendirmek için kullanmanız gerekir.

Entegre OpenID4VP Meta Verileri

Kimlik bilgisi isteğinizi biçimlendirirken client_metadata nesnesinin içine gw_rp_metadata_bytes alanını eklemeniz gerekir (aşağıdaki örnek istek kodunda gösterildiği gibi). Bu alan, Google Cüzdan'ın kimliğinizi doğrulamak ve markanızı kullanıcıya göstermek için ihtiyaç duyduğu Base64URL ile kodlanmış, güvenen taraf meta verilerini içerir.

Kimlik Bilgisi İstek Yükü

requestJson içindeki credential_request parametresi aşağıdaki alanları içerir.

Belirli Kimlik Bilgisi

{
  "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": {
          // Use org.iso.18013.5.1.mDL for mDL,
          // com.google.wallet.idcard.1 for ID pass, or
          // org.iso.23220.photoid.1 for ID pass (using photo ID document type)
          "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
          }
        ]
      }
    ]
  },
  "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
        ],
        "issuerauth_alg_values": [
          -7
        ]
      }
    },
    "gw_rp_metadata_bytes": "<base64url encoded metadata string>"
  }
}

Uygun Kimlik Bilgileri

mDL, dijital kimlik ve dijital kimlik (fotoğraflı kimlik belgesi türü kullanılarak) için örnek istek aşağıda verilmiştir. Kullanıcı ikisinden biriyle devam edebilir.

{
  "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 pass
        "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 type 3: ID pass (using photo ID document type)
        "id": "photo_id-request",
        "format": "mso_mdoc",
        "meta": {
          "doctype_value": "org.iso.23220.photoid.1"
        },
        "claims": [
          {
            "path": [
              "org.iso.23220.1",
              "family_name"
            ],
            "intent_to_retain": false // set this to true if you are saving the value of the field
          },
          {
            "path": [
              "org.iso.23220.1",
              "given_name"
            ],
            "intent_to_retain": false
          },
          {
            "path": [
              "org.iso.23220.1",
              "age_over_18"
            ],
            "intent_to_retain": false
          }
        ]
      }
    ]
    credential_sets : [
      {
        "options": [
          [ "mdl-request" ],
          [ "id_pass-request" ],
          [ "photo_id-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
        ],
        "issuerauth_alg_values": [
          -7
        ]
      }
    },
    "gw_rp_metadata_bytes": "<base64url encoded metadata string>"
  }
}

Google Cüzdan'da saklanan herhangi bir kimlik bilgisinden dilediğiniz sayıda desteklenen özellik isteyebilirsiniz.

İmzalı İstekler

İmzalı İstekler (JWT Güvenli Yetkilendirme İstekleri), doğrulanabilir sunum isteğinizi PKI altyapınızı kullanarak kriptografik olarak imzalanmış bir JSON Web Token (JWT) içinde kapsüller. Bu sayede istek bütünlüğü sağlanır ve kimliğiniz Google Cüzdan'a kanıtlanır.

Ön koşullar

İmzalı istekler için kod değişikliklerini uygulamadan önce aşağıdakileri yaptığınızdan emin olun:

  • Özel Anahtar: Sunucunuzda yönetilen isteği imzalamak için özel bir anahtara (ör. Eliptik Eğri ES256) ihtiyacınız vardır. Temel Alan Taraf olarak korumalı alan testi için Korumalı Alan Testi Özel Anahtarı'nı kullanın.
  • Sertifika: Anahtar çiftinizden türetilen standart bir X.509 sertifikasına ihtiyacınız vardır.
  • Kayıt: Herkese açık sertifikanızın (veya Doğrulayıcı Kayıt Şirketleri için Kök CA) Google Cüzdan tarafından güvenilir olarak kabul edildiğinden emin olun.

İstek Oluşturma Mantığı

OpenID4VP isteğinizi oluşturup imzalarken her alan için beklenen kodlama biçimine dikkat edin. base64 ve base64url veya dolgu (=) karıştırılırsa imza ya da kaynak doğrulama başarısız olur:

Alan Gerekli Kodlama / Biçim Karakterler ve Dolgu
client_id (x509_hash:<hash>) Dolgusuz base64url URL için güvenli alfabeyi (-, _) kullanır; sondaki = karakterini kaldırır.
expected_origins (android:apk-key-hash:<hash>) Dolgu olmadan standart base64 Standart alfabeyi (+, /) kullanır; sondaki = karakterini kaldırır.
expected_origins (https://...) Sonda eğik çizgi içermeyen küçük harfli URL Örnek: https://example.com (Sonda / yok)
x5c JWS başlığı Dolgulu standart base64 Standart alfabeyi (+, /) kullanır; sondaki = dolgusunu korur

İstek oluşturmak için özel anahtarınızı kullanın ve yükü bir JWS'ye sarmalayın:

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()

            # Important: Use URL-safe Base64 (base64url: '-', '_') without padding ('=') for client_id
            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
            # Important: Use standard Base64 (not URL-safe) without padding for android:apk-key-hash:
            # origin = f"android:apk-key-hash:{base64.b64encode(apk_cert_hash).decode('utf-8').rstrip('=')}"
            # Format for web origin (lowercase URL without trailing slash): origin = "https://example.com"
            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.
            # Important: Use standard Base64 ('+', '/') WITH padding ('=') for x5c
            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

B adımı: API'yi tetikleme (istemci tarafı)

API isteğinin tamamı sunucu tarafında oluşturulmalıdır. Platforma bağlı olarak, oluşturulan JSON'u platform API'lerine iletin.

Uygulama içi (Android)

Android uygulamalarınızdan kimlik bilgileri istemek için aşağıdaki adımları uygulayın:

Bağımlılıkları güncelleme

Projenizin build.gradle dosyasında, bağımlılıklarınızı Kimlik Bilgisi Yöneticisi'ni (beta) kullanacak şekilde güncelleyin:

dependencies {
    implementation("androidx.credentials:credentials:1.5.0-beta01")
    implementation("androidx.credentials:credentials-play-services-auth:1.5.0-beta01")
}

Kimlik Bilgisi Yöneticisi'ni yapılandırma

Bir CredentialManager nesnesini yapılandırmak ve ilk kullanıma hazırlamak için aşağıdakine benzer bir mantık ekleyin:

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

Kimlik özellikleri isteğinde bulunma

Uygulama, kimlik istekleri için ayrı ayrı parametreler belirtmek yerine, bunları CredentialOption içinde bir JSON dizesi olarak bir arada sağlar. Kimlik Bilgisi Yöneticisi, bu JSON dizesini içeriğini incelemeden mevcut dijital cüzdanlara iletir. Her cüzdan şunlardan sorumludur:

  • Kimlik isteğini anlamak için JSON dizesini ayrıştırma.
  • Saklanan kimlik bilgilerinden hangilerinin (varsa) isteği karşıladığını belirleme.

İş ortaklarının, Android uygulama entegrasyonları için bile isteklerini sunucuda oluşturmalarını öneririz.

GetDigitalCredentialOption() işlev çağrısında request olarak İsteği Biçimlendirme ve İmzalama bölümündeki requestJson değerini kullanacaksınız.

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

Kimlik bilgisi yanıtını işleme

Cüzdandan yanıt aldıktan sonra yanıtın başarılı olup olmadığını ve credentialJson yanıtını içerip içermediğini doğrulayın:

// 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 yanıtı, W3C tarafından tanımlanan şifrelenmiş bir identityToken (JWT) içerir. Bu yanıtı oluşturmaktan Cüzdan uygulaması sorumludur.

Örnek:

{
  "protocol" : "openid4vp-v1-signed",
  "data" : {
    <encrypted_response>
  }
}

Güvenilirliğini doğrulamak için bu yanıtı sunucunuza geri iletin. Yanıtın şifresini çözme ve yanıtı doğrulama bölümüne bakın.

Web

Chrome'da veya desteklenen diğer tarayıcılarda Dijital Kimlik Bilgileri API'sini kullanarak kimlik bilgileri istemek için aşağıdaki isteği gönderin:

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

Kimlik bilgisi yanıtını doğrulamak için bu API'den gelen yanıtı sunucunuza geri gönderin.

C Adımı: Yanıtın Şifresini Çözme ve Doğrulama (Sunucu Tarafı)

Cüzdan, şifrelenmiş identityToken (JWT) döndürdükten sonra verilere güvenmeden önce sunucu tarafı doğrulama yapmanız gerekir.

Yanıtın şifresini çözme

JWE'nin şifresini çözmek için isteğin client_metadata parametresinde gönderilen ortak anahtara karşılık gelen özel anahtarı kullanın. Bu, vp_token ile sonuçlanır.

Python örneği:

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, kimlik bilgilerini içeren bir vp_token JSON dosyası oluşturur:

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

SessionTranscript'i yeniden oluşturma ve DeviceResponse'u doğrulama

  1. Android veya web'e özel bir aktarım yapısıyla ISO/IEC 18013-5:2021'den SessionTranscript oluşturun:
SessionTranscript = [
  null,                // DeviceEngagementBytes not available
  null,                // EReaderKeyBytes not available
  [
    "OpenID4VPDCAPIHandover",
    AndroidHandoverDataBytes   // BrowserHandoverDataBytes for Web
  ]
]

Hem Android hem de web aktarımları için credential_request oluşturmak üzere kullandığınız nonce değerini kullanın.

Android Handover

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()

Tarayıcı Devri

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 kullanılarak Cihaz Yanıtı, ISO/IEC 18013-5:2021 madde 9'a göre doğrulanmalıdır.

Bu doğrulama dört kontrol içerir:

  1. Veren sertifikasını kontrol edin: Verenin imzalama sertifikası zincirini issuerAuth adresinden çıkarın ve güvenilir IACA kök sertifikalarına göre doğrulayın. Desteklenen Verenler ve IACA Sertifikaları bölümüne bakın (ve korumalı alan test kimliğiyle test ederken Utopia Korumalı Alan sertifikasını ekleyin).
  2. MSO imzasını doğrulama (ISO/IEC 18013-5 Bölüm 9.1.2).
  3. Veri Öğeleri için ValueDigests hesaplayın ve kontrol edin (ISO/IEC 18013-5 Bölüm 9.1.2).
  4. deviceSignature imzasını doğrulayın (ISO/IEC 18013-5 Bölüm 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
}

D adımı (isteğe bağlı): Gizliliği korumaya yönelik yaş doğrulama (ZKP)

Sıfır Bilgi Kanıtları'nı desteklemek için (ör. kullanıcının tam doğum tarihini görmeden 18 yaşından büyük olduğunu doğrulama) istek biçiminizi mso_mdoc_zk olarak değiştirin ve gerekli zk_system_type yapılandırmasını sağlayın.

ZKP'nin ne olduğu ve özellikleri hakkında genel bir bakış için SSS bölümünü inceleyin.

  ...
  "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
            {
              ...

Cüzdandan şifrelenmiş bir sıfır bilgi kanıtı alırsınız. Google'ın longfellow-zk kitaplığını kullanarak bu kanıtı, veren kuruluşun IACA sertifikalarına göre doğrulayabilirsiniz.

verifier-service, yanıtı veren kuruluşun IACA sertifikalarına göre doğrulamanıza olanak tanıyan, dağıtıma hazır, Docker tabanlı bir sunucu içerir.

Güvenmek istediğiniz IACA sertifika veren sertifikalarını yönetmek için certs.pem dosyasını değiştirebilirsiniz.

SDK'lar, Referans Uygulamalar ve Destek

Uygulama sürecinizi hızlandırmak için açık kaynak kitaplıklarımızı, referans sunucumuzu ve web doğrulayıcı aracımızı kullanın:

Kaynak / Kitaplık Sağladığı avantajlar Bağlantı
Kimlik Doğrulayıcılar Referans Uygulaması OpenID4VP istek oluşturma, JWS imzalama, JWE şifre çözme ve mdoc yanıt doğrulama işlemlerini gösteren örnek sunucu ve istemci. GitHub deposu
Multipaz SDK CBOR kod çözme, SessionTranscript yeniden oluşturma ve ISO/IEC 18013-5/7 imza doğrulaması için DeviceResponseParser içeren açık kaynak kitaplığı (OpenWallet Foundation). openwallet-foundation/multipaz
Longfellow ZKP Library & Verifier Service Sıfır Bilgi Kanıtı (mso_mdoc_zk) yaş ve özellik iddialarını doğrulamak için açık kaynaklı kitaplık ve Docker tabanlı sunucu. google/longfellow-zk
Etkileşimli Web Doğrulama Aracı W3C Digital Credentials API / OpenID4VP isteklerini Google Cüzdan'da test etmek için barındırılan web doğrulayıcı. verifier.multipaz.org
OpenID4VP 1.0 Spesifikasyonu Doğrulanabilir Sunumlar 1.0 protokol spesifikasyonu için resmi OpenID. OpenID4VP Spesifikasyonu
SSS ve Geliştirici Desteği Sık sorulan teknik entegrasyon sorularının yanıtları veya hata ayıklama yardımı için wallet-identity-rp-support@google.com adresine e-posta gönderin. Teknik Entegrasyon Hakkında SSS

Sonraki adım

4. Adım: Entegrasyonunuzu test edin → 5. Adım: Güvenen taraf olarak yayına geçin →