Malleable Signatures: Complex Unary Transformations and Delegatable Anonymous Credentials

Transcription

1 Malleable Signatures: Complex Unary Transformations and Delegatable Anonymous Credentials Melissa Chase Microsoft Research Redmond Markulf Kohlweiss Microsoft Research Cambridge Sarah Meiklejohn UC San Diego March 29, 2013 Anna Lysyanskaya Brown University Abstract A signature scheme is malleable if, on input a message m and a signature σ, it is possible to efficiently compute a signature σ on a related message m = T (m), for a transformation T that is allowable with respect to this signature scheme. Previous work considered various useful flavors of allowable transformations, such as quoting and sanitizing messages. In this paper, we explore a connection between malleable signatures and anonymous credentials, and give the following contributions: We define and construct malleable signatures for a broad category of allowable transformation classes, with security properties that are stronger than those that have been achieved previously. Our construction of malleable signatures is generically based on malleable zero-knowledge proofs, and we show how to instantiate it under the Decision Linear assumption. We construct delegatable anonymous credentials from signatures that are malleable with respect to an appropriate class of transformations; we also show that our construction of malleable signatures works for this class of transformations. The resulting concrete instantiation is the first to achieve security under a standard assumption (Decision Linear) while also scaling linearly with the number of delegations. 1 Introduction A signature scheme is malleable alternatively, homomorphic if, given a signature σ on a message m, it is possible to efficiently derive a signature σ on a message m = T (m) for an allowable transformation T ; as an example, we might allow m to be any excerpt from m (in this sense, the malleability of the signature scheme is controlled ). Formal definitions of such signatures were first given by Ahn et al. [3], and their definitions were recently refined by Attrapadung et al. [4]. Without any additional restrictions on the size of the signature or the privacy of the original message m, a construction of a malleable signature is trivial: the signature σ on m is also automatically a signature on T (m) for any allowable T. What makes this problem non-trivial is the following additional twist, called context hiding: the derived signature σ should not reveal anything about the original message m that is not revealed by the message m, and in fact it should be impossible to tell that σ was computed from σ, rather than issued by the signer directly. This definition can also apply to n-ary transformations T, and implicitly requires that the size of the signature depends only on the message (so, in particular, it cannot grow as 1

2 it is transformed unless the transformation outputs a message that requires a longer signature). Using appropriate classes of allowable transformations, malleable signatures are a generalization of a variety of existing signatures, such as quotable or redactable signatures. A natural application for malleable signatures that has not been previously considered is an anonymous credential system [21, 14, 15]. In such a system, a user Alice is known in different contexts by different unlinkable pseudonyms (it s best to think of a pseudonym as an unconditionally binding, computationally hiding commitment to Alice s secret key), yet she can demonstrate possession of a credential issued to pseudonym nym to a verifier who knows her by another pseudonym, nym. Let T be the set of transformations that, on input some pseudonym nym, output another pseudonym nym of the same user, so that there exists some T T such that nym = T (nym). Then a signature scheme that is malleable with respect to the set of transformations T gives us an anonymous credential system: a credential is simply an authority s signature σ on nym; malleability makes it possible for Alice to transform it into σ that is a signature on nym ; context hiding should ensure that σ cannot be linked to the original pseudonym nym to which it was issued; and finally, unforgeability should ensure that Alice cannot compute σ unless she received a signature from the authority on one of her pseudonyms. Somewhat surprisingly, not only do malleable signatures with respect to appropriate sets of transformations T yield anonymous credentials, but, as we show in this paper, they also yield delegatable anonymous credentials (DACs). A DAC system [20, 6] allows users to delegate their anonymous credentials; for example, a company employee can use his employee credential to issue a guest pass to a company visitor, who can in turn issue a credential to a taxi service that comes to pick her up; when presenting their credentials (and also when obtaining and delegating them), the various participants (the employee, his guest, and her driver) need not reveal any persistent identifiers or in fact anything about themselves. DACs are much more privacy-friendly than the traditional anonymous credential model, which assumes that the verifying party knows the public key of the credential issuer(s), as who issued Alice s credentials reveals a lot of information about Alice. For example, the identity of the local DMV that issued her driver s license might reveal her zip code. If, in addition to this, her date of birth and gender are leaked (as could happen in the context of a medical application), this is often enough to uniquely identify her [36, 27]. Verifiers that require more than one credential might learn Alice s identity even more easily. Since DACs protect the identity of every link on Alice s certification chain, they make it impossible to infer any information about Alice based on who issued her credentials. In order to construct a DAC from malleable signatures, we essentially follow the same outline as for the (non-delegatable) anonymous credential, but consider a different class of transformations. In the non-delegatable scenario, the transformation took as input Alice s nym and output Alice s nym. In the DAC scenario, when Alice is delegating her credential to Bob, she uses a transformation T that takes as input Alice s pseudonym nym A and the length l of her certification chain, and outputs Bob s pseudonym nym B and the length of his new certification chain l + 1; to be allowable, T s description must include Alice s secret key (recall that her pseudonym nym A is a commitment to her secret key), so that only Alice can perform this transformation. Intuitively, it is easy to see that this construction yields a DAC; yet its security crucially relies on a transformation being allowable not by virtue of its input-output behavior, but by virtue of what its description contains. As a result, previous definitions of security for malleable and homomorphic signatures are not strong enough to be useful for this application: DAC require not only that an allowable transformation exist, but that the party applying it know its description; i.e. that there exist an extractor that, with a special extraction trapdoor, can compute the description of the transformation. Additionally, to ensure Alice s privacy even in the face of adversarial root authorities, context hiding must hold even for adversarially generated public keys for the signature scheme. This flavor of context hiding has not previously been achieved. 2

