Abstract 1 Introduction 2 Our Results 3 Preliminaries 4 𝒌𝒌+𝟏 Unforgeability of Subset States 5 Multi-Copy Revocable Encryption: Definition 6 Construction of Multi-Copy Secure Revocable Encryption 7 Multi-Copy Revocable Programs: Definition 8 Construction of Multi-Copy Secure Revocable Programs in a Classical Oracle Model 9 Construction of Multi-Copy Secure Revocable Point Functions in the QROM 10 Applications to Sponge Hashing References

Revocable Encryption, Programs, and More:
The Case of Multi-Copy Security

Prabhanjan Ananth ORCID University of California, Santa Barbara, CA, USA Saachi Mutreja Columbia University, New York, NY, USA Alexander Poremba ORCID Massachusetts Institute of Technology, Cambridge, MA, USA
Abstract

Fundamental principles of quantum mechanics have inspired many new research directions, particularly in quantum cryptography. One such principle is quantum no-cloning which has led to the emerging field of revocable cryptography. Roughly speaking, in a revocable cryptographic primitive, a cryptographic object (such as a ciphertext or program) is represented as a quantum state in such a way that surrendering it effectively translates into losing the capability to use this cryptographic object. All of the revocable cryptographic systems studied so far have a major drawback: the recipient only receives one copy of the quantum state. Worse yet, the schemes become completely insecure if the recipient receives many identical copies of the same quantum state – a property that is clearly much more desirable in practice. While multi-copy security has been extensively studied for a number of other quantum cryptographic primitives, it has so far received only little treatment in context of unclonable primitives. Our work, for the first time, shows the feasibility of revocable primitives, such as revocable encryption and revocable programs, which satisfy multi-copy security in oracle models. This suggest that the stronger notion of multi-copy security is within reach in unclonable cryptography more generally, and therefore could lead to a new research direction in the field.

Keywords and phrases:
quantum cryptography, unclonable primitives
Funding:
Prabhanjan Ananth: Supported by the National Science Foundation under the grants FET-2329938 and the Career award (2341004).
Saachi Mutreja: Supported by AFOSR award FA9550-21-1-0040, NSF CAREER award CCF-2144219, and the Sloan Foundation.
Alexander Poremba: Supported by the U.S. Department of Energy, Office of Science, National Quantum Information Science Research Centers, Co-design Center for Quantum Advantage (C2QA) under contract number DE-SC0012704.
Copyright and License:
[Uncaptioned image] © Prabhanjan Ananth, Saachi Mutreja, and Alexander Poremba; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Cryptographic primitives
Related Version:
Full Version: https://eprint.iacr.org/2024/1687
Acknowledgements:
The authors would like to thank Henry Yuen and Tal Malkin for many useful discussions.
Editor:
Niv Gilboa

1 Introduction

Designing mechanisms to provably revoke cryptographic capabilities is an age-old problem [46, 45]. In the public-key infrastructure, certificate authorities have the ability to invalidate public-key certificates [49], especially when the certificates have been compromised. Key rotation policies [29] guarantee that outdated decryption keys become ineffective for future use. The existing approaches to tackle with this problem have their limitations owing to the fact that cryptographic secrets are represented as binary strings and hence, it is infeasible to provably ensure that the malicious attackers have erased information from their devices. In the context of key rotation, a compromised key can still be used to decrypt old ciphertexts. Another issue with using classical information to represent cryptographic keys is that it is difficult to detect compromise: a hacker could steal the classical key from a device without leaving a trace.

Recently, a line of works [47, 11, 5, 13, 28, 41, 8] have leveraged quantum information and proposed new approaches for provable revocation of cryptographic objects, such as ciphertexts, programs and keys. These works studied revocation in the context of many Crypto 101 primitives, including pseudorandom functions, private-key and public-key encryption and digital signatures. In a revocable cryptographic primitive, an object (such as a program or a decryption key, etc.) is associated with a quantum state in such a way that only with access to the state the functionality of the original cryptographic object is retained. The common template for defining revocable security is in the form of a cryptographic game: The adversary receives one copy of the quantum state that it can use for a limited period of time after which it is supposed to return back the state to the owner. The security guarantee stipulates that after the state is returned, the adversary effectively loses the capability to use the cryptographic object. At this point, it should be clear to the reader the necessity that such cryptographic objects are represented as quantum states: indeed, if they were classical, the adversary could always maintain a secret copy, while pretending to have erased everything from its device. On the other hand, the no-cloning theorem [50, 32] of quantum mechanics suggests that the above security experiment could very well be achieved.

Multi-Copy Security

Let us now zoom in on the part of the security experiment, where the adversary receives only one copy of the quantum state. In all of the prior works in the literature so far [5, 13, 28, 41, 8], this limitation persists. One could consider a more general definition, where the adversary receives k identical copies of the quantum state and is later asked to return back all of the copies of the state. The security guarantee is similar to before: after returning all of the k copies, the adversary should effectively lose all access to the underlying crytptographic object. We term this general security experiment to be multi-copy security.

There are a couple of reasons to study multi-copy security for revocable primitives.

  • Historical Context: Multi-copy security is not new and has been extensively studied in quantum cryptography, especially in the context of foundational primitives such as pseudorandom states [35, 23, 14, 7, 21, 22] and one-way state generators [43, 42]. Indeed, multi-copy security has been crucial in the design of many cryptographic constructions. The works of [7, 12, 37] used tomography, which inherently requires multiple copies in order to dequantize the communication in some of the quantum cryptographic primitives. Specifically for revocable primitives, a conceptual reason to study multi-copy security is to understand whether having more copies necessarily makes it easier for the adversary to clone quantum states. Investigating multi-copy security for revocable primitives is a starting step towards understanding multi-copy security for more advanced primitives such as public-key quantum money [3, 52]. The question of whether multi-copy security is possible in unclonable cryptography was also recently raised in [40].

  • Nested Leasing: Having access to many more copies of the quantum state would also give more power to the user; for example, using a permutation test [36] (a generalized version of SWAP test) where one is given |ϕ and polynomially many copies of |ψ, one can approximately test the overlap between |ϕ and |ψ. This ability allows for nested leasing of cryptographic objects, such as programs or keys. Suppose a user A is leased a large number of, say k, copies of a quantum program |ψ. User A could further lease a number, say kk, of copies of |ψ to user B. At a later point in time, when user B is asked to return back its copies to user A. User A can then use its kk copies to approximately test whether the returned copies are correct. If the test succeeds, user A then is in a position to return back all of its k copies to the true owner111A drawback of this approach is that there is some room for user B to cheat with noticeable probability in this approach without user A noticing, which means that the owner would not always be to pinpoint whether user A or user B cheated. Still, this approach offers a non-trivial solution to this challenging problem.. Such a nested leasing approach could be especially useful in organizations with hierarchical structure.

The notion of multi-copy security we consider in this work is closely related to collusion-resistant security, considered in the works of [39, 27]. The crucial difference is that in the prior works, the adversary receives i.i.d copies of the quantum key whereas in our case, the adversary receives identical copies of the quantum key. In the nested leasing application discussed above, it was crucial that the user received many identical copies of the same state.

Multi-copy security using commonly studied unclonable states: Challenges

The first step towards addressing multi-copy security is to identify quantum states that are unclonable. We discuss the commonly studied unclonable quantum states below:

  • BB84 states: these states are of the form Hθ|x, where θ{0,1}n and x{0,1}n. These states have been influential in the design of private-key quantum money [48] and in the design of encryption schemes with unclonable ciphertexts [26, 24]. Given many copies of Hθ|x, one can learn x and θ and hence, recover a complete description of Hθ|x.

  • Subspace and Coset states: these states are of the form (|A|)1𝐱A|𝐱, where A𝔽2n is a sparse subspace of 𝔽2n, for some n. These states have been crucial in the design of public-key quantum money [3, 52], among other primitives. Again given many copies, one can learn the basis of the subspace and hence a complete description of the subspace state. Another related class of unclonable states are coset states which are superpositions over a coset (rather than a subspace) and moreover, each term in the superposition has a phase that depends on a dual coset. Coset states have been influential in constructions of quantum copy-protection [30]. Similar to subspace states, coset states are also learnable.

  • SIS-based states: these states are of the form 𝐱qm,𝐀𝐱=𝐲α𝐱|𝐱, where q,m, |α𝐱|2 is a discrete Gaussian distribution such that most of the weight is on low norm vectors 𝐱 and finally, 𝐀qn×m,𝐲qn. They were useful in designing traditional and advanced encryption systems with unclonable quantum keys [44, 13, 41, 8]. Given many copies of this state, one can recover a short basis of the kernel of 𝐀 which can then be used to recover the above state.

