### A Verifiable and Practical Lattice-Based

### Decryption Mix Net with External Auditing

Xavier Boyen1_{, Thomas Haines}2_{, and Johannes M¨}_{uller}3[0000−0003−2134−3099]

1

Queensland University of Technology, Australia,

2

Norwegian University of Science and Technology, Norway,

3 _{SnT, University of Luxembourg, Luxembourg}

Abstract. Mix nets are often used to provide privacy in modern security protocols, through shuffling. Some of the most important applications, such as secure electronic voting, require mix nets that are verifiable. In the literature, numerous techniques have been proposed to make mix nets verifiable. Some of them have also been employed for securing real political elections.

With the looming possibility of quantum computers and their threat to cryptosystems based on classical hardness assumptions, there is sig-nificant pressure to migrate mix nets to post-quantum alternatives. At present, no verifiable and practical post-quantum mix net with external auditing is available as a drop-in replacement of existing constructions. In this paper, we give the first such construction.

We propose a verifiable decryption mix net which solely employs practi-cal lattice-based primitives. We formally prove that our mix net provides a high level of verifiability, and even accountability which guarantees that misbehaving mix servers can also be identified. Verification is ex-ecuted by a (temporarily trusted) public auditor whose role can easily be distributed. To demonstrate practicality for real-world systems, we provide detailed performance benchmarks on our stand-alone implemen-tation based only on the most conservative lattice hardness assumptions. Keywords: latticbased · verifiability · accountability · mix net · e-voting

### 1

### Introduction

Mix nets are indispensable building blocks of many secure e-voting systems. Es-sentially, a mix net consists of a sequence of mix servers which take as input the encrypted messages provided by the senders (e.g., the voters’ ballots), se-cretely shuffle them, and eventually output the permutated plain messages (e.g., votes). Unless all mix servers are corrupted, the mixing breaks the individual connections between the senders and their revealed messages in the output. In the context of e-voting, this property guarantees vote privacy.

mix net must be verifiable to guarantee that manipulating the senders’ input, and generally incorrect mixing, can be detected. Moreover, in order to deter parties from misbehaving in the first place, accountability is often also desirable. This stronger form of verifiability provides identification of misbehaving parties and adjudication of possible disputes. In the literature, numerous mix nets [1, 2, 4, 10, 11, 14, 15, 17, 19–21, 24, 28, 29, 32–34, 36–38] have been proposed that aim to achieve verifiability and, in some cases, accountability. Some of them have also been used for securing real political elections (see, e.g., [12, 35]).

With more and more powerful quantum computers on the horizon (see, e.g., [3]), it is important to protect mix nets even when actively targeted by quantum attackers, either contemporary or future. Due to the stark possibility that future quantum attackers could retrospectively break vote privacy, there is significant pressure to employ verifiable post-quantum mix nets already today.

Unfortunately, to the best of our knowledge, only a single verifiable mix net scheme [24], named sElect, has been proposed so far that could employ practi-cal post-quantum, e.g., lattice-based, cryptosystems. The unique characteristic of sElect, in contrast to all other known verifiable mix nets, is to avoid (zero-knowledge) proofs of correct decryption, for which, at present, there exist no practical solutions whose security can be reduced to hardness assumptions over lattices (see Section 2 for more details). Alas, although sElect is provably secure, its security relies on the assumption that the senders/voters themselves verify the correctness of the final outcome. While this assumption is reasonable for some election scenarios, it cannot be justified in general; in particular, recourse and adjudication in case of voter-detected fraud is problematic.

Therefore, it is still an open problem to construct a practical and provably secure mix net with external auditing that can defend against quantum attacks. Our contributions. In this paper, we present the first highly efficient and prac-tically realizable lattice-based decryption mix net that provides a high level of verifiability and even accountability. Verification is completely executed by a (temporarily trusted) public auditor whose role can easily be distributed. This structure is the same as the one of the prominent randomized partial checking (RPC) technique [20] which was, for instance, used for elections in the Australian state of Victoria [12].

other”, but place that responsibility on a number of public auditors. Just one of these auditors needs to be trusted, and in fact only temporarily, because each auditor opens its inner state once mixing has finished—which incidentally greatly simplifies adjudication in case of dispute, and could not be done to the mixers themselves. Second, each auditor does not inject just a single but many trip wires, so that the probability of being caught cheating can be made very high even for manipulating just a few messages. Trip wires are cost effective, and since we further use only the most basic and black-box cryptographic primitives (namely, public-key encryption and digital signatures), the resulting mix net can be run with extremely efficient (lattice-based) primitives that more than compensate for the trip wires’ overhead compared to ZKP-based approaches.

Altogether, our contributions are as follows:

1. We first discuss the unique constraints that come into play when building mix nets with quantum resistance, and related works (Section 2).

2. We describe how to extend an arbitrary plain (i.e., unverifiable, proof-less) decryption mix net (Section 3) with our general version of the trip wire technique (Section 4).

3. We precisely characterize how a decryption mix net with trip wires provides a high level of verifiability and even accountability (Section 5). A formal proof is provided in our technical report [7].

4. We instantiate the generic trip wire decryption mix net using practical lattice-based cryptography from conservative hardness assumptions (plain LWE). We have created a self-contained optimized implementation of the lattice construction, and provide detailed benchmarks that demonstrate its practi-cality for real-world elections at a high level of security (Section 6).

5. We candidly discuss the general properties, benefits and drawbacks of trip wire mix nets (Section 7) and conclude in Section 8.

### 2

### Feasibility of Post-Quantum Secure Mixing

Existing mix nets can be divided into two classes: decryption mix nets and re-encryption mix nets. In this section, we describe the main ideas of these two different approaches, and explain why the re-encryption approach is currently impractical for defending against quantum attackers.