3 Our contributions. In this paper, we overcome the definitional obstacle explained above by first proposing, in Section 3, new definitions for malleable signatures. Our definition of context hiding, extending that of Attrapadung et al., allows for adversarially-generated keys and signatures. Our unforgeability definition requires that the transformation T and the original message m that was signed by the signing oracle be extractable from (m, σ ). To ensure that these definitions are not overly strong, we relate them to the relevant definitions of Ahn et al. and Attrapadung et al. and observe that, for many classes of transformations, the definitions of unforgeability are equivalent (whereas working with adversarially-generated keys makes our definition of context hiding strictly stronger than their computational definitions). With these new definitions in hand, we then follow the intuition developed above and construct, in Section 4, a delegatable anonymous credentials scheme generically from a malleable signature and because the pseudonyms used in credentials seem to require it a commitment scheme. Our new definitions for malleable signatures also conveniently allow us to provide a new definition, presented in Section 2, for credential unforgeability; our definition is both more powerful and considerably simpler than existing definitions. In addition to satisfying this new definition, our construction provides several desirable functional features (non-interactive delegation and the ability to delegate polynomially many times), all while relying on a standard assumption (in our concrete instantiation of choice, Decision Linear [11]). Finally, to construct the signature that we generically rely on in our DAC construction, we provide in Section 5 a general construction of context-hiding malleable signatures for a large range of unary transformation classes. Our construction relies generically on non-interactive zero-knowledge (NIZK) proofs that provide controlled malleability; such proofs were recently defined and realized by Chase et al. [17] and allow, on input a proof π for an instance x L, for the efficient computation of a proof π of a related instance T inst (x) for an allowable transformation T = (T inst, T wit ), such that if w is a witness for x L, then T wit (w) is a witness for T inst (x) L. Aside from its usefulness in our construction of delegatable anonymous credentials, our signature construction enjoys other nice properties. Although it is not the first construction of signatures from zero-knowledge proofs the Fiat-Shamir heuristic [24] is an example of this approach, as are the signatures of knowledge due to Chase and Lysyanskaya [20] and the construction using PRFs due to Bellare and Goldwasser [8] ours is the first such construction to achieve malleability. In terms of constructions that focus on malleability, previous work gives adhoc constructions of malleable signatures for various allowable transformations (such as redactable signatures [31, 34, 16], quotable signatures [35], and transitive signatures [33, 9]), but ours is the first general efficient construction of malleable signatures. The only previous work that gave a general approach to homomorphic signatures was by Ahn et al. [3], who gave (among other contributions, such as an efficient construction of a quotable signature) an inefficient general construction for which a malleable signature on m is essentially a set of non-malleable signatures on {m m = T (m) T T }. Related work on malleable signatures. Here we distinguish between work on unary and n-ary transformations. As mentioned above, some specific types of unary homomorphic signatures have been studied over the last decade or so, such as redactable and quotable signatures in which, given a signature on a document m, one can derive signatures on a redacted version of m in which some parts are blacked out, or signatures on quotations from m. These can be viewed as special motivating cases of contexthiding malleable signatures (although some of the constructions in these early papers do not meet more recent definitions). A somewhat related but different type of signature is an incremental signature scheme [7], in which a signature on a document can be efficiently updated when the document is updated. Recent work on computing on authenticated data [3, 4] gives a general definitional framework for the problem (which we draw on in our definitions) and some general (but inefficient, as discussed above) constructions for unary transformations, as well as some efficient and elegant provably secure constructions for specific unary transformation classes, such as quoting and subsets. 3

4 As far as n-ary homomorphisms are concerned, this research direction was initiated by work on transitive signatures [33, 9] (in which, given signatures on the edges (u, v) and (v, w) of a graph, one can derive a signature on the edge (u, w)), and by Rivest in a series of talks; the first paper to address this subject more generally and consider several binary transformations was by Johnson et al. [32]. A more recent line of work explored homomorphic signatures under linear and polynomial functions [13, 12, 25, 5]; the emphasis in the papers cited is in transforming n message-signature pairs into a message-signature pair in which the message is some linear or polynomial function of the input messages. This is incomparable to our work because we are interested in more general transformations. Related work on delegatable anonymous credentials. The first construction of delegatable anonymous credentials, by Chase and Lysyanskaya [20], allowed a constant number of delegations. Belenkiy et al. [6] gave the first DAC system that allowed for a polynomial number of delegations using Groth-Sahai proofs [30]; their construction, however, was somewhat ad-hoc and relied on ad-hoc assumptions. Finally, Fuchsbauer [26] gave a construction that built on the construction of Belenkiy et al. and allows for non-interactive issuing and delegation of credentials, also based on ad-hoc assumptions. Our construction essentially combines many of the nicest features of each of these previous constructions. First, we support non-interactive issuing and delegation of credentials, as do Chase and Lysyanskaya, and Fuchsbauer, but not Belenkiy et al. Second, we support credentials that scale linearly with the number of times they are delegated, as do Belenkiy et al. and Fuschbauer, but not Chase and Lysyanskaya. Third, we can instantiate cm-nizks, and thus our malleable signature and entire credentials construction, under the standard and well-established Decision Linear assumption, whereas Belenkiy et al. and Fuschbauer both use less desirable assumptions. (The construction of Chase and Lysyanskaya is based on general assumptions.) Finally, we realize a simulation-extractable notion of delegatable anonymous credentials that is simpler and more efficiently realizable than any of the previous definitions. 2 Preliminaries and Notation As our construction of a malleable signature in Section 5 depends on malleable proofs, we first discuss the definitions for such proofs here. We next recall existing definitions for delegatable anonymous credentials, and propose our new definition for credential unforgeability. Malleable proofs In Section 5, we generically construct malleable signatures using malleable proofs. Briefly, a malleable proof [17] is a tuple of algorithms (CRSSetup, P, V, ZKEval), in which the first three algorithms constitute a standard non-interactive zero-knowledge proof of knowledge (defined formally in Appendix A). The fourth algorithm, ZKEval, given a transformation T = (T inst, T wit ), an instance x, and a proof π such that V(crs, x, π) = 1, outputs a proof π such that V(crs, T inst (x), π ) = 1; i.e., outputs a valid proof for the transformed instance. The proof system is then malleable with respect to some set of transformations T if for every T T, ZKEval can be efficiently computed. (This is defined formally in a manner similar to our Definition 3.1.) In addition to this basic definition of malleability, Chase et al. give amplified security notions for such proofs that are analogous to our amplified notions for signatures; we recall the formal definitions of their notions in Appendix A. The first, controlled-malleable simulation-sound extractability (CM-SSE) is a strong notion of extractability in which, from a valid proof π for an instance x, an extractor can extract either a witness w such that (x, w) R, or a previously proved instance x and transformation T such that x = T (x ) and T T. The second, derivation privacy, requires that a proof does not reveal whether it was constructed fresh (i.e., using a witness) or by transformation; a related definition, strong derivation privacy, requires instead that a proof does not reveal whether it was constructed by 4