In other words, all the above types of states are learnable and hence, they cannot be the basis of any unclonable cryptographic scheme satisfying multi-copy security. This suggests that we need to look for new unclonable quantum states that are unlearnable even given many copies. In the past, discovering new unclonable quantum states has led to pushing the frontier of unclonable quantum cryptographic primitives and we believe our endeavour could reap similar results.

2 Our Results

We now give an overview of our results.

Our Approach: Quantum Pseudorandomness Meets Unclonable Cryptography

We use subset states to tackle multi-copy security. Subset states have been recently studied in the context of quantum pseudorandomness [33, 34, 2]. A subset state is associated with an unstructured and random subset S{0,1}n of the form |S=(|S|)1xS|x. Several recent works [33, 34] showed that random subset states (of non-trivial size) are approximate state k-designs for any polynomial k as a function of n, which make random subset states222Strictly speaking, we use pseudorandom subset states which can be generated efficiently via pseudorandom permutations. a natural candidate for multi-copy security – particularly since Haar states are unlearnable given polynomially many identical copies. At first sight, it would seem as though that the fact that random subset states are close to Haar states should be discourage us from using them for unclonable cryptography, especially since Haar states have virtually no structure. Indeed, the structure of BB84 states, subspace states and others has been crucially exploited in various applications. Our work shows that subset states, in some sense, have the minimal amount of structure to enable a number of interesting cryptographic primitives in the context of multi-copy revocable cryptography. To the best of our knowledge, these applications also mark the first use case of subset states in the context of cryptography. Our main technical contribution is of information-theoretic nature: we prove a query lower bound for forging subset elements; concretely, we show that any quantum algorithm that receives k copies of a random subset state |S cannot produce k+1 many subset elements in S unless it makes a large amount of queries to a membership oracle for S. We believe that this result could be of independent interest.

Multi-Copy Revocable Encryption.

We first study revocable encryption [47, 5, 13] with multi-copy security. A revocable encryption scheme is a regular encryption scheme but where the ciphertexts are associated with quantum states. Additionally, a revocable encryption scheme comes with the following security notion called multi-copy revocable security: informally, it states that any adversary that successfully returns k valid copies of a quantum ciphertext which it was given by a challenger, where k is an arbitrary polynomial, necessarily loses the ability to decrypt the ciphertexts in the future – even if the secret key is revealed. In more detail, the security game is formulated as follows:

  • The adversary selects a pair of messages (m0,m1) and sends them to the challenger.

  • The challenger randomly selects one of the two messages, say mb, and encrypts it k times using a secret ket 𝗌𝗄, and sends the ciphertext copies |ψbk to the adversary 𝒜.

  • At a later point in time, 𝒜 returns back all the copies of |ψb, which are then verified by the challenger.

  • After successfully returning back the states, 𝒜 receives the secret key 𝗌𝗄 in the clear. Finally, 𝒜 outputs a guess b.

The scheme is said to be secure if the probability that b=b is close to 1/2.

Prior works [47, 5, 13, 28, 8] only studied variants of the above security game in the setting where the adversary receives only one copy of the quantum ciphertext. In fact, their schemes are easily seen to not satisfy multi-copy security. We show the following.

Theorem 1.

If post-quantum one-way functions exist, then there exists an encryption scheme with (an oracular notion of) multi-copy revocable security.

Some remarks are in order. Firstly, our security proof does not fully achieve the standard notion of revocable security guarantee we stated above; rather, we consider a slightly different variant of the experiment, where in the second part of the game (instead of revealing the secret key in the clear) we allow the adversary to query an oracle that is powerful enough to enable decryption during the first phase of the game. While this constitutes a weaker notion of security, it nevertheless results in a meaningful notion of revocable security: once the adversary has successfully returned all of the copies of the ciphertext, it can no longer decrypt the ciphertext in the future – even if it gets access to an oracle that would have previously allowed it to do so. Second, our construction of multi-copy revocable encryption makes use of quantum-secure pseudorandom permutations (QPRPs), which can be constructed from post-quantum one-way functions [51]. In the security experiment which underlies our construction, the aforementioned oracle for decryption (i.e., that which is handed to the adversary after revocation has taken place) is in the form of an ideal oracle for the permutation itself. Once again, the rationale behind our notion of oracular security is that an attacker who receives a QPRP key in the clear would most certainly use it to evaluate the QPRP, and hence it is reasonable to consider a model in which the attacker receives an oracle for the permutation instead.333Note, however, that this does not capture all possible attacks; for example, the adversary could use its knowledge of the QPRP key to break the scheme in other meaningful ways. A key advantage of oracular security is that we can directly invoke the security of the QPRP and use a perfectly random permutation instead. 444This switch is generally not possible in the standard notion of revocable security in which the QPRP key is required to revealed in the clear. Here, QPRP security does not apply. We remark that this model loosely resembles the random permutation model behind the international hash function standard SHA-3 [19, 20], except that the adversary only receives oracle access to the permutation during the second part of the revocable security experiment. While our construction only achieves an oracular notion of revocable security, it is nevertheless the very first construction of revocable encryption which satisfies multi-copy security in any model.

Multi-Copy Revocable Programs

Our previous discussion on revocable encryption illustrates that encryption and decryption functionalities can be protected even if many copies of the quantum ciphertext are made available to the recipient. We generalize this result further and study whether arbitrary functionalities can be protected. We define and study revocable programs with multi-copy security. In this notion, there is a functionality preserving compiler that takes a program and converts it into a quantum state. The security guarantee is defined similar to revocable encryption:

  • The challenger compiles a program P, sampled from a distribution 𝒟 on a set of programs 𝒫, into a state |ψP. It then sends k copies of the state |ψP to the adversary 𝒜.

  • At a later point in time, 𝒜 returns back all of the copies of |ψP.

  • After returning back the state, 𝒜 is given x, where x is sampled from the input distribution of P. It then outputs a guess y.

The scheme is said to be secure if the probability that y=P(x) is roughly close to the trivial success probability. Here, the trivial success probability is defined as the optimal probability of guessing P(x) given just x (and the knowledge of 𝒟 and the input distribution).

Prior works propose revocable programs for specific functionalities in the plain model [30] or for general functionalities in oracle models [4]. However, these works guarantee security only if the adversary receives one copy of the state. And as before, these constructions provably do not satisfy multi-copy security. We show the following.

Theorem 2.

There exist revocable programs which satisfy (an oracular notion of) multi-copy security in a classical oracle model.

Unlike Theorem 1, the above theorem relies upon structured and ideal classical oracles.

Finally, for the special case of point functions, we show that we can again only rely upon pseudorandom permutations together with the (standard) quantum random oracle model. We show the following.

Theorem 3.

There exist revocable multi-bit point functions which satisfy (an oracular notion of) multi-copy security in quantum random oracle model.

Our results and techniques opens the door for building more advanced unclonable primitives that preserve their security even if the adversary receives many copies of the unclonable quantum state.

Are Results in Oracle Models Interesting?

It is natural for a reader to be skeptical of our results given that they are based in the oracle models. However, we would like to emphasize that achieving results in the oracle models still requires non-trivial amount of effort. As history suggests, constructions in the oracle models have eventually been adopted to constructions in the plain model. A classic example is the construction of public-key quantum money, which was first proposed in the oracle models by Aaronson and Christiano [3] and later, being instantiated in the plain model by Zhandry [52]. In a similar vein, our techniques could be useful for future works on achieving multi-copy security in the plain model.

Applications to Sponge Hashing

As a complementary contribution, we show that the techniques we developed in this paper are more broadly applicable and extend to other cryptographic settings as well. Here, we single out the so-called sponge construction used in SHA-3 [19, 20].

We study a simple query problem: Suppose that an adversary receives as input a hash table for a set of random input keys, where each hash is computed using a salted (one-round) sponge hash function. How many quantum queries are necessary to find a new valid element in the range of the hash function? Our contribution is a space-time trade-off which precisely characterizes the hardness of finding hash table elements in the presence of oracles that depend non-trivially on the sponge hash function.

2.1 Related work

We now discuss related notions which are relevant to this work.

Copy-Protection

This notion was first introduced by Aaronson [1]. Informally speaking, a copy-protection scheme is a compiler that transforms programs into quantum states in such a way that using the resulting states, one can run the original program. Yet, the security guarantee stipulates that any adversary given one copy of the state cannot produce a bipartite state wherein both parts compute the original program. Copy-protection schemes have since been constructed for various classes of programs and under various different models, for example as in [1, 4, 31, 9, 10, 39, 27]. We remark, however, that all of the aforementioned works are completely insecure if multiple identical copies of the program are made available. The notion of multi-copy security we consider in this work is closely related to collusion-resistant security, considered in the works of [39, 27]. The crucial difference is that in the prior works, the adversary receives i.i.d copies of the quantum key whereas in our case, the adversary receives identical copies of the quantum key.