In a decryption mix net, originally proposed by Chaum [8], an IND-CCA2 secure public-key encryption scheme is employed. Each mix server holds a pub-lic/secret key pair. Each sender iteratively encrypts its input message under the mix servers’ public keys in reverse order, forming a multi-layered onion. Mixing starts with the first mix server, which “peels off” the outermost encryption layer, shuffles the result, forwards it to the second mix server, and so on. Eventually, all encryption layers have been removed and the plain input messages are published in the resulting random order.

trustees. Each sender encrypts its input message under this public key. Mixing starts with the first mix server which re-encrypts its input ciphertexts, shuffles the result, forwards it to the second mix server, and so on. Eventually, all re-encrypted input ciphertexts are published in random order. Depending on the application, the output ciphertexts are either decrypted by the trustees or not.

In their plain unverifiable modes, re-encryption mix nets are more lightweight than decryption mix nets because input messages are not encrypted iteratively but only once under a single public key. However, when verifiability in the pres-ence of quantum attackers is required, the trade-offs get more complicated. In general, there are two different approaches for making re-encryption mix nets verifiable, namely, by using randomized partial checking (RPC) [20] or by a proof of correct shuffle [1, 2, 4, 10, 11, 14, 15, 17, 19, 28, 29, 33, 34, 37]. On the positive side, RPC could potentially be used for making a lattice-based re-encryption mix net verifiable, for instance using one of three recently proposed lattice-based proofs of correct shuffle [10, 11, 33], although it is unclear whether or not these are practical. On the negative side, both proof-based approaches merely guarantee that the output ciphertexts are in fact shuffled re-encryptions of the input ciphertexts. In order to be useful for our motivating application, i.e., secure e-voting, we also have to decrypt the output ciphertexts verifiably. Un-fortunately, to the best of our knowledge, no practical zero-knowledge proofs of correct decryption for lattice-based encryption have been proposed so far, whose security can itself be reduced to lattice-based hardness assumptions. Even with recent developments on sublinear arguments from lattices [5], ZK proofs tend to be, and will likely remain, much heavier and more cumbersome than simple primitives such as public-key encryption based on comparable assumptions.

As the main purpose of our mix nets would be for quantum-secure e-voting where integrity, performance and simplicity of implementation are paramount, our best bet is to devise a lattice-based decryption mix net that provides external auditability using only the simplest fastest primitives as building blocks.

### 3

### Plain Decryption Mix Net

In this section, we first recall the main idea of a plain unverifiable decryption mix net [8] and then precisely describe its protocol. In Section 4, we describe the generic trip wire technique to endow a plain decryption mix net with correctness verification (and external/third-party adjudication) of its outcome.

3.1 Idea

At a high level, a decryption mix net works as follows. It consists of a num-ber of mix servers M1, . . . , MnMS each of which holds a public/private

(encryp-tion/decryption) key pair (pk_{k}, skk). Each sender iteratively encrypts its plain

input message m under the public keys pk_{1}, . . . , pk_{n}

MS of the mix servers in

encryption layer of all input ciphertexts, then shuffles the decrypted messages, and forwards the permutated list to the second mix server M2. The second mix

server uses its secret key sk2 to “peel off” the second encryption layer, then

shuffles the result, and so on. Eventually, the last mix server MnMS outputs all

the plain messages initially chosen by the senders in random order.

3.2 Protocol

We now precisely describe the protocol of a plain decryption mix net.

Protocol participants. A plain decryption mix net protocol is run among senders, S1, . . . , SnS, and mix servers, M1, . . . , MnMS, using a public, append-only bulletin

board B.

Channels. For each sender Si, we assume that there is an authenticated channel

from Sito the bulletin board B. These channels ensure that only eligible senders

are able to submit their inputs.4

Cryptographic primitives. We use the following cryptographic primitives: – An IND-CCA2-secure public-key encryption scheme E .5

– An EUF-CMA-secure signature scheme S.

Protocol overview. A protocol run consists of the following consecutive phases. In the setup phase, parameters are generated. In the submission phase, the senders generate and submit their input. In the mixing phase, the mix servers collaboratively mix the input.

We now describe each of the protocol phases in more detail.

Setup phase. Each mix server Mk runs the key generation algorithm of the

digital signature scheme S to generate its public/private (verification/signing) keys. The verification keys are published on the bulletin board B.

Each mix server Mk runs the key generation algorithm KeyGen of the

public-key encryption scheme E to generate its public/private (encryption/decryption)
key pair (pk_{k}, skk), and posts its public key pkk on the bulletin board B.

Submission phase. Each sender Siiteratively encrypts its secret input miunder

the mix servers’ public keys in reverse order, i.e., starting with the public key pknMS of the last mix server MnMS to the public key pk1 of the first mix server

M1:

ci= Enc(pk1, (. . . , Enc(pknMS, mi))).

Mixing phase. The list of ciphertexts C0← (ci)ni=1S posted by the senders on the

bulletin board B is the input to the mixing phase. Starting with the first mix

4

By assuming such authenticated channels, we abstract away from the exact method the senders use to authenticate to the bulletin board; in practice, several methods can be used, such as one-time codes, passwords, or external authentication services.

5 _{We also require that E, for every public-key and any two plaintexts of the same}

server M1, each mix server Mk takes Ck−1 as input and performs the following

tasks:

1. Mk decrypts all ciphertexts in Ck−1 under its private key skk:

∀i ∈ {1, . . . , nS} : Ck0[i] ← Dec(skk, Ck−1[i])

2. Mkchooses a permutation πkover {1, . . . , nS} uniformly at random, and sets

∀i ∈ {1, . . . , nS} : Ck[πk(i)] ← Ck0[i].

3. Mk posts Ck on the bulletin board B.

The output CnMS of the last mix server MnMS is the output of the mixing