5 the simulator or by transformation. Putting these together, if a proof is zero knowledge, CM-SSE, and strongly derivation private, then it is called a cm-nizk. Delegatable anonymous credentials At a high level, delegatable anonymous credentials (DAC) allow credentials to be both delegated and issued within the context of a system in which users are pseudonymous; i.e., may be using a different pseudonym for each of the different people with whom they interact. As such, algorithms are required for generating each of these pseudonyms, as well as issuing and delegating credentials, and proving (in an anonymous way) the possession of a credential. More formally, a delegatable anonymous credentials scheme consists of eight algorithms (Setup, KeyGen, NymGen, NymVerify, Issue, CredProve, CredVerify, Delegate) that behave as follows: Setup(1 k ): Generate public parameters params for the system. KeyGen(params): Generate public and secret keypair (pk, sk); the secret key sk represents a user s true identity. NymGen(params, sk): Compute a pseudonym for the user corresponding to sk. NymVerify(params, nym, sk, open): Check that a given pseudonym nym belongs to the user corresponding to sk. (In practice, this algorithm will never be run; instead, a user might form a proof of knowledge of a sk corresponding to nym such that this holds.) Issue(params, sk 0, pk 0, nym r ): Issue a credential, rooted at the authority who owns pk 0, to the pseudonym nym r. CredProve(params, sk, nym, open, nym, open, cred): Prove possession of credential cred that has been delegated to nym, where the owner of nym also owns a pseudonym nym. CredVerify(params, pk 0, nym, l, π): Verify that the pseudonym nym is in possession of a level-l credential, rooted at pk 0. Delegate(params, sk old, nym old, open old, nym new, cred): Delegate the credential cred, currently delegated to the pseudonym nym old, to the pseudonym nym new. The main security requirements are anonymity and unforgeability. For anonymity, we require that pseudonyms hide their owners secret keys, and that a proof of possession of a credential does not reveal the pseudonym to which the credential was initially issued by the root authority, or the pseudonyms to which the credential was delegated. For unforgeability, we require that one cannot prove possession or delegate a credential without knowing a secret key corresponding to some pseudonym to which a credential has been issued. In order to conceptually identify users with pseudonyms, we require that a nym output by NymGen is a computationally hiding, unconditionally binding commitment to the underlying sk, such that NymVerify verifies the opening (sk, open). Our definition of anonymity is fairly similar to the definition given by Belenkiy et al.; the main modifications are our non-interactive Issue protocol and that simulated parameters are distributed identically to those output by Setup. Essentially, we require that there exist a simulator (SimSetup, SimCred, SimProve) such that (1) SimSetup produces parameters and the simulation trapdoor, (2) SimCred takes as input the parameters, the simulation trapdoor, the root authority public key, a pseudonym and a level, and produces credentials indistinguishable from those produced by Issue and Delegate, and (3) SimProve, given the same set of inputs as SimCred, produces proofs indistinguishable from those produced by CredProve. Our definition of unforgeability, on the other hand, is a departure from that of Belenkiy et al. It is conceptually similar to the definition of simulation-sound extractability for non-interactive zero knowledge, in that we require that unforgeability should hold in the presence of a simulator that grants and proves possession of credentials at any level for any pseudonym of the adversary s choice without 5

