WorksComputer Science
Fooling Relying Parties of the EUDI Wallet Architecture: Credential Pooling Attacks and CRESTA, a Standard-Compliant Countermeasure
Abstract
The European Digital Identity (EUDI) Wallet will let millions of EU citizens prove who they are and what they are entitled to, disclosing only what is needed. Many services need several credentials at once, such as an identity card and a university degree, so combined presentations are essential. We present credential pooling attacks on relying parties of the EUDI Wallet reference architecture. Colluding users, each holding some credentials in their own wallet, cooperate through a proxy that acts as a single synthetic user and presents all the requested credentials, although no single user holds them all. Every signature is genuine and computed by certified hardware, and nothing is extracted or forged. We ran the attack against the European Commission's reference implementation, also on two Android phones. The attack would fail if all credentials of a user carried the same public key, but colluding relying parties could then link all presentations of that user. For this reason, the Architecture and Reference Framework (ARF) requires a fresh key for each credential and recommends batches of single-use copies, each with its own key: precisely what makes pooling possible. One might think that preventing pooling requires giving up unlinkability or adopting non-standard cryptography, such as zero-knowledge proofs. We show that this is not the case: we present CRESTA (CREdential STApling), an efficient countermeasure that uses only standard cryptography and credential formats and preserves unlinkability. In CRESTA, an ordinary issuer checks at issuance that a set of keys was generated in the same secure hardware, and certifies it in a binding attestation: a standard credential whose attributes can be selectively disclosed. CRESTA works entirely within the EUDI Wallet framework and costs a relying party one additional signature verification per presentation.
Introduction
The eIDAS 2.0 regulation [1], the EU legal framework for electronic identification, requires every EU Member State to offer its citizens a European Digital Identity (EUDI) Wallet by the end of 2026. The wallet is specified in the Architecture and Reference Framework (ARF) [2], a technical document published by the European Commission together with Member State experts.
The wallet is a smartphone application that stores credentials: sets of attributes about a person, signed by the organization that vouches for them, the issuer. The most important credential is the Person Identification Data (PID), the digital counterpart of a national identity card. All other credentials, such as diplomas or driving licenses, are called Electronic Attestations of Attributes (EAAs). A service that needs to learn something about the user, called a relying party, receives a presentation of the requested credentials, in which only the requested attributes are revealed. Credentials are encoded as ISO 18013-5 mdocs [3] or as SD-JWT verifiable credentials (SD-JWT VCs) [4], are signed by issuers with ECDSA, and are exchanged through OpenID for Verifiable Credential Issuance (OpenID4VCI) [5] and OpenID for Verifiable Presentations (OpenID4VP) [6]. Table 1 in § 2 summarizes the terms used in this paper.
| Term | Meaning |
| ARF | Architecture and Reference Framework, the technical design of the EUDI Wallet |
| PID, EAA | Person Identification Data, the digital identity card; Electronic Attestation of Attributes, any other credential |
| Issuer | The organization that signs a credential |
| Relying party | The service that asks the user to present credentials |
| User, holder | The person who holds credentials in the wallet; we use the two terms interchangeably |
| Wallet Provider (WP) | The organization that provides the wallet app and vouches for its secure hardware |
| Wallet Unit | One installation of the wallet on one smartphone, with its secure hardware |
| WSCD | Wallet Secure Cryptographic Device: the smartphone’s secure hardware, from which keys cannot be extracted |
| Device binding | Each credential names a key in the WSCD; presenting it requires a signature with that key |
| Key Attestation (KA) | A statement signed by the WP listing keys that were generated in one WSCD |
| Batch issuance | Issuing each credential as several single-use copies, each with its own key |
| Relying-party unlinkability | Colluding relying parties cannot tell whether two presentations come from the same user |
| Pooling | Colluding users combining credentials from different wallets in one presentation |
| Pooling resistance | A relying party can tell whether the presented credentials belong to one person |
| Attest key | An Android key that an app generates in the secure hardware; it certifies only keys generated by the same app [14] |
| Binding attestation | A standard credential stating that a set of keys was generated in one WSCD |
| Binding Attestation Issuer (BAI) | An ordinary issuer that issues binding attestations |
Table 1. Terms used in this paper.
Device binding. At issuance, the wallet generates a key pair inside its Wallet Secure Cryptographic Device (WSCD), a certified tamper-resistant component of the smartphone from which the private key cannot be extracted. A Key Attestation (KA), signed by the Wallet Provider, an organization mandated or recognized by a Member State that provides the wallet app and establishes the trust mechanisms for hardware security, tells the issuer that the key was generated in a genuine WSCD, and the issuer includes the public key in the credential. When presenting the credential, the wallet signs with that key a fresh challenge sent by the relying party, which proves that it holds the private key. This mechanism prevents the cloning of a credential, which therefore guarantees that a credential can only be used with the active online participation of the smartphone that generated the corresponding public key.
Relying-party unlinkability and batch issuance. The ARF also provides a mechanism for relying-party unlinkability, that is, it prevents colluding relying parties from telling whether two presentations come from the same user. This feature of the ARF relies on the batch issuance of a credential, which gives the wallet several single-use copies, each bound to a fresh key, with the wallet using one copy per presentation.
Pooling resistance. Many real-world services require several credentials at once: a car rental company asks for a PID and a driving license, an employer for a PID and a university degree. The relying party then needs to know that all presented credentials belong to the same person, a property we call pooling resistance. In [7], it is remarked within a broader privacy argument that batch issuance may make credential sharing hard to prevent. Since the keys of a user look uncorrelated, nothing in a presentation shows that the presented credentials belong to the same user. In this respect, the ARF sets high-level requirements for a cryptographic binding of attestations, envisioning an issuer that verifies a proof that a new key was generated in the same WSCD as an existing one [8]. However, the ARF does not specify any explicit mechanism that realizes this binding, leaving open the question of simultaneously avoiding pooling while maintaining unlinkability and usability. The discussion topics associated with the ARF mention the “risk of malicious combinations” [9], and the problem had also been raised in the W3C credentials community [10]. The risks of such attacks, initially envisioned in [7], were also more concretely illustrated by Verheul in [11] where in particular the need is remarked that a relying party be able to verify that the keys of different attestations are bound to the same WSCD. Verheul also proposed a countermeasure [11], Section 2.1, Annex D}, but it requires the WSCD to perform computations on private keys which currently deployed secure hardware does not allow [12], and relying parties to verify an additional zero-knowledge proof, so it is out of the bounds of the ARF. Our countermeasure instead uses only operations available in a large number of currently available smartphones ({xref}Section 2`).
Staying within the bounds of the ARF. The main challenge is to defeat pooling attacks while maintaining usability and unlinkability and remaining within the bounds of the ARF. More concretely, we identify the following requirements:
C1 WSCD unchanged. The WSCD is used only through operations largely available in the secure hardware of existing smartphones, such as generating keys, attesting them and computing ECDSA signatures (§ 2);
C2 Credentials unchanged. Issuers keep producing ECDSA-signed mdocs and SD-JWT VCs, each with a fresh device key as the ARF requires [8 ISSU_12b];
C3 Relying parties unchanged in kind. Relying parties are only involved in presentations of standard credentials to check attributes according to their known access control policies;
C4 Relying-party unlinkability. Colluding relying parties cannot tell whether two presentations come from the same user, unless this is inherent in the disclosed attributes required by their access control policies;
C5 Pooling resistance. Colluding users cannot make a relying party accept, in one presentation, credentials that were not all issued to the same user;
C6 Efficiency and usability. A presentation consumes only the credential copies that the use case requires and involves no party other than the holder and the relying party, so that it also works offline, as the ARF requires for proximity presentations, which must be possible without an Internet connection [8 EDP_10]; binding the credentials of a holder takes a number of attestations at most linear in the batch size and in the number of credentials to be linked together.
As shown in § 2, none of the approaches of the ARF achieves all the above properties simultaneously.
Our Contribution
The credential pooling attack. We have implemented a credential pooling attack on device binding in the latest version of the EUDI Wallet reference architecture (Figure 1). A relying party asks Alice for two credentials, a PID and a university degree. Alice holds a PID but no degree; Bob holds a degree. Alice and Bob collude: a proxy that they control answers the relying party with Alice’s PID and Bob’s degree, and asks each of their smartphones to sign the relying party’s challenge with the key bound to its own credential. Each signature is genuine and verifies under the key bound to its credential, and nothing in the response relates the two keys, so the relying party accepts the two credentials as those of one person. No key leaves its WSCD: the smartphones only sign, and both holders must be online at presentation time. We reproduced the attack end to end against the unmodified reference issuer and relying party published by the European Commission [13], both with software wallets and with two Android smartphones. The median time of the whole pooled presentation is below 0.2 s.

Figure 1. The Credential Pooling Attack. Alice holds a PID and Bob a university degree, each bound to a key in the secure hardware of their own smartphone. A proxy that they control receives the relying party’s request and challenge (1) and forwards the challenge to both smartphones as a request for a proof of possession (PoP) (2). Each smartphone signs it with the key bound to its own credential and returns the signed PoP (3), and the proxy sends both credentials with both PoPs in one response (4). Every signature is genuine and no key leaves its smartphone, yet the relying party accepts the two credentials as those of a single person (5).
The above attack would fail if the -th copies of all credentials were bound to the same key and the -th presentation of the wallet spent the -th copy of every issued credential, otherwise unlinkability would be lost. This countermeasure is however concretely inapplicable for two reasons. The main one is that burning so many credentials for just one presentation can be extremely expensive. The second is that the ARF requires a new key pair for every credential, as specified in § 2.
CRESTA: a standard-compliant countermeasure. We have designed a countermeasure to the credential pooling attack focusing on maintaining standardized credentials, presentations, efficiency and cryptographic tools. Our countermeasure, CRESTA (CREdential STAppling), runs entirely within the ARF and obtains both pooling resistance and relying-party unlinkability, while preserving efficiency and usability, staying with what existing WSCDs can already compute. The key observation is that whether two keys belong to the same holder cannot be seen at presentation, where batch issuance makes them look unrelated, but can be checked at issuance: a single KA generated by a Wallet Provider can attest that all the keys it lists are in the same WSCD. This can be implemented with current Android smartphones, as shown in § 3. An issuer can then certify this fact in a binding attestation: a credential in a standard format, issued to the wallet like any other, whose content states that a set of fresh, selectively disclosable keys was generated in the same WSCD. We call an issuer that issues binding attestations a Binding Attestation Issuer (BAI). This is not a new role: a BAI is an ordinary issuer in the sense of the ARF, which issues standard credentials with special contents, and it can be an issuer that the holder already uses, as long as it is considered trustworthy for such a task. The BAI receives only the public keys to be bound, never the credentials or their attributes. Our binding attestations therefore achieve the issuer-attested binding that the ARF lists [9], and to the best of our knowledge ours is the first specified realization satisfying all properties from C1 to C6. Figure 2 summarizes the mechanism.

Figure 2. CRESTA, our countermeasure, for two credentials and . At issuance, the attest key in the holder’s smartphone certifies the device keys and of the two credentials (1). The Wallet Provider lists both keys in one Key Attestation (KA) only if the same certified them (2), and the Binding Attestation Issuer (BAI), an ordinary issuer, checks the KA and returns a binding attestation BA on , a credential in a standard format (3). At presentation, the wallet sends BA with the two credentials (4), and the relying party checks that BA covers their keys. Alice and Bob cannot obtain a BA on their two keys, because no attest key certifies keys in two smartphones.
We discuss how binding attestations prevent pooling attacks exactly in the setting of the ARF, where every single credential is bound to a key in the WSCD of its subject and a WSCD belongs to one person. We also implemented our countermeasure: it costs the relying party one additional signature verification (about 0.42 ms) per presentation.
Background
Parties. Besides users, issuers and relying parties, the ARF [2 Section 3] defines the Wallet Provider (WP), an organization mandated or recognized by a Member State, which provides the wallet and vouches for its secure hardware, and trusted list providers, which publish the issuers, Wallet Providers and other parties that may be trusted. Issuers are PID Providers, which issue the PID after verifying the user’s identity, and Attestation Providers, which issue EAAs. One installation of the wallet app on a smartphone, together with its WSCD, is called a Wallet Unit.
Presentations. When a relying party requests several credentials in one presentation, the wallet proves possession of each device key separately. In an mdoc presentation, each document carries its own signature, computed with that document’s device key over a structure that includes the session transcript [3]. In an SD-JWT VC presentation, each credential carries its own key-binding JWT, signed with that credential’s device key over the relying party’s nonce, an audience value identifying the relying party and a hash of the presented credential [15]. In both formats, nothing in the response relates the device keys of different credentials to each other.
Key attestation. An issuer learns that a key was generated by a WSCD from a Key Attestation (KA) signed by the WP1: a KA lists public keys and states that their private keys were generated in the WSCD [8]. The issuer verifies the KA, checks that it has not been revoked, and binds the credential to one of the listed keys. Together with the Wallet Instance Attestation, which attests the integrity of the wallet application, the KA forms the Wallet Unit Attestation (WUA). A relying party never sees a KA: it trusts the device binding of a credential because the issuer checked a KA before signing the credential. The ARF does not specify how the WP verifies that the keys it lists were generated in the WSCD [8].
Activation. After the user installs the wallet application, the Wallet Unit must be activated with its WP before any credential can be issued to it. During activation, the WP verifies that the application is a genuine instance of its wallet and that the device has a WSCD certified for Level of Assurance High. It then issues to the Wallet Unit its first KA, after verifying that the listed keys are protected by the WSCD, and its first Wallet Instance Attestation, and re-issues both as needed during the lifetime of the Wallet Unit [8].
Batch issuance. The ARF enables every wallet to support once-only credentials, issued in batches of copies that are each presented only once, and limited-time credentials, which are short-lived but may be presented repeatedly [8]. Every copy has its own device key, and the device-binding key is among the values that must differ across all credentials issued by that Provider. In this paper, batch issuance refers to once-only credentials, and denotes the number of copies in a batch. We write for the -th copy () of the batch associated with the -th credential () stored in the wallet, where is the total number of credentials held by the wallet, and for its device key.
Verifying device binding. The ARF states that a relying party should verify the device-binding signature in a presentation [8], but no requirement makes the check mandatory. A relying party that skips this check would accept a credential from anyone who holds a copy, so we consider only relying parties that perform the check.
Secure hardware. Depending on the operating system, different features can be available to the wallet app. Here we will focus on Android smartphones. On Android, a wallet reaches secure hardware through the Android Keystore, which is backed either by StrongBox, implemented in an embedded secure element or an integrated secure enclave, or by a trusted execution environment (TEE). StrongBox supports only a few standard algorithms, among them ECDSA and ECDH on the P-256 curve [16]. When it generates a key, the secure hardware can also issue an attestation certificate for it, the Android key attestation, which records, among other things, the challenge chosen by the app, whether the key was generated or imported, and whether it lives in StrongBox or elsewhere, such as a TEE [17]. By default this certificate is signed by a platform attestation key, either a factory key shared by many devices or a remotely provisioned key, so it does not identify the device [17, 18]. Starting with version 12 of Android, an app can generate its own attest key [14], a key whose only purpose is to sign the attestation certificates of other keys generated by the same app. All keys that the app generates afterward can then be attested by that attest key. The attest key can be used only for the above purpose [19].
Pooling adversary and trust assumptions. The specific adversary that we consider consists of a group of colluding users, each holding genuine credentials in a genuine Wallet Unit. They may modify their wallet apps and coordinate their action in any phase, but they cannot extract private keys from a WSCD or forge signatures. Their goal is to violate the pooling resistance property.
As trust assumptions, we keep those of the ARF:
the WSCD keeps private keys inside and its attestation certificates are correct;
the WP lists keys together in one KA only if they were generated in the same WSCD (§ 3 shows how it can check this on Android);
issuers certify only correct attributes, which for the Binding Attestation Issuer of § 3.1 means binding only keys listed in the same KA;
a PID is issued only to a WSCD controlled by the PID’s subject.
Like the ARF, we do not protect users against issuers that collude with relying parties. The ARF calls this Attestation Provider linkability: it cannot be fully eliminated with credential formats based on salted hashes, and organizational measures and audits deter it [2 Section 7.4.3.5]. CRESTA inherits this limitation.
Cryptographic and issuer-attested binding. The ARF names five approaches to provide pooling resistance [9], but only two of them could prevent pooling without identifying the user: cryptographic binding and issuer-attested binding. In cryptographic binding, the Wallet Unit proves to the relying party, at presentation, that the private keys of all the presented attestations were generated in the same WSCD.2 The ARF does not provide the specifications to implement cryptographic binding and recommends a zero-knowledge proof (ACP 03 [8]), which relying parties would have to verify, violating C3.
Verheul [11 Section 2.1] proposed to relate two device keys in the same WSCD through a Proof of Association, which must be computed inside the WSCD, requiring customized instructions, therefore violating C1; relying parties then need to verify a Schnorr-type proof, violating C3 [11, 12].
Issuer-attested binding is described in one sentence: an issuer “may issue a dedicated attestation to the Wallet Unit explicitly confirming that two or more attestations relate to the same entity” [9]. If the user has to show the issuer every attestation to bind, the issuer obtains the full content of credentials that it did not issue, although it only needs to know that they belong to the same user. This violates the data minimization principle, under which personal data must be “limited to what is necessary in relation to the purposes for which they are processed” [20, Article 5(1)(c)], a principle that the ARF adopts [2 Section 4.2.4]. On the other hand, if it is restricted to binding only attestations that it issued itself, it cannot bind a PID to a university degree, which is a combination explicitly mentioned in the examples in Topic K of the discussions associated with the ARF requirements {citep}[9]. In both cases, a naive unlinkable variant of the issuer-attested binding would need an attestation for each possible combination of credentials that could be presented together, which is unfeasible since the number of binding attestations grows exponentially with the batch size and the number of credentials. Alternatively, there could be a request to the issuer at every presentation, but this rules out offline use (C6). The Spanish data protection authority judged that, realized with privacy-preserving techniques such as zero-knowledge proofs, issuer-attested binding “may represent the approach most GDPR-aligned” {citep}[21]`.
Other unsuitable approaches to bind attestations. Binding all credentials of a wallet to one device key would let a relying party check that the presented keys are equal, but that key would link every presentation, and the ARF requires a new key pair for every PID or attestation [8 ISSU_12b]. Binding to a common key only the copies at index of all batches of credentials would avoid this linking, but it would be extremely expensive, since a presentation would waste the copies at its index of credentials it does not even refer to.
Our Proposal: CRESTA
In order to prevent pooling attacks, someone must check that the keys of the presented credentials have been generated by the same WSCD. The relying party cannot run this check: batch issuance makes the keys of one user look uncorrelated. At issuance, however, the check is possible, because a single KA, signed by the WP, can list several keys and state that they were all generated in the same WSCD. A binding attestation carries this fact from issuance, where it can be checked, to presentation, where it is needed.
Attest keys in Android. At activation, the wallet generates an attest key in its WSCD, and the WP verifies the attestation certificate of , signed by the platform attestation key (§ 2), and records for that Wallet Unit. Every device key that the wallet later generates is attested under . The WSCD uses only to attest keys that it generates, so two keys attested under the same have been generated in the same WSCD, and no modified wallet can have Alice’s attest a key that was generated in the WSCD of Bob’s smartphone. The WP therefore lists keys in one KA only if all of them are attested under the it recorded for the Wallet Unit, and were generated, not imported, in the expected secure hardware. A KA listing several keys is then sound evidence that they are within the same WSCD, and producing it needs nothing beyond what is available in many existing Android smartphones. The attest key is a stable identifier of the Wallet Unit, but only the WP, which already knows the Wallet Unit, ever sees it: issuers see KAs, and relying parties see neither.
How CRESTA Works
We now describe how our countermeasure CRESTA works within the ARF.
Consider a holder who wants to present together two credentials, from issuer and from issuer , each issued in a batch of copies. For simplicity we describe the case of two credentials; in § 3.2 we generalize it to credentials. An issuer acts as a Binding Attestation Issuer (BAI) when it verifies a KA signed by a WP on a trusted list and issues, in a standard credential format, a binding attestation whose content is a set of keys listed in that KA. Any issuer recognized through a trusted list can act as a BAI. We distinguish four phases:
Activation: this procedure follows the one of the ARF (see § 2), and in addition the wallet generates an attest key in its WSCD, which the WP verifies and records for the Wallet Unit;
Paired key generation: the wallet generates key pairs , for all , in its WSCD, each attested under ;
Issuance: the user runs two ordinary OpenID4VCI procedures with issuer A and issuer B and obtains two batches of copies each of credentials and , bound to the keys and for all , respectively;
Binding attestation issuance: the wallet obtains from the WP a KA listing the keys and for all and sends it to BAI only. BAI verifies the KA and issues, for all , the binding attestation , an SD-JWT VC signed by BAI whose selectively disclosable attributes are the keys .
Notice that BAI receives only the public keys listed in the KA. It never receives or , nor any of their attributes.
Presentation. The wallet selects an unused index , sends , and to the relying party, signs the session transcript with both keys, and never uses , or in other presentations. Below, and denote the keys and of the presented copies.
What the relying party checks. The relying party performs three checks:
run the standard OpenID4VP verification of a combined credentials presentation, extracting and from and respectively;
verify BAI’s signature on BA against the trusted list;
check that the keys certified in BA are exactly .
Step 1 is what a relying party already does for a combined presentation; steps 2 and 3 add one signature verification, that of BAI on BA, and an equality comparison, so the relying party still checks only ordinary signatures.
More than two credentials. § 3.2 shows how a single binding attestation per batch element covers any combination of the credentials, avoiding the exponential number of attestations a naive scheme would need.
When Binding Attestations Are Issued
The wallet can obtain its binding attestations right after obtaining some credentials, for instance from their issuer. Alternatively, the wallet can obtain a binding attestation when a presentation with multiple credentials needs to start. In this last case, the wallet sends the public keys of the requested credentials to BAI, receives a binding attestation over them, and forwards it to the relying party. In both cases BAI checks a KA, but each option has advantages and disadvantages.
BA at presentation. Obtaining binding attestations at presentation has two shortcomings.
Latency. Every combined presentation waits for additional online round trips to the WP and to BAI, within the relying party’s session, and depends on the network and on the availability of both.
Connectivity. A holder without connectivity cannot obtain a binding attestation, and so
cannot complete any combined presentation, even in proximity flows, which ISO/IEC 18013-5 supports without an Internet connection [3].
BA at issuance. Obtaining binding attestations at issuance circumvents the above shortcomings: the WP and BAI are contacted only outside presentations, when the wallet obtains credentials or binding attestations, they learn nothing about individual presentations, and presentations proceed offline with no additional round trip. At issuance, however, the wallet does not know which credentials a relying party will later request together. If a binding attestation states exactly the set of keys to be presented, covering every combination of credentials needs one binding attestation for each subset of them, which is clearly infeasible.
Removing the trade-off: the best of both worlds. Selective disclosure in SD-JWT VCs lets us bind at issuance and choose the combination at presentation: a binding attestation lists the keys as selectively disclosable attributes. Let , , be the device keys of the -th copies of the holder’s credentials. For each (), BAI issues a single binding attestation over attributes , where for , is the cryptographic hash function of the SD-JWT and each is a fresh random salt. The holder stores with the disclosures (Figure 3). When the relying party requires attributes belonging to credentials stored in the wallet, the wallet selects an index such that and the -th copies of those credentials are all unused, and sends these copies together with disclosing the requested attributes of the credentials and, in , only the corresponding keys. The relying party verifies like any SD-JWT VC, with a single signature verification, and performs the checks of Section 3.1 on the disclosed keys.

Figure 3. Structure of the binding attestation of a holder with three credentials: a PID , a degree and a driving license . (a) What BAI issues and the wallet stores. (b) What the wallet presents to a relying party that requests a PID and a degree.
The combination is thus chosen at presentation, through the disclosures, and yet no party is contacted at presentation: a single binding attestation, issued in advance, covers all combinations at once, so the holder needs binding attestations, one per batch element, and the non-disclosed keys stay hidden and thus can still be disclosed individually without any linkability issue.
Remark on hiding the number of credentials. A binding attestation includes as (selectively disclosable) attributes keys belonging to credentials of the user. Since a standard presentation does not hide the number of included attributes, the relying party learns the number of credentials that the wallet decided to link through a binding attestation. In applications in which this is considered a privacy leak, the wallet can simply ask the binding attestation issuer to add several random digests as attributes and to shuffle all attributes, so that the leak is then practically canceled, since only a large upper bound on the number of credentials is revealed.
Why Binding Attestations Prevent Pooling
A relying party accepts a combined presentation only if a binding attestation from a trusted issuer covers exactly the device keys of the presented credentials, and the presentation carries a valid signature under each of those keys. Tracing a binding attestation back to its origin shows why colluding holders cannot obtain one for credentials of different people:
the Binding Attestation Issuer certifies only keys that are listed together in one KA;
the WP lists keys together in one KA only if all of them are attested under the attest key that it recorded for one Wallet Unit;
the secure hardware uses an attest key only to attest key pairs stored in that same secure hardware, and marks each as GENERATED or IMPORTED, so the WP can require keys generated inside the secure hardware.
The keys covered by a binding attestation therefore were generated in the same WSCD. In the setting that the ARF assumes, every credential is bound to a key in the WSCD of its subject, and a WSCD belongs to one person, so all the credentials covered by one binding attestation have the same subject. In the credential pooling attack, Alice’s PID key is generated in her smartphone and Bob’s degree key in his: no attest key attests both, so no KA lists both, and no issuer certifies them together. Nor can the colluders forge a binding attestation, a KA or a device signature, since all of them are ordinary ECDSA signatures. The argument above relies only on the trust assumptions of the threat model (§ 2).
Limitations. A binding attestation states that the keys belong to the same WSCD at issuance. That this still holds at presentation follows from the secure hardware, since no key can leave its WSCD. The mechanism also needs a way for the WP to tell that keys belong to a WSCD, and this leverages attest keys on Android. CRESTA follows a general-purpose design and the example we have given for existing versions of Android can be replaced by other mechanisms to include other operating systems (e.g., iOS) and future versions of Android.
Implementation and Evaluation
Testbed. We tested both the attack and the countermeasure against the official reference issuer (eudi-srv-pid-issuer, commit 3ebd78f) and reference relying-party service (eudi-srv-web-verifier-endpoint-23220-4-kt, commit d74c971), both unmodified and run from their published container images. Our wallet and pooling proxy are built on the official EUDI libraries (openid4vp-kt 0.15.1, openid4vci-kt 0.13.1, sdjwt-kt 0.20.1) and use the deployed OpenID4VP 1.0 and SD-JWT VC profile. The two colluding holders run either as software processes or on two Android smartphones: a Samsung Galaxy S24 Ultra, with its key in StrongBox, and a Galaxy A53, with its key in the TEE. On each smartphone, a small app generates the device key in the Android Keystore and signs whatever the proxy sends. Software measurements run on a desktop with an AMD Ryzen 9, OpenJDK 21 and Linux. All experiments use our own devices and sample credentials.
The pooling attack. We reproduced the scenario of Figure 1. Alice’s smartphone holds a PID, and Bob’s a university degree issued to a different person. The relying party sends a single request for Alice’s birthdate from a PID and for a graduation date from a degree. The proxy answers it, asks each smartphone to sign the relying party’s challenge with the key bound to its credential, and returns both credentials in one response. The reference relying party, which checks every device signature, accepts the response as coming from a single person. This holds both with software holders and with the two smartphones.
Latency. Table 2 reports the end-to-end time of the pooled presentation. Since the proxy asks for the two signatures in parallel, the pooled presentation over two smartphones (147 ms over USB, 182 ms over WiFi) takes about as long as an honest presentation signed in StrongBox (139 ms). Timing therefore cannot tell a pool from an honest holder, and all these latencies are far below realistic session timeouts: the reference relying party defaults to 6400 min.
| Setup | Median (ms) |
| Pooled presentation (two credentials, two holders) | |
| software holders, one host | 75 |
| two smartphones, USB, sequential signing | 166 |
| two smartphones, USB, parallel signing | 147 |
| two smartphones, WiFi, parallel signing | 182 |
| Honest presentation, one credential (USB) | |
| PID on Galaxy S24 Ultra (StrongBox) | 139 |
| degree on Galaxy A53 (TEE) | 91 |
Table 2. End-to-end latency of the Credential Pooling Attack on the remote OpenID4VP flow, median of 25 runs.
CRESTA. We implemented CRESTA, our fix, by adding a Binding Attestation Issuer, which runs as a separate issuer with its own key pair, and by adding to the unmodified reference implementation’s relying party an external check performing steps 2 and 3 of § 3.1. The reference implementation’s issuer is unchanged.
In the testbed, the WSCDs and the attestation PKI are emulated on the model of KeyMint, the Android interface to the secure hardware that generates and attests keys [19]: each key generated in an emulated WSCD comes with its Android key attestation, signed by the attest key of its WSCD, whose own certificate is signed by an emulated platform attestation key (§ 2).
In deployment, the WP checks the Android key attestation for each key generated in the WSCD and, if one attest key certifies all the keys, the WP generates a KA that lists them (§ 3); the BAI then verifies this KA. For concreteness, in the testbed the BAI runs the check of the WP itself and binds the keys only if one attest key certifies them all. A genuine presentation of two credentials whose keys were generated by the same WSCD is accepted. The pooled response is now rejected, since it includes two keys belonging to two different Wallet Units and no BA binds them. Our experiments show that ARF relying parties need no change other than an additional condition on the access control policy to resist pooling attacks. On Android, the attest keys of § 3 ensure that colluding holders cannot obtain a valid BA for keys in two different devices. The testbed also simplifies the construction in two ways: binding attestations are issued on demand at presentation rather than in advance, and they are plain signed objects rather than SD-JWT VCs.
Cost. Table 3 reports the overhead of the countermeasure. The binding check adds to the relying party one signature verification, which takes 0.42 ms, and a set comparison; the presentation grows by the binding attestation (1342 B).
| Metric | Baseline | With BA |
| Relying-party CPU (ms) | 0.84 | 1.27 |
| Presentation size (B) | 6755 | 8097 |
Table 3. Overhead of the countermeasure, measured on the desktop with P-256 ECDSA (JCA SHA256withECDSA). Baseline: the verification of an ordinary combined presentation of two credentials; with BA: the same plus the binding check. Medians of 4001 runs.
Concluding Remarks
Device binding in the EUDI Wallet establishes that a single credential is being presented with the participation of the device it was issued to. It does not establish that the credentials presented together belong to one person, and batch issuance, introduced for privacy, removes the signal a relying party would need to check it. The ARF foresees a cryptographic binding of attestations, but specifies no mechanism for it. The other approaches that the ARF retains either fail against pooling or identify the user (§ 2). We have shown that the problem is exploitable today, against the reference implementation and with keys held in the secure hardware of commercial smartphones. We have also shown a countermeasure, CRESTA, that stays within the ARF: binding attestations are standard credentials, issued by ordinary issuers and checked by relying parties like any other signature, and they rely only on capabilities that are available in a large number of currently available smartphones. The price is that the issuer of binding attestations must be trusted to certify honestly which keys share a WSCD.
Recommendations. Our findings suggest two changes to the ARF. First, holder collusion should be more explicitly part of the threat model for combined presentations. Second, relying parties that request several credentials together should require a binding attestation covering their keys, as in CRESTA.
Ethical considerations. The credential pooling attack concerns a system in pre-deployment. All experiments ran against the open-source reference implementations, deployed on our own machines. No production issuance or verification service was contacted, no real PID was obtained, and no third party’s credential was used. The two holders in every experiment are researchers involved in this work, consenting to the collusion, so no participant is deceived and no personal data of any non-author is processed.
Acknowledgments
We thank Dario Castellano and Pierpaolo Della Monica for helpful discussions on credential pooling attacks.
References
- [1]European Parliament and Council of the European Union. Regulation (EU) 2024/1183 amending Regulation (EU) No 910/2014 as regards establishing the European Digital Identity Framework. Official Journal of the European Union, L 2024/1183, 2024. URL: https://eur-lex.europa.eu/legal-content/EN/TXT/?uri=OJ:L_202401183.
- [2]European Commission. European Digital Identity Wallet Architecture and Reference Framework, v3.0.0, July 2026. URL: https://eudi.dev/3.0.0/main/.
- [3]ISO/IEC. ISO/IEC 18013-5:2021 Personal identification — ISO-compliant driving licence — Part 5: Mobile driving licence (mDL) application. International Organization for Standardization, 2021. URL: https://www.iso.org/standard/69084.html.
- [4]O. Terbu, D. Fett, and B. Campbell. SD-JWT-based Verifiable Digital Credentials (SD-JWT VC). Internet-Draft draft-ietf-oauth-sd-jwt-vc-19, IETF, August 2026. URL: https://datatracker.ietf.org/doc/draft-ietf-oauth-sd-jwt-vc/.
- [5]T. Lodderstedt, K. Yasuda, T. Looker, and P. Bastian. OpenID for Verifiable Credential Issuance 1.0. Final specification, OpenID Foundation, September 2025. URL: https://openid.net/specs/openid-4-verifiable-credential-issuance-1_0.html.
- [6]O. Terbu, T. Lodderstedt, K. Yasuda, D. Fett, and J. Heenan. OpenID for Verifiable Presentations 1.0. Final specification, OpenID Foundation, July 2025. URL: https://openid.net/specs/openid-4-verifiable-presentations-1_0.html.
- [7]C. Baum, O. Blazy, J. Camenisch, J.-H. Hoepman, E. Lee, A. Lehmann, A. Lysyanskyaya, R. Mayrhofer, H. Montgomery, N. K. Nguyen, B. Preneel, a. shelat, D. Slamanig, S. Tessaro, S. E. Thomsen, and C. Troncoso. Cryptographers’ feedback on the EU Digital Identity’s ARF, June 2024. URL: https://hpi.de/oldsite/fileadmin/user_upload/fachgebiete/lehmann/Publications/cryptographers-feedback.pdf.
- [8]European Commission. European Digital Identity Wallet Architecture and Reference Framework, v3.0.0, Annex 2.02: High-Level Requirements by Topic, July 2026. URL: https://eudi.dev/3.0.0/annexes/annex-2/annex-2.02-high-level-requirements-by-topic/.
- [9]European Commission. Topic K: Combined presentation of attestations. European Digital Identity Wallet Architecture and Reference Framework, version 3.0.0, discussion topics. URL: https://eudi.dev/3.0.0/discussion-topics/k-combined-presentation-of-attestations/.
- [10]w3c/vc-data-model. Collusion, i.e. collaboration, between Alice and Bob. GitHub issue 1136, opened 22 May 2023, closed 29 June 2023. URL: https://github.com/w3c/vc-data-model/issues/1136.
- [11]E. R. Verheul. Attestation proof of association: provability that attestation keys are bound to the same hardware and person. Cryptology ePrint Archive, Paper 2024/1444, version 1.2, January 2025. URL: https://eprint.iacr.org/2024/1444.
- [12]P. Altmann. Topic K: Combined presentation of attestations. Discussion 442, eu-digital-identity-wallet/eudi-doc-architecture-and-reference-framework, GitHub, March 2025. URL: https://github.com/eu-digital-identity-wallet/eudi-doc-architecture-and-reference-framework/discussions/442.
- [13]European Commission. EUDI Wallet reference implementation: PID issuer and verifier endpoint. GitHub repositories eudi-srv-pid-issuer and eudi-srv-verifier-endpoint. Accessed November 2026. URL: https://github.com/eu-digital-identity-wallet.
- [14]Android Developers. KeyGenParameterSpec.Builder: setAttestKeyAlias. API reference, Android 12 (API level 31) and later. Accessed October 2026. URL: https://developer.android.com/reference/android/security/keystore/KeyGenParameterSpec.Builder.
- [15]D. Fett, K. Yasuda, and B. Campbell. Selective Disclosure for JSON Web Tokens. RFC 9901, IETF, November 2025. URL: https://www.rfc-editor.org/rfc/rfc9901.DOI
- [16]Android Developers. Android Keystore system. Developer documentation. Accessed October 2026. URL: https://developer.android.com/privacy-and-security/keystore.
- [17]Android Open Source Project. Key and ID attestation. Documentation. Accessed October 2026. URL: https://source.android.com/docs/security/features/keystore/attestation.
- [18]M. Bires. Upgrading Android attestation: remote provisioning. Android Developers Blog, March 2022. URL: https://android-developers.googleblog.com/2022/03/upgrading-android-attestation-remote.html.
- [19]Android Open Source Project. IKeyMintDevice HAL interface specification. Accessed October 2026. URL: https://android.googlesource.com/platform/hardware/interfaces/+/refs/heads/main/security/keymint/aidl/android/hardware/security/keymint/IKeyMintDevice.aidl.
- [21]Agencia Española de Protección de Datos (AEPD). Response to ARF discussion topics: Topic K “Combined presentation of Attestations”. Comment on ARF discussion #519, 30 May 2025. URL: https://github.com/eu-digital-identity-wallet/eudi-doc-architecture-and-reference-framework/discussions/519#discussioncomment-13318988.