phase. It equals (mπ(i))ni=1S , where π = πnMS◦ . . . ◦ π1 is the overall permutation

of the mix net.

### 4

### Trip Wire Technique

We describe how to extend a plain decryption mix net (Section 3) with trip wires. We will show in Section 5 that the resulting mix net provides a high level of verifiability and accountability in the presence of fully malicious mix servers.

Fig. 1: Examplified run of a decryption mix net with trip wires, where nAD= 3, nMS= 3,

nS = 3, and ntw= 1. Rectangles and circles symbolize senders’ and auditors’ message

4.1 Idea

At a high level, the trip wire technique works as follows. The plain decryption mix net is extended with a number of auditors AD1, . . . , ADnAD each of which

executes the submission program of the senders ntwtimes. For this purpose, ADj

chooses dummy input messages (e.g., 0l_{) and encrypts them in layers as a normal}

user would. The resulting ciphertexts are called ADj’s trip wires. Furthermore,

ADj stores the random coins that it has used to generate its ntw trip wires.

Now, the plain decryption mix net (with only “main mixing” servers for now) is run with this extended set of inputs. Once mixing has finished, each auditor ADj reveals its inner states, including its trip wires’ random coins. With this,

the traces of ADj’s trip wires through the mix net can publicly be verified. If a

mix server Mk did manipulate one of these dummy traces, this can be detected,

and furthermore Mkcan be held accountable through its digital signature (more

on this later).

Even though this high-level description gives some intuition on the “integrity challenge” underlying the trip wires, verifiability is obviously not yet guaranteed: 1. At the start of the mix, it is clear which input ciphertexts belong to the senders and which ones to the auditors. Hence, if the first mix server M1 is

malicious, then the adversary can completely manipulate the outcome of the mix net without being detected.

2. In general, we cannot assume that the auditors are able to simulate the senders’ message distribution. Therefore, realistically, the auditors’ and the senders’ plaintext distributions are distinguishable. Now, recall that the last mix server MnMS knows the final plaintext output before it publishes it.

Hence, if MnMS is malicious, then the adversary can undetectably manipulate

the outcome of the mix net.

We propose the following additional mechanisms to address the above problems: 1. Prior to the main mixing, the input ciphertexts are “pre-mixed” using the same kind of plain decryption mix net, but now run by the auditors. This phase is called explicit mixing (see below for the reason). Unless all auditors are corrupted, it is no longer possible, for the original main mixing servers, to distinguish between the senders’ ciphertexts and the auditors’ trip wires. 2. An additional layer of encryption (whose private key is secret-shared among the auditors) is added directly to the plain input messages. This is called the repetition layer. Unless all auditors are corrupted, the last mix server gets to know only the still encrypted output.

4.2 Protocol

In this section, we precisely describe how to extend a plain decryption mix net (Section 3) with the trip wire technique.

To preserve readibility, we make the following implicit assumptions:

– Whenever a party (mix server or auditor) holding a verification/signing key pair publishes information, it signs this data with its secret signing key. – Whenever a mix server or an auditor deviates from its honest program in

an obvious way (e.g., refuses to participate, or publishes an invalid secret key), then the protocol aborts immediately and the misbehaving party is held accountable.

– In order to protect against replay attacks which may affect message privacy of senders (see, e.g., [9]), ciphertext deduplication is always in effect, where only the first instance of a multiply occurring ciphertext is retained. Protocol participants. The set of protocol participants is extended by a number of auditors AD1, . . . , ADnAD.

Cryptographic primitives. We additionally use an IND-CCA2-secure (nAD, nAD

)-threshold public-key encryption scheme Ed.6

Setup phase. The following additional steps are executed.

Each auditor ADj runs the key generation algorithm of the digital signature

scheme S to generate its public/private (verification/signing) keys. The verifica-tion keys are published on the bulletin board B.

Each auditor ADj runs the key generation algorithm KeyGen of the

public-key encryption scheme E to generate a public/private public-key pair (pkexpl_{j} , skexpl_{j} ), and
posts the public key pkexpl_{j} on the bulletin board B.

Each auditor ADj runs the key share generation algorithm KeyShareGen of

the distributed public-key encryption scheme Ed to generate a public/private

key share pair (pkrep_{j} , skrep_{j} ), and posts the public key share pkrep_{j} on the bulletin
board B. From those, using the deterministic algorithm PublicKeyGen, everyone
can then compute the joint public key pkrep.

Altogether, the public parameters consist of the public keys pkexpl_{1} , . . . , pkexplnAD

for the explicit decryption mix net, the public keys pk1, . . . , pknMS for the main

decryption mix net, and the joint public key pkrep for the repetition encryption layer.

Submission phase (senders). Each sender Sifirst encrypts its message miunder

the auditors’ joint public key pkrep:

crep_{i} = Enc(pkrep, mi).

After that, Siencrypts c rep

i under the mix servers’ public keys pk1, . . . , pknMS

of the main decryption mix net in reverse order:
cmain_{i} = Enc(pk_{1}, (. . . , Enc(pk_{n}

MS, c rep i ))).

6

Afterwards, Siencrypts cmaini under the auditors’ public keys pk expl 1 , . . . , pk

expl nAD

of the explicit decryption mix net in reverse order:
cexpl_{i} = Enc(pkexpl_{1} , (. . . , Enc(pkexplnAD, c

main i ))).

The resulting ciphertext ci← c expl

i is Si’s input to the mix net.

Submission phase (auditors). Each auditor ADj executes ntwtimes the senders’

submission steps described above, every time with (dummy) input message m =
0l _{(where l is the bit size of a sender’s message). We denote AD}

j’s trip wire

ciphertexts by (cnS+(j−1)·ntw+l) ntw

l=1. Furthermore, ADj stores the random coins