6 access to the root authority s secret key. (In contrast, Belenkiy et al. s unforgeability game required a parameter setting for which the simulator was undefined.) Formally, we define an augmented setup algorithm SimExtSetup that produces (params, τ s, τ e ) such that (params, τ s ) is distributed identically to the output of SimSetup. We then have the following definition. Definition 2.1 (Unforgeability). A delegatable anonymous credentials scheme (Setup, KeyGen, NymGen, NymVerify, Issue, CredProve, CredVerify, Delegate) with simulator (SimSetup, SimCred, SimProve) is unforgeable if there exists a pair (SimExtSetup, Extract) (where SimExtSetup augments SimSetup) such that (1) nym is a computationally hiding, unconditionally binding commitment when params are chosen by SimExtSetup, even when τ s and τ e are given; and (2) it is hard to form a proof of a credential for a pseudonym nym at level l without knowing the secret key corresponding to nym as well as the secret key corresponding to some nym 1 to which a credential at level l l has been issued; formally, for any adversary A, consider the following game, wherein SimCred, SimProve, and Extract share state: Step 1. (params, τ s, τ e ) $ SimExtSetup(1 k ); (vk 0, sk 0 ) $ KeyGen(params). Step 2. ((nym, l), π) $ A SimCred(params,τs,vk 0,, ),SimProve(params,τ s,vk 0,, ) (params, vk 0 ). Step 3. ({(nym i, sk i, open i )} k i=1, l ) Extract(params, τ e, (vk 0, nym, l), π), where nym k = nym and l + k 2 = l. Then for all PPT algorithms A there exists a negligible function ν( ) such that the probability (over the choices of SimExtSetup, SimCred, SimProve, and A) that CredVerify(params, vk 0, nym, l, π) = 1 and (nym, l) was not queried to SimProve but either 1. A created a new credential; i.e., (nym 1, l ) was not queried to SimCred or l < l, 2. A delegated through pseudonyms it did not own; i.e., NymVerify(params, nym j, sk j, open j ) = 0 for some j, 1 j k, or 3. A proved possession for a credential it did not own; i.e., sk k 1 sk k, is at most ν(k). Note that in the definition above, it is important that a pseudonym hides the underlying secret key even given the simulation and extraction trapdoors because otherwise the extractor s job would be too easy: it could just pick any pseudonym nym 1 (with a low enough level) that the adversary has queried, use the extraction trapdoor to learn the corresponding sk 1, and pretend that that s the one from which the credential was delegated. This way, however, the extractor can only do this if the proof of possession π is a proof of knowledge of, among other things, sk 1. In addition to our new definition of credential unforgeability, we also give formal notions of correctness and of anonymity, which we briefly sketched above. Before we can establish the definition of correctness for a credentials scheme, we first need to define what it means for a credential to be valid. Definition 2.2 (Valid credential). For parameters params, we say that a value cred is a valid level- l credential rooted at pk 0 and belonging to nym if proofs of the credential with respect to compatible pseudonyms always verify. More formally, for all sk, open, open such that NymVerify(params, nym, sk, open) = 1 and NymVerify(params, nym, sk, open ) = 1, Pr[π $ CredProve(params, sk, nym, open, nym, open, cred) : CredVerify(params, pk 0, nym, l, π) = 1] = 1. In what follows, we use the notation y D(x) to denote that P r[d(x) = y] > 0; e.g., params Setup(1 k ) indicates that params might have been produced by Setup (using some appropriate randomness). 6

7 Definition 2.3 (Correctness). A delegatable anonymous credentials scheme (Setup, KeyGen, NymGen, NymVerify, Issue, CredProve, CredVerify, Delegate) is correct if for all params Setup(1 k ) and (pk 0, sk 0 ) KeyGen(params), the following properties are satisfied: Valid pseudonyms verify; i.e., for all (nym, open) NymGen(params, sk 0 ), NymVerify(params, nym, sk 0, open) = 1. Only valid credentials verify; i.e., if there exist sk, open, and open with NymVerify(params, nym, sk, open) = 1 and NymVerify(params, nym, sk, open ) = 1, such that CredVerify(params, pk 0, nym, l, CredProve(params, sk, nym, open, nym, open, cred)) = 1, then cred is a valid credential. The credential output by Issue verifies; i.e., for all (pk, sk) KeyGen(params), (nym, open) NymGen(params, sk), and cred Issue(params, sk 0, pk 0, nym), cred is a valid level-1 credential, rooted at pk 0 and belonging to nym. An honestly delegated credential verifies; i.e., for all (pk, sk), (pk new, sk new ) KeyGen(params), (nym, open) NymGen(params, sk), (nym new, open new ) NymGen(params, sk new ), valid level-l credentials cred rooted at pk 0, and cred Delegate(params, sk, nym, open, nym new, cred), cred is a valid level-l + 1 credential, rooted at pk 0 and belonging to nym. Definition 2.4 (Anonymity). A delegatable anonymous credentials scheme (Setup, KeyGen, NymGen, NymVerify, Issue, CredProve, CredVerify, Delegate) is anonymous if there exist PPT algorithms SimSetup, SimCred, SimProve, and VerifyPK such that the following properties are satisfied: For all params Setup(1 k ), VerifyPK(params, pk 0, sk 0 ) = 1 if and only if (pk 0, sk 0 ) KeyGen(params). The pseudonyms are hiding even given the trapdoors, i.e. for a bit b and a PPT adversary A, define p A b (k) to be the probability of the event that b = 0 in the following game: Step 1. (params, τ s, τ e ) $ SimExtSetup(1 k ). Step 2. (vk 0, sk 0, vk 1, sk 1, state) $ A(params, τ s, τ e ). Step 3. If VerifyPK(params, vk 0, sk 0 ) = 0 or VerifyPK(params, vk 1, sk 0 ) = 0, output. Otherwise, compute (nym, open) NymGen(params, sk b ). Step 4. b $ A(state, nym). Then for all PPT algorithms A, there exists a negligible function ν( ) such that p A 0 (k) pa 1 (k) < ν(k). The simulator SimCred can simulate issuing credentials; i.e. for all PPT adversaries A, Pr[params $ Setup(1 k ) : A Issue (params,,, ) (params) = 1] Pr[(params, τ s ) $ SimSetup(1 k ) : A SimCred (params,τ s,,, ) (params) = 1], where these oracles behave as follows: given (sk 0, pk 0, nym), both Issue and SimCred output if VerifyPK(params, pk 0, sk 0 ) = 0; otherwise, Issue outputs Issue(params, sk 0, pk 0, nym) and SimCred outputs SimCred(params, τ s, pk 0, nym, 1). The simulator SimCred can simulate delegation of credentials at any level l; i.e., for a bit b and a PPT adversary A, define p A b (k) to be the probability of the event that b = 0 in the following game: Step 1. (params, τ s ) $ SimSetup(1 k ). Step 2. (state, sk old, nym old, open old, nym new, pk 0, l, cred) $ A(params, τ s ). 7