Secure Software Leasing

Another primitive relevant to revocable cryptography is secure software leasing [11]. The notion of secure software leasing states that any program can be compiled into a functionally equivalent program, represented as a quantum state, in such a way that once the compiled program is returned, the (honest) evaluation algorithm on the residual state cannot compute the original functionality. Secure leasing has been constructed for various functionalities [11, 31, 25, 38]. Similar to copy-protection, none of the aforementioned works consider multi-copy security.

Encryption Schemes with Revocable Ciphertexts

Unruh [47] proposed a (private-key) quantum timed-release encryption scheme that is revocable, i.e. it allows a user to return the ciphertext of a quantum timed-release encryption scheme, thereby losing all access to the data. Broadbent and Islam [24] introduced the notion of certified deletion, which is incomparable with the related notion of unclonable encryption. This has led to the development of other certified deletion protocols, for example as in Ref. [44, 15, 17, 16, 18]. However, the notion of multi-copy security, such as in our work, has not been studied.

3 Preliminaries

Let λ denote the security parameter throughout this work. We assume that the reader is familiar with the fundamental cryptographic concepts.

For N, we use [N]={1,2,,N} to denote the set of integers up to N. The symmetric group on [N] is denoted by SN. In slight abuse of notation, we oftentimes identify elements x[N] with bit strings x{0,1}n via their binary representation whenever N=2n and n. Similarly, we identify permutations πSN with permutations π:{0,1}n{0,1}n over bit strings of length n. For a bit string x{0,1}n, we frequently use the notation (x||), where serves as a placeholder to denote the set {(x||y):y{0,1}m}, where m is another integer which is typically clear in context.

We write 𝗇𝖾𝗀𝗅() to denote any negligible function, which is a function f such that, for every constant c, there exists an integer N such that for all n>N, f(n)<nc.

Lemma 4 (One-Way-to-Hiding Lemma, [6]).

Let 𝒳,𝒴 be arbitrary sets and let 𝒮𝒳 be a (possibly random) subset. Let G,H:𝒳𝒴 be arbitrary (possibly random) functions such that H(x)=G(x), for all x𝒮. Let z be a classical bit string or a (possibly mixed) quantum state (Note that G,H,S,z may have arbitrary joint distribution). Let 𝒜 be an oracle-aided quantum algorithm that makes at most q quantum queries. Let be an algorithm that on input z chooses a random query index i[q], runs 𝒜H(z), measures 𝒜’s i-th query and outputs the measurement outcome. Then, we have

|Pr[𝒜G(z)=1]Pr[𝒜H(z)=1]|2qPr[H(z)𝒮].

Moreover, for any fixed choice of G,H,S and z (when z is a classical string or a pure state), we get

|ψqH|ψqG2q1qi=0q1Π𝒮|ψiH2,

where |ψiH denotes the intermediate state of 𝒜 just before the (i+1)-st query, where the initial state at i=0 corresponds to z, and Π𝒮 is a projector onto 𝒮.

Pseudorandom Permutations

A quantum-secure pseudorandom permutation is a a bijective function family which can be constructed from quantum-secure one-way functions [51].

Definition 5 (QPRP).

Let λ denote the security parameter. Let P:{0,1}λ×{0,1}n{0,1}n be a function, where n(λ)=poly(λ) is an integer, such that each function Pk(x)=P(k,x) in the corresponding family {Pk}k{0,1}λ is bijective. We say P is a (strong) quantum-secure pseudorandom permutation (or QPRP) if, for every QPT 𝒜 with access to both the function and its inverse, it holds that

|Prk{0,1}λ[𝒜Pk,Pk1(1λ)=1]Prφ𝒫n[𝒜φ,φ1(1λ)=1]|𝗇𝖾𝗀𝗅(λ),

where 𝒫n denotes the set of permutations over n-bit strings.

Subset States

We consider the following notations.

  • We denote the set of distinct k-tuples over a set S by dist(S,k).

  • Suppose S is a set. We denote |S=1|S|xS|x.

  • Suppose X={x1,,xt}{0,1}n. We denote |𝝈X=1t!σSt|xσ(1),,xσ(t), where St denotes the symmetric group on [t].

We use the following lemma which follows from Propositions 3.3 and 3.4 in [34].

Lemma 6 ([34]).

Let n,k. Let T{0,1}n be a subset of size |T|=t. Then, it holds that

𝖳𝖣(𝔼ST|S|=s[|SS|k],𝔼XT|X|=k[|𝝈X𝝈X|])O(ks+skt).

4 𝒌𝒌+𝟏 Unforgeability of Subset States

We now prove the following theorem. Roughly speaking, our theorem says that any quantum algorithm which receives k copies of a random subset state |S (and a membership oracle for S) cannot find k+1 distinct elements in S with high probability unless it makes a large number of queries.

Theorem 7 (kk+1 Unforgeability of Subset States).

Let n and k. Then, for any q-query quantum oracle algorithm 𝒜, and any 1k<s<t2n, it holds that

PrS{0,1}n|S|=s[(x1,,xk+1)dist(S,k+1):(x1,,xk+1)𝒜𝒪S(|Sk)]
O(qts2n+qtk2n+ks+skt)+𝗇𝖾𝗀𝗅(n).

In particular, we can let k=poly(n), q=poly(n) and s(n)=nω(1) be superpolynomial. Then, for any t(n)=nω(1) with s(n)/t(n)=1/nω(1) and t(n)/2n=1/nω(1), the probability is at most 𝗇𝖾𝗀𝗅(n).

Proof.

Using Lemma 8, we can prove Theorem 7 as follows: Let’s assume for contradiction that there exists a q query quantum oracle algorithm 𝒜, and a 1k<s<t2n, such that

PrS{0,1}n|S|=s[(x1,,xk+1)dist(S,k+1):(x1,,xk+1)𝒜𝒪S(|Sk)]
=O(qts2n+qtk2n+ks+skt)+δ(n).

where δ(.) is some non negligible function. Then, from Lemma 8, this implies that,

PrX{0,1}n,|X|=k[(x1,,xk+1)dist(X,k+1):(x1,,xk+1)𝒜𝒪X(|𝝈X)]
δ(n)

However, the probability that 𝒜 can succeed in this experiment is 0. This is because, X only contains k elements, and therefore, 𝒜 can never produce k+1 distinct elements from X. This must imply that δ(n) is negligible.

Technical Lemma

We need to show the following lemma which made use of in Theorem 7.

Lemma 8.

Let n,k,t be integers such that 1k<s<t2n. Then, for any q-query quantum oracle algorithm 𝒟 which outputs a single bit, it holds that

| PrS{0,1}n|S|=s[𝒟𝒪S(|Sk)=1]PrX{0,1}n|X|=k[𝒟𝒪X(|𝝈X)=1]|
O(qts2n+qtk2n+ks+skt).
Proof.

Consider the following hybrid distributions.

𝐇𝟏.

Output 𝒟𝒪S(|Sk), where S{0,1}n is a random subset of size |S|=s.

𝐇𝟐.

Output 𝒟𝒪S(|Sk), where the subset S is sampled as follows: first, sample a random subset T{0,1}n of size |T|=t, and then let ST be a random subset of size |S|=s.

Let p(𝐇i) be the probability that 𝐇i outputs 1, for some i. We now show the following.

Claim 9.

p(𝐇2)=p(𝐇1).

Proof.

The distribution of sampling S{0,1}n of size |S|=s is identical to the distribution of first sampling a superset T{0,1}n of size |T|=t, and letting ST be a random subset of size |S|=s.

𝐇𝟑.

Output 𝒟𝒪T(|Sk), where the subset S is sampled as follows: first, sample a random subset T{0,1}n of size |T|=t, and then let ST be a random subset of size |S|=s.

Claim 10.
|p(𝐇3)p(𝐇2)|O(qts2n).
Proof.

We can model the quantum oracle algorithm 𝒟𝒪S on input |St as a sequence of oracle queries and unitary computations followed by a measurement. Thus, the final output state just before the measurement can be written as

|ΨqS=Uq𝒪SUq1U1𝒪SU0|ψ0|Sk,

where U0,U1,,Uq are unitaries (possibly acting on additional workspace registers, which we omit above), and where |ψ0 is some fixed initial state which is independent of S.

In the next step of the proof, we will use the “subset flooding” technique to drown S in a random superset. Let T{0,1}n be a random superset of S of size t>s. We now consider the state

|ΨqT=Uq𝒪TUq1U1𝒪TU0|ψ0|Sk.

We now claim that the states |ΨqS and |ΨqT are sufficiently close. From the definition of 𝒪T and 𝒪S, we have that 𝒪T(x)𝒪S(x) iff xT\S{0,1}n. By the O2H Lemma (Lemma 4),