that were used to generate its trip wire ciphertexts.

Mixing phase. The input to the mixing phase is (ci)i∈Iexpl which consists of

(a subset of)7 _{the n}

S ciphertexts submitted by the senders and the nAD· ntw

ciphertexts submitted by the auditors. Then, the overall mixing phase consists of two consecutive parts:

1. Explicit mixing: The auditors use their secret decryption keys skexpl_{1} , . . . ,
skexplnAD to run the plain decryption mix net (Section 3) with input (ci)i∈Iexpl. The

output of this mix net is (˜cmain

i )i∈Imain, where Imain⊆ Iexpl.

2. Main mixing: The mix servers use their secret decryption keys sk1, . . . , sknMS

to run the plain decryption mix net (Section 3) with input (˜cmain

i )i∈Imain. The

out-put of this mix net is (˜crep_{i} )i∈Irep, where Irep⊆ Imain.

Auditing phase. Each auditor ADj publishes its secret key skexplj associated to

the explicit decryption mix net. With this, everyone can verify that the explicit mixing was executed correctly. If verification fails, a misbehaving auditor is iden-tified through its signature and the whole protocol stops.

After that, each auditor ADj publishes the random coins that it used to

create its trip wires. With this, everyone can verify the integrity of trip wires’ traces through the main decryption mix net. If verification fails, a misbehaving mix server is identified and the whole protocol stops.

Final decryption phase. Each auditor ADj publishes its secret key share sk rep j

on the bulletin board B. Then, for each ciphertext ˜crep_{i} (i ∈ Irep_{), the decryption}

key share is publicly computed: decrep_{j,i} ← DecShare(skrep_{j} , ˜crep_{i} ). After that, the
decryption shares are combined to decrypt ˜crep_{i} : ˜mi ← Dec(dec

rep

1,i, . . . , dec rep nAD,i).

Alternatively, and more efficiently if the threshold encryption scheme supports
it (it normally would), the joint secret key skrep iz explicitly reconstituted from
the published secret key shares (skrep_{j} )j∈[nAD] and from there using sk

rep _{each}

ciphertext ˜crep_{i} is directly decrypted into ˜mi.

The list of decrypted messages ( ˜mi)i∈Irep is the final outcome of the mix net.

### 5

### Verifiability

In this section, we analyze verifiability of the decryption mix net with trip wires in the generic verifiability framework by K¨usters, Truderung, and Vogt [26]. We

7

briefly recall a specific instance of their general framework (Section 5.2) that was previously applied to analyze a number of further mix nets [18, 24, 25, 27] and that we now apply to the decryption mix net with trip wires (Section 5.3).

5.1 Notation

The decryption mix net extended with the trip wire technique can be modeled in a straightforward way as a protocol Ptw

DMN(nS, nhonS , nMS, nAD, ntw), described

next. The protocol participants consist of nS senders (in total), nhonS honest

senders, nMSmix servers, nADauditors, a scheduler SC, and a public append-only

bulletin board B. The scheduler SC plays the role of the mix net authority and schedules all other agents in a run according to the protocol phases. We assume that SC and the bulletin board B are honest, i.e., they are never corrupted. While SC is merely a virtual entity, in reality, B should be implemented in a distributed way (see, e.g., [13, 22]). The parameter ntwdenotes the number of trip wires per

auditor.

5.2 Verifiability Definition

Intuitively, a mix net is verifiable if an incorrect final outcome is not accepted. More precisely, an outcome of the mix net should be rejected if it does not correspond to the actual input as provided by the senders. However, such a na¨ıve definition of verifiability would be too strong for most reasonably verifiable mix nets. Instead, the intuitive definition is judiciously adjusted as follows:

1. Completeness is relaxed such that an incorrect outcome may falsely be ac-cepted with some (small) probability δ ∈ [0, 1]. This parameter is called the verifiability tolerance of the mix net.

2. Many verifiable mix nets (besides the ones equipped with a proof of correct shuffle) do not aim to ensure that all input messages are reflected correctly in the final outcome but almost of them. Therefore, we allow for manipulating a small number of k input messages. (Typically, the verifiability tolerance δ = δk decreases when k increases.)

3. Since corrupted senders may not (necessarily) complain in case their mes-sages were dropped or manipulated by a colluding mix net authority (e.g., mix server), it is often sufficient to guarantee the integrity of the final result only w.r.t. the honest input messages (as long as no input message stuffing by dishonest senders occurs.)

These refinements lead to the following expressive, widely applicable and currently accepted definition of verifiability. Due to space limitations, we state it informally, and refer to [26] for the complete formal definition.

5.3 Verifiability Result

We are now able to precisely state the verifiability level offered by the decryption mix net with trip wires according to Definition 1. The level depends on the number of honest senders nhon

S and the number of dummy messages per auditor

ntw, as described in Section 5.1.

Assumptions. We prove the verifiability result under the following assumptions: (V1) The public-key encryption scheme E is IND-CCA2-secure.

(V2) The (nAD, nAD)-threshold public-key encryption scheme Edis

IND-CCA2-secure.

(V3) The signature scheme S is EUF-CMA-secure.

(V4) The scheduler SC, the bulletin board B, and at least one auditor are honest.

(V5) For all honest senders and auditors, the length of the message plaintext has the same size in each run of the protocol (given a security parameter). (V6) For E and Ed, we require that for any two plaintexts of the same length,

their encryption always yields ciphertexts of the same length.

Our Result. Intuitively, the following theorem states that the probability that, in a run of the trip wire decryption mix net, more than k honest sender inputs have been manipulated, but the final result of this run is nevertheless accepted, is bounded by a function δk(nhonS , ntw) which we can quantify.

Theorem 1 (Verifiability). Under the assumptions (V1) to (V6) stated above, the decryption mix net protocol with trip wires Ptw