8 Step 3. If NymVerify(params, nym old, sk old, open old ) = 0 or cred is not a valid level-l 1 credential rooted at pk 0 belonging to nym old, output. 1 Otherwise, cred $ { Delegate(params, sk old, nym old, open old, nym new, cred) if b = 0 SimCred(params, τ s, pk 0, nym new, l) if b = 1 Step 4. b $ A(state, cred ). Then for all PPT algorithms A, there exists a negligible function ν( ) such that p A 0 (k) pa 1 (k) < ν(k). The simulator SimProve can simulate proving credentials for any level l; i.e., for a bit b and a PPT adversary A, define p A b (k) to be the probability of the event that b = 0 in the following game: Step 1. (params, τ s ) $ SimSetup(1 k ). Step 2. (state, pk 0, sk, nym, open, nym, open, l, cred) $ A(params, τ s ). Step 3. If NymVerify(params, nym, sk, open) = 0 or NymVerify(params, nym, sk, open ) = 0 or cred is not a valid level-l 1 credential rooted at pk 0 and belonging to nym, output. Otherwise, { π $ CredProve(params, sk, nym, open, nym, open, cred) if b = 0 SimProve(params, τ s, pk 0, nym, l) if b = 1 Step 4. b $ A(state, cred ). Then for all PPT algorithms A, there exists a negligible function ν( ) such that p A 0 (k) pa 1 (k) < ν(k). 3 Defining Malleable Signatures Formally, a malleable signature scheme consists of four algorithms: KeyGen, Sign, Verify, and SigEval. The first three comprise a standard signature; the additional algorithm, SigEval, on input the verification key vk, messages m = (m 1,..., m n ), signatures σ = (σ 1,..., σ n ), and a transformation T on messages, outputs a signature σ on the message T ( m). (Here, and in all of our definitions, we consider the most general case wherein the transformation may combine many messages. Our construction in Section 5, however, supports only unary transformations; i.e., those operating on a single message.) Definition 3.1 (Malleability). A signature scheme (KeyGen, Sign, Verify) is malleable with respect to a set of transformations T if there exists an efficient algorithm SigEval that on input (vk, T, m, σ), where (vk, sk) $ KeyGen(1 k ), Verify(vk, σ i, m i ) = 1 for all i, and T T, outputs a valid signature σ for the message m := T ( m); i.e., a signature σ such that Verify(vk, σ, m) = 1. Here we immediately note one key notational difference with the previous definitions of Ahn et al. [3] and Attrapadung et al. [4]; whereas their definitions were given with respect to a predicate on input and output messages, we found it more natural to instead consider the set of allowed transformations. (This was especially natural given that our construction of a malleable signature uses a malleable proof, which is itself defined in the context of transformations.) By using transformations, we inherently capture the dual requirements that the result of an operation be efficiently computable, and that an adversary know the transformation that was applied; these requirements could also potentially be captured using predicates (e.g., by using an optional witness input to the predicate), but in a more roundabout way. 1 By correctness, to test this latter property efficiently it suffices to form a proof of possession of cred and then see if it verifies, as only valid credentials verify. 8

9 3.1 Simulation-based definitions for malleable signatures In order to achieve the stronger notions of unforgeability and context hiding needed to support credentials, we begin with the idea of a simulatable signature, introduced by Abe, Haralambiev, and Ohkubo [2, 1], in which there are two indistinguishable ways of producing a signature: using the signing key and the standard signing algorithm, or using a global trapdoor and a simulated signing algorithm. Our reasons for using simulatability are two-fold: first, it allows us to easily consider the notion of context hiding with respect to adversarially-chosen keys, as well as a simpler notion for signature unforgeability (much as Ahn et al. used context hiding to achieve a simpler version of their unforgeability definition). Second, simulatability lines up nicely with the anonymity requirements for credentials, in which there should exist a simulator that can simulate credentials. Before we present our definition of simulatability which is somewhat modified from the original; in particular they required only that simulated signatures verify, whereas we require them to be indistinguishable from standard signatures we must expand the standard notion of a signature scheme to consider signature schemes in which the key generation process is split up into two parts: a trusted algorithm Gen for generating universal parameters crs (we can think of these as the setting; e.g., the description of a group), and an algorithm KeyGen that, given these parameters, generates a keypair (vk, sk) specific to a given signer. Definition 3.2 (Simulatability). A signature scheme (Gen, KeyGen, Sign, Verify) is simulatable if there exists an additional PPT algorithm KeyCheck that, on input crs, vk, and sk, outputs whether or not (vk, sk) is in the range of KeyGen(crs), and a PPT simulator (SimGen, SimSign) such that the CRS in (crs, τ s ) $ SimGen(1 k ) is indistinguishable from crs $ Gen(1 k ) and signatures produced by SimSign are indistinguishable from honest signatures; i.e., for all PPT A, Pr[crs $ Gen(1 k ) : A S(crs,,, ) (crs) = 1] Pr[(crs, τ s ) $ SimGen(1 k ) : A S (crs,τ s,,, ) (crs) = 1], where, on input (vk, sk, m), S outputs if KeyCheck(crs, vk, sk) = 0 and Sign(crs, sk, m) otherwise, and S outputs if KeyCheck(crs, vk, sk) = 0 and SimSign(crs, τ s, vk, m) otherwise. Although simulatability might seem to be a fairly strong property, we show in Appendix B that any non-simulatable signature scheme in the standard model can be easily transformed into a simulatable signature scheme in the CRS model (i.e., using split Gen and KeyGen algorithms) by adding a proof of knowledge to the public key. Our signature construction in Section 5 also achieves simulatability directly by using cm-nizks. 3.2 Simulation context hiding With simulatability in hand, we next present a definition of context hiding that requires transformed signatures to be indistinguishable from freshly simulated signatures on the transformed messages; note that if regular signatures were used instead of simulated signatures, this would be quite similar to the standard notion of context hiding. As mentioned above, however, incorporating simulatability allows us to easily build in the notion of adversarially-generated keys, which will be especially useful for our credentials application. Definition 3.3 (Simulation context hiding). For a simulatable signature (Gen, KeyGen, Sign, Verify, SigEval) with an associated simulator (SimGen, SimSign), malleable with respect to a class of transformations T, and an adversary A and a bit b, let p A b (k) be the probability of the event that b = 0 in the following game: Step 1. (crs, τ s ) $ SimGen(1 k ). 9

10 Step 2. (state, vk, m, σ, T ) $ A(crs, τ s ). Step 3. If Verify(crs, vk, σ i, m i ) = 0 for some i or T / T, abort and output. Otherwise, form σ $ SimSign(crs, τ s, vk, T ( m)) if b = 0, and σ $ SigEval(crs, vk, T, m, σ) if b = 1. Step 4. b $ A(state, σ). Then the signature scheme satisfies simulation context hiding if for all PPT algorithms A there exists a negligible function ν( ) such that p A 0 (k) pa 1 (k) < ν(k). Unsurprisingly, as we show in Appendix B, by incorporating the notion of adversarially-generated keys we provide a strictly stronger definition than any of the existing definitions for computational context hiding. While Ahn et al. and Attrapadung et al. both provide statistical variants on context hiding, we cannot hope to simultaneously achieve statistical hiding and a meaningful notion of extractability in our unforgeability definition. 3.3 Simulation unforgeability The main point at which our unforgeability definition diverges significantly from previous definitions is in considering how to check whether a message and signature output by the adversary are in fact a forgery, or whether they were instead obtained using a valid transformation from the signatures issued by the signer. For many simple classes of transformations this may be easy to do given the set of signed messages, but for classes of transformations that are exponentially (or even infinitely) large, it is not clear that this can be done in an efficient manner. Whereas previous definitions for unforgeability were limited to these simple classes of transformations (as was explicitly acknowledged by Ahn et al., who point out that for many predicates it may be impossible to verify whether or not the adversary has won their unforgeability game), for our credentials application it is crucial that the winning conditions be efficiently testable, even in the face of a complex and infinitely large class of unary transformations; beyond efficient testability, credentials inherently require that signatures can t be transformed without knowledge of some appropriate secret information. Translating this requirement back to malleable signatures, we therefore require that an adversary knows which valid transformation it is applying in order to generate a transformed signature; again, this is quite different from previous definitions, that require only that there exists some valid transformation corresponding to any signature produced by the adversary. We build in this requirement by using an extractor that given the produced message and signature, as well as the set of signed messages produces the transformation (if one exists) that was used to get from the signed message to the produced message; checking if the adversary won is then as simple as checking if this extracted transformation is in the allowed class. Note that giving the extractor the set of signed messages is a deviation from the standard simulation-sound extractability approach for proofs; this is because in a proof system, it is impossible to describe all the proved statements, as the adversary can form proofs himself. Signatures, however, should be created only with the signing key and thus this notion is meaningful; furthermore, it allows us to support larger classes of transformations, such as n-ary transformations, that would seem to be impossible without this extra information. By using simulatability, we are able to replace all honestly generated and transformed signatures with signatures generated by a simulator; this means that we can simply give the adversary access to an oracle that generates simulated signatures, which has the advantage that we end up with a much cleaner definition than the main one of Ahn et al. (they also provide a similar simplification using the notion of statistical context hiding). The result is a definition similar to that of simulation-sound extractability [22, 28], in which we simulate and extract at the same time. To formalize this game, in which we need to both simulate and extract, we require an amplified setup, SimExtGen, that outputs a tuple (crs, τ s, τ e ); we then require the (crs, τ s ) part of this to be distributed 10

11 identically to the output of SimGen, and we now give τ e as input to SigExt. To cover the case of simple but potentially n-ary transformations, where not all the information about a transformation can be encoded in the signature, the extractor is also given access to the query history Q. Definition 3.4 (Simulation unforgeability). For a simulatable signature (Gen, KeyGen, Sign, Verify, SigEval) with an associated PPT simulator/extractor (SimExtGen, SimSign, SigExt) that is malleable with respect to a class of transformations T, an adversary A, and a table Q = Q m Q σ that contains messages queried to SimSign and their responses, consider the following game: Step 1. (crs, τ s, τ e ) $ SimExtGen(1 k ); (vk, sk) $ KeyGen(crs). Step 2. (m, σ ) $ A SimSign(crs,τs,vk, ) (crs, vk, τ e ). Step 3. ( m, T ) SigExt(crs, vk, τ e, m, σ, Q). Then the signature scheme satisfies simulation unforgeability if for all such PPT algorithms A there exists a negligible function ν( ) such that the probability (over the choices of KeyGen, SimSign, and A) that Verify(vk, σ, m ) = 1 and (m, σ ) / Q but either (1) m Q m, (2) m T ( m ), or (3) T / T is at most ν(k). Having now argued that our definition is significantly stronger than previous definitions, one might be concerned that our definition might be overly restrictive, in the sense that it might rule out previous constructions or many interesting classes of transformations. As we show in Appendix B, however, when considering many transformation classes, including essentially all those for which constructions are known, our definition of unforgeability is equivalent to that of Ahn et al. (with respect to simulatable signatures which, as mentioned above, can be easily and generically obtained from non-simulatable signatures). Thus, although our definition does automatically rule out certain classes of transformations (i.e., those where the transformation cannot be efficiently derived given the query list and some limited amount of extra information), to date this does not seem to be a significant limitation on the schemes we can construct. 4 Delegatable Anonymous Credentials from Malleable Signatures Recall the desired functionality of a credential system: there are various users, each in possession of some secret key, who can use different pseudonyms to represent themselves to other participants; a credential authority (CA) publishes some public key pk. To form a pseudonym, a user Alice can compute a commitment to her secret key sk A ; again, each user might know her under a different pseudonym. The CA may issue a credential to Bob, known to it by the pseudonym B 1, by forming a signature on B 1 using sk; this signature attests to the fact that the CA issued a level-1 credential to the user who owns the pseudonym B 1. Bob might now wish to do one of two things with this credential: he can either prove possession of this credential to another user, who might know him under a different pseudonym B 2, or he can delegate this credential to another user, Carol, whom he knows under the pseudonym C 1. To delegate, Bob can give to Carol a level-2 credential belonging to her pseudonym C 1, that is rooted at the authority pk; note that Bob shold only be able to perform this operation if he is the rightful owner of the pseudonym B 1 to which the credential was issued. In order to fit this framework, credentials must therefore reveal three pieces of information: the root authority, denoted pk 0, the recipient of the credential, denoted nym r, and the level of the credential, denoted l. 4.1 Allowable transformations First, let us describe all of the components in the above landscape in terms of commitments, messages, signatures, and transformations. We already saw that pseudonyms are represented as commitments; 11

12 this leaves delegation and issuing of credentials, which will be represented using transformations, and credentials and proofs of possession, which will be represented using signatures. Intuitively, to create an initial credential, the root authority signs the message m = (nym, 1), using a signing key pair (vk, sk), to obtain a signature σ; the credential is the tuple (vk, nym, 1, σ), and anyone can verify that this is a valid credential by running the signature verification algorithm Verify(vk, σ, (nym, 1)). To delegate, the user corresponding to nym can maul the signature σ, using SigEval, to specify a new recipient nym and increase the level. This intuitive construction, however, does not contain enough information to allow users to prove possession of credentials. To do this, we add a bit of information to the message, meaning messages are now of the form m = (nym, l, flag), where either flag = credential (to indicate that Alice is delegating a credential) or flag = proof (to indicate that Alice is proving possession of a credential). Delegation can still proceed in the same way as before, but now Alice can additionally prove possession of the credential by switching the flag from credential to proof, and changing the recipient to a fresh pseudonym nym (that still belongs to Alice); this means that a proof object is really still a credential. Formally, messages to be signed are of the form m = (nym, l, flag), where nym is a pseudonym, l is a level, and flag = credential/proof. In order to carry out a valid transformation and delegate a credential to another pseudonym, nym, one must know (sk, open) that corresponds to nym. Thus, the description of a valid transformation that takes as input the message m = (nym, l, credential) and outputs T (m) = (nym, l+1, credential) must include (sk, open). In order to carry out the transformation that allows the owner of nym to prove possession of a credential in a context where she is known by another pseudonym, nym, one needs to know (sk, open, open ) such that (sk, open) correspond to nym, and (sk, open ) correspond to nym. Thus, the description of a valid transformation that takes as input the message m = (nym, l, credential) and outputs T (m) = (nym, l, proof) must include (sk, open, open ). More generally, transformations may take a level-l credential and output a level-l + k credential, which means that its description T is of the form T = ({nym j, sk j, open j } k j=1, nym new, flag ), where flag = credential means the transformation outputs a delegated credential and flag = proof means it outputs a proof, and (nym new, l + k, credential) if nym 1 = nym and flag = flag = credential T (nym, l, flag) := (nym new, l + (k 2), proof) if nym 1 = nym, flag = credential, and flag = proof otherwise. (1) Thus, the set of allowable transformations T dac consists of transformations whose description is T = ({nym j, sk j, open j } k j=1, nym new, flag ), whose input/output behavior is as in Equation 1, and such that 1. A user needs a pseudonym to which a credential was issued before the user can delegate: k > A user can only delegate a credential he owns; i.e., he must know the opening of the pseudonym to which it was issued: for commitment parameters params, nym j = Com(params, sk j ; open j ) for all 1 j k. 3. If this is a proof of possession, meaning flag = proof, then k 2 and T must include the opening of nym new, so nym k = nym new. Additionally, the owner of nym new must be the same as the owner of the pseudonym to which the credential was delegated, so sk k = sk k 1. In terms of credential size, we can see that messages scale logarithmically with the number of levels (as they need to represent the integer l), while the size of the description of a transformation scales linearly. Since credentials should (as part of their functionality) explicitly reveal how many times they have been delegated, this dependence seems inevitable. 12

13 4.2 Our construction Our construction follows the intuition developed above: to form a pseudonym, a user forms a commitment to a signing secret key; to issue a credential, the root authority signs the recipient s pseudonym and the intended level of the credential; and to delegate and prove possession of a credential, a user mauls the credential (i.e., signature) using one of the allowable transformations defined above. Formally, we use a simulatable signature (Gen, KeyGen, Sign, Verify, SigEval), malleable with respect to T dac, and a commitment scheme (ComSetup, Com) as follows: Setup(1 k ): Compute crs $ Gen(1 k ) and params $ ComSetup(1 k ). Output params := (crs, params ). KeyGen(params): Output (vk, sk) $ KeyGen(1 k ). NymGen(params, sk): Pick a random opening open, compute nym := Com(params, sk; open), and output (nym, open). NymVerify(params, nym, sk, open): Check that nym = Com(params, sk; open); output 1 if this holds and 0 otherwise. Issue(params, sk 0, vk 0, nym r ): Compute σ $ Sign(crs, sk 0, (nym r, 1, credential)) and output cred := (vk 0, 1, nym r, σ). CredProve(params, sk, nym, open, nym, open, cred): Parse cred = (vk 0, l, nym, σ) and abort if Verify( crs, vk 0, σ, (nym, l, credential)). Otherwise, set T := (((nym, sk, open), (nym, sk, open )), nym, proof), compute σ $ SigEval(crs, vk 0, T, (nym, l, credential), σ), and output π := (nym, σ ). CredVerify(params, vk 0, nym, l, π): Parse π = (nym, σ ); output 0 if nym nym. Otherwise, output Verify(crs, vk 0, σ, (nym, l, proof)). Delegate(params, sk old, nym old, open old, nym new, cred): Parse cred = (vk 0, l, nym old, σ) and abort if Verify(crs, vk 0, σ, (nym, l, credential)). Otherwise, set T := ((nym old, sk old, open old ), nym new, credential), compute σ $ SigEval(crs, vk 0, T, (nym old, l, credential), σ), and output cred := (vk 0, l+ 1, nym new, σ ). Theorem 4.1. If the commitment scheme is computationally hiding and perfectly binding, and the signature is simulatable, simulation unforgeable, and simulation context hiding with respect to T dac, then the above construction describes a secure delegatable anonymous credentials scheme, as defined in Section 2. In the next section, we see how to instantiate the malleable signature, using cm-nizks, to achieve the required malleability and security properties. As we can instantiate both the cm-nizk and thus the malleable signature and the commitment scheme using the Decision Linear assumption [11], the security of our entire credentials construction is based on this relatively mild assumption. To prove Theorem 4.1, we break it up into three lemmas, one for each desired property: correctness, anonymity, and unforgeability. Lemma 4.2. If the commitment scheme is correct, and the signature scheme is correct and malleable, as defined in Definition 3.1, the above construction describes a correct DAC scheme. Proof. By the correctness of the commitment scheme, valid pseudonyms (i.e., pseudonyms produced by NymGen) always verify. To see that CredProve produces a verifying proof only when given a valid credentials as input, we observe that verifying credentials must contain a valid signatures, as otherwise a proof under any pseudonym would fail. Thus by malleability the π output by CredProve verifies for all pseudonyms and thus the credential is valid. To see that honestly issued credentials also verify, we observe that by signature correctness the credential output by Issue is a valid credential, and by malleability the π output by CredProve verifies as well. Similarly, by malleability the credential output 13

14 by Delegate is a valid credential, and again by malleability the π output by CredProve will verify as well. Lemma 4.3. If (Gen, KeyGen, Sign, Verify, SigEval) is simulatable and simulation context hiding (as defined in Definitions 3.2 and 3.3 respectively), and the commitment scheme is hiding, then the above construction describes an anonymous DAC scheme, as defined in Definition 2.4. Proof. To prove this, we must prove that the four properties described in Definition 2.4 are satisfied. We take each of them in turn. We first define the simulators SimSetup and SimCred and VerifyPK. The simulator SimSetup runs $ (crs, τ s ) SimGen(1 k ) and params $ ComSetup(1 k ), and outputs (params := (crs, params ), τ s ). The simulator SimCred on input (params, τ s, vk 0, nym new, l) outputs (vk 0, l + 1, nym new, SimSign(crs, τ s, vk 0, (nym new, l + 1, credential)). Finally, VerifyPK is defined in terms of KeyCheck. Pseudonym hiding. This follows directly from the hiding property of the commitment. Issue simulatability. We argue that signature simulatability implies that an adversary cannot distinguish between honest parameters and honestly issued credentials and parameters formed by SimSetup and credentials formed by SimCred. To do this, we assume there exists an adversary A that can distinguish between these two cases with some non-negligible advantage ɛ and use it to construct an adversary B that breaks simulatability with the same advantage. To start, B receives as input a CRS crs. It now forms params $ ComSetup(1 k ) and gives params := (crs, params ) to A. When A queries for (sk 0, pk 0, nym r ), B queries (pk 0, sk 0, m = (nym r, 1, credential)) to the signing oracle of the simulatability game to get back a signature σ; it then returns (pk 0, 1, nym r, σ) to A. At the end of the game, if A guesses b = 0 then B guesses it is using an honest CRS and interacting with the signer, and if A guesses b = 1 then B guesses it is using a simulated CRS and interacting with the simulator. As B gives to A crs $ Gen(1 k ) and credentials of the form (pk 0, 1, nym r, σ $ Sign(crs, sk 0, (nym r, 1, credential))) = Issue(params, sk 0, pk 0, nym r ) when it is interacting with the real signer using an honest CRS, and crs $ SimGen(1 k ) and credentials of the form (pk 0, 1, nym r, σ $ SimSign(crs, τ s, pk 0, (nym r, 1, credential))) = SimCred(params, τ s, pk 0, nym r, 1) when it is interacting with SimSign using a simulated CRS, it therefore perfectly simulates the behavior that A expects. As B furthermore succeeds whenever A does, B succeeds with the same non-negligible advantage. Delegation simulatability. We argue that simulatable context hiding implies that an adversary cannot distinguish between honestly delegated credentials and ones formed by SimCred. To prove this we assume there exists an adversary A that can distinguish between credentials from Delegate and from SimCred with some non-negligible advantage ɛ and use it to construct an adversary B that breaks simulation context hiding with the same advantage. To start, B receives as input a pair (crs, τ s ); it then forms params $ ComSetup(1 k ) and gives params := (crs, params ) to A. When A outputs (sk old, nym old, open old, nym new, pk 0, l, cred), B first checks that NymVerify(params, nym old, sk old, open old ) = 1 and that cred is a valid level-l credential rooted at pk 0 ; it aborts and outputs if any of these checks fail. Otherwise, B parses cred = (pk 0, l, nym old, σ) and sets T := ((nym old, sk old, open old ), nym new, credential) and m := (nym old, l, credential); it then outputs its own tuple (pk 0, (m, σ), T ) to get back a signature σ, and returns (pk 0, l + 1, nym new, σ ) to A. At the end, B outputs the opposite guess bit as A. As B returns (pk 0, l+1, nym new, σ $ SimSign(crs, τs, pk 0, T (m))) = SimCred(params, τ s, pk 0, nym new, l) in the case that b = 0, and (pk 0, l + 1, nym new, σ $ SigEval(crs, pk 0, T, (m, σ))) = 14