𝔼T{0,1}n,|T|=tST,|S|=s|ΨqS|ΨqT 2q𝔼T{0,1}n,|T|=tST,|S|=s1qi=0q1ΠT\S|ΨiS2
2q1qi=0q1𝔼T{0,1}n,|T|=tST,|S|=sΠT\S|ΨiS2 (Jensen’s inequality)
=O(qts2n).

Therefore, the probability (over the choice of S and T) that 𝒟𝒪S(|Sk) succeeds is at most the probability that 𝒟𝒪T(|Sk) succeeds – up to an additive loss of O(qts2n).

𝐇𝟒.

Output 𝒟𝒪T(|𝝈X), where the subset X is sampled as follows: first, sample a random subset T{0,1}n of size |T|=t, and then let XT be a random subset of size |X|=k.

Claim 11.
|p(𝐇4)p(𝐇3)|O(ks+skt).
Proof.

Here, we make use of Lemma 6 which says that, for any superset T{0,1}n of size |T|=t,

𝖳𝖣(𝔼ST|S|=s[|SS|k],𝔼XT|X|=k[|𝝈X𝝈X|])O(ks+skt).

𝐇𝟓.

Output 𝒟𝒪X(|𝝈X), where the subset X is sampled as follows: first, sample a random subset T{0,1}n of size |T|=t, and then let XT be a random subset of size |X|=k.

Claim 12.
|p(𝐇5)p(𝐇4)|O(qtk2n).
Proof.

Suppose that XT is a random subset of size |X|=k, and let |𝝈X=1k!σSk|xσ(1),,xσ(k), where Sk denotes the symmetric group on [k]. Consider the state

|ΦqT=Uq𝒪TUq1U1𝒪TU0|ψ0|𝝈X.

prepared by 𝒟𝒪T(|𝝈X) just before the measurement. Similarly, we let

|ΦqX=Uq𝒪XUq1U1𝒪XU0|ψ0|𝝈X.

be the state prepared by 𝒜𝒪X(|𝝈X). Using Lemma 4 as before, we get that

𝔼T{0,1}n,|T|=tXT,|X|=k|ΦqT|ΦqX 2q𝔼T{0,1}n,|T|=tXT,|X|=k1qi=0q1ΠT\X|ΦiX2
2q1qi=0q1𝔼T{0,1}n,|T|=tXT,|X|=kΠT\X|ΦiX2 (Jensen’s inequality)
O(qtk2n).

Therefore, the probability (over the choice of X and T) that 𝒟𝒪T(|𝝈X) succeeds is at most the probability that 𝒟𝒪X(|𝝈X) succeeds (up to an additive error of qtk). Therefore, by applying the triangle inequality, we get that

|p(𝐇1)p(𝐇5)|O(qts2n+qtk2n+ks+skt).

This proves the claim.

5 Multi-Copy Revocable Encryption: Definition

In this section we formally define and construct multi-copy secure revocable encryption schemes. These are regular encryption scheme but where the ciphertexts are associated with quantum states. Moreover, the security property guarantees that any adversary that successfully returns k valid copies of a quantum ciphertext (which it received from a trusted party), where k is an arbitrary polynomial, necessarily loses the ability to decrypt the ciphertexts in the future – even if the secret key is revealed.

Our definition of revocable encryption is as follows:

Definition 13 (Revocable Encryption).

Let λ denote the security parameter. A revocable encryption scheme Σ=(𝖪𝖾𝗒𝖦𝖾𝗇,𝖤𝗇𝖼,𝖣𝖾𝖼,𝖱𝖾𝗏𝗈𝗄𝖾) with plaintext space consists of the following QPT algorithms:

  • 𝖪𝖾𝗒𝖦𝖾𝗇(1λ): on input the security parameter 1λ, output a secret key 𝗌𝗄.

  • 𝖤𝗇𝖼(𝗌𝗄,m): on input the secret key 𝗌𝗄 and a message m, output a (pure) ciphertext state |ψ and a (private) verification key 𝗏𝗄.

  • 𝖣𝖾𝖼(𝗌𝗄,ρ): on input the secret key 𝗌𝗄 and a quantum state ρ, output a message m.

  • 𝖱𝖾𝗏𝗈𝗄𝖾(𝗌𝗄,𝗏𝗄,σ): on input the secret key 𝗌𝗄, a verification key 𝗏𝗄 and a state σ, output or .

In addition, we require that Σ satisfies the following two properties:

Correctness of decryption:

for all plaintexts m, it holds that

𝖯𝗋[m𝖣𝖾𝖼(𝗌𝗄,|ψ):𝗌𝗄𝖪𝖾𝗒𝖦𝖾𝗇(1λ)(|ψ,𝗏𝗄)𝖤𝗇𝖼(𝗌𝗄,m)]1𝗇𝖾𝗀𝗅(λ).
Correctness of revocation:

for all plaintexts m, it holds that

𝖯𝗋[𝖱𝖾𝗏𝗈𝗄𝖾(𝗌𝗄,𝗏𝗄,|ψ):𝗌𝗄𝖪𝖾𝗒𝖦𝖾𝗇(1λ)(|ψ,𝗏𝗄)𝖤𝗇𝖼(𝗌𝗄,m)]1𝗇𝖾𝗀𝗅(λ).

There are two properties we require the above scheme to satisfy.
Firstly, we require the above scheme to be correct. That is, we require the following to hold for all m{0,1},

𝖯𝗋[m𝖣𝖾𝖼(𝗌𝗄,|ψ):𝗌𝗄𝖪𝖾𝗒𝖦𝖾𝗇(1λ)|ψ𝖤𝗇𝖼(𝗌𝗄,m)]1ϵ(λ),

for some negligible function ϵ().

Multi-Copy Revocable Security

We use the following notion of security.

Definition 14 (Multi-Copy Revocable Security).

Let λ denote the security parameter and let Σ=(𝖪𝖾𝗒𝖦𝖾𝗇,𝖤𝗇𝖼,𝖣𝖾𝖼,𝖱𝖾𝗏𝗈𝗄𝖾) be a revocable encryption scheme with plaintext space . Consider the following experiment between a QPT adversary 𝒜 and a challenger.

𝖱𝖾𝗏𝗈𝗄𝖾𝖤𝗑𝗉𝗍λ,Σ,𝒜(b):

  1. 1.

    𝒜 submits two messages m0,m1 and a polynomial k=k(λ) to the challenger.

  2. 2.

    The challenger samples a key 𝗌𝗄𝖪𝖾𝗒𝖦𝖾𝗇(1λ) and produces |ψb𝖤𝗇𝖼(𝗌𝗄,mb). Afterwards, the challenger sends the quantum state |ψbk to 𝒜.

  3. 3.

    𝒜 returns a quantum state ρ.

  4. 4.

    The challenger performs the measurement {|ψbψb|k,𝕀|ψbψb|k} on the returned state ρ. If the measurement succeeds, the game continues; otherwise, the challenger aborts.

  5. 5.

    The challenger sends the secret key 𝗌𝗄 to 𝒜.

  6. 6.

    𝒜 outputs a bit b.

We say that the revocable encryption scheme Σ=(𝖪𝖾𝗒𝖦𝖾𝗇,𝖤𝗇𝖼,𝖣𝖾𝖼,𝖱𝖾𝗏𝗈𝗄𝖾) has multi-copy revocable security, if the following holds for all μ{0,1,}:

|𝖯𝗋[μ𝖱𝖾𝗏𝗈𝗄𝖾𝖤𝗑𝗉𝗍λ,Σ,𝒜(0)]𝖯𝗋[μ𝖱𝖾𝗏𝗈𝗄𝖾𝖤𝗑𝗉𝗍λ,Σ,𝒜(1)]|𝗇𝖾𝗀𝗅(λ),
 Remark 15.

In this work, we will work with a weaker variant of this security game, one where the post revocation adversary is given access to an oracle that depends on the key 𝗌𝗄 instead. The reason for this will become clear from context.

 Remark 16 (Search variant).

Occasionally, we also consider the search variant of multi-copy revocable encryption. Here, the experiment is similar, except that in Step 1, the adversary only submits k to the challenger. Then, in Step 2, the challenger chooses a message m uniformly at random from the plaintext space, encrypts it k times and sends all of the copies to the adversary. Finally, the adversary is said to win the game if it guesses m correctly.

6 Construction of Multi-Copy Secure Revocable Encryption

In this section, we instantiate our revocable encryption scheme using quantum-secure pseudorandom permutations (QPRPs), and we prove security in an oracular model: this means that, rather than revealing the QPRP key in the final part of the revocable security experiment, we instead allow the adversary to query an oracle for a the permutation instead.

Construction 17.