DMN(nS, nhonS , nMS, nAD, ntw) is

(δk(nhonS , ntw), k)-verifiable, where

δk(nhonS , ntw) = nhon S k+1 nhon S +ntw k+1 .

The main reasoning behind this theorem is as follows. Since the explicit mix-ing and the shared decryption of the repetition layer are perfectly verifiable, an adversary can only manipulate honest senders’ messages in the main mix net without being detected. However, due to the IND-CCA2-security of the under-lying public-key encryption schemes, the adversary has to do this manipulation “blindly” as the nhon

S + ntw ciphertexts related to the honest input parties (one

ciphertext for each of the nhon

S honest senders plus ntw ciphertexts by the honest

auditor) are indistinguishable. Now, if an adversary wants to manipulate k + 1
honest inputs, the probability that he is not caught cheating is captured by the
following urn experiment. An urn contains nhon_{S} white and ntw black balls,

rep-resenting honest messages and trip wires respectively. Upon picking k + 1 balls from this urn without replacement, the probability that none of the removed balls was black (i.e., no trip wire was touched) is exactly nhonS

k+1/

nhon_{S} +ntw
k+1 .

Importantly, for all k, the verifiability tolerance δk(nhonS , ntw) is bounded by

(nhon

of manipulated honest inputs k. For example, if we choose ntw = nS, then the

adversary’s risk is more than 90% for manipulating more than 4 honest messages, and even more than 99% for manipulating more than 7 honest messages.

Theorem 1 follows immediately from the even stronger result of accountabil-ity which we state and formally prove in our technical report [7]. Precisely, we show that a decryption mix net with trip wires even provides individual account-ability. This security property not only guarantees that the correctness of the mix net outcome can be verified and adjudicated externally, but also that mis-behaving parties can be identified and held accountable. Since K¨usters et al. [26] proved that accountability is a stronger form of verifiability, the formal proof of our accountability result [7] implies the verifiability result (Theorem 1) stated above.

### 6

### Implementation

In terms of efficiency, the core component of the verifiable mix net protocol is the (post-quantum) IND-CCA2-secure public-key encryption scheme: this com-ponent must be fast and robust enough to process thousands, possibly millions, of untrusted encrypted ballots, and do so safely and efficiently. Decryption per-formance is of particular importance since each mix server will be decrypting (one layer of) the entire set of encrypted ballots, while encryption is naturally done piecemeal in a distributed way by the individual voters. Encryption perfor-mance will start to matter (for the auditors) if the number of trip wires is large, or (for the voters) if there are many mix servers hence encryption layers.

6.1 Design

We implement essentially the textbook Regev scheme (technically its dual), which is provably secure under the now-classic LWE hardness assumption [31]. Our implementation attempts to remain faithful to the theoretical scheme, but rearranges it to optimize its computation. We merely summarize the salient points in Appendix A, while referring the reader to standard texts or surveys on lattice-based cryptography for background. We also elaborate on our imple-mentation rationale in our technical report [7], in particular on why we refrained from choosing one of the current NIST proposals.

6.2 Technical Details

techniques are used to provide chosen-ciphertext security for each of the KEM and the DEM, albeit only implicitly in the sense of [6], causing malformed cipher-texts to decrypt indistinguishably randomly rather than be explicitly rejected.

Our implementation targets the 240-bit security level, and accordingly uses 240-bit or wider data paths everywhere including the KEM-crypted symmetric session key and the DEM redundancy. As stated, we erred on the side of over-shooting our target, and used lattices of dimension n = 1024, modulus q = 216

and sampler-mandated LWE discrete Gaussian noise σ ≈ 2, providing sufficient headroom to reliably encode 5-bit payload per 16-bit ciphertext component. These parameters are conservative but not normative, and were selected mainly for the purpose of conducting a realistic performance evaluation.

As stated in the theoretical part of the paper, the final decryption (in the repetition layer) does not need to operate as a true threshold scheme, as long as the private key can be reconstituted from the revealed private-key shares. Regev key generation supports this, by linearity of the public key in the private key. We can thus reuse the same implementation for the final layer, by letting each auditor create its own private-key share and publish the corresponding share of the public key. The “dependent part” of the public key is reconstituted as the modular sum of the public shares. The “independent part” of the public key, namely the large public matrix “A”, does not need to be shared and continues to be pseudorandomly expanded from a public random seed that the auditors will have agreed on. The private-key shares eventually revealed by the auditors can be verified for correctness based on the corresponding public-key shares, before the final decryption of the repetition layer takes place.

Our implementation is completely independent and does not borrow any code from anywhere, other than a few lines for the canonical usage of AESNI.

6.3 Local-Scale Performance

Our test platform is a 2019 Dell XPS 13 Intel i7-8565U CPU, fully mitigated in microcode and OS (Linux) against all known speculative execution/loading attacks, and running a single core at 4.1GHz measured clock frequency. At the 240-bit target security level, using 1024-dimension lattices, the performance of our IND-CCA2 subsystem (assuming 240-bit canary and 16-bit payload for the DEM plaintext) is as follows:

– Public-key size: 93 kB

– Ciphertext overhead incl. canary: 2.3 kB – Key generation time: 36 µs (0.036 s) – Encryption time: 201 µs (0.000201 s) – Decryption time: 133 µs (0.000133 s)

scales almost perfectly linearly with the number of ballots (see Section 6.4), and we measure (on the same hardware as above):

– 7500 ballots in 1.02 s, or – 1 million ballots in 132.22 s.

In practice, the decryption running time for a large number of independent ciphertexts can be divided almost exactly by the number of available CPU cores.

6.4 Whole-System Performance

The random permutation of the ballots in each layer of the mix net does not add any appreciable time to the mixing, as long as it can be assumed that the entire set fits in random-access memory (normally a reasonable assumption). Likewise, while based signatures are generally much more expensive than lattice-based encryption, the overhead of issueing a single signature on the published mix does not make any difference with a large number of ballots.

Therefore, when considering the performance of the entire mix net, the two principal factors are the sequential nature of the encryption and decryption operations (by the voter and the mix servers respectively), and the growth of the multi-layer encrypted ballot with the number of layers. Clearly, the first consideration introduces a linear factor in the total mixing time, since each mix server must finish its mixing task on the entire set of ballots before certifying the result and passing the baton to the next mix server.

The ciphertext growth is also linear in the number of layers (or equivalently, mix servers). In our implementation at 240-bit security level, each layer adds an overhead of 2.3 kB (consisting of 2.1 kB of KEM data plus 0.2 kB of redundancy, to be added to the size of the plaintext, which in every layer except the first one is the total size of the previous layer’s ciphertext). In theory, this makes the total mixing time quadratic in the number n of mix servers as n → ∞. In practice, however, the hybrid encryption and decryption running times are dominated by the public-key KEM component, the processing of which at each layer is independent of the size of the DEM hence the number of layers.

Our experiments (Table 1) show the evolution of encryption and decryption running time of one layer of the ”onion” or encrypted ballot, in function of the number of layers of encryption beneath it (level 0 indicates direct encryption of the plaintext vote, while level 1,000,000 is clearly impractical and provided only to show asymptotic behavior).

Table 1: Encryption/decryption times and ciphertext size in function of layer height. # layers ctx size (kB) encrypt time decrypt time

0 2,144 201 us 133 us 1 4,256 201 us 134 us 10 23,264 209 us 141 us 30 65,504 214 us 154 us 100 213,344 254 us 194 us 300 635,744 368 us 308 us 1,000 2,114,144 792 us 753 us 1,000,000 2,112,002,144 0.641 s 0.607 s

the total number of ciphertexts will matter, in terms of performance. How these are partitioned between explicit and main mixers, as well as between actual and trip wire ballots, has no significant impact on running time.

On the voter’s size, encrypting a complete onion even for an exceedingly large 1000-layer mixnet would still require less than one second on most modern commodity consumer hardware.

### 7

### Discussion

In this section, we discuss the main properties of the decryption mix net with trip wires.

Verifiability and Accountability. We have formally proven that, even if all mix servers are malicious, an adversary’s risk of being caught cheating is high.

More precisely, our accountability result implies that, if an adversary wants
to manipulate more than k honest inputs, then (at least) one misbehaving mix
server is identified with probability at least 1 − (nhon_{S} /(nhon_{S} + ntw))k+1, where

nhon_{S} is the given number of honest senders and ntw is the given number of trip

wires per auditor. In particular, an adversary knows upfront that its risk of being caught cheating converges exponentially fast against 1 in the number of manipulated messages k.

Moreover, recall that during the main mixing, both the explicit mixing and the repetition layer are still locked. Hence, even if the race between two candi-dates A and B was very close, an adversary trying to manipulate the election outcome in favor of A by swapping just a few votes from B to A, has to do this “blindly”. In particular, the adversary may accidentally swap a message from A to A. Hence, an adversary’s chance of successfully manipulating the outcome is significantly reduced, independently of whether the adversary is caught cheating or not.

External auditing. At a high level, the verification procedure of the trip wire mix net can be regarded as an “integrity experiment” that is run between an adversary (controlling all mix servers) and an external auditor who challenges the adversary by “injecting” trip wires. If the adversary is able to manipulate (a significant number of) honest inputs without touching one of the trip wires, then the adversary wins. Our verifiability/accountability result (see above) provides an upper bound for an adversary’s advantage in this experiment.

Obviously, the external auditor needs to be trusted for the integrity experi-ment but this trust assumption is mitigated by two means. First, the auditor’s role can easily be distributed among several auditors, only one of which needs to be trusted. Second, the auditor opens its complete inner states once the in-tegrity challenge has finished so that the correctness of its internal computation can publicly be verified.

Privacy. The original purpose of employing a mix net is to break the individual links between the senders and their plain input messages. This property is called (message) privacy. Assuming one honest mix server and one honest auditor, the trip wire mix net guarantees privacy. A formal proof of this statement can be based on a sequence of games similar to the one of our accountability proof. Post-quantum practicality. We experimentally benchmarked our verifiable mix net scheme using an optimized post-quantum IND-CCA2-secure hybrid encryp-tion scheme, consisting of a lattice-based CCA2-secure KEM, combined with an AES256-based DEM/MAC. The benchmarks on our prototype demonstrate that our verifiable mix net with trip wires is highly practical, even for large-scale elections run entirely on commodity hardware.

Example: Practical PQ-secure e-voting. We now demonstrate how to put all these pieces together. For this purpose, we consider two different kinds of elec-tions, one with few and one with many voters. Clearly, for an election with few voters, manipulating just a single message can have a major impact on the elec-tion result with significant probability, whereas this is much less likely for an election with many voters. In what follows, we exemplify how the decryption mix net with trip wires can be set up to take this aspect into account.

Assume we have one election with 100 and one with 100,000 voters. We choose ntw= 100, 000 for both elections. (For the sake of simplicity, we assume that all

voters are honest, i.e., nS = nhonS .) From the verifiability theorem, it follows

that the risk of being caught cheating is ≥ 99% both in the election with 100 voters for manipulating k ≥ 1 votes, and in the election with 100,000 voters for manipulating k ≥ 7 votes. Therefore, in both cases, an adversary knows upfront that tampering significantly with the election result is extremely risky.

At the same time, our benchmarks demonstrate that increasing ntw, and

### 8

### Conclusion

We have presented the first practical and verifiable lattice-based decryption mix net with external auditing which can be dropped into existing e-voting schemes. Our mix net is fully implemented and supports arbitrarily many authorities.

### Acknowledgements

All authors acknowledge support from the Luxembourg National Research Fund (FNR) and the Research Council of Norway for the joint INTER project SUR-CVS (Number 11747298). Xavier Boyen thanks the Australian Research Council for support as Future Fellow under ARC grant FT140101145.

### Bibliography

[1] Ben Adida and Douglas Wikstr¨om. How to Shuffle in Public. In TCC 2007, Proceedings, pages 555–574, 2007.

[2] Ben Adida and Douglas Wikstr¨om. Offline/Online Mixing. In ICALP 2007, Proceedings, pages 484–495, 2007.

[3] Frank Arute, Kunal Arya, Ryan Babbush, Dave Bacon, Joseph C. Bardin, Rami Barends, Rupak Biswas, Sergio Boixo, Fernando GSL Brandao, David A. Buell, et al. Quantum Supremacy using a Programmable Su-perconducting Processor. Nature, 574(7779):505–510, 2019.

[4] Stephanie Bayer and Jens Groth. Efficient Zero-Knowledge Argument for Correctness of a Shuffle. In EUROCRYPT 2012, volume 7237 of Lecture Notes in Computer Science, pages 263–280. Springer, 2012.

[5] Baum C., Bootle J., Cerulli A., del Pino R., Groth J., and Lyubashevsky V. Sub-Linear Lattice-Based Zero-Knowledge Arguments for Arithmetic Circuits. In CRYPTO 2018, volume 10992 of Lecture Notes in Computer Science. Springer, 2018.

[6] Xavier Boyen. Miniature CCA2 PK Encryption : Tight Security With-out Redundancy. In ASIACRYPT 2007, volume 4833 of Lecture Notes in Computer Science, pages 485–501. Springer, 2007.

[7] Xavier Boyen, Thomas Haines, and Johannes Mueller. A Verifiable and Practical Lattice-Based Decryption Mix Net with External Auditing. IACR Cryptology ePrint Archive, 2020:115, 2020.

[8] David Chaum. Untraceable Electronic Mail, Return Addresses, and Digital Pseudonyms. Communications of the ACM, 24(2):84–88, 1981.

[9] V´eronique Cortier and Ben Smyth. Attacking and Fixing Helios: An Anal-ysis of Ballot Secrecy. In IEEE CSF, 2011, pages 297–311, 2011.

[10] N´uria Costa, Ramiro Mart´ınez, and Paz Morillo. Proof of a Shuffle for Lattice-Based Cryptography. In NordSec 2017, Proceedings, pages 280–296, 2017.

[12] Chris Culnane, Peter Y. A. Ryan, Steve A. Schneider, and Vanessa Teague. vVote: A Verifiable Voting System. ACM Trans. Inf. Syst. Secur., 18(1):3:1– 3:30, 2015.

[13] Chris Culnane and Steve A. Schneider. A Peered Bulletin Board for Robust Use in Verifiable Voting Systems. In IEEE CSF 2014, pages 169–183, 2014. [14] Prastudy Fauzi, Helger Lipmaa, Janno Siim, and Michal Zajac. An Efficient Pairing-Based Shuffle Argument. In ASIACRYPT 2017, Proceedings, Part II, pages 97–127, 2017.

[15] Prastudy Fauzi, Helger Lipmaa, and Michal Zajac. A Shuffle Argument Secure in the Generic Model. In ASIACRYPT 2016, Proceedings, Part II, pages 841–872, 2016.

[16] Eiichiro Fujisaki and Tatsuaki Okamoto. Secure Integration of Asymmetric and Symmetric Encryption Schemes. In CRYPTO ’99, Proceedings, pages 537–554, 1999.

[17] Jun Furukawa and Kazue Sako. An Efficient Scheme for Proving a Shuffle. In CRYPTO 2001, Proceedings, volume 2139 of Lecture Notes in Computer Science, pages 368–387. Springer, 2001.

[18] Thomas Haines and Johannes M¨uller. SoK: Techniques for Verifiable Mix Nets. In IEEE CSF 2020, to appear, 2020.

[19] Chlo´e H´ebant, Duong Hieu Phan, and David Pointcheval. Linearly-Homomorphic Signatures and Scalable Mix-Nets. IACR Cryptology ePrint Archive, 2019:547, 2019.

[20] Markus Jakobsson, Ari Juels, and Ronald L. Rivest. Making Mix Nets Robust for Electronic Voting by Randomized Partial Checking. In USENIX Security Symposium, 2002, pages 339–353, 2002.

[21] Shahram Khazaei, Tal Moran, and Douglas Wikstr¨om. A Mix-Net from Any CCA2 Secure Cryptosystem. In ASIACRYPT 2012, Proceedings, volume 7658 of Lecture Notes in Computer Science, pages 607–625. Springer, 2012. [22] Aggelos Kiayias, Annabell Kuldmaa, Helger Lipmaa, Janno Siim, and Thomas Zacharias. On the Security Properties of e-Voting Bulletin Boards. In SCN 2018, Proceedings, pages 505–523, 2018.

[23] Paul Kocher, Jann Horn, Anders Fogh, Daniel Genkin, Daniel Gruss, Werner Haas, Mike Hamburg, Moritz Lipp, Stefan Mangard, Thomas Prescher, Michael Schwarz, and Yuval Yarom. Spectre Attacks: Exploit-ing Speculative Execution. In 2019 IEEE SP 2019, pages 1–19, 2019. [24] Ralf K¨usters, Johannes M¨uller, Enrico Scapin, and Tomasz Truderung.

sE-lect: A Lightweight Verifiable Remote Voting System. In IEEE CSF 2016, pages 341–354, 2016.

[25] Ralf K¨usters and Tomasz Truderung. Security Analysis of Re-Encryption RPC Mix Nets. In IEEE EuroS&P 2016, pages 227–242, 2016.

[26] Ralf K¨usters, Tomasz Truderung, and Andreas Vogt. Accountability: Defi-nition and Relationship to Verifiability. In ACM CCS 2010, pages 526–535, 2010.

[28] Helger Lipmaa and Bingsheng Zhang. A More Efficient Computationally Sound Non-Interactive Zero-Knowledge Shuffle Argument. In SCN 2012. Proceedings, pages 477–502, 2012.

[29] C. Andrew Neff. A Verifiable Secret Shuffle and its Application to E-Voting. In ACM CCS 2001, pages 116–125. ACM, 2001.

[30] Choonsik Park, Kazutomo Itoh, and Kaoru Kurosawa. Efficient Anonymous Channel and All/Nothing Election Scheme. In EUROCRYPT ’93, Proceed-ings, volume 765 of Lecture Notes in Computer Science, pages 248–259. Springer, 1993.

[31] Oded Regev. On Lattices, Learning with Errors, Random Linear Codes, and Cryptography. In Proceedings of the 37th Annual ACM Symposium on Theory of Computing, 2005, pages 84–93, 2005.

[32] Bruce Schneier. Applied Cryptography - Protocols, Algorithms, and Source Code in C, 2nd Edition. Wiley, 1996.

[33] Martin Strand. A Verifiable Shuffle for the GSW Cryptosystem. In FC 2018 International Workshops, BITCOIN, VOTING, and WTSC, Revised Selected Papers, pages 165–180, 2018.

[34] Bj¨orn Terelius and Douglas Wikstr¨om. Proofs of Restricted Shuffles. In AFRICACRYPT 2010, volume 6055 of Lecture Notes in Computer Science, pages 100–113. Springer, 2010.

[35] Verificatum Mix Net (VMN). https://www.verificatum.org/html/ product_vmn.html.

[36] Douglas Wikstr¨om. A Sender Verifiable Mix-Net and a New Proof of a Shuffle. In ASIACRYPT 2005, Proceedings, pages 273–292, 2005.

[37] Douglas Wikstr¨om. A Commitment-Consistent Proof of a Shuffle. In ACISP 2009, Proceedings, pages 407–421, 2009.

[38] Douglas Wikstr¨om and Jens Groth. An Adaptively Secure Mix-Net Without Erasures. In ICALP 2006, Proceedings, Part II, pages 276–287, 2006.

### A

### Optimizations

As mentioned in Section 6, our implementation attempts to remain faithful to Regev’s theoretical scheme [31], but rearranges it to optimize its computation. In what follows, we summarize the salient points.

Our first optimization, which does deviate from the theoretical scheme, is, rather than to publish the encryption key as a truly random matrix, we publish a random seed from which the key is pseudo-randomly generated it using AES. This is a trick used by several NIST submissions, including the “front runners” still in play, but we have the opportunity to do it much faster without function calls as explained in our technical report [7].

fixed variance (e.g., σ ≈ 2) with provable 64-bit or 128-bit accuracy, suitable as
LWE noise, in a few clock cycles. 8 _{For comparison, we note that FrodoKEM}

which also implements plain-LWE Regev encryption, samples from a cumula-tive probability table of about 20-bit effeccumula-tive accuracy, and goes to lengths to show that this is okay. Our equally fast sampler is far more accurate, and closely matches the theoretical Regev scheme which requires high accuracy. It is also data-independent (unlike table lookups whose access patterns could lead to cer-tain cache-based side-channel leakage). The main downside of our sampler is that it is highly inflexible and specifically suited for that particular usage.9

Another extension to the textbook Regev scheme that we make, is the
ad-dition of an “all-or-nothing” transform such as [16] to obtain chosen-ciphertext
security, as is standard practice. Unlike [16], though, our all-or-nothing
trans-form does not cause invalid ciphertexts to be rejected, but only scrambled (or
randomized), as proposed in [6]. We do this to ensure that there truly is no
data-dependent test anywhere in the crypto code. We still get true CCA2 security,
and we can recover the classic explicit rejection behavior simply by adding and
testing a known string such as 0λ _{to the plaintext, i.e., outside of the crypto}

code, to act as a “canary”.

Other that those differences, the mathematical functions computed by our
implementation are functionally very similar to the NIST submission FrodoKEM,
which both implement the Regev scheme. This allows us to borrow from its
ex-tensive security analyses and use similar lattice dimension parameters to
tar-get similar security levels. In particular, we were pleasantly surprised that the
FrodoKEM designers chose a Gaussian noise variance parameter close to that
which was forced on us by our optimized but inflexible sampler circuit design—
making their analysis a good match for our implementation. Nevertheless, to
err on the side of caution, we collected lattice hardness estimates from multiple
sources and, seeing that they loosely agreed with the FrodoKEM
recommenda-tions, we still rounded up the main lattice dimension to the higher power of 2.
Minor optimizations included selecting the modulus q = 216 _{“sizeof(short)”}

for its ability to give us vectorized (SIMD) modular reductions for free.10

We reiterate that our optimizations mostly affect not what we compute but how we compute it. Unbound from the NIST rules, our code is not only faster, but also safer, not in a cryptographic sense but against side-channel attacks. None of our code borrows from the NIST contest; we merely frame this discussion in relation with NIST to preempt any preconception than official standardization would necessarily produce an optimal outcome.

8 _{Sampling accuracy is here meant in the sense of KL divergence to a true integer}

Gaussian; clearly the output itself is just a small integer that fits in a few bits.

9 _{Describing and analyzing the sampler is very much out of the scope of this paper,}

but it is one example of a very impactful optimization we could make that does not involve what we compute, only how we do it.

10