1. Introduction
1.1. Context and State of the Art
The goal of relativistic cryptography is to exploit the no superluminal signaling (NSS) principle in order to perform various cryptographic tasks. NSS states that no information carrier can travel at a speed greater than the speed of light. Note that NSS is closely related to the non-signaling principle that says that a local action performed in a laboratory cannot have an
immediate influence outside of the lab. NSS is more precise since it gives an upper bound on the speed at which such an influence can propagate. Apart from this physical principle, we want to ensure information-theoretic security meaning that the proposed schemes cannot be attacked by any classical (nor quantum) computer, even with infinite computing power. This is in contrast with used schemes, which most often rely on computational assumptions such as the hardness of factoring [
1].
The idea of using physical assumptions laws to ensure information theoretic security for cryptographic schemes is not a new one. The most striking example in recent years is Quantum Key Distribution (QKD), which allows two distant parties to distill a secret key with information-theoretic security [
2]. The main idea of QKD is to exchange quantum states on an insecure quantum channel and check a posteriori whether they have been disturbed. If not, it means that no eavesdropper was tampering with the quantum channel and the quantum states can be safely used to distill a secret. In fact, this work provided that the quantum states are not too noisy. QKD is quite practical and has indeed been widely deployed, but, at the same time, it requires dedicated hardware and can only work today provided the two parties are not too far away from each other, at most a few hundred kilometers (see for instance [
3] for the current record).
The idea of using the NSS principle for cryptographic protocols originated in a pioneering work by Kent in 1999 [
4] as a way to physically enforce a non communication constraint between the different agents of one party (the idea of splitting up a party into several agents dates back to [
5], but without an explicit implementation proposal). The original goal of Kent was to bypass the no-go theorems for quantum bit-commitment [
6,
7]. Interestingly, this original protocol was classical and allowed for several rounds that increased the lifespan of the protocol. However, the protocol required to exchange messages whose length scaled exponentially in the number of rounds (i.e., the commitment time) and a feasible implementation was not possible for a large number of rounds. A subsequent work [
8] improved this scaling, but, to our knowledge, no precise time/security tradeoff is available for this protocol.
More recently, quantum relativistic bit commitment protocols were developed where the parties exchange quantum systems, with the hope that combining the no superluminal signaling principle with quantum theory will lead to more secure (but less practical) protocols [
9,
10,
11]. In particular, the protocol [
10] was implemented in [
12]. We note that the scope of relativistic cryptography is not limited to bit commitment. For instance, there was recently some interest (sparked again by Kent) for position–verification protocols [
13,
14,
15], but, contrary to the case of bit commitment, it was shown that secure position–verification is impossible both in the classical and the quantum settings [
16,
17].
The original idea of [
5] was recently revisited by Crépeau et al. [
18] (see also [
19]). Based on this work, Lunghi et al. devised a multi-round bit commitment protocol involving only four agents, two for Alice and two for Bob [
20]. They managed to prove that this protocol, which we call the “
protocol” from now on, remains secure for several rounds, against classical attacks. Unfortunately, this proof was rather inefficient since the complexity of the protocol (the size of the messages the agents need to exchange at each round) scaled exponentially with the number of rounds. Recently, two papers improved the security proof and showed that the complexity of the protocol in fact only scales logarithmically with the number of rounds [
21,
22], implying that the commitment time is essentially unlimited:
Theorem 1 ([
21,
22]).
The relativistic m-round bit commitment protocol is ε-binding with against classical adversaries, meaning that Alice’s cheating probability is at most . While the two proofs of this fact are very different, they rely to some extent on the analysis of , a non-signaling game that generalizes the well-known game to the case where inputs and outputs are not restricted to being bits, but rather belong to the Galois Field of order Q.
Notice that, in the way the cheating probability is defined, a perfectly secure protocol will have cheating probability of for both Alice and Bob and an -secure (here -binding) protocol will have a cheating probability of . The protocol has (stand-alone) security when is small.
Theorem 1 shows that the protocol is secure as long as
, but it was not known for larger values of
Q, in particular when
m approaches, or even exceeds
. Very recently, this protocol has been implemented by keeping the agents 7 km apart with a validity time of 24 h [
23]. In addition, it is important to know that the number of bits sent at each round is
and therefore
Q can be efficiently made exponentially big in the security parameter.
Until now, no cheating strategy has been proposed for this scheme.
1.2. Contributions
Our main contribution is to present the first attack on the protocol. We show the following.
Theorem 2. There exists an attack on the m-round protocol in which Alice’s cheating probability iswhere is the classical value of the game and . In [
24], it was shown for any prime
p and integer
n that
where
is a constant proven to be positive.
In particular, Theorem 2, combined with the above bound, shows that the upper bound of [
21,
22] (Theorem 1) is essentially optimal when considering an even prime power:
Corollary 1. For any integer n, prime number p and , there is a cheating strategy for Alice that achieves success probability If , then the above cheating probability is equal to .
If , then the above cheating probability is lower bounded by , which quickly approaches 1 as t increases.
From the above bounds, we can conclude that, up to constant factors, our attack is optimal when Q is an even power of a prime.
We note also that there is an upper bound on the value of
when
Q is an odd power of a prime. In this case, we have
[
24,
25]. From there, we have the following.
Corollary 2. For any integer n, prime number p and , there is a cheating strategy for Alice that achieves success probability Therefore, if , then Alice can cheat with probability which quickly converges to 1 as t increases.
This result also shows that even an improved bound on
variants presented in [
26] cannot be used to improve—except in the constants—the security of the
protocol, at least for even prime powers of
Q.
Our second contribution is an extension of this attack to more realistic scenarios from the attacker’s point of view. In the relativistic model, we assume that cheating Alice can perform communications between and such that both agents of Alice know exactly the whole transcript of the protocol, except the last round message sent to the other Alice. Proving security in this setting allows us to minimize the spacetime requirements in order to achieve security.
However, our attack also assumes this power for cheating Alice, and this could be very challenging in practice. Therefore, we introduce the notion of propagation time, which corresponds to the number of rounds that can pass until the Alices are able to send some information to one another. In the original model, this propagation time is two rounds. We extend Theorem 2 to the following setting:
Showing that the attack works in this setting ensures that simple countermeasures consisting of increasing the distance between the two pairs will not significantly reduce the efficiency of the attack. We show the following.
Theorem 3. For any propagation time , and any decision time , there exists an attack on the m-round protocol, where Alice’s cheating probability isfor . In
Section 2, we present the
protocol as well as the
game. In
Section 3, we present our main result, namely the attack on the
protocol. In
Section 4, we present the extension of this attack to more realistic scenarios.
2. Preliminaries
2.1. Bit Commitment
Bit commitment is a cryptographic primitive between two distrustful parties Alice and Bob, which consists of two phases: a Commit phase and a Reveal phase. Alice has a random bit d at the beginning of the protocol. In the commit phase, Alice will commit to this value d by performing some communication protocol such that, at the end of the commit phase, Bob knows no information about d. In the second phase, the reveal phase, Alice and Bob also perform some communication, which results in Alice revealing d. A desired property here is that Alice is unable to reveal a bit different from the one chosen during the commit phase.
In some sense, a bit commitment protocol simulates a digital safe. In the commit phase, Alice writes her input d on a piece of paper, puts that paper into the safe and sends the safe to Bob. If Bob has no information about the key safe, then he cannot open it and therefore has no information about d. In the reveal phase, Alice would send to Bob the key to open the safe. However, she cannot change the value of the bit in the safe because Bob has control of the safe. This primitive has been widely studied. However, bit commitment can only be performed with computational security in most usual models.
We now give a formal definition of the bit commitment scheme.
Definition 1. A bit commitment scheme is an interactive protocol between Alice and Bob with two phases, a Commit phase and a Reveal phase.
Commit phase. Alice chooses a uniformly random input d that she wants to commit to. To do so, Alice and Bob perform a communication protocol that corresponds to this commit phase.
Reveal phase. Alice interacts with Bob in order to reveal d. To do so, they perform a second communication protocol, where, at the end, Bob should know the value revealed by Alice. Bob, depending on this revealed value and the interaction with Alice, outputs “Accept” or “Reject”.
We also define the following security requirements for the commitment scheme.
Definition 2. A bit commitment protocol is said to be correct if when both players are honest, Bob never outputs “Reject”.
A cheating strategy S for Alice can be therefore decomposed into a cheating strategy for the commit phase and for the reveal phase and we will usually write . The goal of a cheating Alice is to choose the value she wants to reveal only after the commit phase. The reveal strategy will depend on the value d she wants to reveal. We denote by Alice’s cheating strategy in the reveal phase for a fixed d.
Definition 3. For a fixed cheating strategy for Alice, we define Alice’s cheating probability as Definition 4. We define Alice’s optimal cheating probability asWe say that a bit commitment is ε sum-binding if . Here, we used one of several possible definitions for the binding property. This definition is weak, since it doesn’t necessarily behave well under composition. In order to prove security, even for relativistic bit commitment protocols, some stronger definitions of security are used (see for example [
22]). While using a stronger security definitions strengthens upper bounds on the cheating probability, it is by using the weakest security definition that we have the strongest lower bounds on those cheating probabilities. Since in this paper, we present cheating strategies, i.e., lower bounds, we use the weak notion of sum-binding.
Another security condition we want to ensure is the hiding property. At the end of the commit phase, we don’t want Bob to have a lot of information about the committed bit d. This means that to ensure the hiding property, we will only be interested in a cheating Bob’s strategy during the commit phase, and a cheating strategy for Bob will be a strategy that he will use to try to learn d after the commit phase.
Definition 5. For a fixed cheating strategy for Bob, we define his cheating probability as Definition 6. We define Bob’s optimal cheating probability asWe say that a bit commitment is ε-hiding if . 2.2. Relativistic Bit Commitment
A relativistic bit commitment scheme is a commitment scheme where we use physical property that no information carrier can travel faster than the speed of light. In order to take advantage of this principle, we split Alice (resp. Bob) into two agents and (respectively, and ). For each , interacts only with . If we put the two pairs and far apart, and use some timing constraints, we can create some non-signaling type scenarios. Here, we will only use the property that the two honest Bobs know their respective location. In particular, there is no trust needed regarding the location of the cheating parties.
The security definitions for relativistic bit commitment are the ones we presented in the section above. We will now describe the
relativistic bit commitment scheme. This description will consist of four phases: the preparation phase, the commit phase, the sustain phase and the reveal phase. The preparation phase is some preprocessing phase that can be done anytime before the protocol. The sustain phase can be seen as a part of the reveal phase and corresponds to the time where the committed bit is safe. We assume here that the two Alices know at the beginning of the sustain phase the bit
d they want to reveal. In
Section 4, we will relax this requirement.
The single-round protocol—The single-round version corresponds to the protocol introduced by Crépeau et al. [
18] (see also [
19]). Both players, Alice and Bob, have agents
and
present at two spatial locations, 1 and 2, separated by a distance
D. We consider the case where Alice makes the commitment. The protocol (followed by honest players) consists of four phases: preparation, commit, sustain and reveal. The sustain phase in the single-round protocol is trivial and simply consists in waiting for a time less than
, which is the time needed for light to travel between the two locations. The bit commitment protocol goes as follows:
Preparation phase: (resp. ) share a random number (resp. );
Commit phase: sends x to , who returns where is the committed bit;
Sustain phase: and wait for some time ;
Reveal phase: reveals the values of d and a to who checks that .
The multi-round protocol—The protocol above was recently extended to a multi-round commitment scheme [
20]. The main idea to increase the commitment time is to delay the reveal phase and have
commit to the string
a instead of revealing it. In fact, the new sustain phase will now consist of many rounds where the active players (i.e., the player who commits in that given round and the corresponding player for Bob) alternate between locations 1 and 2, separated by a distance
D. The
m-round bit commitment protocol goes as follows:
Preparation phase: (resp. ) share m random numbers (resp. ) .
Commit phase: sends to , who returns , where is the committed bit.
Sustain phase: for each round k, with , sends to , who returns .
Reveal phase: reveals d and to . Bob checks that , where we recursively define , . We defined such that it corresponds to what “should be”.
The main idea of the multi-round protocol is to delay the reveal phase in order to increase the commitment time. This delay is obtained by making the passive Alice commit to the value of the string she was supposed to reveal in the previous round. Since each round increases the total commitment time by , modulo the time needed for the various algebraic manipulations in , one sees that the required number of rounds scales linearly with the commitment time one wishes to achieve.
We require that round j finishes before any information about reaches the other Alice. For any j, we therefore have the following: active Alice has no information about . This means that is independent from . This will be crucial in order to show security of the protocol. One important thing to notice is that d, the bit Alice wants to reveal can be decided just after the commit phase. Therefore, is independent of d but all the other messages can depend on d.
Both of those protocols are perfectly hiding. Moreover, from Theorem 1, the multi-round protocol is sum-binding, with .
2.3. The Game
A crucial tool for our attack (and for the previous security analysis) is the
two-player game introduced by Buhrman and Massar [
27]. This game is a natural generalization of the
game to the field
, where two cooperating but non-communicating parties, Alice and Bob, are, respectively, given an input
x and
y chosen uniformly at random from
, and must output two numbers
. They win the game whenever the condition
is satisfied. The value of a game
G, denoted
, corresponds to the maximum probability of winning the game. A recent result by Bavarian and Shor [
24] establishes bounds on
. They show the following.
Proposition 1. For any prime p and integer n, we havefor some absolute constant . We define a variant of the
game, which we call
, which will be well defined for any
. We will use this variant in
Section 4, when we will have longer propagation and decision times.
Definition 7. In , Alice receives with probability γ and a random element , each with probability . Bob receives an input y according to the same probability distribution. They output, respectively, a and b in , and they win the game iff .
In short, is the same game as , but the input distribution of each player is slightly biased towards 0. We have by definition . When playing , we have:
The probability that Alice and Bob get is .
The probability that they get an element or with is equal to for each such element.
The probability that they get an element with is equal to for each such element.
In [
24], the authors used a shifting technique to show that any strategy for
can be balanced into a strategy with equal winning probability for each input. The technique use relies on adding a random shift to each of the inputs and changing the strategy accordingly. Inspired by those techniques, we can show:
Lemma 1. For any , .
Proof. As randomized strategies are nothing more than linear combinations of deterministic strategies, of which winning probability is given by the same linear combination, we can assume that all used optimal strategies are deterministic without loss of generality.
We consider an optimal strategy for the game i.e., function such that , where the probability is over a uniform choice of x and y. We define if and 0 otherwise, which implies .
Let
be the winning probability using
S when considering the following input distribution: Alice receives
with probability
and a random element
, each with probability
. Bob receives an input
with probability
and a random element
, each with probability
:
In particular, corresponds to the probability of winning when using strategy S. One can check that , where the probability is over a uniform choice of u and v. This means that we can fix a pair such that .
We now consider the strategy
, where
and
.
wins for
precisely when
S wins for
. Indeed:
Similarly, as before, we define
if
and 0 otherwise. From the above equivalence, we have
. We also define
Notice that
corresponds to the probability of winning
when using strategy
. Moreover, for any
, we have
. From there, we conclude
which proves the desired result. ☐
3. Attack with Perfect Conditions
In this section, we present our construction of a cheating strategy that will be essentially optimal for some values of Q. The protocol is perfectly hiding. Therefore, we are only interested in the binding property, i.e., in cheating Alice.
The idea of the attack is the following. Every three rounds (or more in
Section 4), Alice’s agents have an occasion to play a
game. If they win this game, which happens with probability
, they can easily fool Bob (with the provided strategy, sending only zeros until the
reveal phase is fine). If they do not manage to win the
game, they just try again three rounds later. More precisely, for each step of three rounds, the last two rounds are used to play the
game. The first one allows
and
to determine if they won during the previous step, or calculate a corrective factor
if they did not. Thus, for a m-round protocol, Alice’s agent can play roughly
such
games. As it is sufficient for them to win one of these games, we see that cheating probability grows exponentially with the number of rounds. Moreover, at each of these sets of three rounds, an additional factor
appears. Indeed, if at the third round of the set Bob sends a 0, Alice is also in a situation in which she can cheat because this 0 makes Alice’s error collapse to zero. However, the contribution of this additional factor can be neglected (it is only
, compared to the
given by
).
We assume for now that the propagation time of the information is two rounds. This means that when receives , the other Alice will know the value of at round . Therefore, a cheating strategy for Alice is described by a m-tuple of functions , where each corresponds to Alice’s output function at round i. The function is a function of and is a function of for , where we use the convention . For each and the output space of each is .
Consider any fixed cheating strategy
S for Alice. At the end of the protocol, Bob checks that
. When we expand
as a function of
, the checking condition, which we call
, becomes
If Equation (
5) is not verified, Alice is caught cheating. On the other hand, if
is verified, then Bob cannot distinguish an honest Alice from a dishonest one, and he does not abort.
Let
be the event that corresponds to the above equality being verified. Alice’s cheating probability using
S, which we denote
, is therefore
where
d is a uniformly random bit and
are uniformly random elements of
. We also define
, which is Alice’s maximal cheating probability in
. In this section, we present a cheating strategy
S for Alice such that
which will prove Theorem 2. In order to do so, we first modify protocol
to make it more symmetric (
Section 3.1). Then, we describe our attack (
Section 3.2) and we prove its cheating probability (
Section 3.3).
3.1. Symmetrization of the Protocol
We want to describe a recursive strategy for protocol . Unfortunately, this protocol induces a difference between Alice’s strategy at round and her strategy at round m. Because of that, it is difficult to study the protocol recursively.
We therefore consider a modified protocol , which, as we will show, is a bit easier than to win, but harder than . In this modified version, at round m, sends an additional random string , and returns instead of . All other rounds are unchanged. Similarly, as for , a cheating strategy for Alice can be described as a m-tuple of functions that give Alice’s outputs depending on her accessible information at round i.
Bob checks now that
, and, therefore, the condition Alice must satisfy to win is modified into
, where
By expanding
, it can be written down as:
or using a compact form:
For a cheating strategy
, Alice’s winning probability
for this modified protocol is therefore defined as
We show the following
Lemma 2. , we have
Proof. For the first inequality, let us consider the optimal strategy
for
, where
is Alice’s strategy at round
k (i.e., a function that outputs
when given Alice’s knowledge at round
k). Alice’s cheating probability for
is
. Consider the following strategy
for
, where
.
allows for winning on
at least as efficiently as
S on
because
wins whenever
S does. Indeed, suppose that
S is a winning strategy for a given
. This means that
is satisfied or equivalently:
Then, since
, we get
which implies
, for any
. From there, we immediately get
For the other inequality, we fix an optimal strategy
for
. We consider the following strategy
for
, where
is the function that always outputs 0, no matter the inputs. This means that, when performing
S, we always have
.
S is at least as good to win
as
is to win
. Indeed, if for a tuple
,
wins on
, then
holds or equivalently
From there, we immediately have
which implies
. From there, we immediately get
☐
The above lemma shows in particular how to transform a strategy for into a strategy for with at least as good cheating probability. This means that we can study instead of . The first inequality shows that we do not lose much doing so.
The above equations can be hard to follow because of the alternating − signs. In order to simplify calculations, each
will be mapped to
. We will mostly use
from now on instead of
. With this notation, Alice’s victory condition
for the protocol becomes:
In the description of the protocol, when we say that Alice outputs for any v, then this means that Alice outputs .
In the next section, we present a cheating strategy for protocol .
3.2. Description of the Attack
In the previous section, we transformed protocol into a slightly modified protocol , which has extra symmetries and for which it will be simpler to construct a recursive cheating strategy. In this section, we describe this strategy for .
More precisely, we define recursively a strategy with a step of three rounds. The idea is that and will use the two first rounds to play a game and will use the third round as a waiting in order for both players to know whether they won the game or not.
To initialize, we consider the following strategy for :
always outputs .
and perform the optimal strategy for the game with inputs and . Let a and b be their respective outputs.
outputs for round 2 and outputs for round 3. Recall that this means Alice outputs and .
With this strategy, becomes . Alice wins if , if , or if . These events are independent, which gives .
We now describe a strategy for rounds using a strategy for k rounds. We fix a cheating strategy for Alice for and we present a cheating strategy for .
Recursive Description of a cheating strategy given |
Rounds 1 to k: Alice performs the strategy to get outputs .
Round : Alice always outputs .
Rounds
and
: From round
,
and
both know
. Let
and
perform the optimal strategy for
on respective inputs
and
to get respective outputs
a and
b. Their outputs of the protocol are, respectively,
and
. Notice that, if
, which will correspond to the strategy
succeeding to achieve
, and Alice outputs
independently of
a and
b.
In the next section, we will prove the cheating probability achieved by this strategy, which will imply our main theorem.
3.3. Analysis
Lemma 3. , satisfies: Proof. We consider
. Alice’s winning condition
is:
or by taking apart the last three terms:
Recall that
. Using
, we get:
Recall from our protocol description that
and
, where
a and
b are the Alice’s outputs of the
game. From there, we have
These three events ; ; are independent as:
only depends on , and happens with probability .
only depends on , and happens with probability .
only depends on and ( and optimally play the game on inputs , ignoring any unnecessary information). This happens therefore with probability .
Thus, this particular strategy gives
or equivalently
☐
We can now prove our main theorem, restated below
Proof. By iterating the above lemma, we obtain
Combining this with the initialization step
gives
Using the symmetrization lemma (Lemma 2), we immediately get
If
m can be written
for some
k, we have
Since
is an increasing function, we have for all
:
☐
4. Generalization
In the previous section, we assumed that and can communicate very efficiently, meaning that the propagation time is two rounds. With such a propagation time, relativistic constraints ensure that at a given round k, Alice cannot use any information concerning round . However, we supposed that she knows everything about the rounds and before. Notice that she obviously has access to the information of round because it occurs at the same place than round k.
What happens if and cannot reliably share their knowledge so fast? In this case, the propagation time will be larger, and at any round k, Alice knows everything about rounds with. We use an even propagation time without loss of generality since computations rotate between two places, and Alice always knows what happened at rounds , , etc. In this situation, we will show that and cannot just play the game. They will have to play the game, for some that will be specified later.
Another restriction that we do on the cheating players is that and may need some time to determine the bit d they want to decommit to. We call the round starting from which both and know if they try to reveal or .
In this more practical setting, we propose the following recursive variant of our attack, for , for any propagation time .
Recursive Description of a Cheating Strategy given |
Rounds 1 to k: Alice performs the strategy to get outputs .
Rounds to : Alice outputs .
Rounds
and
: From round
,
and
both know
. Let
also knows
and
knows
.
and
perform the optimal strategy for
with
on respective inputs
X and
Y to get respective outputs
a and
b. Their outputs of the protocol are, respectively,
and
.
Proof. This demonstration will be similar to Lemma 3. We consider the cheating strategy described above. Alice’s winning condition
is:
or by separating the last
terms:
where
d is the bit Alice wants to reveal.
Recall that
, which allows to simplify
as follows:
In her cheating strategy, Alice answers
and
, where
a and
b are Alices’ answers when playing the
game, on inputs
X and
Y. Thus,
The three events ; ; are independent. The first one occurs with probability , the second one with probability . For the third one, notice that X is a product of uniformly random number in . Therefore, we have and for any , . Y satisfies the same probability distribution. Therefore, is exactly the probability of winning the game using its optimal strategy.
Then, using Lemma 1:
i.e.,
☐
Theorem 3. For any and , for any , we have Proof. We use the recursive inequality from Lemma 4, and the trivial initialization
. This gives us
, and we have
and, by using Lemma 2,
If
m can be written
, we have
and
In order, to conclude, notice that
is an increasing function in
m. We can therefore conclude that
☐