Let λ be the security parameter. Let n,m be polymomial in λ. Let Φ={Φλ}λ be an ensemble of permutations Φλ={φκ:{0,1}n+m{0,1}n+m}κ𝒦λ, for some set 𝒦λ. Consider the scheme ΣΦ=(𝖪𝖾𝗒𝖦𝖾𝗇,𝖤𝗇𝖼,𝖣𝖾𝖼,𝖱𝖾𝗏𝗈𝗄𝖾) which consists of the following QPT algorithms:

  • 𝖪𝖾𝗒𝖦𝖾𝗇(1λ): sample a uniformly random key κ𝒦λ and let 𝗌𝗄=κ.

  • 𝖤𝗇𝖼(𝗌𝗄,μ): on input the secret key 𝗌𝗄=κ and message μ{0,1}m, sample y{0,1}m and prepare the subset state given by

    |Sy=12nx{0,1}n|φκ(x||y).

    Output the ciphertext state (|Syk,yμ) and (private) verification key 𝗏𝗄=y.

  • 𝖣𝖾𝖼(𝗌𝗄,𝖼𝗍): on input the decryption key κ and ciphertext state (|Sy,z)𝖼𝗍, do the following:

    • Coherently compute φκ1 on |Sy and store the answer in a separate output register.

    • Measure the output register to get x||y{0,1}n+m.

    • Output yz.

  • 𝖱𝖾𝗏𝗈𝗄𝖾(𝗌𝗄,𝗏𝗄,ρ): on input 𝗌𝗄, a state ρ and verification key 𝗏𝗄, it parses κ𝗌𝗄, y𝗏𝗄 and applies the measurement {|SySy|,𝕀|SySy|} to ρ; it outputs if it succeeds, and otherwise.

Proof of Multi-Copy Revocable Security

Theorem 18.

Construction 17, when instantiated with a QPRP Φ={Φλ}λ, satisfies (an oracular notion of) multi-copy revocable security.

Proof.

Because we are working in the oracular model of revocable security, we can invoke QPRP security and assume that Σ in Construction 17 is instantiated with a perfectly random permutation φ rather than a QPRP permutation φκ.

Suppose that our construction does not achieve multi-copy revocable security. Then, there exists an adversary 𝒜 such that

|𝖯𝗋[μ𝖱𝖾𝗏𝗈𝗄𝖾𝖤𝗑𝗉𝗍λ,Σ,𝒜(0)]𝖯𝗋[μ𝖱𝖾𝗏𝗈𝗄𝖾𝖤𝗑𝗉𝗍λ,Σ,𝒜(1)]|=ϵ(λ),

for some non-negligible function ϵ(). For convenience, we model 𝒜 as a pair of quantum algorithms (𝒜0,𝒜1), where 𝒜0 corresponds to the pre-revocation adversary, and 𝒜1 corresponds to the post-revocation adversary. We consider the following sequence of hybrid distributions.

𝐇𝟏𝒃.

This corresponds to 𝖱𝖾𝗏𝗈𝗄𝖾𝖤𝗑𝗉𝗍𝒜(1λ,b).

  1. 1.

    𝒜0 submits two m-bit messages (μ0,μ1) and a polynomial k=k(λ) to the challenger.

  2. 2.

    The challenger samples y{0,1}m and produces a quantum state

    |Sy=12nx{0,1}n|φ(x||y).

    The challenger then sends |Syk and yμb to 𝒜0.

  3. 3.

    𝒜0 prepares a bipartite state on registers 𝖱 and 𝖠𝖴𝖷, and sends 𝖱 to the challenger and 𝖠𝖴𝖷 to 𝒜1.

  4. 4.

    The challenger performs the projective measurement {|SySy|k,𝕀|SySy|k} on 𝖱. If the measurement succeeds, the challenger outputs . Otherwise, the challenger continues.

  5. 5.

    The challenger grants 𝒜1 quantum oracle access to φ1.

  6. 6.

    𝒜1 outputs a bit b.

𝐇𝟐𝒃.

This is the same experiment as in 𝐇1b, except that we change how |Syk is generated before revocation:

  • The challenger samples a random subset S{0,1}n+m of size |S|=2n.

  • The challenger samples a random y{0,1}m.

  • The challenger sends |Sk and yμb to 𝒜0.

Later, the challenger samples a random permutation π:{0,1}n+m{0,1}n+m subject to the constraint that π(s)=||y, for all sS. In other words, π(S)=Ty, where

Ty:={x{0,1}n+m:x=(||y)}

and |S|=|Ty|=2n. After revocation, 𝒜1 receives oracle access to π.

Claim 19.

𝐇1b and 𝐇2b are identically distributed.

Proof.

This follows immediately. We just changed the order in which we sample things.

𝐇𝟑𝒃.

This is the same experiment as in 𝐇2b, except that we change the second part of the experiment: after the challenger sends |Sk and yμb to 𝒜0, he does the following:

  • The challenger samples a random function g:STy. 555Note that we have g(S)Ty in general.

  • The challenger samples a random permutation ω:({0,1}n+mS)({0,1}n+mTy).

After revocation, 𝒜1 receives oracle access to f:{0,1}n+m{0,1}n+m, where

