Skip to main content
promotional banner for can you prove your CC^ checklist
Five Dynamic Linking Mistakes Before EUDI Wallet Payments Go LiveGovernance & Compliance
5 min readFor CISOs & Security Leaders

Five Dynamic Linking Mistakes Before EUDI Wallet Payments Go Live

Dynamic linking has been a core requirement of European payment security since Strong Customer Authentication (SCA) arrived with PSD2. What's changing is the infrastructure. The proposed Payment Services Regulation (PSR) and PSD3 framework tighten liability for Authorized Push Payment (APP) fraud, requiring regulated payment service providers to accept the European Digital Identity (EUDI) Wallet as a standardized, cross-border authentication channel.

For CISOs, this means the controls your team built around proprietary banking apps and SMS one-time passwords won't carry over unchanged. Wallet-based flows use OpenID for Verifiable Presentations (OpenID4VP) and SD-JWT Verifiable Credentials, and the failure modes are different. Fully native wallet payment acceptance is still an emerging capability, so architecture choices made now will be hard to unwind later.

Why These Mistakes Keep Happening

Three forces collide. First, teams treat dynamic linking as a solved PSD2 problem and reuse mental models from push-notification SCA. Second, the standards stack is layered: OpenID4VP 1.0 is final, RFC 9901 (SD-JWT) is final, but the SD-JWT VC profile is still a draft and the payment schema profile (EWC RFC-008) is a pilot specification. Ownership of each layer is unclear, so gaps appear between them. Third, the stakes have shifted. Under tighter APP fraud liability, a weak binding between approval and transaction becomes a financial exposure, not just an audit finding.

Mistake 1: Treating the Wallet as a Login, Not a Transaction Signer

Why it happens: Wallets are introduced through identity use cases. Teams assume a successful credential presentation means the payment is authorized.

Consequence: A valid presentation proves who the user is. It doesn't prove what they approved. Without transaction data in the request, you've authenticated a person and left the amount and payee unbound, which fails the dynamic linking rule.

Fix: Require the transaction_data parameter on every payment authorization request, used alongside the Digital Credentials Query Language (DCQL). The payee, amount, and currency must travel with the request, and the credential_ids array must reference the id of the credential defined in your DCQL query. Reject any payment flow that completes without a hash of that data in the response.

Mistake 2: Re-serializing the Transaction Payload Before Hashing

Why it happens: Developers instinctively decode the Base64URL entry, work with the JSON object, and re-encode it for comparison. It feels cleaner than handling raw strings.

Consequence: JSON key ordering, whitespace, and library differences produce different bytes from the same logical content. Your verifier computes a different digest than the wallet signed, so legitimate payments fail. Worse, teams "fix" this by loosening the comparison, which weakens the control.

Fix: Follow the rule OpenID4VP sets for wallets: hash the exact ASCII bytes of the Base64URL-encoded entry as received. On the verifier side, store the original raw string in the server session when you build the request. At validation, compute the SHA-256 digest over that stored string and compare it to the transaction_data_hashes entry in the Key Binding JWT (KB-JWT). Never parse and rebuild.

Mistake 3: Skipping or Reordering the Validation Pipeline

Why it happens: Each check looks independent, so teams implement them in whatever order the library exposes. Some stop after verifying the issuer signature.

Consequence: A credential with a valid issuer signature but a replayed nonce, wrong audience, or revoked status still looks legitimate. Replay is the obvious risk; stale credential status is the quieter one.

Fix: Run the pipeline in sequence and treat any failure as terminal:

  1. Confirm the audience matches your verifier identifier. Confirm the nonce exists in the active session cache, then evict it immediately.
  2. Validate the issuer signature on the base credential and check credential status against the relevant status list.
  3. Extract the public key from the cnf confirmation claim, verify the KB-JWT signature and sd_hash, and check the iat timestamp.
  4. Compare the transaction data hash against the stored original request.
  5. Mark the specific transaction payload as authorized, once.

Step five needs idempotency. A retry or duplicate callback must not execute the payment twice.

Mistake 4: Assuming the Wallet Guarantees What the User Saw

Why it happens: OpenID4VP governs transmission. It's easy to read "the wallet displays the payment" as a protocol guarantee.

Consequence: A matching hash only proves the user signed those bytes. If the wallet showed something different, or rendered the prompt in an untrusted context, the "what you see is what you sign" property is gone. That gap matters directly to liability.

Fix: Treat display assurance as a wallet certification and procurement question, not a protocol feature. Ask vendors and wallet providers how the confirmation prompt is isolated from the rest of the app, whether it relies on operating system security controls, and how approval via biometrics or PIN is tied to the signing operation. Keep the private key hardware-backed, since the KB-JWT signature only means something if the attacker can't reach that key.

Mistake 5: Misidentifying the Verifier Role

Why it happens: Demo code uses a merchant as the verifier, so teams assume that's the production model.

Consequence: In a two-party model, the issuing bank is the verifier. In a three-party model such as e-commerce, the merchant starts the flow but typically relays the Verifiable Presentation to the acquiring Payment Service Provider (PSP) or the issuing bank, via open banking APIs or EMV 3-D Secure rails. If you assume the merchant validates everything, nobody owns the nonce cache, status checks, or hash comparison, and liability is unclear.

Fix: Map the verifier role per payment model before you build. Document who holds the session state, who validates, and who bears fraud liability. Contract for it explicitly with your acquirer or PSP.

Prevention Checklist

  • transaction_data is mandatory on every payment authorization request, with payee, amount, and currency present.
  • The raw Base64URL string is stored server-side and used for hash comparison; no re-serialization anywhere.
  • Validation runs in fixed order: audience and nonce, credential and status, key binding, transaction hash, idempotent execution.
  • Nonces are single-use and evicted on first check.
  • Any amount or payee change invalidates approval; test this with deliberate tampering in staging.
  • Wallet display assurance is a documented procurement and certification requirement.
  • Verifier roles are mapped per payment model, with liability assigned in contracts.
  • Your spec tracking covers each layer: OpenID4VP 1.0, RFC 9901, the draft SD-JWT VC profile, EWC RFC-008, and forthcoming European Banking Authority Regulatory Technical Standards.
  • Draft and pilot specifications are isolated behind interfaces so schema changes don't require a rebuild.

You don't need to wait for final regulation. The binding logic is stable even while the profiles mature. Get the hashing, ordering, and role assignments right now, and PSD3 becomes a configuration exercise rather than a rewrite.

Promotional banner highlighting failures found in PCI audits and how to spot the gaps

You Might Also Like