f(x)={g(x), if xSω(x), if xS.

Claim 20.

𝐇2b and 𝐇3b are O(q3/2n)-close whenever 𝒜 makes q queries.

Proof.

Here, we apply Zhandry’s result which says that random functions are indistinguishable from random permutations. Consider the following algorithm which receives oracle access to O, which is either a random function F:{0,1}n{0,1}n or a random permutation P:{0,1}n{0,1}n:

  1. 1.

    samples a random subset S{0,1}n+m of size |S|=2n and a random y{0,1}m.

  2. 2.

    sends |Syk and yμb to 𝒜0.

  3. 3.

    When 𝒜0 replies with a bipartite state on registers 𝖱 and 𝖠𝖴𝖷, performs the projective measurement {|SS|k,𝕀|SS|k} on 𝖱. If it succeeds, outputs . Otherwise, continues.

  4. 4.

    runs the post-revocation adversary 𝒜1 on input 𝖠𝖴𝖷. Whenever 𝒜1 makes a query, answers using the function

    f(x)={(τOσ)(x), if xSω(x), if xS

    where we let

    • σ be some canonical mapping from S (with |S|=2n) onto {0,1}n, i.e., σ is a a function which assigns each element of S{0,1}n+m a unique bit string in {0,1}n.

    • τ be the function which maps each x{0,1}n to (x||y){0,1}n+m.

Note that whenever O is a random permutation, the view of 𝒜 is precisely 𝐇3b; whereas, if O is a random function, the view of 𝒜 is precisely 𝐇4b. Therefore, the claim follows from Zhandry’s result on indistinguishability of random pemrutations from random functions (see full version for formal statement).

𝐇𝟒𝒃.

This is the same experiment as in 𝐇3b, except that we change the second part of the experiment once again: after the challenger sends |Syk and yμb to 𝒜0, he does the following:

  • the challenger samples a random function f:{0,1}n+m{0,1}n+m subject to the constraint that f(s)=||y, for all sS.

After revocation, 𝒜1 receives oracle access to f.

Claim 21.

𝐇3b and 𝐇4b are O(q3/(2n+m2n))-close whenever 𝒜 makes q queries.

Proof.

The proof again follows since distinguishing 𝐇3b and 𝐇4b amounts to distinguishing a random function from a random permutation mapping a random permutation ω:({0,1}n+mS)({0,1}n+mTy). Since the domain and co-domain are of equal size 2n+m2n, the advantage is at most O(q3/(2n+m2n)).

𝐇𝟓𝒃.

This is the same experiment as in 𝐇4b, but now we change what 𝒜0 receives in the pre-revocation phase:

  • The challenger samples a random subset S{0,1}n+m of size |S|=2n.

  • The challenger samples a random y{0,1}m.

  • The challenger sends (|Syk,y) to 𝒜0.

After revocation, the challenger samples a random function f:{0,1}n+m{0,1}n+m subject to the constraint that f(s)=||yμb, for all sS. 𝒜 receives oracle access to f.

Claim 22.

𝐇4b and 𝐇5b are indentical.

Proof.

This follows from the fact that we have just re-labeled the variables.

𝐇𝟔𝒃.

This is the same experiment as in 𝐇5b, except that we once again change what 𝒜0 receives in the pre-revocation phase:

  • The challenger samples a random subset S{0,1}n+m of size |S|=2n.

  • The challenger samples a random y{0,1}m.

  • The challenger samples a random u{0,1}m.

  • The challenger sends (|Syk,y) to 𝒜0.

After revocation, the challenger samples a random function f:{0,1}n+m{0,1}n+m subject to the constraint that f(s)=||u, for all sS. 𝒜 receives oracle access to f.

Note that hybrids 𝐇60 and 𝐇61 are identically distributed. By assumption, we also know that 𝒜 distinguishes 𝐇10 and 𝐇11 with non-negligible advantage. Therefore, our previous hybrid argument has shown that 𝒜 must also distinguish 𝐇50 and 𝐇60 (respectively, hybrids 𝐇51 and 𝐇61) with advantage at least ϵ(λ), for some non negligible function ϵ(λ). To complete the proof, we show the following claim which yields the desired contradiction to the kk+1 unforgeability property of subset states from Theorem 7.

Claim 23.

𝖥𝗈𝗋𝗀𝖾 in Algorithm 1 is a poly(λ)-query algorithm (which internally runs 𝒜) such that

PrS{0,1}n+m|S|=2n[(x1,,xk+1)dist(S,k+1):(x1,,xk+1)𝖥𝗈𝗋𝗀𝖾𝒪S(|Sk)]1/poly(λ).
Proof.

Since 𝐇5b and 𝐇6b can be distinguished by the adversary 𝒜=(𝒜0,𝒜1) with advantage ϵ(λ), for some non-negligible function ϵ(λ), this implies that the post-revocation adversary 𝒜1 is an algorithm for which the following property holds: given as input uniformly random string y and an auxiliary register (conditioned on revocation succeeding), 𝒜1 can distinguish whether it is given an oracle for a function H:{0,1}n+m{0,1}n+m which is random subject to the constraint that H(s)=||yμb for all sS, or whether it is given an oracle for a function G:{0,1}n+m{0,1}n+m which is a random function subject to the constraint that G(s)=||u for all sS. Crucially, the two functions differ precisely on inputs belonging to S, and are otherwise identical.

Consider the quantum extractor 𝖤𝗑𝗍G(y,𝖠𝖴𝖷) which is defined as follows:

  1. 1.

    Sample i[q], where q denotes the total number of queries made by 𝒜.

  2. 2.

    Run 𝒜1G(y,𝖠𝖴𝖷) just before the (i1)-st query to G.

  3. 3.

    Measure 𝒜1’s i-th query in the computational basis, and output the measurement outcome.

From the O2H Lemma (see full version for the formal statement), we get that |Pr[𝒜1H(y,𝖠𝖴𝖷|)=1:S{0,1}n+m,|S|=2ny{0,1}m(𝖱,𝖠𝖴𝖷)𝒜0(|Sk,y)H s.t. H(s)=||yμb,sS]Pr[𝒜1G(y,𝖠𝖴𝖷|)=1:S{0,1}n+m,|S|=2ny{0,1}m,u{0,1}m(𝖱,𝖠𝖴𝖷)𝒜0(|Sk,y)G s.t. G(s)=||u,sS]| 2qPr[𝖤𝗑𝗍G(y,𝖠𝖴𝖷|)S:S{0,1}n+m,|S|=2ny{0,1}m,u{0,1}m(𝖱,𝖠𝖴𝖷)𝒜0(|Sk,y)G s.t. G(s)=||u,sS],

where 𝖠𝖴𝖷| corresponds to the register 𝖠𝖴𝖷 conditioned on the event that the projective measurement

{|SS|k,𝕀|SS|k}

succeeds on register 𝖱. Because the distinguishing advantage of the adversary 𝒜1 is non-negligible (conditioned on the event that revocation succeeds on register 𝖱) and q=poly(λ), we get

Pr[𝖤𝗑𝗍G(y,𝖠𝖴𝖷|)S:S{0,1}n+m,|S|=2ny{0,1}m,u{0,1}m(𝖱,𝖠𝖴𝖷)𝒜0(|Sk,y)G s.t. G(s)=||u,sS]1/poly(λ).

To complete the proof, we now show that 𝖥𝗈𝗋𝗀𝖾𝒪S(|Sk) in Algorithm 1 is a successful algorithm against the kk+1 unforgeability of subset states.

Algorithm 1 𝖥𝗈𝗋𝗀𝖾𝒪S(|Sk).

Let 𝖱𝖾𝗏𝗈𝗄𝖾(S,k,𝖱) denote the projective measurement {|SS|k,𝕀|SS|k} of register 𝖱. Using the Simultaneous Distinct Extraction Lemma (Lemma 24), we get that

PrS{0,1}n+m|S|=2n[(x1,,xt+1)dist(S,k+1):(x1,,xk+1)𝖥𝗈𝗋𝗀𝖾𝒪S(|Sk)]
(1O(k22n))Pr[𝖱𝖾𝗏𝗈𝗄𝖾(S,k,𝖱)=:S{0,1}n+m,|S|=2ny{0,1}m(𝖱,𝖠𝖴𝖷)𝒜0(|Sk,y)]
Pr[𝖤𝗑𝗍G(y,𝖠𝖴𝖷|)S:S{0,1}n+m,|S|=2ny{0,1}m,u{0,1}m(𝖱,𝖠𝖴𝖷)𝒜0(|Sk,y)G s.t. G(s)=||u,sS]

which is at least inverse polynomial in λ. This proves the claim. Thus, we obtain the desired contradiction to the kk+1 unforgeability property of subset states from Theorem 7. This completes the proof of multi-copy revocable encryption security.

6.1 Simultaneous Distinct Extraction Lemma

The following lemma allows us to analyze the probability of simultaneously extracting k+1 distinct subset elements in some subset S{0,1}n in terms of the success probability of revocation (i.e., the projection onto |SS|k) and the success probability of extracting another subset element from the adversary’s state.

Lemma 24 (Simultaneous Distinct Extraction).

Let n,k and let ρ𝒟(XY) be an any density matrix, where X is an nk-qubit Hilbert space and where Y is an arbitrary Hilbert space. Let |S denote a subset state, for some subset S{0,1}n, and let :(Y)(X) be any 𝖢𝖯𝖳𝖯 map of the form

YX(σ)=TrE[VYXEσVYXE],σ𝒟(Y),

for some isometry VYXE and n-qubit Hilbert space X. Consider the 𝖯𝖮𝖵𝖬 element

Λ=s1,,sk+1S(s1,,sk+1)dist(S,k+1)|s1,,sks1,,sk|XVYXE(|sk+1sk+1|XIE)VYXE.

Let ρX=TrY[ρXY] denote the reduced state. Then, it holds that

Tr[Λρ](1O(k2|S|))Tr[|SS|kρX]Tr[|SS|YX(σ)],

where σ=Tr[(|SS|kI)ρ]1TrX[(|SS|kI)ρ] is a reduced state in system Y.

7 Multi-Copy Revocable Programs: Definition

In this section, we study whether arbitrary functionalities can be revoked. We define and study revocable programs with multi-copy security. In this notion, there is a functionality preserving compiler that takes a program and converts it into a quantum state, which can later be certifiably revoked.

We now give a formal definition of revocable programs.

Definition 25 (Revocable Program).

Let 𝒫=λ𝒫λ be a class of efficiently computable program families 𝒫λ={P:𝒳λ𝒴λ} with domain 𝒳λ and range 𝒴λ. A revocable program compiler for the class 𝒫 is a tuple Σ=(𝖢𝗈𝗆𝗉𝗂𝗅𝖾,𝖤𝗏𝖺𝗅,𝖱𝖾𝗏𝗈𝗄𝖾) consisting of the following QPT algorithms:

  • 𝖢𝗈𝗆𝗉𝗂𝗅𝖾(1λ,P): on input the security parameter 1λ and a program P𝒫λ with P:𝒳λ𝒴λ, output a quantum state |ΨP and a (private) verification key 𝗏𝗄.

  • 𝖤𝗏𝖺𝗅(|ΨP,x): on input a quantum state |ΨP and input x𝒳λ, output P(x).

  • 𝖱𝖾𝗏𝗈𝗄𝖾(𝗏𝗄,σ): on input the verification key 𝗏𝗄 and a state σ, output or .

In addition, we require that Σ satisfies the following two properties for all λ:

Correctness of evaluation:

for all programs P𝒫λ and inputs x𝒳λ, it holds that

𝖯𝗋[P(x)𝖤𝗏𝖺𝗅(|ΨP,x):(|ΨP,𝗏𝗄)𝖢𝗈𝗆𝗉𝗂𝗅𝖾(1λ,P)]1𝗇𝖾𝗀𝗅(λ).
Correctness of revocation:

for all programs P𝒫λ, it holds that

𝖯𝗋[𝖱𝖾𝗏𝗈𝗄𝖾(𝗏𝗄,(|ΨP):(|ΨP,𝗏𝗄)𝖢𝗈𝗆𝗉𝗂𝗅𝖾(1λ,P)]1𝗇𝖾𝗀𝗅(λ).

Multi-Copy Revocable Security

We use the following notion of security.

Definition 26 (Multi-Copy Revocable Security for Programs).

Let 𝒫=λ𝒫λ be a class of efficiently computable program families 𝒫λ={P:𝒳λ𝒴λ} and let 𝒟𝒫=λ𝒟𝒫λ be an ensemble of program distributions. Let 𝒟𝒳=λ𝒟𝒳λ be an ensemble of challenge distribution families with 𝒟𝒳λ={𝒟𝒳λ(P)}P𝒫λ. Consider the following experiment between a QPT adversary 𝒜 and a challenger.

𝖱𝖾𝗏𝗈𝗄𝖾𝖤𝗑𝗉𝗍λ,Σ,𝒜𝒟𝒫,𝒟𝒳:

  1. 1.

    𝒜 submits a polynomial k=k(λ) to the challenger.

  2. 2.

    The challenger samples a program P𝒟𝒫λ with domain 𝒳λ and range 𝒴λ, and runs 𝖢𝗈𝗆𝗉𝗂𝗅𝖾(1λ,P) to generate a pair (|ΨP,𝗏𝗄). Afterwards, the challenger sends the quantum state |ΨP to 𝒜.

  3. 3.

    𝒜 returns a quantum state ρ.

  4. 4.

    The challenger performs the measurement {|ΨPΨP|k,𝕀|ΨPΨP|k} on the returned state ρ. If the measurement succeeds, the game continues; otherwise, the challenger aborts.

  5. 5.

    The challenger samples a challenge input x𝒟𝒳λ(P) sends x to 𝒜.

  6. 6.

    The adversary outputs y𝒴λ.

  7. 7.

    The challenger outputs 1 if and only if P(x)=y.

We say that a revocable program compiler Σ=(𝖢𝗈𝗆𝗉𝗂𝗅𝖾,𝖤𝗏𝖺𝗅,𝖱𝖾𝗏𝗈𝗄𝖾) has multi-copy revocable security for the ensembles 𝒟𝒫 and 𝒟𝒳, if the following holds for any QPT adversary 𝒜:

𝖯𝗋[1𝖱𝖾𝗏𝗈𝗄𝖾𝖤𝗑𝗉𝗍λ,Σ,𝒜𝒟𝒫,𝒟𝒳]ptriv𝒟𝒫,𝒟𝒳(λ)+𝗇𝖾𝗀𝗅(λ),

where ptriv𝒟𝒫,𝒟𝒳(λ)=sup𝒜{𝖯𝗋[P(x)𝒜(x):x𝒟𝒳λ(P)]} is the trivial guessing probability.

8 Construction of Multi-Copy Secure Revocable Programs in a Classical Oracle Model

In this section, we give a construction of multi-copy secure revocable programs; specifically, we work with a classical oracle model. Our construction is as follows:

Construction 27.

Let λ be the security parameter. Let n,m be polymomial in λ. Let Φ={Φλ}λ be an ensemble of permutations Φλ={φκ:{0,1}n+m{0,1}n+m}κ𝒦λ, for some set 𝒦λ.

  • 𝖲𝖾𝗍𝗎𝗉(1λ): sample a uniformly random key κ𝒦λ and let 𝗏𝗄=κ.

  • 𝖢𝗈𝗆𝗉𝗂𝗅𝖾(1λ,P): on input 1λ and a program P𝒫λ with P:𝒳λ𝒴λ, do the following:

    • Sample y{0,1}m and prepare the subset state given by

      |Sy=12nx{0,1}n|φκ(x||y).
    • Let |ΨP=|Sy and, for brevity, let S={φκ(x||y):x{0,1}n} be the corresponding subset.

    • Let O=OP,S denote an a (public) classical oracle, which is defined as follows:

      OP,S(x,s)={P(x), if sS0, otherwise 
  • 𝖤𝗏𝖺𝗅O(|ΨP,x): on input |ΨP, x𝒳λ, do the following:

    • Coherently evaluate OP,S on input |x|ΨP, and compute its output into an ancillary register.

    • Measure the ancillary register and then output the measurement outcome.

  • 𝖱𝖾𝗏𝗈𝗄𝖾(𝗏𝗄,ρ): on input 𝗏𝗄, a state ρ and verification key 𝗏𝗄, it parses y𝗏𝗄 and applies the measurement {|SySy|,𝕀|SySy|} to ρ; it outputs if it succeeds, and otherwise.

The above scheme is easily seen to satisfy correctness.

Proof of Multi-Copy Revocable Security

Before we analyze the security of Construction 27, let us first remark that we can instantiate the scheme using a QPRP family Φλ={φκ:{0,1}n+m{0,1}n+m}κ𝒦λ, for some key space 𝒦λ. In the security proof, however, we will work with the random permutation model instead. This means that we will consider random permutations throughout the security game.

Theorem 28.

Construction 27 satisfies multi-copy revocable security for any pair of distributions 𝒟𝒫,𝒟𝒳 in a classical oracle model, where the recipient receives an (ideal classical) oracle for the purpose of evaluation.

Proof.

Please see full version.

9 Construction of Multi-Copy Secure Revocable Point Functions in the QROM

Please see the full version for this section.

10 Applications to Sponge Hashing

Please see the full version for this section.

References

  • [1] Scott Aaronson. Quantum copy-protection and quantum money. In 2009 24th Annual IEEE Conference on Computational Complexity, pages 229–242. IEEE, 2009. doi:10.1109/CCC.2009.42.
  • [2] Scott Aaronson, Adam Bouland, Bill Fefferman, Soumik Ghosh, Umesh Vazirani, Chenyi Zhang, and Zixin Zhou. Quantum Pseudoentanglement. In Venkatesan Guruswami, editor, 15th Innovations in Theoretical Computer Science Conference (ITCS 2024), volume 287 of Leibniz International Proceedings in Informatics (LIPIcs), pages 2:1–2:21, Dagstuhl, Germany, 2024. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.ITCS.2024.2.
  • [3] Scott Aaronson and Paul Christiano. Quantum money from hidden subspaces. In Proceedings of the forty-fourth annual ACM symposium on Theory of computing, pages 41–60, 2012. doi:10.1145/2213977.2213983.
  • [4] Scott Aaronson, Jiahui Liu, Qipeng Liu, Mark Zhandry, and Ruizhe Zhang. New approaches for quantum copy-protection. In Advances in Cryptology–CRYPTO 2021: 41st Annual International Cryptology Conference, CRYPTO 2021, Virtual Event, August 16–20, 2021, Proceedings, Part I 41, pages 526–555. Springer, 2021. doi:10.1007/978-3-030-84242-0_19.
  • [5] Shweta Agrawal, Fuyuki Kitagawa, Ryo Nishimaki, Shota Yamada, and Takashi Yamakawa. Public key encryption with secure key leasing. In Annual International Conference on the Theory and Applications of Cryptographic Techniques, pages 581–610. Springer, 2023. doi:10.1007/978-3-031-30545-0_20.
  • [6] Andris Ambainis, Mike Hamburg, and Dominique Unruh. Quantum security proofs using semi-classical oracles. Cryptology ePrint Archive, Paper 2018/904, 2018. URL: https://eprint.iacr.org/2018/904.
  • [7] Prabhanjan Ananth, Aditya Gulati, Luowen Qian, and Henry Yuen. Pseudorandom (function-like) quantum state generators: New definitions and applications. In Theory of Cryptography Conference, pages 237–265. Springer, 2022. doi:10.1007/978-3-031-22318-1_9.
  • [8] Prabhanjan Ananth, Zihan Hu, and Zikuan Huang. Quantum key-revocable dual-regev encryption, revisited. Cryptology ePrint Archive, 2024.
  • [9] Prabhanjan Ananth and Fatih Kaleoglu. A note on copy-protection from random oracles. arXiv preprint, 2022. arXiv:2208.12884.
  • [10] Prabhanjan Ananth, Fatih Kaleoglu, and Qipeng Liu. Cloning games: A general framework for unclonable primitives. arXiv preprint, 2023. arXiv:2302.01874.
  • [11] Prabhanjan Ananth and Rolando L La Placa. Secure software leasing. In Annual International Conference on the Theory and Applications of Cryptographic Techniques, pages 501–530. Springer, 2021. doi:10.1007/978-3-030-77886-6_17.
  • [12] Prabhanjan Ananth, Yao-Ting Lin, and Henry Yuen. Pseudorandom strings from pseudorandom quantum states. In ITCS, 2024.
  • [13] Prabhanjan Ananth, Alexander Poremba, and Vinod Vaikuntanathan. Revocable cryptography from learning with errors. In Theory of Cryptography Conference, pages 93–122. Springer, 2023. doi:10.1007/978-3-031-48624-1_4.
  • [14] Prabhanjan Ananth, Luowen Qian, and Henry Yuen. Cryptography from pseudorandom quantum states. In Annual International Cryptology Conference, pages 208–236. Springer, 2022. doi:10.1007/978-3-031-15802-5_8.
  • [15] James Bartusek and Dakshita Khurana. Cryptography with certified deletion. In Advances in Cryptology – CRYPTO 2023: 43rd Annual International Cryptology Conference, CRYPTO 2023, Santa Barbara, CA, USA, August 20–24, 2023, Proceedings, Part V, pages 192–223, Berlin, Heidelberg, 2023. Springer-Verlag. doi:10.1007/978-3-031-38554-4_7.
  • [16] James Bartusek, Dakshita Khurana, Giulio Malavolta, Alexander Poremba, and Michael Walter. Weakening assumptions for publicly-verifiable deletion. Cryptology ePrint Archive, Paper 2023/559, 2023. URL: https://eprint.iacr.org/2023/559.
  • [17] James Bartusek, Dakshita Khurana, and Alexander Poremba. Publicly-verifiable deletion via target-collapsing functions. In Advances in Cryptology – CRYPTO 2023: 43rd Annual International Cryptology Conference, CRYPTO 2023, Santa Barbara, CA, USA, August 20–24, 2023, Proceedings, Part V, pages 99–128, Berlin, Heidelberg, 2023. Springer-Verlag. doi:10.1007/978-3-031-38554-4_4.
  • [18] Amit Behera, Zvika Brakerski, Or Sattath, and Omri Shmueli. Pseudorandomness with proof of destruction and applications. In Theory of Cryptography Conference, pages 125–154. Springer, 2023. doi:10.1007/978-3-031-48624-1_5.
  • [19] G. Bertoni, J. Daemen, M. Peeters, and G. Van Assche. Cryptographic sponge functions. Submission to NIST (Round 3), 2011. URL: http://sponge.noekeon.org/CSF-0.1.pdf.
  • [20] G. Bertoni, J. Daemen, M. Peeters, and G. Van Assche. The keccak sha-3 submission. Submission to NIST (Round 3), 2011. URL: http://keccak.noekeon.org/Keccak-submission-3.pdf.
  • [21] John Bostanci, Yuval Efron, Tony Metger, Alexander Poremba, Luowen Qian, and Henry Yuen. Unitary complexity and the uhlmann transformation problem, 2023. doi:10.48550/arXiv.2306.13073.
  • [22] John Bostanci, Jonas Haferkamp, Dominik Hangleiter, and Alexander Poremba. Efficient quantum pseudorandomness from hamiltonian phase states, 2024. doi:10.48550/arXiv.2410.08073.
  • [23] Zvika Brakerski and Omri Shmueli. (pseudo) random quantum states with binary phase. In Theory of Cryptography Conference, pages 229–250. Springer, 2019. doi:10.1007/978-3-030-36030-6_10.
  • [24] Anne Broadbent and Rabib Islam. Quantum encryption with certified deletion. In Theory of Cryptography: 18th International Conference, TCC 2020, Durham, NC, USA, November 16–19, 2020, Proceedings, Part III 18, pages 92–122. Springer, 2020. doi:10.1007/978-3-030-64381-2_4.
  • [25] Anne Broadbent, Stacey Jeffery, Sébastien Lord, Supartha Podder, and Aarthi Sundaram. Secure software leasing without assumptions. In Theory of Cryptography Conference, pages 90–120. Springer, 2021. doi:10.1007/978-3-030-90459-3_4.
  • [26] Anne Broadbent and Sébastien Lord. Uncloneable quantum encryption via oracles. arXiv preprint, 2019. arXiv:1903.00130.
  • [27] Alper Çakan and Vipul Goyal. Unclonable cryptography with unbounded collusions. Cryptology ePrint Archive, 2023.
  • [28] Orestis Chardouvelis, Vipul Goyal, Aayush Jain, and Jiahui Liu. Quantum key leasing for pke and fhe with a classical lessor. arXiv preprint, 2023. arXiv:2310.14328.
  • [29] Google Cloud. Key rotation, 2024. URL: https://cloud.google.com/kms/docs/key-rotation.
  • [30] Andrea Coladangelo, Jiahui Liu, Qipeng Liu, and Mark Zhandry. Hidden cosets and applications to unclonable cryptography. In Advances in Cryptology – CRYPTO 2021: 41st Annual International Cryptology Conference, CRYPTO 2021, Virtual Event, August 16–20, 2021, Proceedings, Part I, pages 556–584, Berlin, Heidelberg, 2021. Springer-Verlag. doi:10.1007/978-3-030-84242-0_20.
  • [31] Andrea Coladangelo, Christian Majenz, and Alexander Poremba. Quantum copy-protection of compute-and-compare programs in the quantum random oracle model. Quantum, 8:1330, May 2024. doi:10.22331/q-2024-05-02-1330.
  • [32] DGBJ Dieks. Communication by epr devices. Physics Letters A, 92(6):271–272, 1982.
  • [33] Tudor Giurgica-Tiron and Adam Bouland. Pseudorandomness from subset states. arXiv preprint, 2023. doi:10.48550/arXiv.2312.09206.
  • [34] Fernando Granha Jeronimo, Nir Magrafta, and Pei Wu. Subset states and pseudorandom states. arXiv preprint, 2023. doi:10.48550/arXiv.2312.15285.
  • [35] Zhengfeng Ji, Yi-Kai Liu, and Fang Song. Pseudorandom quantum states. In Advances in Cryptology–CRYPTO 2018: 38th Annual International Cryptology Conference, Santa Barbara, CA, USA, August 19–23, 2018, Proceedings, Part III 38, pages 126–152. Springer, 2018. doi:10.1007/978-3-319-96878-0_5.
  • [36] Masaru Kada, Harumichi Nishimura, and Tomoyuki Yamakami. The efficiency of quantum identity testing of multiple states. Journal of Physics A: Mathematical and Theoretical, 41(39):395309, 2008.
  • [37] Dakshita Khurana and Kabir Tomer. Commitments from quantum one-wayness. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing, pages 968–978, 2024. doi:10.1145/3618260.3649654.
  • [38] Fuyuki Kitagawa, Ryo Nishimaki, and Takashi Yamakawa. Secure software leasing from standard assumptions. In Theory of Cryptography Conference, pages 31–61. Springer, 2021. doi:10.1007/978-3-030-90459-3_2.
  • [39] Jiahui Liu, Qipeng Liu, Luowen Qian, and Mark Zhandry. Collusion resistant copy-protection for watermarkable functionalities. In Theory of Cryptography Conference, pages 294–323. Springer, 2022. doi:10.1007/978-3-031-22318-1_11.
  • [40] Tony Metger, Alexander Poremba, Makrand Sinha, and Henry Yuen. Simple constructions of linear-depth t-designs and pseudorandom unitaries, 2024. doi:10.48550/arXiv.2404.12647.
  • [41] Tomoyuki Morimae, Alexander Poremba, and Takashi Yamakawa. Revocable quantum digital signatures. arXiv preprint, 2023. arXiv:2312.13561.
  • [42] Tomoyuki Morimae and Takashi Yamakawa. One-wayness in quantum cryptography. arXiv preprint, 2022. arXiv:2210.03394.
  • [43] Tomoyuki Morimae and Takashi Yamakawa. Quantum commitments and signatures without one-way functions. In Annual International Cryptology Conference, pages 269–295. Springer, 2022. doi:10.1007/978-3-031-15802-5_10.
  • [44] Alexander Poremba. Quantum proofs of deletion for learning with errors. arXiv preprint, 2022. arXiv:2203.01610.
  • [45] Ronald L Rivest. Can we eliminate certificate revocation lists? In Financial Cryptography: Second International Conference, FC’98 Anguilla, British West Indies February 23–25, 1998 Proceedings 2, pages 178–183. Springer, 1998. doi:10.1007/BFB0055482.
  • [46] Stuart G Stubblebine. Recent-secure authentication: Enforcing revocation in distributed systems. In Proceedings 1995 IEEE Symposium on Security and Privacy, pages 224–235. IEEE, 1995. doi:10.1109/SECPRI.1995.398935.
  • [47] Dominique Unruh. Revocable quantum timed-release encryption. Cryptology ePrint Archive, Paper 2013/606, 2013. doi:10.1145/2817206.
  • [48] Stephen Wiesner. Conjugate coding. SIGACT News, 15(1):78–88, January 1983. doi:10.1145/1008908.1008920.
  • [49] Wikipedia. Certificate revocation, 2024. URL: https://en.wikipedia.org/wiki/Certificate_revocation.
  • [50] William K Wootters and Wojciech H Zurek. A single quantum cannot be cloned. Nature, 299(5886):802–803, 1982.
  • [51] Mark Zhandry. A note on quantum-secure prps, 2016. arXiv:1611.05564.
  • [52] Mark Zhandry. Quantum lightning never strikes the same state twice. or: quantum money from cryptographic assumptions. Journal of Cryptology, 34:1–56, 2021.