Anonymity Preserving Byzantine Vector Consensus

TL;DR

This paper introduces AVCP, an efficient, resilient distributed protocol for anonymous vector consensus that preserves voter anonymity, tolerates Byzantine faults, and is practical for geo-distributed deployment.

Contribution

It presents AVCP, a novel protocol combining traceable ring signatures and vector consensus reduction, achieving optimal Byzantine fault tolerance with practical efficiency.

Findings

Achieves anonymous consensus with up to one-third Byzantine faults.

Operates with linear communication and constant message overhead.

Successfully deployed on 100 geo-distributed machines, reaching decisions within 10 seconds.

Abstract

Collecting anonymous opinions finds various applications ranging from simple whistleblowing, releasing secretive information, to complex forms of voting, where participants rank candidates by order of preferences. Unfortunately, as far as we know there is no efficient distributed solution to this problem. Previously, participants had to trust third parties, run expensive cryptographic protocols or sacrifice anonymity. In this paper, we propose a resilient-optimal solution to this problem called AVCP, which tolerates up to a third of Byzantine participants. AVCP combines traceable ring signatures to detect double votes with a reduction from vector consensus to binary consensus to ensure all valid votes are taken into account. We prove our algorithm correct and show that it preserves anonymity with at most a linear communication overhead and constant message overhead when compared to a recent consensus baseline. Finally, we demonstrate empirically that the protocol is practical by deploying it on 100 machines geo-distributed in 3 continents: America, Asia and Europe. Anonymous decisions are reached within 10 seconds with a conservative choice of traceable ring signatures.

Tables

Table 1. Table 1 : Comparing the complexity of AVCP and DBFT  [ 20 ] after GST  [ 27 ]

Complexity	AVCP	DBFT
Fault-free message complexity	$O\left(n^3\right)$	$O\left(n^3\right)$
Worst-case message complexity	$O\left(t{n}^3\right)$	$O\left(t{n}^3\right)$
Fault-free bit complexity	$O\left(\left(S+c\right)n^3\right)$	$O\left(n^3\right)$
Worst-case bit complexity	$O\left(\left(S+c\right)t{n}^3\right)$	$O\left(t{n}^3\right)$

Table 2. Table 2: Threshold encryption operations

Operation	Time to execute (ms)
Encryption	$0.407$
Encryption verification	$0.358$
Share decryption	$0.247$
Share verification	$0.339$

Equations

$$\mathsf{Trace}(ID,m,\sigma ,m^{\prime },{\sigma }^{\prime })=\{\begin{array}{ll}\text{“indep”}& \text{ if }i\ne i^{\prime },\\ \text{“linked”}& \text{ else if }m=m^{\prime },\\ i& \text{ otherwise }(i=i^{\prime }\wedge m\ne m^{\prime })\text{.}\end{array}$$

$$m>\frac{n-t}{2}\iff m\ge \lfloor \frac{n-t}{2}+1\rfloor .$$

$$|P\cap P^{\prime }|$$

$$\ge |P|+|P^{\prime }|-n,$$

$$>2\left(\frac{n+t}{2}\right)-n=t,$$

$$\Rightarrow |P\cap P^{\prime }|\ge t+1.$$

$$\text{normalised speedup}=\frac{T_{LRS}-T_{TRS}}{T_{TRS}}$$

Full text

1 Introduction and related work

Consider a distributed survey where a group of mutually distrusting participants wish to exchange their opinions about some issue. For example, participants may wish to communicate over the Internet to rank candidates in order of preference to change the governance of a blockchain. Without making additional trust assumptions [21, 2, 42], one promising approach is to run a Byzantine consensus algorithm [44], or more generally a vector consensus algorithm [26, 50, 19] to allow for arbitrary votes. In vector consensus, a set of participants decide on a common vector of values, each value being proposed by one process. Unlike interactive consistency [44], a protocol solving vector consensus can be executed without fully synchronous communication channels, and as such is preferable for use over the Internet. Unfortunately, vector consensus protocols tie each participant's opinion to its identity to ensure one opinion is not overrepresented in the decision and to avoid double voting. There is thus an inherent difficulty in solving vector consensus while preserving anonymity.

In this paper, we introduce the anonymity-preserving vector consensus problem that prevents an adversary from discovering the identity of non-faulty participants that propose values in the consensus and we introduce a solution called Anonymised Vector Consensus Protocol (AVCP). To prevent the leader in some Byzantine consensus algorithms [15] from influencing the outcome of the vote by discarding proposals, AVCP reduces the problem to binary consensus that is executed without the need for a traditional leader [20].

We provide a mechanism to prevent Byzantine processes from double voting whilst also decoupling their ballots from their identity. In particular, we adopt traceable ring signatures [32, 38], which enable participants to anonymously prove their membership in a set of participants, exposing a signer's identity if and only if they sign two different votes. This can disincentivise participants from proposing multiple votes to the consensus. Alternatively, we could use linkable ring signatures [45], but would not ensure that Byzantine processes are held accountable when double-signing. We could also have used blind signatures [16, 14], but this would have required an additional trusted authority.

We also identify interesting conditions to ensure anonymous communication. Importantly, participants must propagate their signatures anonymously to hide their identity. To this end, we could construct anonymous channels directly. However, these protocols require additional trusted parties, are not robust or require $O(n)$ message delays to terminate [17, 41, 35, 36]. Thus, we assume access to anonymous channels, such as through publicly-deployed [25, 63] networks which often require sustained network observation or large amounts of resources to de-anonymise with high probability [34, 48]. Anonymity is ensured then as processes do not reveal their identity via ring signatures and communicate over anonymous channels. When correlation-based attacks on certain anonymous networks may be viable [46] and for efficiency's sake, processes may anonymously broadcast their proposal and then continue the protocol execution over regular channels. However, anonymous channels alone cannot ensure anonymity when combined with regular channels as an adversary could infer identities through latency [3] and message transmission ordering [52]. For example, an adversary may relate late message arrivals from a single process over both channels to deduce the identity of a slow participant. This is why, to ensure anonymity, the timing and order of messages exchanged over anonymous channels should be statistically independent (or computationally indistinguishable with a computational adversary) from that of those exchanged over regular channels. In practice, one may attempt to ensure that there is a low correlation by ensuring that message delays over anonymous and regular channels are sufficiently randomised.

We construct our solution iteratively first by defining the anonymity-preserving all-to-all reliable problem that may be of independent interest. Here, anonymity and comparable properties to reliable broadcast [9] with $n$ broadcasters are ensured. By construction a solution to this problem with Bracha's reliable broadcast [7], AVCP can terminate after three regular and one anonymous message delay. With this approach, our experimental results are promising—with 100 geo-distributed nodes, AVCP generally terminates in less than ten seconds. We remark that, to ensure confidentiality of proposals until after termination, threshold encryption [23, 57], in which a set threshold of participants must cooperate to decrypt any message, can be used at the cost of an additional message delay.

Related constructions. We consider techniques without additional trusted parties. Homomorphic tallying [21] encodes opinions as values that are summed in encrypted form prior to decryption. Such schemes that rely on a public bulletin board for posting votes [37] could use Byzantine consensus [44] and make timing assumptions on vote submission to perform an election. Unfortunately, homomorphic tallying is impractical when the pool of candidates is large and impossible when arbitrary. Using a multiplicative homomorphic scheme [28], decryption work is exponential in the amount of candidates, and additive homomorphic encryption like Paillier's scheme [51] incur large (RSA-size) parameters and more costly operations. Fully homomorphic encryption [33, 10] is suitable in theory, but at present is untenable for computing complex circuits efficiently. Self-tallying schemes [37], which use homomorphic tallying, are not appropriate as at some point all participants must be correct, which is untenable with arbitrary (Byzantine) behaviour. Constructions involving mix-nets [18] allow for arbitrary ballot structure. However, decryption mix-nets are not a priori robust to a single Byzantine or crash failure [18], and re-encryption mix-nets which use proofs of shuffle are generally slow in tallying [2, 43], requiring hours to tally in larger elections since $O(t)$ processes need to perform proofs of shuffle [49] in sequence. DC-nets and subsequent variations [17, 36] are not sufficiently robust and generally require $O(n)$ message delays for an all-to-all broadcast. On multi-party computation, general techniques like Yao's garbled-circuits [60] incur untenable overhead given enough complexity in the structure of ballots. Private-set intersection [30, 61] can be efficient for elections that require unanimous agreement, but do not generalise arbitrarily.

Roadmap. The paper is structured as follows. Section 2 provides preliminary definitions and specifies the model. Section 3 presents protocols and definitions required for our consensus protocol. Section 4 presents our anonymity-preserving vector consensus solution. We consider the case where regular and anonymous message channels are combined in Section 5. Section 6 benchmarks AVCP on up to 100 geo-distributed located on three continents. Section 7 concludes. Appendix 0.A proves the correctness of AVCP. Appendix 0.B describes handling the termination of binary consensus instances used in AVCP. Appendix 0.C details and proves correct AARBP, presented using a single anonymous broadcast per process. Appendix 0.D combines AVCP and threshold encryption, forming a voting scheme which is then analysed. Appendix 0.E evaluates our other distributed protocols and necessary cryptographic schemes.

2 Model

We assume the existence of a set of processes $P=\{p_{1},\dots,p_{n}\}$ (where $|P|=n$, and the $i$th process is $p_{i}$), an adversary $A$ who corrupts $t<\frac{n}{3}$ processes in $P$, and a trusted dealer $D$ who generates the initial state of each process. For simplicity of exposition, we assume that cryptographic primitives are unbreakable. With concrete primitives that provide computational guarantees, each party could be modelled as being able to execute a number of instructions each message step bounded by a polynomial in a security parameter $k$ [13], in which case the transformation of our proofs is straight forward given the hardness assumptions required by the underlying cryptographic schemes.

Network: We assume that $P$ consists of asynchronous, sequential processes that communicate over reliable, point-to-point channels in an asynchronous network. An asynchronous process is one that executes instructions at its own pace. An asynchronous network is one where message delays are unbounded. A reliable network is such that any message sent will eventually be delivered by the intended recipient. We assume that processes can also communicate using reliable one-way anonymous channels, which we soon describe.

Each process is equipped with the primitive $\mathord{\sf send}$ $M$ to $p_{j}$'', which sends the message $M$ (possibly a tuple) to process $p_{j}\in P$. For simplicity, we assume that $p_{j}$ can send a message to itself. A process receives a message $M$ by invoking the primitive $\mathord{\sf receive}$ $m$''. Each process may invoke $\mathord{\sf broadcast}$ $M$'', which is short-hand for for each $p_{i}\in P$ do $\mathord{\sf send}$ $M$ to $p_{i}$ end for''. Analogously, processes may invoke $\mathord{\sf anon\_send}$ $M$ to $p_{j}$'' and $\mathord{\sf anon\_broadcast}$ $M$'' over anonymous channels, which we characterise below.

Since reaching consensus deterministically is impossible in failure-prone asynchronous message-passing systems [29], we assume that partial synchrony holds among processes in $P$ in Section 4. That is, we assume there exists a point in time in protocol execution, the global stabilisation time (GST), unknown to all processes, after which the speed of each process and all message transfer delays are upper bounded by a finite constant [27].

Adversary: We assume that the adversary $A$ schedules message delivery over the regular channels, restricted to the assumptions of our model (such as partial synchrony). For each $\mathord{\sf send}$ call made, $A$ determines when the corresponding $\mathord{\sf receive}$ call is invoked. A portion of processes— exactly $t<\frac{n}{3}$ members of $P$—are initially corrupted by $A$ and may exhibit Byzantine faults [44] over the lifetime of a protocol's execution. That is, they may deviate from the predefined protocol in an arbitrary way. We assume $A$ can see all computations and messages sent and received by corrupted processes. A non-faulty process is one that is not corrupted by $A$ and therefore follows the prescribed protocol. $A$ can only observe $\mathord{\sf anon\_send}$ and $\mathord{\sf anon\_receive}$ calls made by corrupted processes. $A$ cannot see the (local) computations that non-faulty processes perform. We do not restrict the amount or speed of computation that $A$ can perform.

Anonymity assumption: Consider the following experiment. Suppose that $p_{i}\in P$ is non-faulty and invokes ``$\mathord{\sf anon\_send}$ $m$ to $p_{j}$'', where $p_{j}\in P$ and is possibly corrupted, and $p_{j}$ invokes $\mathord{\sf anon\_receive}$ with respect to $m$. No process can directly invoke $\mathord{\sf send}$ or invoke $\mathord{\sf receive}$ in response to a $\mathord{\sf send}$ call at any time. $p_{j}$ is allowed to use $\mathord{\sf anon\_send}$ to message corrupted processes if it is corrupted, and can invoke $\mathord{\sf anon\_recv}$ with respect to messages sent by corrupted processes. Each process is unable to make oracle calls (described below), but is allowed to perform an arbitrary number of local computations. $p_{j}$ then outputs a single guess, $g\in\{1,\dots,n\}$ as to the identity of $p_{i}$. Then for any run of the experiment, $Pr(i=g)\leq\frac{1}{n-t}$.

As $A$ can corrupt $t$ processes, the anonymity set [22], i.e. the set of processes $p_{i}$ is indistinguishable from, comprises $n-t$ non-faulty processes. Our definition captures the anonymity of the anonymous channels, but does not consider the effects of regular message passing and timing on anonymity. As such, we can use techniques to establish anonymous channels in practice with varying levels of anonymity with these factors considered.

Traceable ring signatures: Informally, a ring signature [54, 32] proves that a signer has knowledge of a private key corresponding to one of many public keys of their choice without revealing the corresponding public key. Hereafter, we consider traceable ring signatures (or TRSs), which are ring signatures that expose the identity of a signer who signs two different messages. To increase flexibility, we can consider traceability with respect to a particular string called an issue [59], allowing signers to maintain anonymity if they sign multiple times, provided they do so each time with respect to a different issue.

We now present relevant definitions of the ring signatures which are analogous to those of Fujisaki and Suzuki [32]. Let $\mathord{\it ID}\in\{0,1\}^{*}$, which we denote as a tag. We assume that all processes may query an idealised distributed oracle, which implements the following four operations:

$\sigma\leftarrow\mathord{\sf Sign}(i,\mathord{\it ID},m)$, which takes the integer $i\in\{1,\dots,n\}$, tag $\mathord{\it ID}\in\{0,1\}^{*}$ and message $m\in\{0,1\}^{*}$, and outputs the signature $\sigma\in\{0,1\}^{*}$. We restrict $\mathord{\sf Sign}$ such that only process $p_{i}\in P$ may invoke $\mathord{\sf Sign}$ with first argument $i$. 2. 2.

$b\leftarrow\mathord{\sf VerifySig}(\mathord{\it ID},m,\sigma)$, which takes the tag $\mathord{\it ID}$, message $m\in\{0,1\}^{*}$, and signature $\sigma\in\{0,1\}^{*}$, and outputs a bit $b\in\{0,1\}$. All parties may query $\mathord{\sf VerifySig}$. 3. 3.

$out\leftarrow\mathord{\sf Trace}(\mathord{\it ID},m,\sigma,m^{\prime},\sigma^{\prime})$, which takes the tag $\mathord{\it ID}\in\{0,1\}^{*}$, messages $m,m^{\prime}\in\{0,1\}^{*}$ and signatures $\sigma,\sigma^{\prime}\in\{0,1\}^{*}$, and outputs $out\in\{0,1\}^{*}\cup\{1,\dots,n\}$ (possibly corresponding to a process $p_{i}$). All parties may query $\mathord{\sf Trace}$. 4. 4.

$x\leftarrow\mathord{\sf FindIndex}(\mathord{\it ID},m,\sigma)$ takes a tag $\mathord{\it ID}\in\{0,1\}^{*}$, a message $m\in\{0,1\}^{*}$, and a signature $\sigma\in\{0,1\}^{*}$, and outputs a value $x\in\{1,\dots,n\}$. $\mathord{\sf FindIndex}$ may not be called by any party, and exists only for protocol definitions.

We describe the behaviour of the idealised distributed oracle:

• •

Signature correctness and unforgeability: $\mathord{\sf VerifySig}(\mathord{\it ID},m,\sigma)=1$ $\Longleftrightarrow$ there exists some process $p_{i}\in P$ that previously invoked $\mathord{\sf Sign}(i,\mathord{\it ID},m)$ and obtained $\sigma$ as a response. Unforgeability is captured by the ``$\Rightarrow$'' claim.

• •

Traceability and entrapment-freeness: The function $\mathord{\sf Trace}$ behaves as defined below $\Longleftrightarrow$ $\sigma\leftarrow\mathord{\sf Sign}(i,\mathord{\it ID},m)$ and $\sigma^{\prime}\leftarrow\mathord{\sf Sign}(i^{\prime},\mathord{\it ID},m^{\prime})$:

[TABLE]

Traceability is captured by the $\Leftarrow$'' claim: if $m=m^{\prime}$, then the messages are linked, otherwise, the identity of the signing process $p_{i}=p_{i^{\prime}}$ is exposed. Entrapment-freeness is captured by the $\Rightarrow$'' claim: loosely, processes cannot be falsely accused of double-signing.

• •

Signature anonymity: Consider the following scenario. Let $D$ be an adversary.Let $i\in\{1,\dots,n\}$ be the identifier of a non-faulty process. Suppose that $D$ is given a set of signatures of arbitrary length $S=\{\sigma_{1},\dots\}$ such that, for each pair $(\sigma_{x},\sigma_{y})=(\mathord{\sf Sign}(i,\mathord{\it ID}_{x},m_{x}),\mathord{\sf Sign}(i,\mathord{\it ID}_{y},m_{y}))$, either $\mathord{\it ID}_{x}=\mathord{\it ID}_{y}$ and $m_{x}=m_{y}$ holds or $\mathord{\it ID}_{x}\neq\mathord{\it ID}_{y}$ holds. $D$ is allowed access to the set $S$, but not any of its previous computations, and may not communicate with other parties. Then, suppose that $D$ is required to output a value $g\in\{1,\dots,n\}$, corresponding to its guess of the value of $i$, after performing an arbitrary number of computations and oracle calls subject to the restrictions described above. Then $Pr(i=g)=\frac{1}{n-t}$. Signature anonymity ensures that a process that signs with respect to a single message $m$ per tag $\mathord{\it ID}$ maintains anonymity.

With respect to $\mathord{\sf FindIndex}(\mathord{\it ID},m,\sigma)$, $i\in\{1,\dots,n\}$ is outputted if and only if $\sigma$ is the result of process $p_{i}$ having previously queried $\mathord{\sf Sign}(i,\mathord{\it ID},m)$. The unforgeability property implies signature uniqueness: If calls $\sigma\leftarrow\mathord{\sf Sign}(i,\mathord{\it ID},m)$ and $\sigma^{\prime}\leftarrow\mathord{\sf Sign}(j,\mathord{\it ID},m^{\prime})$ are made, then $\sigma\neq\sigma^{\prime}$ holds unless $i=j$ and $m=m^{\prime}$.

The concrete scheme proposed by Fujisaki and Suzuki [32] computationally satisfies these properties in the random oracle model [4] provided the Decisional Diffie-Hellman problem is intractable. It has signatures of size $O(kn)$, where $k$ is the security parameter. To simplify the presentation, we assume that its properties hold unconditionally in the following.

3 Communication primitives

In this section, we detail communication primitives that are invoked in our consensus algorithm presented in Section 4. In particular, we describe and present a mechanism for processes to replace communication calls over regular channels to ones over anonymous channels, we present the binary consensus problem, and define the properties of anonymity-preserving all-to-all reliable broadcast, an extension of reliable broadcast, initially described by Bracha [7].

3.1 Traceable broadcast

Suppose a process $p$ wishes to anonymously message a given set of processes $P$. By invoking anonymous communication channels, $p$ can achieve this, but $P\setminus\{p\}$ is unable to verify that $p$ resides in $P$, and so cannot meaningfully participate in protocol execution. By using (traceable) ring signatures, $p$ can verify its membership in $P$ over anonymous channels without revealing its identity. To this end, we outline a simple mechanism to replace the invocation of $\mathord{\sf send}$ and $\mathord{\sf receive}$ primitives (over regular channels) with calls to ring signature and anonymous messaging primitives $\mathord{\sf anon\_send}$ and $\mathord{\sf anon\_receive}$.

State.

Each process in $P$ tracks $\mathord{\it msg\_buf}[]$, which maps a key (an ordered list of strings) to a set of messages of the form $(m,\sigma)$, where $\sigma$ is the output of a call to $\mathord{\sf Sign}$. Each set is initially empty. Messages of the form $(\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label},m,\sigma)$ (where $\mathord{\sf label}=(l_{1},\dots,l_{k})$ for some $k\geq 0$) are deposited as $\mathord{\it msg\_buf}[\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label}]\leftarrow\mathord{\it msg\_buf}[\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label}]\cup\{m,\sigma\}$.

Protocol.

Suppose that a process $p$ wishes to invoke $\mathord{\sf broadcast}$ with respect to a tuple $(\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label},m)$ To replace $\mathord{\sf broadcast}$ (resp. $\mathord{\sf send}$) calls, a process first signs the value $m$ with respect to string $T=\mathord{\it ID}||{\mathord{\it TAG}}||l_{1}||\dots||l_{k}$ for some $k\geq 0$ (at line 2), outputting $\sigma$. We assume every $T$ in Algorithm 1 takes this form. Then, $p$ invokes $\mathord{\sf anon\_broadcast}$ (resp. $\mathord{\sf anon\_send}$) with respect to $(\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label},m,\sigma)$ (line 3).

On receipt of a tuple $(\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label},m,\sigma)$ via anonymous channels, $p$ first checks that the signature $\sigma$ is well-formed (line 5). Given this, all message/signature pairs in the set $\mathord{\it msg\_buf}[\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label}]$ are compared to the received tuple via $\mathord{\sf Trace}$ calls (line 8). Irrespective of the outcome, the received tuple is stored in $\mathord{\it msg\_buf}[]$ (line 11). Provided that the tuple is independent with respect to the signer of all messages stored thus far in $\mathord{\it msg\_buf}[\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label}]$, $(\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label},m)$ is considered receipt over regular channels (line 13).

We now prove that the protocol is correct and ensures anonymity under the assumptions of the model.

Lemma 1

Suppose $p_{i}\in P$ is non-faulty and invokes $\mathord{\sf broadcast}$ $(\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label},m)$. Suppose $p_{i}$ has previously invoked $\mathord{\sf broadcast}$ an arbitrary number of times. Then, all non-faulty processes will eventually invoke $\mathord{\sf receive}$ $(\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label},m)$. Moreover, $p_{i}$ preserves anonymity which is modelled as follows, provided that $p_{i}$ does not invoke $\mathord{\sf broadcast}$ $(\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label},m)$ and $\mathord{\sf broadcast}$ $(\mathord{\it ID}^{\prime},{\mathord{\it TAG}}^{\prime},\mathord{\sf label},m^{\prime})$ where $(\mathord{\it ID},{\mathord{\it TAG}},\mathord{\sf label})=(\mathord{\it ID}^{\prime},{\mathord{\it TAG}}^{\prime},\mathord{\sf label}^{\prime})$. Suppose that an adversary $A$ is allowed to output a single guess, $g\in\{1,\dots,n\}$ as to the identity of $p_{i}$ a finite amount of time after invoking $\mathord{\sf receive}$ at a corrupted process of its choice. $A$ is then allowed to perform an arbitrary number of computations and make oracle calls described in Section 2 before outputting its guess. Then for any $A$, $Pr(i=g)\leq\frac{1}{n-t}$.

Proof

Process $p_{i}$ invokes $\mathord{\sf Sign}(i,\mathord{\it ID}||{\mathord{\it TAG}}||l_{1}||\cdots||l_{k},m)$, producing the signature $\sigma$ (line 2). Then, $p_{i}$ invokes ``$\mathord{\sf anon\_broadcast}$ $(i,\mathord{\it ID}||{\mathord{\it TAG}}||l_{1}||\cdots||l_{k},m,\sigma)$'' (line 3). By construction of the model, $A$ is unable to observe the existence or timing of $p_{i}$'s call to $\mathord{\sf anon\_broadcast}$. By the anonymity assumption, $A$ is not able to produce a guess $g\neq\frac{1}{n-t}$ when unable to make oracle calls, since it is only aware that the $t$ processes it has corrupted are different from $p_{i}$. By the reliability of the network, $A$ will eventually invoke $\mathord{\sf anon\_receive}$ with respect to $m$ at one of its $t$ corrupted processes, as will every non-faulty process.

By signature correctness, each process will deduce that $\mathord{\sf VerifySig}(\mathord{\it ID}||{\mathord{\it TAG}}||l_{1}||\cdots||l_{k},m,\sigma)=1$ at line 5. By definition of $\mathord{\sf Sign}$, $A$ cannot invoke $\mathord{\sf Sign}(i,\mathord{\it ID}||{\mathord{\it TAG}}||l_{1}||\cdots||l_{k},m^{\prime})$ nor produce a value $\sigma^{\prime}$ such that $\mathord{\sf VerifySig}(\mathord{\it ID}||{\mathord{\it TAG}}||l_{1}||\cdots||l_{k},m^{\prime},\sigma^{\prime})=1$ for any $m^{\prime}$. This holds for any tuple of the form $(\mathord{\it ID},{\mathord{\it TAG}},l_{1},\dots,l_{k})$. Thus, every non-faulty process will progress to line 7. By traceability and entrapment-freeness, $A$ cannot produce $(m^{\prime},\sigma^{\prime})$ such that $\mathord{\sf Trace}(\mathord{\it ID}||{\mathord{\it TAG}}||l_{1}||\cdots||l_{k},m,\sigma,m^{\prime},\sigma^{\prime})\neq$ ``indep''. In particular, if $m^{\prime}\neq m$, then $A$ cannot expose the identity of $p_{i}$ through a $\mathord{\sf Trace}$ call, as $\mathord{\sf Trace}$ will never output $i$. Thus, every non-faulty process will reach line 13. By signature anonymity, and the fact that $p_{i}$ never signs with respect to two tuples such that $(\mathord{\it ID}^{\prime},{\mathord{\it TAG}}^{\prime},l_{1^{\prime}},\dots,l_{k^{\prime}})=(\mathord{\it ID},{\mathord{\it TAG}},l_{1},\dots,l_{k})$, no previous computation or messages can aid $A$'s guess to be such that $g\neq\frac{1}{n-t}$.

Hereafter, we assume that calls to primitives $\mathord{\sf send}$ and $\mathord{\sf receive}$ are handled by the procedure presented in this subsection unless explicitly stated otherwise.

3.2 Binary consensus

Broadly, the binary consensus problem involves a set of processes reaching an agreement on a binary value $b\in\{0,1\}$. We first recall the definitions that define the binary Byzantine consensus (BBC) problem as stated in [20]. In the following, we assume that every non-faulty process proposes a value, and remark that only the values in the set $\{0,1\}$ can be decided by a non-faulty process.

BBC-Termination: Every non-faulty process eventually decides on a value. 2. 2.

BBC-Agreement: No two non-faulty processes decide on different values. 3. 3.

BBC-Validity: If all non-faulty processes propose the same value, no other value can be decided.

We present the safe, non-terminating variant of the binary consensus routine from [20] in Algorithm 2. As assumed in the model (Section 2), the terminating routine relies on partial synchrony between processes in $P$. The protocols execute in asynchronous rounds.

State.

A process keeps track of a binary value $est\in\{0,1\}$, corresponding to a process' current estimate of the decided value, arrays $bin\_values[1..]$, a round number $r$ (initialised to 0), an auxiliary binary value $b$, and lists of (binary) values $\mathord{\it values_{r}}$, $r=1,2,\dots$, each of which are initially empty.

Messages.

Messages of the form $($EST$,r,b)$ and $($AUX$,r,b)$, where $r\geq 1$ and $b\in\{0,1\}$, are sent and processed by non-faulty processes. Note that we have omitted the dependency on a label $label$ and identifier $\mathord{\it ID}$ for simplicity of exposition.

BV-broadcast.

To exchange EST messages, the protocol relies on an all-to-all communication abstraction, BV-broadcast [47], which satisfies the following properties for a given round $r\geq 1$ that a process is executing:

• •

BV-Obligation: If at least $(t+1)$ non-faulty processes BV-broadcast the same value $v$, then $v$ will eventually be added to the set $\mathord{\it bin\_values}$ of each non-faulty process.

• •

BV-Justification: If $p$ is non-faulty and $v\in\mathord{\it bin\_values}[r]$, then $v$ must have been BV-broadcast by a non-faulty process.

• •

BV-Uniformity: If $v$ is added to a non-faulty process $p$'s $\mathord{\it bin\_values}[r]$ set, then eventually $v\in\mathord{\it bin\_values}[r]$ at every non-faulty process.

• •

BV-Termination: Eventually, $\mathord{\it bin\_values}[r]$ becomes non-empty for every non-faulty process.

Primarily, BV-broadcast serves to filter values that are only proposed by faulty processes (BV-Obligation and BV-Justification), to ensure progress (BV-Termination), and to work towards agreement (BV-Uniformity). When a process adds a value $v\in\{0,1\}$ to its array $\mathord{\it bin\_values}[r]$ for some $r\geq 1$, we say that $v$ was BV-delivered.

Functions.

Let $b\in\{0,1\}$. In addition to $\mathord{\sf BV-broadcast}$ and the communication primitives in our model (Section 2), a process can invoke $\mathord{\sf bin\_propose}(b)$ to begin executing an instance of binary consensus with input $b$, and $\mathord{\sf decide}(b)$ to decide the value $b$. In a given instance of binary consensus, these two functions may be called exactly once. In addition, the function $list.\mathord{\sf append}(v)$ appends the value $v$ to the list $list$.

Protocol description.

Upon the invocation bin_propose($b$), where $b\in\{0,1\}$, a process will enter a sequence of asynchronous rounds.

In a given round, a process will invoke BV-broadcast (line 5), broadcasting its current estimate (line 20) for the round $r$, which is $est$. In an instance of BV-broadcast, after receiving a binary value from $t+1$ different processes, a process will broadcast the value if not yet done (line 22). Eventually, a process will BV-deliver a value $v$ upon reception from $2t+1$ different processes, fulfilling the condition at line 24. In doing so, a process appends $v$ to its set $\mathord{\it bin\_values}[r]$ (line 25), and we note that $\mathord{\it bin\_values}[r]$ is not necessarily in its final form at this point in time.

Since $\mathord{\it bin\_values}[r]$ is now a singleton set (after line 6), non-faulty processes will broadcast the value $v$ contained in $\mathord{\it bin\_values}[r]$ (line 7). Then, processes wait until they can form a list $\mathord{\it values_{r}}$ such that $val\in\mathord{\it bin\_values}[r]$ for all $val\in\mathord{\it values_{r}}$ and $\mathord{\it values_{r}}$ is formed from at least $n-t$ $($AUX$,r,b)$ messages sent by distinct processes that they have received (line 8). This ensures that enough processes have sent messages to be able to (potentially) decide, and that only values BV-broadcast previously are considered candidates for being decided.

Then, processes attempt to decide a value via local computation. $b$ is set to $r\pmod{2}$ (line 9), and then each process checks the following:

• •

If each element of $\mathord{\it values_{r}}$ is $w$, the estimate for the next round is set to $w$ (line 11).

• •

Given the above, $w$ is then decided if $r\pmod{2}=w$, (lines 12 and 13). If this does not hold, the value can be decided in the next round provided that $\mathord{\it values_{r+1}}$ is uniform at line 11.

• •

Else, $\mathord{\it values_{r}}$ contains both 0's and 1's (and $\mathord{\it bin\_values}[r]=\{0,1\}$), and $est$ is set to be $r\pmod{2}$ (line 15), as a process cannot decide at this point.

Note that, upon invocation of $\mathord{\sf decide}()$, processes still participate in the protocol, enabling other processes who may not have decided to decide. The interested reader may verify the correctness of this protocol, and the corresponding terminating, partially-synchronous protocol in [20].

3.3 Anonymity-preserving all-to-all reliable broadcast

To reach eventual agreement in the presence of Byzantine processes without revealing who proposes what, we introduce the anonymity-preserving all-to-all reliable broadcast problem that preserves the anonymity of each honest sender reliably broadcasting. In this primitive, all processes are assumed to (anonymously) broadcast a message, and all processes deliver messages over time. It ensures that all honest processes always receive the same message from one specific sender while hiding the identity of any non-faulty sender.

Let $\mathord{\it ID}\in\{0,1\}^{*}$ be an identifier, a string that uniquely identifies an instance of AARB-broadcast. Let $m$ be a message, and $\sigma$ be the output of the call $\mathord{\sf Sign}(i,T,m)$ for some $i\in\{1,\dots,n\}$, where $T=f(ID,\mathord{\sf label})$ is as in Algorithm 2. Each process is equipped with two operations, $\mathord{\sf AARBP}$'' and $\mathord{\sf AARB-deliver}$''. $\mathord{\sf AARBP}[\mathord{\it ID}](m)$ is invoked once with respect to $\mathord{\it ID}$ and any message $m$, denoting the beginning of a process' execution of AARBP with respect to $\mathord{\it ID}$. $\mathord{\sf AARB-deliver}[ID](m,\sigma)$ is invoked between $n-t$ and $n$ times over the protocol's execution. When a process invokes $\mathord{\sf AARB-deliver}[\mathord{\it ID}](m,\sigma)$, they are said to ``AARB-deliver'' $(m,\sigma)$ with respect to $\mathord{\it ID}$. Let $T=f(ID,\mathord{\sf label})$ be as in Algorithm 2. Then, given $t<\frac{n}{3}$, we define a protocol that implements anonymity-preserving all-to-all reliable broadcast (AARB-broadcast) with respect to $\mathord{\it ID}$ as satisfying the following six properties:

AARB-Signing: If a non-faulty process $p_{i}$ AARB-delivers a message with respect to $\mathord{\it ID}$, then it must be of the form $(m,\sigma)$, where a process $p_{i}\in P$ invoked $\mathord{\sf Sign}(i,T,m)$ and obtained $\sigma$ as output. 2. 2.

AARB-Validity:

Suppose that a non-faulty process AARB-delivers $(m,\sigma)$ with respect to $\mathord{\it ID}$. Let $i=\mathord{\sf FindIndex}(T,m,\sigma)$ denote the output of an idealised call to $\mathord{\sf FindIndex}$. Then if $p_{i}$ is non-faulty, $p_{i}$ must have anonymously broadcast $(m,\sigma)$. 3. 3.

AARB-Unicity: Consider any point in time in which a non-faulty process $p$ has AARB-delivered more than one tuple with respect to $\mathord{\it ID}$. Let $delivered=\{(m_{1},\sigma_{1}),\dots,(m_{l},\sigma_{l})\}$, where $|delivered|=l$, denote the set of these tuples. For each $i\in\{1,\dots,l\}$, let $out_{i}=\mathord{\sf FindIndex}(T,m_{i},\sigma_{i})$ denote the output of an idealised call to $\mathord{\sf FindIndex}$. Then for all distinct pairs of tuples $\{(m_{i},\sigma_{i}),(m_{j},\sigma_{j})\}$, $out_{i}\neq out_{j}$. 4. 4.

AARB-Termination-1: If a process $p_{i}$ is non-faulty and invokes $\mathord{\sf AARBP}[ID](m)$, all the non-faulty processes eventually AARB-deliver $(m,\sigma)$ with respect to $\mathord{\it ID}$, where $\sigma$ is the output of the call $\mathord{\sf Sign}(i,T,m)$. 5. 5.

AARB-Termination-2: If a non-faulty process AARB-delivers $(m,\sigma)$ with respect to $\mathord{\it ID}$, then all the non-faulty processes eventually AARB-deliver $(m,\sigma)$ with respect to $\mathord{\it ID}$.

We require AARB-Signing to ensure that the other properties are meaningful. Since messages are anonymously broadcast, properties refer to the index of the signing process determined by an idealised call to $\mathord{\sf FindIndex}$. In spirit, AARB-Validity ensures if a non-faulty process AARB-delivers a message that was signed by a non-faulty process $p_{i}$, then $p_{i}$ must have invoked AARBP. Similarly, AARB-Unicity ensures that a non-faulty process will AARB-deliver at most one message signed by each process. We note that AARB-Termination-2 is critical for consensus, as without it, different processes may AARB-deliver different messages produced by the same process, as in the two-step algorithm implementing no-duplicity broadcast [8, 53]. Finally, we state the anonymity property:

AARB-Anonymity:

Suppose that non-faulty process $p_{i}$ invokes $\mathord{\sf AARBP}[\mathord{\it ID}](m)$ for some $m$ and given $\mathord{\it ID}$, and has previously invoked an arbitrary number of $\mathord{\sf AARBP}[\mathord{\it ID_{j}}](m_{j})$ calls where $\mathord{\it ID}\neq\mathord{\it ID_{j}}$ for all such $j$. Suppose that an adversary $A$ is required to output a guess $g\in\{1,\dots,n\}$, corresponding to the identity of $p_{i}$ after performing an arbitrary number of computations, allowed oracle calls and invocations of networking primitives. Then for any $A$, $Pr(i=g)\leq\frac{1}{n-t}$.

Informally, AARB-Anonymity guarantees that the source of an anonymously broadcast message by a non-faulty process is unknown to the adversary, in that it is indistinguishable from $n-t$ (non-faulty) processes. AARBP can be implemented by composing $n$ instances of Bracha's reliable broadcast algorithm, which we describe and prove correct in Appendix 0.C.

4 Anonymity-preserving vector consensus

In this section, we introduce the anonymity-preserving vector consensus problem and present and discuss the protocol Anonymised Vector Consensus Protocol (AVCP) that solves it. We defer its proof to Appendix 0.A. The anonymity-preserving vector consensus problem brings anonymity to the vector consensus problem [26] where non-faulty processes reach an agreement upon a vector containing at least $n-t$ proposed values. More precisely, anonymised vector consensus asserts that the identity of a process who proposes must be indistinguishable from that of all non-faulty processes. As in AARBP, instances of AVCP are identified uniquely by a given identifier $\mathord{\it ID}$. Each process is equipped with two operations. Firstly, $\mathord{\sf AVCP}[\mathord{\it ID}](m)$'' begins execution of an instance of AVCP with respect to $\mathord{\it ID}$ and proposal $m$. Secondly, $\mathord{\sf AVC-decide}[\mathord{\it ID}](V)$'' signals the output of $V$ from the instance of AVCP identified by $\mathord{\it ID}$, and is invoked exactly once per identifier. We define a protocol that solves anonymity-preserving vector consensus with respect to these operations as satisfying the following four properties:

AVC-Anonymity: Suppose that non-faulty process $p_{i}$ invokes $\mathord{\sf AVCP}[\mathord{\it ID}](m)$ for some $m$ and given $\mathord{\it ID}$, and has previously invoked an arbitrary number of $\mathord{\sf AVCP}[\mathord{\it ID_{j}}](m_{j})$ calls where $\mathord{\it ID}\neq\mathord{\it ID_{j}}$ for all such $j$. Suppose that an adversary $A$ is required to output a guess $g\in\{1,\dots,n\}$, corresponding to the identity of $p_{i}$ after performing an arbitrary number of computations, allowed oracle calls and invocations of networking primitives. Then for any $A$, $Pr(i=g)\leq\frac{1}{n-t}$.

It also requires the original agreement and termination properties of vector consensus to be ensured:

AVC-Agreement: All non-faulty processes that invoke $\mathord{\sf AVC-decide}[\mathord{\it ID}](V)$ do so with respect to the same vector $V$ for a given $\mathord{\it ID}$. 2. 3.

AVC-Termination: Every non-faulty process eventually invokes $\mathord{\sf AVC-decide}[\mathord{\it ID}](V)$ for some vector $V$ and a given $\mathord{\it ID}$.

It also requires a validity property that depends on a pre-determined, deterministic validity predicate $\mathord{\sf valid}()$ [12, 20] which we assume is common to all processes. We assume that all non-faulty processes propose a value that satisfies $\mathord{\sf valid}()$.

AVC-Validity: Consider each non-faulty process that invokes $\mathord{\sf AVC-decide}[\mathord{\it ID}](V)$ for some $V$ and a given $\mathord{\it ID}$. Each value $v\in V$ must satisfy $\mathord{\sf valid}()$, and $|V|\geq n-t$. Further, at least $|V|-t$ values correspond to the proposals of distinct non-faulty processes.

4.1 AVCP

We present a reduction to binary consensus which may converge in four message steps, as in the reduction to binary consensus in DBFT [20], at least one of which must be performed over anonymous channels. We note that comparable problems [24], including agreement on a core set over an asynchronous network [5], rely on such a reduction. The protocol is divided into two components. Firstly, the reduction component (Algorithm 3) reduces anonymity-preserving vector consensus to binary consensus. Here, one instance of AARBP and $n$ instances of binary consensus are executed. But, since proposals are made anonymously, processes cannot associate proposals with binary consensus instances a priori. Consequently, processes start with $n$ unlabelled binary consensus instances, and label them over time with the hash digest of proposals they deliver (of the form $h\in\{0,1\}^{*}$). To cope with messages sent and received in unlabelled binary consensus instances, we require a handler component (Algorithm 4) that replaces function calls made in binary consensus instances.

Functions.

In addition to the communication primitives detailed in Section 2 and the two primitives $\mathord{\sf AVCP}$'' and $\mathord{\sf AVC-decide}$'', the following primitives may be called: $inst.\mathord{\sf bin\_propose}(v)$'', where $inst$ is an instance of binary consensus and $v\in\{0,1\}$, begins execution of $inst$ with initial value $v$, $\mathord{\sf AARBP}$'' and $\mathord{\sf AARB-deliver}$'', as in Section [3](#S3), $\mathord{\sf valid}()$'' as described above, $m.\mathord{\sf keys}()$'' (resp. $m.\mathord{\sf values}()$''), which returns the keys (resp. values) of a map $m$, $item.\mathord{\sf key}()$'', which returns the key of $item$ in a map $m$, $s.\mathord{\sf pop}()$'', which removes and returns a value from set $s$, and ``$H(v)$'', a collision-resistant hash function which returns $h\in\{0,1\}^{*}$ based on $v\in\{0,1\}^{*}$.

State.

Each process tracks the following variables: $\mathord{\it ID}\in\{0,1\}^{*}$, a common identifier for a given instance of AVCP. $\mathord{\it proposals}[]$, which maps labels of the form $l\in\{0,1\}^{*}$ to AARB-delivered messages of the form $(m,\sigma)\in(\{0,1\}^{*},\{0,1\}^{*})$ that may be decided, and is initially empty. $\mathord{\it decision\_count}$, tracking the number of binary consensus instances for which a decision has been reached, initialised to 0. $\mathord{\it decided\_ones}$, the set of proposals for which 1 was decided in the corresponding binary consensus instance, initialised to $\emptyset$. $\mathord{\it labelled}[]$, which maps labels, which are the hash digest $h\in\{0,1\}^{*}$ of AARB-delivered proposals, to binary consensus instances, and is initially empty. $\mathord{\it unlabelled}$, a set of binary consensus instances (initially of cardinality $n$) with no current label. $\mathord{\it ones}[][]$, which maps two keys, EST and AUX, to maps with integer keys $r\geq 1$ which map to a set of labels, all of which are initially empty. $\mathord{\it counts}[][]$, which maps two keys, EST and AUX, to maps with integer keys $r\geq 1$ which map to an integer $n\in\{0,\dots,n\}$, all of which are initialised to 0.

Messages.

In addition to messages propagated in AARBP, non-faulty processes process messages of the form $(\mathord{\it ID},$TAG$,r,\mathord{\it label},b)$, where TAG $\in\{$EST, AUX$\}$, $r\geq 1$, $\mathord{\it label}\in\{0,1\}^{*}$ and $b\in\{0,1\}$. A process buffers a message $(\mathord{\it ID},$TAG$,r,label,b)$ until $\mathord{\it label}$ labels an instance of binary consensus $inst$, at which point the message is considered receipt in $inst$. The handler, described below, ensures that all messages sent by non-faulty processes eventually correspond to a label in their set of labelled consensus instances (i.e. contained in $\mathord{\it labelled}.\mathord{\sf keys}()$). Similarly, a non-faulty process can only broadcast such a message after labelling the corresponding instance of binary consensus. Processes also process messages of the form $(\mathord{\it ID},$TAG$,r,ones)$, where TAG $\in\{$EST_ONES, AUX_ONES$\}$, $r\geq 1$, and $ones$ is a set of strings corresponding to binary consensus instance labels.

Reduction.

In the reduction, $n$ (initially unlabelled) instances of binary consensus are used, each corresponding to a value that one process in $P$ may propose. Each (non-faulty) process invokes AARBP with respect to $\mathord{\it ID}$ and their value $m^{\prime}$ (line 2), anonymously broadcasting $(m^{\prime},\sigma^{\prime})$ therein. On AARB-delivery of some message $(m,\sigma)$, an unlabelled instance of binary consensus is deposited into $\mathord{\it labelled}$, whose key (label) is set to $H(m\mid\mid\sigma)$ (line 11). Proposals that fulfil $\mathord{\sf valid}()$ are stored in $\mathord{\it proposals}$ (line 13), and $inst.\mathord{\sf bin\_propose}(1)$ is invoked with respect to the newly labelled instance $inst=\mathord{\it labelled}[H(m\mid\mid\sigma)]$ if not yet done (line 14). Upon termination of each instance (line 16), provided 1 was decided, the corresponding proposal is added to $\mathord{\it decided\_ones}$ (line 18). For either decision value, $\mathord{\it decision\_count}$ is incremented (line 19). Once 1 has been decided in $n-t$ instances of binary consensus, processes will propose 0 in all instances that they have not yet proposed in (line 6). Note that upon AARB-delivery of valid messages after this point, $\mathord{\sf bin\_propose}(1)$ is not invoked at line 14. Upon the termination of all $n$ instances of binary consensus (after line 7), all non-faulty processes decide their set of values for which 1 was decided in the corresponding instance of binary consensus (line 8).

Handler.

As proposals are anonymously broadcast, binary consensus instances cannot be associated with process identifiers a priori, and so are labelled by AARB-delivered messages. Thus, we require the handler, which overrides two of the three $\mathord{\sf broadcast}$ calls in the non-terminating variant of the binary consensus of [20] (Algorithm 2). We defer the reader to Appendix 0.B for a description of the non-terminating algorithm and the terminating variant that requires handling.

We now describe the handler (Algorithm 4). Let $inst$ be an instance of binary consensus. On calling $inst.\mathord{\sf bin\_propose}(b)$ ($b\in\{0,1\}$) (and at the beginning of each round $r\geq 1$), processes invoke BV-broadcast (line 5 of Algorithm 2), immediately calling ``broadcast $(\mathord{\it ID},$EST$,r,\mathord{\it label},b)$'' (line 20 of Algorithm 2). If $b=1$, $(\mathord{\it ID},$EST$,r,\mathord{\it label},1)$ is broadcast, and $\mathord{\it label}$ is added to the set $\mathord{\it ones}[$EST$][r]$ (line 23). Note that, given AARB-Termination-2, all messages sent by non-faulty processes of the form $(\mathord{\it ID},$EST$,r,\mathord{\it label},1)$ will be deposited in an instance $\mathord{\it inst}$ labelled by $\mathord{\it label}$. Then, as the binary consensus routine terminates when all non-faulty processes propose the same value, all processes will decide the value 1 in $n-t$ instances of binary consensus (i.e. will pass line 3), after which they execute $\mathord{\sf bin\_propose}(0)$ in the remaining instances of binary consensus.

Since these instances may not be labelled when a process wishes to broadcast a value of the form $(\mathord{\it ID},$EST$,r,label,0)$, we defer their broadcast until ``$\mathord{\sf broadcast}$ $(\mathord{\it ID},$EST$,r,label,b)$'' is called in all $n$ instances of binary consensus. At this point (line 25), $(\mathord{\it ID},$EST_ONES$,r,\mathord{\it ones}[EST][r])$ is broadcast (line 26). A message of the form $(\mathord{\it ID},$EST_ONES$,r,\mathord{\it ones})$ is interpreted as the receipt of zeros in all instances not labelled by elements in $\mathord{\it ones}$ (at lines 40 and 42). This can only be done once all elements of $\mathord{\it ones}$ label instances of binary consensus (i.e., after line 35). Note that if $|\mathord{\it ones}[$EST$][r]=n|$, then there are no zeroes to be processed by receiving processes, and so the broadcast at line 26 can be skipped.

Handling $\mathord{\sf broadcast}$ $(\mathord{\it ID},$*AUX$,r,\mathord{\it label},b)$*'' calls (line [7](#alg2.l7) of Algorithm [2](#alg2)) is identical to the handling of initial $\mathord{\sf broadcast}$ $(\mathord{\it ID},$EST$,r,\mathord{\it label},b)$'' calls. Note that the third broadcast in the original algorithm, where $(\mathord{\it ID},$EST$,r,\mathord{\it label},b)$ is broadcast upon receipt from $t+1$ processes if not yet done before (line 22 of Algorithm 2 (BV-Broadcast)), can only occur once the corresponding instance of binary consensus is labelled. Thus, it does not need to be handled. From here, we can see that messages in the handler are processed as if $n$ instances of the original binary consensus algorithm were executing.

4.2 Complexity and optimizations

Let $k$ be a security parameter, $S$ the size of a signature and $c$ the size of a message digest. We compare the message and communication complexity of AVCP with DBFT [20], which, as written, can be easily altered to solve vector consensus. We assume that AVCP is invoking the terminating variant of the binary consensus of [20]. When considering complexity, we only count messages in the binary consensus routines once the global stabilisation time (GST) has been reached [27]. Both fault-free and worst-case message complexity are identical between the two protocols. We remark that there exist runs of AVCP where processes are faulty with $O(n^{3})$ message complexity, such as when a process has crashed. AVCP mainly incurs greater communication complexity proportional to the size of the signatures, which can vary from size $O(k)$ [58, 38] to $O(kn)$ [31]. If processes make a single anonymous broadcast per run, the fault-free and worst-case bit complexities of AVCP are lowered to $O(Sn^{2}+cn^{3})$ and $O(Sn^{2}+ctn^{3})$.

As is done in DBFT [20], we can combine the anonymity-preserving all-to-all reliable broadcast of a message $m$ and the proposal of the binary value 1 in the first round of a binary consensus instance. To this end, a process may skip the BV-broadcast step in round 1, which may allow AVCP to converge in four message steps, at least one of which must be anonymous. It may be useful to invoke $\mathord{\sf broadcast}$ *TAG$[r](b)$*'', where *TAG* $\in\{$*EST,AUX$\}$* (lines [22](#alg4.l22) and [29](#alg4.l29)) when the instance of binary consensus is labelled, rather than simply when $b=1$ (i.e., the condition preceding these calls). Since it may take some time for all $n$ instances of binary consensus to synchronise, doing this may speed up convergence in the faster'' instances.

5 Combining regular and anonymous channels

If processes only use anonymous channels to communicate, it is clear that their anonymity is preserved provided that processes do not double-sign with ring signatures for each message type. For performance and to prevent long-term correlation attacks on certain anonymous networks [46], it may be of interest to use anonymous message passing to propose a value, and then to use regular channels for the rest of a given protocol execution. In this setting, the adversary can de-anonymise a non-faulty process by observing message transmission time [3] and the order in which messages are sent and received [52]. For example, a single non-faulty process may be relatively slow, and so the adversary may deduce that messages it delivers late over anonymous channels were sent by that process. To cope, we make the following assumption about message passing:

Independence assumption: Consider processes in $P$ who participate in $k\geq 1$ instances of some distributed protocol where messages are exchanged over both regular and anonymous channels. Let $X_{i}$ be a random variable that maps all invocations of $\mathord{\sf send}$ or $\mathord{\sf receive}$ by every process to the time that the operation was called in instance $i$. Analogously, let $Y_{i}$ be a random variable, defined as above, but with respect to invocations of $\mathord{\sf anon\_send}$ and $\mathord{\sf anon\_receive}$. Then $X_{1},\dots,X_{k},Y_{1},\dots,Y_{k}$ are mutually independent.

This ensures that the adversary cannot correlate the behaviour of a process over regular channels with their behaviour over anonymous channels, and thus the adversary cannot de-anonymise them. We show that AVCP and our protocol solving anonymity-preserving all-to-all reliable broadcast satisfy their respective definitions of anonymity under our assumption in Appendices 0.A and 0.C.

Our assumption is quite general, and so achieving it in practice depends on the latency guarantees of the anonymous channels, the speed of each process, and the latency guarantees of the regular channels. One possible strategy could be to use public networks like Tor [25] where message transmission time through the network can be measured111https://metrics.torproject.org/. Then, based on the behaviour of the anonymous channels, processes can vary the timing of their own messages by introducing random message delays [46] to minimise the correlation between random variables. It may also be useful for processes to synchronise between protocol executions. This prevents a process from being de-anonymised when they, for example, invoke $\mathord{\sf anon\_send}$ in some instance when all other processes are executing in a different instance.

6 Experiments

Benchmarks of distributed protocols were performed using Amazon EC2 instances. We refer to each EC2 instance used as a node, corresponding to a process in protocol descriptions. For each value of $n$ (the number of nodes) chosen, we ran experiments with an equal number of nodes from four regions: Oregon (us-west-2), Ohio (us-east-2), Singapore (ap-southeast-1) and Frankfurt (eu-central-1). The type of instance chosen was c4.xlarge, which provide 7.5GiB of memory, and 4 vCPUs, i.e. 4 cores of an Intel Xeon E5-2666 v3 processor. We performed between 50 and 60 iterations for each value of $n$ and $t$ benchmarked. We vary $n$ incrementally, and vary $t$ both with respect to the maximum fault-tolerance (i.e. $t=\lfloor\frac{n-1}{3}\rfloor$), and also fix $t=6$ for values of $n=20,40,\dots$ All networking code, and the application logic, was written in Python (2.7). As we have implemented our cryptosystems in golang, we call our libraries from Python using ctypes222https://docs.python.org/2/library/ctypes.html. To simulate reliable channels, nodes communicate over TCP. Nodes begin timing once all connections have been established (i.e. after handshaking).

Our protocol, Anonymised Vector Consensus Protocol (AVCP), was implemented on top of the existing DBFT [20] codebase, as was the case with AARBP. We do not use the fast-path optimisation described in Section 4, but we hash messages during reliable broadcast to reduce bandwidth consumption. We use the most conservative choice of ring signatures, $O(kn)$-sized traceable ring signatures [32], which require $O(n)$ operations for each signing and verification call, and $O(n^{2})$ work for tracing overall. Each process makes use of a single anonymous broadcast in each run of the algorithm. To simulate the increased latency afforded by using publicly-deployed anonymous networks, processes invoke a local timeout for 750ms before invoking $\mathord{\sf anon\_broadcast}$, which is a regular broadcast in our experiments.

Figure 1(a) compares the performance of AARBP with that of AVCP. In general, convergence time for AVCP is higher as we need at least three more message steps for a process to decide. Given that the fast-path optimisation is used, requiring 1 additional message step over AARBP in the good case, the difference in performance between AVCP and AARBP would indeed be smaller.

Comparing AVCP with $t=max$ and $t=6$, we see that when $t=6$, convergence is slower. Indeed, AVC-Validity states at least $n-t$ values fulfilling valid() are included in a process' vector given that they decide. Consequently, as $t$ is smaller, $n-t$ is larger, and so nodes will process and decide more values. Although AARB-delivery may be faster for some messages, nodes generally have to perform more TRS verification/tracing operations. As nodes decide 1 in more instances of binary consensus, messages of the form ($$\mathord{\sf MSG}$$,0,r,S=\{s_{1},\cdots\}) are propagated where $|S|$ is generally larger, slowing down decision time primarily due to size of the message. We conjecture that nodes having to AARB-deliver all values in $S$ before processing such a message does not slow down performance, as all nodes are non-faulty in our experiments.

Figure 1(b) compares the performance of DBFT as a vector consensus vector routine with AVCP. Indeed, the difference in performance between AVCP and DBFT when $n=20$ and $n=40$ is primarily due to AVCP's 750ms timeout. As expected when scaling $n$, cryptographic operations result in worse scaling characteristics for AVCP. As can be seen, DBFT performs relatively well. However, DBFT does not leverage anonymous channels, nor relies on ring signatures, and so AVCP's comparatively slow performance was expected. It is reassuring that AVCP's performance does not differ by an order of magnitude from that of DBFT, given AVCP provides anonymity guarantees.

Overall, AVCP performs reasonably well. Interestingly, AVCP performs better when $t$ is set as the maximum possible value, and so is best used in practice when maximising fault tolerance. Nevertheless, converging when $n=100$ takes between 5 and 7 seconds, depending on $t$, which is practically reasonable.

7 Conclusion

In this paper, we have presented modular and efficient distributed protocols which allow identified processes to propose values anonymously. Importantly, anonymity-preserving vector consensus ensures that the proposals of non-faulty processes are not tied to their identity, which has applications in electronic voting. We proposed definitions of anonymity in the context of Byzantine fault-tolerant computing and corresponding assumptions to mitigate the de-anonymisation of identified processes. In terms of future work, it is of interest to evaluate anonymity in different formal models [55, 39] and with respect to various practical attack vectors [52]. It will be useful also to formalise anonymity under more practical assumptions so that the timing of anonymous and regular message passing do not correlate highly. In addition, a reduction to a randomized [13] binary consensus algorithm would remove the dependency on the weak coordinator, a form of leader used in each round of the binary consensus algorithm we rely on [20].

\phantomsection

Appendix 0.A Analysis of AVCP

In this appendix, we prove that the properties of anonymity-preserving vector consensus (AVC), presented in Section 4, are satisfied by our protocol Anonymised Vector Consensus Protocol (AVCP) (Algorithms 3 and 4 in Section 4).

Lemma 2

In AVCP, for each identifier $\mathord{\it ID}$, a non-faulty process' data structure ``$\mathord{\it labelled}[]$'' is such that $|\mathord{\it labelled}.\mathord{\sf values}()|\leq n$. Further, no two binary consensus instances are labelled by the same value $l$.

Proof

For the first part of the lemma, recall that an instance $inst$ is only moved to $\mathord{\it labelled}$ at line 11 upon AARB-delivery of $(m,\sigma)$. By AARB-Unicity, a non-faulty process will AARB-deliver at most one tuple $(m,\sigma)$ for every process $p_{i}$ s.t. $\sigma\leftarrow\mathord{\sf Sign}(i,\mathord{\it ID},m)$. Since $|P|=n$, at most $n$ instances $inst$ will thus be moved to $\mathord{\it labelled}$.

For the second part of the lemma, recall that we assume signature uniqueness. Thus, every tuple $(m,\sigma)$ anonymously broadcast by a non-faulty process is unique. Moreover, any duplicate tuple $(m,\sigma)$, even if broadcast by a faulty process, cannot be AARB-delivered twice (checked at line 25). Thus, by the collision-resistance of $H$, $H(m\mid\mid\sigma)\neq H(m^{\prime}\mid\mid\sigma^{\prime})$ for any two distinct tuples $(m,\sigma)$ and $(m^{\prime},\sigma^{\prime})$ that are AARB-delivered. Since each instance is labelled by $H(m\mid\mid\sigma^{\prime})$ for some tuple $(m,\sigma)$, it follows that no two instances will conflict in label.

Lemma 3

Consider AVCP. Let $p$ be a non-faulty process. Then, given that the ``for'' loop on lines 41 and 42 is executed as an atomic operation, all instances in $\mathord{\it unlabelled}.\mathord{\sf values}()$ will always contain the same set of messages.

Proof

At the protocol's outset, all instances of binary consensus are in $\mathord{\it labelled}$, where no messages have been received. The only place that messages are deposited to unlabelled instances is at lines 41 and 42, where messages are deposited into all members of $\mathord{\it unlabelled}$. Finally, note that instances can only moved out of $\mathord{\it unlabelled}$, which occurs at line 11.

Lemma 4

In AVCP, a non-faulty process $p$ sends a message of the form $(\mathord{\it ID},$TAG$,r,\mathord{\it label},b)$, then there locally exists an instance of binary consensus $inst$ such that $\mathord{\it labelled}[\mathord{\it label}]=inst$.

Proof

Suppose $p$ sends $(\mathord{\it ID},$EST$,r,\mathord{\it label},b)$. If $b=1$, then one of three scenarios holds: (i) $r=1$ and $p$ has invoked $inst.\mathord{\sf bin\_propose}(1)$ where $\mathord{\it labelled}[\mathord{\it label}]=inst$, (ii) $r\geq 1$, $p$ has received $t+1$ messages of the form $(\mathord{\it ID},$EST$,r,\mathord{\it label},b)$ and has not yet broadcast $(\mathord{\it ID},$EST$,r,\mathord{\it label},b)$, or (iii) their value $est$ was set to $b=1$ at the end of the previous round of binary consensus. In case (i), note that $\mathord{\sf bin\_propose}(1)$ (at line 14) is executed after $inst$ is labelled (at line 11). Note that in both cases (ii) and (iii), $p$ must have processed messages of the form $(\mathord{\it ID},$EST$,r,\mathord{\it label},1)$. As described in the text, these messages are only processed after the AARB-delivery of the corresponding message $(m,\sigma)$ where $\mathord{\it label}=H(m\mid\mid\sigma)$ and some instance $inst$ is labelled by $\mathord{\it label}$ (at line 11). If $b=0$, only case (ii) needs to be considered, since the other $\mathord{\sf broadcast}$ call is handled by the handler (Algorithm 4). Here, $b=1$ must have been initially broadcast, which is described by cases (i) and (iii). Suppose $p$ sends $(\mathord{\it ID},$AUX$,r,\mathord{\it label},b)$. Note that $b\neq 0$, since the handler handles this case. Thus, we consider $b=1$. $b$ must have been BV-delivered (line 6 of Algorithm 2), requiring $p$ to have processed messages of the form $(\mathord{\it ID},$EST$,r,\mathord{\it label},b)$, which requires some instance to be labelled by $\mathord{\it label}$ to do. This exhausts the possibilities.

Lemma 5

Consider AVCP. Let $r\geq 1$ be an integer. Then, all messages sent by non-faulty processes of the form $(\mathord{\it ID},$TAG$,r,\mathord{\it label},b)$ where TAG $\in$ $\{$EST, AUX$\}$ and $b\in\{0,1\}$, and $(\mathord{\it ID},$TAG$,r,ones)$ where TAG $\in$ $\{$EST_ONES, AUX_ONES$\}$ and $b\in\{0,1\}$, are eventually deposited into the corresponding binary consensus instances of a non-faulty process.

Proof

Let $p$ be the recipient of a message in the above forms. We first consider messages of the form $(\mathord{\it ID},$TAG$,r,\mathord{\it label},b)$ where TAG $\in$ $\{$EST, AUX$\}$ and $b\in\{0,1\}$. By Lemma 4, the non-faulty sender of such a message must have AARB-delivered some message $(m,\sigma)$ such that $\mathord{\it label}=H(m\mid\mid\sigma)$. By AARB-Termination-2, $p$ will eventually AARB-deliver $(m,\sigma)$ and subsequently label an instance of binary consensus which is uniquely defined by $\mathord{\it label}$ (Lemma 2). Thus, $p$ will eventually process $(\mathord{\it ID},$TAG$,r,\mathord{\it label},b)$ in instance $inst=\mathord{\it labelled}[\mathord{\it label}]$. Consider messages of the form $(\mathord{\it ID},$TAG$,r,ones)$ where TAG $\in$ $\{$EST_ONES, AUX_ONES$\}$ and $b\in\{0,1\}$. Since the sender is non-faulty, every element of $ones$ (i.e. every label) must correspond to a message that was AARB-delivered by the sender. By AARB-Termination-2, $p$ will eventually AARB-deliver these messages, label instances of binary consensus (at line 11) and thus progress beyond line 35. Thus, $p$ will deposit 0 in all instances not labelled by elements of $ones$ (at lines 40 and 42), which is the prescribed behaviour.

Lemma 6

In AVCP, every non-faulty process reaches line 6, i.e. decides 1 in $n-t$ instances of binary consensus.

Proof

Given at most $t$ faulty processes, at least $n-t$ non-faulty processes invoke AARBP at line 2, broadcasting a value that satisfies $\mathord{\sf valid}()$ by assumption. By AARB-Termination-1, every message anonymously broadcast by a non-faulty process is eventually AARB-delivered by all non-faulty processes. Suppose a non-faulty process $p$ labels an instance of consensus $\mathord{\it inst}$ by one of these messages. By Lemma 5, all messages sent by non-faulty processes associated with $\mathord{\it inst}$ are eventually processed by $p$. Then, all non-faulty processes will invoke $\mathord{\sf bin\_propose}(1)$ in at least $n-t$ instances of binary consensus (i.e. while blocked at line 3). Consider the first $n-t$ instances of consensus for which a decision is made at. By the intrusion tolerance of binary consensus, no coalition of faulty processes can force 0 to be a valid value in these consensus instances, since all non-faulty processes must invoke $\mathord{\sf bin\_propose}(1)$ in them. Then, by BBC-Agreement, BBC-Validity and BBC-Termination, all non-faulty processes will eventually decide 1 in $n-t$ $\mathord{\it BIN\_CONS}$ instances. Thus, all non-faulty processes eventually reach line 6.

We now prove that AVC-Validity holds.

Theorem 0.A.1

AVCP satisfies AVC-Validity, which is stated as follows. Consider each non-faulty process that invokes $\mathord{\sf AVC-decide}[\mathord{\it ID}](V)$ for some $V$ and a given $\mathord{\it ID}$. Each value $v\in V$ must satisfy $\mathord{\sf valid}()$, and $|V|\geq n-t$. Further, at least $|V|-t$ values correspond to the proposals of distinct non-faulty processes.

Proof

Let $p$ be a non-faulty process. By construction of the binary consensus algorithm, $p$ must process messages of the form $(\mathord{\it ID},$TAG$,r,\mathord{\it label},b)$ where TAG $\in$ $\{$EST, AUX$\}$ and $b\in\{0,1\}$ to reach a decision. By Lemma 5, $p$ must have AARB-delivered the corresponding message $(m,\sigma)$ such that $\mathord{\it label}=H(m\mid\mid\sigma)$ before deciding. That is, $\mathord{\it proposals}$ must have been populated with the corresponding message $(m,\sigma)$ at line 13, and $\mathord{\sf valid}()$ must be true for $(m,\sigma)$, checked previously at line 12. By Lemma 6, $p$ eventually decides 1 in $n-t$ instances of binary consensus. Upon each decision, the corresponding message is added to $V=\mathord{\it decided\_ones}$ (at line 18). For the latter component of the definition, we note that ARB-Unicity ensures that each value in $V$ contains a signature produced by a different process. So, given $V$ is decided, at most $t$ of the corresponding signatures could have been produced by faulty processes.

Lemma 7

Consider AVCP. Fix $r\geq 1$. Given that a non-faulty process $p$ invokes $\mathord{\sf broadcast}$ $(\mathord{\it ID},$EST$,r,\mathord{\it label},b)$'' or $\mathord{\sf broadcast}$ $(\mathord{\it ID},$AUX$,r,\mathord{\it label},b)$'' in all $n$ instances of binary consensus, then all non-faulty processes interpret the corresponding messages sent by $p$ as if $p$ were executing the original binary consensus algorithm.

Proof

Without loss of generality, suppose $p$ invokes $\mathord{\sf broadcast}$ $(\mathord{\it ID},$*EST$,r,\mathord{\it label},b)$*'' in all $n$ instances of binary consensus. For every instance $inst$ such that $b=1$, $p$ broadcasts $(\mathord{\it ID},$*EST$,r,\mathord{\it label},b)$* (at line [22](#alg4.l22)) which is identical to the behaviour in the original algorithm. Note that $p$ does not broadcast $(\mathord{\it ID},$*EST$,r,\mathord{\it label},b)$* here when $b=0$. By Lemma [4](#Thmlemma4), $p$ must have labelled $inst$ with $\mathord{\it label}$. Thus, $p$ adds $\mathord{\it label}$ to $\mathord{\it ones}[$*EST$][r]$* (at line [23](#alg4.l23)). Once $n$ invocations of $\mathord{\sf broadcast}$ $(\mathord{\it ID},$EST$,r,\mathord{\it label},b)$'' have been executed, $\mathord{\it ones}[$EST$][r]$ is sent to all non-faulty processes. By Lemma 5, all non-faulty processes deposit [math] in all instances not labelled by elements of $\mathord{\it ones}[$EST$][r]$, corresponding to all broadcasts not performed by $p$ previously. In this sense, this behaviour is equivalent to having broadcast all values $(\mathord{\it ID},$EST$,r,\mathord{\it label},b)$ where $b=0$.

Theorem 0.A.2

AVCP ensures AVC-Termination. That is, every non-faulty process eventually invokes $\mathord{\sf AVC-decide}[\mathord{\it ID}](V)$ for some vector $V$ and a given $\mathord{\it ID}$.

Proof

Consider a non-faulty process $p$. By Lemma 6, $p$ reaches line 6 with $n-t$ values in their local array $\mathord{\it decided\_ones}$. At this point, $p$ invokes $\mathord{\sf bin\_propose}(0)$ in all other instances of binary consensus. Since all $n$ instances are thus executed, $p$ will eventually invoke $\mathord{\sf broadcast}$ $(\mathord{\it ID},$*EST$,r,\mathord{\it label},b)$*'' in all $n$ instances of binary consensus. By Lemma [7](#Thmlemma7), non-faulty processes interpret $p$'s corresponding messages as if $p$ were executing the original binary consensus algorithm. Similarly, $p$ will eventually invoke $\mathord{\sf broadcast}$ $(\mathord{\it ID},$AUX$,r,\mathord{\it label},b)$'' in all $n$ instances.

Note that DBFT [20] is guaranteed termination with $n$ instances of binary consensus as each instance is guaranteed to terminate due to BBC-Termination. It remains to show that AVCP preserves BBC-Termination for all $n$ instances of consensus. Lemma 11 in [20] states that, at some point after which the global stabilistation time (GST) is reached, any execution of the original binary consensus routine eventually executes in synchronous steps. Note that in our construction, the slowest binary consensus instance is no slower than if $n$ instances of the original binary consensus routine were executing. For example, in AVCP, a message of the form $({\mathord{\it EST\_ONES}},r,ones)$ is sent after $n$ invocations of ``$\mathord{\sf broadcast}$ $(\mathord{\it ID},$EST$,r,\mathord{\it label},b)$'' are performed for a given $r$. Then, Lemma 7 implies that messages sent by non-faulty processes remain unchanged as in an execution of $n$ instances of the original binary consensus routine. Thus, Lemma 11 holds for the slowest instance of consensus. Since all other instances are faster, they too are synchronised, and so Lemma 11 holds for them also. By Lemma 9 in [20], which asserts that BBC-Termination holds for an instance of binary consensus, it follows that each non-faulty process will decide a value in the $n$ instances of consensus in AVCP. At this point, $p$ immediately invokes $\mathord{\sf AVC-decide}$ with respect to $\mathord{\it ID}$ and $\mathord{\it decided\_ones}$ (at line 8). Since $p$ was arbitrary (but non-faulty), it follows that AVC-Termination holds.

Theorem 0.A.3

AVCP ensures AVC-Agreement. That is, all non-faulty processes that invoke $\mathord{\sf AVC-decide}[\mathord{\it ID}](V)$ do so with respect to the same vector $V$ for a given $\mathord{\it ID}$.

Proof

Consider two non-faulty processes, $p_{i}$ and $p_{j}$ that have decided (AVC-Termination). Suppose that $p_{i}$ has decided $\mathord{\it decided\_ones}$. Each value in $\mathord{\it decided\_ones}$ must have been AARB-delivered to $p_{i}$ in order to decide 1 in the corresponding instances of binary consensus (Lemma 4). By AARB-Unicity and AARB-Termination-2, $p_{j}$ will AARB-deliver all values in $\mathord{\it decided\_ones}$. By Lemma 6, all non-faulty processes eventually decide 1 in $n-t$ instances of binary consensus. Consequently, $p_{i}$ and $p_{j}$ participate in all $n$ instances of binary consensus which by Lemma 7 is equivalent to participating in $n$ instances of binary consensus as per the original algorithm. Then, by BBC-Agreement, $p_{j}$ decides 1 in an instance of binary consensus if and only if $p_{i}$ decides 1 in that instance. Consequently, each corresponding value, which have all been AARB-delivered prior to deciding 1 in each instance of binary consensus (Lemma 4) will be added to $p_{j}$'s local array $\mathord{\it decided\_ones}^{\prime}$. Thus, $\mathord{\it decided\_ones}^{\prime}=\mathord{\it decided\_ones}$.

Theorem 0.A.4

AVCP ensures AVC-Anonymity under the assumptions of our model (Section 2) and the three conditions described in Section 5. AVC-Anonymity is stated as follows: Suppose that non-faulty process $p_{i}$ invokes $\mathord{\sf AVCP}[\mathord{\it ID}](m)$ for some $m$ and given $\mathord{\it ID}$, and has previously invoked an arbitrary number of $\mathord{\sf AVCP}[\mathord{\it ID_{j}}](m_{j})$ calls where $\mathord{\it ID}\neq\mathord{\it ID_{j}}$ for all such $j$. Suppose that the adversary $A$ is required to output a guess $g\in\{1,\dots,n\}$, corresponding to the identity of $p_{i}$ after performing an arbitrary number of computations, allowed oracle calls and invocations of networking primitives. Then $Pr(i=g)=\frac{1}{n-t}$.

Proof

We note that each process invokes AARBP exactly once at the beginning of any execution of AVCP. In the case all communication is performed over anonymous channels, it suffices to observe that no process sends more than one message of a given type across many executions of AVCP. Then, from the proof of correctness of traceable broadcast (Lemma 1), it follows that $A$ is unable to output a guess $g$ s.t. $g\neq\frac{1}{n-t}$. In the case that all communication except for the initial broadcasting is performed over reliable channels, the proof of AVC-Anonymity follows from the proof of AARB-Anonymity (Lemma 9).

Appendix 0.B Ensuring termination in binary consensus

The terminating algorithm (Figure 2 in [20]) uses in each round an additional $\mathord{\sf broadcast}$, which is performed by a rotating coordinator. This message contains the header COORD_VALUE. Note that $i\in\{1,\dots,n\}$ denotes the index of the process $p_{i}$ who is locally executing instructions, and that these instructions are executed after $\mathord{\it bin\_values}[r]\neq\emptyset$ (i.e. after line 6 of Algorithm 2).

This broadcast call can be handled exactly as in the logic beginning at lines 20 and 27 of the handler (Algorithm 4), provided that for a given round $r$, the coordinator is common across all $n$ instances of consensus. No other communication steps are added in the terminating algorithm.

In the non-terminating binary consensus algorithm, a process executes indefinitely after invoking $\mathord{\sf decide}()$. The terminating variant, by contrast, imposes certain conditions upon termination, which are checked at the end of each round $r$. In the context of the following algorithm excerpt, a process that invokes the instruction $\mathord{\sf halt}$ discontinues executing instructions in the binary consensus instance that $\mathord{\sf halt}$ was called in, and drops all related messages.

It is shown in [20] that, given that some non-faulty process decides in round $r$, all non-faulty processes will decide by round $r+2$. Note that a process may invoke $\mathord{\sf decide}()$ in different rounds in different instances of binary consensus. Thus, a process may invoke $\mathord{\sf halt}$ in some, but not all, instances of binary consensus. Suppose that a process has invoked $\mathord{\sf halt}$ in $k$ instances of binary consensus, where $1<k<n$, in some round $r$. Then, broadcasting a message with header EST_ONES in the handler (Algorithm 4), say, will be impossible, since $counts[$EST$][r]$ will never be incremented to $n$.

To cope with this problem, we define a new termination condition. Let $r_{max}$ be the largest round number of the $n$ instances of binary consensus that a given process decides in. Then, that process can invoke $\mathord{\sf halt}$ at the end of round $r_{max}+2$.

Appendix 0.C AARBP

In this appendix, we first present Anonymised All-to-all Reliable Broadcast Protocol. Notably, the protocol as presented terminates in after single anonymous message step and two regular message steps. We then show that it satisfies each property of the anonymity-preserving all-to-all reliable broadcast problem described in Section 3.

0.C.1 Protocol

State and messages. Each process tracks $\mathord{\it ID}$, which identifies an instance of AARB-broadcast. For each $\mathord{\it ID}$, each process tracks two buffers: $\mathord{\it m\_buffer}$, corresponding to messages that they may AARB-deliver, and $\mathord{\it m\_delivered}$, corresponding to all messages that they have AARB-delivered; both are initially set to $\emptyset$. For a given instance of AARBP identified by $\mathord{\it ID}$, all messages sent by non-faulty processes must contain $\mathord{\it ID}$. Similarly, messages must contain one of three headers: INIT, corresponding to the initial broadcast of a process' proposal, ECHO, corresponding to an acknowledgement of the INIT message, or READY, corresponding to an acknowledgement that enough processes have received the message to ensure eventual, safe AARB-delivery.

Protocol. We now present AARBP (Algorithm 7).

To begin, each process $p_{i}$ broadcasts $(\mathord{\it ID},$INIT$,m^{\prime},\sigma^{\prime})$ over anonymous channels (line 3), where $\sigma^{\prime}\leftarrow\mathord{\sf Sign}(i,\mathord{\it ID},m^{\prime})$. Upon first receipt of each message of the form $(\mathord{\it ID},$INIT$,m,\sigma)$, a process checks the following (line 5):

• •

Whether the signature $\sigma$ is well-formed as per $\mathord{\sf VerifySig}$, verifying the signer's membership in $P$ (line 6).

• •

Whether any message in $\mathord{\it m\_buffer}\cup\mathord{\it m\_delivered}$ is not independent from $m$ via $\mathord{\sf Trace}$, ensuring AARB-Unicity as $m$ is discarded if double-signing is detected (lines 8 to 11).

Then, given that $(m,\sigma)$ passes the above checks, $(\mathord{\it ID},$ECHO$,m,\sigma)$ is broadcast (line 14). Note that this broadcast, and all subsequent broadcasts with respect to $(m,\sigma)$, are performed over regular (reliable, non-anonymous) channels of communication. To mitigate de-anonymisation, the signer of $m$ performs the same message processing and message propagation as all other non-faulty processes.

The rest of the protocol proceeds as per Bracha's reliable broadcast [7]: If processes receive $(\mathord{\it ID},$ECHO$,m,\sigma)$ from more than $\frac{n+t}{2}$ different processes, they broadcast $(\mathord{\it ID},$READY$,m,\sigma)$ (lines 16–18). If processes receive $(\mathord{\it ID},$READY$,m,\sigma)$ from $t+1$ different processes, they broadcast $(\mathord{\it ID},$READY$,m,\sigma)$ if not yet done (lines 20–22). This ensures convergence and implies that at least one non-faulty process must have sent $(\mathord{\it ID},$READY$,m,\sigma)$ to the receiving process. Once processes have received $(\mathord{\it ID},$READY$,m,\sigma)$ from $2t+1$ different processes, they AARB-deliver $(m,\sigma)$ with respect to $\mathord{\it ID}$ if not yet done (line 28). At this point, at least $t+1$ non-faulty processes must have broadcast $(\mathord{\it ID},$READY$,m,\sigma)$. Thus, all non-faulty processes will eventually broadcast $(\mathord{\it ID},$READY$,m,\sigma)$ at line 22 if not yet done.

Complexity. Whilst Bracha's protocol [7] requires three message steps to converge, AARBP requires an initial, anonymous message step and two (regular) message steps. Both AARBP and $n$ invocations of Bracha's protocol have a message complexity of $O(n^{3})$. If we consider unsigned messages to be of size $O(1)$, then each message propagated in AARBP is of size $O(kn)$, the size of a TRS as in [32] where $k$ is a security parameter. Thus, the bit complexity of all-to-all AARBP is $O(kn^{4})$ (as opposed to $O(n^{3})$ in all-to-all reliable broadcast [7]). To reduce the bit complexity when some messages are delivered in order, we can hash ECHO and READY messages [12]. Consequently, communication complexity can be reduced to $O((c+k)n^{3})$.

We consider cryptographic overhead as if Fujisaki and Suzuki's TRS scheme [32] were used. In AARBP, each process signs one message ($O(n)$ work), verifies up to $n$ messages ($O(n^{2})$ work), and perform tracing upon receipt of each INIT message (up to $n$). Tracing requires $O(n^{3})$ work naively and $O(n^{2})$ expected work if signatures are stored in and accessed using hash tables.

0.C.2 Proof of correctness

We now prove that AARBP satisfies each property of the anonymity-preserving all-to-all reliable broadcast problem.

Remark 1

Let $m,n,t$ be positive integers s.t. $n>3t$. We have:

[TABLE]

Thus, we refer to $\lfloor\frac{n-t}{2}\rfloor+1$ processes'' and more than $\frac{n-t}{2}$ processes'' interchangeably.

Lemma 8

AARBP ensures AARB-Signing. That is, if a non-faulty process $p_{i}$ AARB-delivers a message with respect to $\mathord{\it ID}$, then it must be of the form $(m,\sigma)$, where a process $p_{i}\in P$ invoked $\mathord{\sf Sign}(i,\mathord{\it ID},m)$ and obtained $\sigma$ as output.

Proof

Suppose $p$ is non-faulty and AARB-delivers a message $msg$. We aim to show that $msg=(m,\sigma)$, where $\sigma\leftarrow\mathord{\sf Sign}(i,\mathord{\it ID},m)$ was called by some process $p_{i}$. For a non-faulty process to broadcast $(\mathord{\it ID},$READY$,msg)$, they must have either received $(\mathord{\it ID},$READY$,msg)$ from $t+1$ different processes or $(\mathord{\it ID},$ECHO$,msg)$ from $\lfloor\frac{n+t}{2}\rfloor+1$ different processes. Since $t+1>t$, there exists a non-faulty process $p^{\prime}$ that must have broadcast $(\mathord{\it ID},$READY$,msg)$ on receipt of $(\mathord{\it ID},$ECHO$,msg)$ from $\lfloor\frac{n+t}{2}\rfloor+1$ different processes to ensure that $msg$ was AARB-delivered to any process. Similarly, since $\lfloor\frac{n+t}{2}\rfloor+1>t$, there exists a non-faulty process $p^{\prime\prime}$ that must have broadcast $(\mathord{\it ID},$ECHO$,msg)$ to ensure $(\mathord{\it ID},$READY$,msg)$ was broadcast by a non-faulty process. Process $p^{\prime\prime}$ must have checked that $msg=(m,\sigma)$ (implicitly) and that $\mathord{\sf VerifySig}(\mathord{\it ID},m,\sigma)=1$ holds (at line 6). By signature unforgeability, $\mathord{\sf VerifySig}(\mathord{\it ID},m,\sigma)=1$ implies that $\sigma\leftarrow\mathord{\sf Sign}(i,\mathord{\it ID},m)$ was called by some process $p_{i}$. Thus, the property holds.

Lemma 9

AARBP ensures AARB-Anonymity under the assumptions of the model (Section 2) and those made in Section 5. AARB-Anonymity is stated as follows. Suppose that non-faulty process $p_{i}$ invokes $\mathord{\sf AARBP}[\mathord{\it ID}](m)$ for some $m$ and given $\mathord{\it ID}$, and has previously invoked an arbitrary number of $\mathord{\sf AARBP}[\mathord{\it ID_{j}}](m_{j})$ calls where $\mathord{\it ID}\neq\mathord{\it ID_{j}}$ for all such $j$. Suppose that the adversary $A$ is required to output a guess $g\in\{1,\dots,n\}$, corresponding to the identity of $p_{i}$ after performing an arbitrary number of computations, allowed oracle calls and invocations of networking primitives. Then $Pr(i=g)=\frac{1}{n-t}$.

Proof

We proceed by contradiction. Let $p_{i}$ be a non-faulty process that participates in the scenario described in the definition of AARB-Anonymity. Suppose that $A$ is able to output $g$ such that $Pr(i=g)\neq\frac{1}{n-t}$. Now, in $\mathord{\sf AARBP}$, process $p_{i}$ invokes $\mathord{\sf Sign}(i,\mathord{\it ID},m)$, producing the signature $\sigma$ (line 2). Then, $p_{i}$ invokes ``$\mathord{\sf anon\_broadcast}$ $(\mathord{\it ID},$INIT$,m,\sigma)$'' (line 3). By Lemma 1 (Section 3) and the symmetry between Algorithm 1 and AARBP, $A$ must utilise some combination of regular communication, its message history and previous computation to output $g$ s.t. $Pr(i=g)\neq\frac{1}{n-t}$.

Firstly, we remark that $A$ cannot view the local state or computations of non-faulty processes by assumption, and so cannot, for example, view their calls to $\mathord{\sf Sign}$. Note that (non-faulty) processes propagate messages over regular (reliable) channels after their initial invocation of $\mathord{\sf anon\_broadcast}$ (such as at line 14). By assumption, $A$ has no inherent knowledge of when $\mathord{\sf anon\_send}$ or $\mathord{\sf anon\_receive}$ calls are made by non-faulty processes. Indeed, $A$ may observe when non-faulty processes respond to $\mathord{\sf anon\_receive}$ calls via messages they send over regular channels, and when $A$'s corrupted processes invoke any message passing primitive. Thus, under the assumptions of Section 2 alone, it is conceivable that an adversary could correlate timing information regarding message passing over regular channels and anonymous channels in a given protocol execution to de-anonymise $p_{i}$. As the network is asynchronous, the timing and relative order in which messages are sent and received by processes in $\mathord{\sf AARBP}[\mathord{\it ID}]$ could be arbitrary. The independence assumption (Section 5) assumes, however, that the order and timing of message delivery over anonymous channels is statistically independent from that of regular channels in a particular protocol execution. Note that this independence holds for the timing and ordering of messages sent of any number of processes during any stage of the protocol. In particular, this accounts for the behaviour of non-faulty processes in response to messages received from Byzantine processes of whom $A$ is free to control. Consequently, $A$ gains no information about the identity of $p_{i}$ through correlation, and so $A$ could not have produced $g$ such that $Pr(i=g)\neq\frac{1}{n-t}$ using this strategy. Since the independence assumption also considers timing and message ordering between instances of AARBP, it follows that $A$ cannot de-anonymise $p_{i}$ by considering many executions. This exhausts $A$'s conceivable strategies to de-anonymise $p_{i}$ under our model.

Lemma 10

AARBP ensure AARB-Termination-1. That is, if a process $p_{i}$ is non-faulty and invokes $\mathord{\sf AARBP}[ID](m)$, all the non-faulty processes eventually AARB-deliver $(m,\sigma)$ with respect to $\mathord{\it ID}$, where $\sigma$ is the output of the call $\mathord{\sf Sign}(i,\mathord{\it ID},m)$.

Proof

Suppose that the non-faulty process $p_{i}$ invokes AARBP with respect to identifier $\mathord{\it ID}$ and message $m$. So, $p_{i}$ anonymously broadcasts $(\mathord{\it ID},$INIT$,m,\sigma)$, where $\sigma=\mathord{\sf Sign}(i,\mathord{\it ID},m)$. Since the network is reliable, all non-faulty processes eventually receive $(\mathord{\it ID},$INIT$,m,\sigma)$ (and indeed all messages broadcast by non-faulty processes). At line 6, $\mathord{\sf VerifySig}$ is queried with respect to $(m,\sigma)$. By signature correctness, $\mathord{\sf VerifySig}(\mathord{\it ID},m,\sigma)=1$ is guaranteed, since $p_{i}$ invoked $\sigma\leftarrow\mathord{\sf Sign}(i,\mathord{\it ID},m)$. So, all non-faulty processes proceed to line 8. By traceability and entrapment-freeness, no non-faulty process could have received a message $(m^{\prime},\sigma^{\prime})$ such that $\mathord{\sf Trace}(\mathord{\it ID},m,\sigma,m^{\prime},\sigma^{\prime})\neq$ ``indep''. Consequently, all non-faulty processes reach line 12 with value $\mathord{\it valid}$ s.t. $\mathord{\it valid}=\mathord{\sf true}$. Thus, all non-faulty processes (of which there are at least $n-t$) reach line 14, broadcasting $(\mathord{\it ID},$ECHO$,m,\sigma)$. Since $n-t>\frac{n+t}{2}$, every non-faulty process will eventually receive more than $\frac{n+t}{2}$ $(\mathord{\it ID},$ECHO$,m,\sigma)$ messages, fulfilling the predicate at line 16. More than $\frac{n+t}{2}>t+1$ non-faulty processes will not have broadcast $(\mathord{\it ID},$READY$,m,\sigma)$, and so will do so (at line 18). Thus, all honest processes will eventually receive $t+1$ $(\mathord{\it ID},$READY$,m,\sigma)$ messages, broadcasting $(\mathord{\it ID},$READY$,m,\sigma)$ there if not yet done. Then, since $n-t\geq 2t+1$, line 24 will eventually be fulfilled for each non-faulty process. Thus, every non-faulty process will AARB-deliver $(m,\sigma)$ at line 28, as required.

Lemma 11

AARBP ensures AARB-Validity, which is stated as follows. Suppose that a non-faulty process AARB-delivers $(m,\sigma)$ with respect to $\mathord{\it ID}$. Let $i=\mathord{\sf FindIndex}(\mathord{\it ID},m,\sigma)$ denote the output of an idealised call to $\mathord{\sf FindIndex}$. Then if $p_{i}$ is non-faulty, $p_{i}$ must have anonymously broadcast $(m,\sigma)$.

Proof

Let $p_{i}$ be non-faulty. From the protocol specification, $p_{i}$ must have invoked $\sigma\leftarrow\mathord{\sf Sign}(i,\mathord{\it ID},m)$. By definition of $\mathord{\sf Sign}$, no other process could have produced such a value of $\sigma$. By traceability and entrapment-freeness, no other process can produce a tuple $(m^{\prime},\sigma^{\prime})$ such that $\mathord{\sf Trace}(\mathord{\it ID},m,\sigma,m^{\prime},\sigma^{\prime})\neq$ ``indep''. Consequently, no process can produce a message that prevents non-faulty processes from propagating $(\mathord{\it ID},$ECHO$,m,\sigma)$ messages. Thus, since $p_{i}$ is non-faulty, and therefore followed the protocol, $p_{i}$ must have anonymously broadcast $(m,\sigma)$.

Remark 2

No non-faulty process will broadcast more than one message of the form $(\mathord{\it ID},$ECHO$,m^{\prime},\sigma^{\prime})$ where $\sigma^{\prime}$ is such that $\sigma^{\prime}=\mathord{\sf Sign}(x,\mathord{\it ID},m^{\prime})$ for any message $m^{\prime}$.

Proof

This follows from the proof of Lemma 10: if non-faulty process $p$ receives another message $(m,\sigma)$ s.t. $\sigma\leftarrow\mathord{\sf Sign}(x,\mathord{\it ID},m)$ for any $m$, then $\mathord{\sf Trace}(\mathord{\it ID},m,\sigma,m^{\prime},\sigma^{\prime})\neq$ ``indep'', and so $p$ will not reach line 14.

Lemma 12

In AARBP, if $p_{i}$ AARB-delivers $(m,\sigma)$ with respect to $\mathord{\it ID}$, where $\sigma\leftarrow\mathord{\sf Sign}(x,\mathord{\it ID},m)$, and $p_{j}$ AARB-delivers $(m^{\prime},\sigma^{\prime})$ with respect to $\mathord{\it ID}$, where $\sigma^{\prime}\leftarrow\mathord{\sf Sign}(x,\mathord{\it ID},m^{\prime})$, then $(m,\sigma)=(m^{\prime},\sigma)$.

Proof

For $p_{i}$ (resp. $p_{j}$) to have AARB-delivered $(m,\sigma)$ (resp. $(m^{\prime},\sigma^{\prime})$), $p_{i}$ (resp. $p_{j}$) must have broadcast $(\mathord{\it ID},$READY$,m,\sigma)$ (resp. $(\mathord{\it ID},$READY$,m^{\prime},\sigma^{\prime})$). Then, one of two predicates (at lines 16 and 20) must have been true for each process. That is, $p_{i}$ (resp. $p_{j}$) must have received either:

$(\mathord{\it ID},$ECHO$,m,\sigma)$ (resp. $(\mathord{\it ID},$ECHO$,m^{\prime},\sigma^{\prime})$) from $\lfloor\frac{n+t}{2}\rfloor$ different processes, or 2. 2.

$(\mathord{\it ID},$READY$,m,\sigma)$ (resp. $(\mathord{\it ID},$READY$,m^{\prime},\sigma^{\prime})$) from $(t+1)$ different processes.

We first prove the following claim: if $(\mathord{\it ID},$READY$,m,\sigma)$ is broadcast by $p_{i}$, and $(\mathord{\it ID},$READY$,m^{\prime},\sigma^{\prime})$ is broadcast by $p_{j}$, then $(m,\sigma)=(m^{\prime},\sigma^{\prime})$. Suppose that both processes fulfill condition (1), receiving ECHO messages from sets of processes $P$ and $P^{\prime}$ respectively, where $p_{i}$ broadcasts $(\mathord{\it ID},$READY$,m,\sigma)$ and $p_{j}$ broadcasts $(\mathord{\it ID},$READY$,m^{\prime},\sigma^{\prime})$. Assume that $(m,\sigma)\neq(m^{\prime},\sigma^{\prime})$. Then:

[TABLE]

Therefore, $P\cap P^{\prime}$ must contain at least one correct process, say $p_{c}$. By Remark 2, $p_{c}$ must have sent the same ECHO message for some message to both processes, and so $p_{i}$ and $p_{j}$ must have received the same message $(\mathord{\it ID},$ECHO$,m,\sigma)$ = $(\mathord{\it ID},$ECHO$,m^{\prime},\sigma^{\prime})$, contradicting the assumption that $(m,\sigma)\neq(m^{\prime},\sigma^{\prime})$. Thus, they must broadcast the same READY message.

Suppose now that at least one process broadcasts READY due to condition (2) being fulfilled. Without loss of generality, assume exactly one process $p$ broadcasts READY on this basis. Then, $p$ must have received a READY message from at least one correct process (since out of $t+1$ processes, at least 1 must be non-faulty), say $p_{a}$. Either $p_{a}$ received READY from at least one correct process, say $p_{b}$, or it satisfied condition (1). By continuing the logic (and since $|P|$ is finite), there must exist a process $p_{(1)}$ that fulfilled condition (1). Then, by the correctness of processes $p_{(1)},\dots,p_{b},p_{a}$, READY messages sent by $p_{i}$ and $p_{j}$ must be the same, completing the proof.

Therefore, $p_{i}$ broadcasting $(\mathord{\it ID},$READY$,m,\sigma)$, and $p_{j}$ broadcasting $(\mathord{\it ID},$READY$,m^{\prime},\sigma^{\prime})$ implies $(m,\sigma)=(m^{\prime},\sigma^{\prime})$ given that $p_{i}$ and $p_{j}$ are non-faulty.

We now directly prove the lemma. If $p_{i}$ AARB-delivers $(m,\sigma)$, it received $(\mathord{\it ID},$READY$,m,\sigma)$ from $(2t+1)$ different processes, and thus received $(\mathord{\it ID},$READY$,m,\sigma)$ from at least one non-faulty process. Similarly, if $p_{j}$ AARB-delivers $(m^{\prime},\sigma^{\prime})$, it must have received $(\mathord{\it ID},$READY$,m^{\prime},\sigma^{\prime})$ from at least one non-faulty process. It follows from the previous claim that all non-faulty processes broadcast the same READY message. Thus, $p_{i}$ and $p_{j}$ AARB-deliver the same tuple.

Lemma 13

AARBP ensures AARB-Termination-2. That is, if a non-faulty process AARB-delivers $(m,\sigma)$ with respect to $\mathord{\it ID}$, then all the non-faulty processes eventually AARB-deliver $(m,\sigma)$ with respect to $\mathord{\it ID}$.

Proof

By Lemma 12, all non-faulty processes that AARB-deliver a message $(m^{\prime},\sigma^{\prime})$ s.t. $\sigma^{\prime}\leftarrow\mathord{\sf Sign}(x,\mathord{\it ID},m^{\prime})$ AARB-deliver $(m,\sigma)$. Then, $p_{i}$ must have received the message $(\mathord{\it ID},$READY$,m,\sigma)$ from $(2t+1)$ processes (line 24), at least $t+1$ of which must be non-faulty. These $t+1$ processes must have broadcast $(\mathord{\it ID},$READY$,m,\sigma)$ (at line 18 or 22), and so every non-faulty process will eventually receive $(t+1)$ $(\mathord{\it ID},$READY$,m,\sigma)$ messages, and thus broadcast $(\mathord{\it ID},$READY$,m,\sigma)$ at some point. Given there are $n-t\geq 2t+1$ non-faulty processes, each non-faulty process eventually receives $(\mathord{\it ID},$READY$,m,\sigma)$ from at least $2t+1$ processes. Therefore, every non-faulty process will AARB-deliver $(m,\sigma)$.

Lemma 14

AARBP ensures AARB-Unicity, which is stated as follows. Consider any point of time in which a non-faulty process $p$ has AARB-delivered more than one tuple with respect to $\mathord{\it ID}$. Let $delivered=\{(m_{1},\sigma_{1}),\dots,(m_{l},\sigma_{l})\}$, where $|delivered|=l$, denote the set of these tuples. For each $i\in\{1,\dots,l\}$, let $out_{i}=\mathord{\sf FindIndex}(\mathord{\it ID},m_{i},\sigma_{i})$ denote the output of an idealised call to $\mathord{\sf FindIndex}$. Then for all distinct pairs of tuples $\{(m_{i},\sigma_{i}),(m_{j},\sigma_{j})\}$, $out_{i}\neq out_{j}$.

Proof

We proceed by contradiction. Without loss of generality, suppose that $p$ AARB-delivers two tuples $(m,\sigma)$ and $(m^{\prime},\sigma^{\prime})$ such that $\mathord{\sf FindIndex}(\mathord{\it ID},m,\sigma)=\mathord{\sf FindIndex}(\mathord{\it ID},m^{\prime},\sigma^{\prime})$. Then, AARB-Termination-2 implies that all non-faulty processes will eventually AARB-deliver $(m,\sigma)$ and $(m^{\prime},\sigma^{\prime})$. But, Lemma 12 asserts that $\mathord{\sf FindIndex}(\mathord{\it ID},m,\sigma)=\mathord{\sf FindIndex}(\mathord{\it ID},m^{\prime},\sigma^{\prime})$, a contradiction. Thus, for each $i\in\{1..n\}$, $p$ AARB-delivers at most one tuple $(m,\sigma)$ such that $\mathord{\sf FindIndex}(\mathord{\it ID},m,\sigma)=i$.

Theorem 0.C.1

AARBP (Algorithm 7 in Section 3) satisfies the properties of AARB-Broadcast.

Proof

From Lemmas 8, 9, 11, 14, 10 and 13, it follows that all properties of AARB-Broadcast are satisfied.

Appendix 0.D Composing threshold encryption and AVCP

Threshold encryption [23, 57] typically involves a set of processes who have a common encryption key and an individual share of the decryption key who must collaborate to decrypt any message. A $k$-out-of-$n$ threshold encryption scheme requires the joint collaboration of $k$ processes to decrypt any encrypted value. Importantly, $k-1$ or less processes are unable to determine any additional information about a given encrypted value in collaboration. Generally, the keying material can be reused in the sense that many values can be decrypted without compromising the security of the scheme.

AVCP assumes that $t$ processes may be Byzantine faulty. Thus, by setting the decryption threshold to $t+1$, a coalition of $t$ malicious processes are unable to deduce the contents of encrypted values until a non-faulty process initiates threshold decryption. Consequently, a protocol that ensures that the contents of all non-faulty process' proposals to an instance of AVCP is not revealed until after termination can be designed as follows:

All processes encrypt their proposal under a pre-determined public key. 2. 2.

All processes invoke AVCP with input as their encrypted value. 3. 3.

Upon termination, all processes initiate threshold decryption.

In this appendix, we realise and analyse this protocol.

0.D.1 Preliminaries

We assume that the assumptions made by AVCP, including those made in our model (Section 2), hold true. In particular, the dealer generates the initial state, including the values of $n$ and $t$. As such, the decryption threshold for the instance of threshold encryption is set to $k=t+1$. As done in characterising traceable ring signatures in Section 2, we assume processes have access to a distributed oracle which handles cryptographic operations, rather than explicitly referring to keying material as is done in practice. In addition to the queries described in Section 2, we assume that the distributed oracle handles queries of the following functions:

$c\leftarrow\mathord{\sf Enc}(\mathord{\it ID},m)$, which takes identifier $\mathord{\it ID}\in\{0,1\}^{*}$ and message $m\in\{0,1\}^{*}$ as input, and outputs the ciphertext $c\in\{0,1\}^{*}$. All parties (even those not in $P$) may query $\mathord{\sf Enc}$. 2. 2.

$b\leftarrow\mathord{\sf VerifyEnc}(\mathord{\it ID},c)$, which takes identifier $\mathord{\it ID}$ and ciphertext $c$ as input, and outputs a bit $b\in\{0,1\}$. All parties may query $\mathord{\sf VerifyEnc}$. 3. 3.

$\sigma\leftarrow\mathord{\sf ShareGen}(i,\mathord{\it ID},c)$, which takes integer $i\in\{1..n\}$, identifier $\mathord{\it ID}$ and ciphertext $c$ as input, and outputs the decryption share $\sigma\in\{0,1\}^{*}$. We restrict the interface $\mathord{\sf ShareGen}$ such that only process $p_{i}\in P$ may invoke $\mathord{\sf ShareGen}$ with first argument $i$. 4. 4.

$b\leftarrow\mathord{\sf VerifyShare}(\mathord{\it ID},c,\sigma)$, which takes identifier $\mathord{\it ID}$, ciphertext $c$ and decryption share $\sigma$ as input, and outputs a bit $b\in\{0,1\}$. All parties may query $\mathord{\sf VerifyShare}$. 5. 5.

$m\leftarrow\mathord{\sf Dec}(\mathord{\it ID},c,\Sigma)$, which takes the identifier $\mathord{\it ID}$, ciphertext $c$ and set $\Sigma=\{\sigma_{1},\dots,\sigma_{k}\}$ of $k$ decryption shares, and outputs the plaintext $m\in\{0,1\}^{*}$. All parties may query $\mathord{\sf Dec}$.

These definitions are inspired by those used in defining Shoup and Gennaro's non-interactive threshold encryption scheme [57]. The behaviour of calls to the above functions satisfies the following properties:

• •

Encryption correctness and non-malleability: $\mathord{\sf VerifyEnc}(\mathord{\it ID},c)=1$ $\Longleftrightarrow$ there exists a party which previously invoked $\mathord{\sf Enc}(\mathord{\it ID},m)$ and obtained $c$ as a response. Non-malleability is captured by the ``$\Rightarrow$'' claim, which ensures that any correct encryption was produced by a call to $\mathord{\sf Enc}$. In particular, non-malleability implies that combining any value and an encryption (e.g. via concatenation) will not produce another valid encryption.

• •

Share correctness and unforgeability: $\mathord{\sf VerifyShare}(\mathord{\it ID},c,\sigma)=1$ $\Longleftrightarrow$ there exists process $p_{i}\in P$ that previously invoked $\mathord{\sf ShareGen}(i,\mathord{\it ID},c)$ and obtained $\sigma$ as a result.

• •

Decryption correctness and decryption security: $\mathord{\sf Dec}(\mathord{\it ID},c,\Sigma)=m$, where $m$ was the input to a previous call to $\mathord{\sf Enc}(\mathord{\it ID},m)$ $\Longleftrightarrow$ the following conditions are met:

$c\leftarrow\mathord{\sf Enc}(\mathord{\it ID},m)$ was called by some party. 2. 2.

$\Sigma=\{\sigma_{1},\dots,\sigma_{k}\}$ ($|\Sigma|=k$), where for each distinct pair $\sigma_{i},\sigma_{j}\in\Sigma$, distinct processes $p_{i},p_{j}\in P$ respectively called $\sigma_{i}\leftarrow\mathord{\sf ShareGen}(i,\mathord{\it ID},c)$ and $\sigma_{j}\leftarrow\mathord{\sf ShareGen}(j,\mathord{\it ID},c)$.

The $\Leftarrow$'' claim captures decryption correctness. The $\Rightarrow$'' claim captures security, ensuring that $k$ valid shares produced by distinct processes are required for decryption.

• •

Encryption hiding: Suppose $c\leftarrow\mathord{\sf Enc}(\mathord{\it ID},m)$ is called by a party $p$. Then, $m$ can only be obtained by either $p$ revealing $m$ or a valid call $m\leftarrow\mathord{\sf Dec}(\mathord{\it ID},c,\Sigma)$ being made.

0.D.2 Arbitrary Ballot Election (ABE)

At a high level, processes first perform AVCP with respect to their proposal which is encrypted under the threshold encryption scheme. Then, processes perform threshold decryption, which requires an additional message delay for termination. We call this algorithm an Arbitrary Ballot Election (ABE), since processes can propose arbitrary values and are ensured of certain properties that are defined in the context of electronic voting. We describe and prove these hold in the next subsection.

Functions.

Each process has access to the distributed oracle and in addition to all functions invoked AVCP (Section 4). For a given tuple $(m,\sigma)$ we assume that the predicate $\mathord{\sf valid}()$ in AVCP returns $\mathord{\sf true}$ only if $\mathord{\sf VerifyEnc}(\mathord{\it ID},m)=1$. That is, $m$ was the result of a query to $\mathord{\sf Enc}(\mathord{\it ID},msg)$ for some $msg\in\{0,1\}^{*}$.

State.

Each process tracks the variables ID, a string uniquely identifying an instance of ABE, has-broadcast, a Boolean that is initially $\mathord{\sf false}$, unique-encs and plaintexts, sets of messages $m\in\{0,1\}^{*}$ that are initially empty, and partial-decs, which maps ciphertexts to sets of decryption shares, each of which are initially empty.

Messages.

In addition to messages propagated in AVCP (which includes messages from AARBP), messages of the form $($DECS$,\mathord{\it ID},\mathord{\it encs})$ are propagated, where $\mathord{\it encs}$ is a map, each value of which is a singleton set.

Protocol description.

Each process begins with the plaintext $m$ to propose to consensus. Processes encrypt $m$ under $\mathord{\sf Enc}$, producing the ciphertext $c$ (line 2). Processes propose their encrypted value to an instance of AVCP identified by $\mathord{\it ID}$. Since $\mathord{\sf valid}()$ checks that $\mathord{\sf VerifyEnc}(\mathord{\it ID},m)=1$ for a given tuple $(m,\sigma)$, $\mathord{\it encs}$ will thus contain well-formed encryptions (AVC-Validity) of processes' proposals.

Now, AVCP guarantees that signatures, rather than the contents of messages, are unique. So, it is conceivable that a process will mount a replay attack, which aims to disrupt an election by mimicking the input of some process. Since values are encrypted under a common instantiation of threshold encryption, it is desirable to prevent this attack. Consequently, we require that non-faulty processes prepend a sufficiently large sequence of random bits to their plaintext. For simplicity, we assume that each sequence that a non-faulty proposes derives is unique. So, non-unique encrypted messages are discarded (lines 4 and 5), resulting in the set $\mathord{\it unique-encs}$. At this point, threshold decryption is performed with respect to each element of $\mathord{\it unique-encs}$ (line 6). For each (encrypted) value that a process decided, a decryption share is produced. Then, processes broadcast each share and the corresponding ciphertext used to produce it.

Processes do not process shares that they have received from other processes until they have broadcast their shares, ensuring termination for all non-faulty processes. In practice, processes can process shares provided they delay termination until after they have broadcast. Upon receipt of a (potential) set of shares, processes check that the ciphertexts received match theirs. Given this holds, they check that all shares are well-formed. At this point, processes store these shares in encs. Once a process has received $k$ shares for every ciphertext in $\mathord{\it unique-encs}$, each ciphertext is decrypted, and the resulting plaintexts are returned.

0.D.3 Analysis

We prove a number of properties hold:

Lemma 15

ABE satisfies termination. That is, all non-faulty processes eventually complete protocol execution.

Proof

At the protocol's outset, all non-faulty processes produce a value $c$ s.t. $c\leftarrow\mathord{\sf Enc}(\mathord{\it ID},m)$ was called for some $m\in\{0,1\}$ (line 2). Then, processes execute AVCP with respect to the identifier $\mathord{\it ID}$, where every non-faulty process proposes a valid ciphertext $c$ (line 3). On AARB-delivery of each value, a process' call to $\mathord{\sf valid}()$ will return $\mathord{\sf true}$ by encryption correctness, as it must be the case $\mathord{\sf VerifyEnc}(\mathord{\it ID},c)=1$ for such a $c$. By AVC-Termination, AVC-Validity and AVC-Agreement, all non-faulty processes eventually terminate AVCP with the same set of values, each of which satisfies $\mathord{\sf valid}()$. By AVC-Agreement, all non-faulty processes will obtain the same set $\mathord{\it unique-encs}$ (after line 5). Then, all non-faulty processes will produce decryption shares for each value in $\mathord{\it unique-encs}$ via calls to $\mathord{\sf ShareGen}$, which are guaranteed to be broadcast as no non-faulty process can terminate until the condition at line 17 is fulfilled. On receipt of a set of decryption shares (line 15) (with identical corresponding ciphertexts) from a non-faulty process, by share correctness each share $\sigma$ will satisfy $\mathord{\sf VerifyShare}(\mathord{\it ID},c,\sigma)=1$ for the corresponding ciphertext $c$. Thus, a non-faulty process will eventually receive $k=t+1$ valid decryption shares for each unique value that was decided by AVCP. Thus, they can call $\mathord{\sf Dec}$ with respect to each set of shares (line 22) which by decryption correctness will pass, and thus the process will return the corresponding plaintexts.

Comparable definitions to anonymity-preserving vector consensus (Section 4) regarding agreement, validity and anonymity follow straightforwardly from the fact that AVCP satisfies AVC-Agreement, AVC-Validity and AVC-Anonymity, respectively.

Lemma 16

ABE satisfies public verifiability. That is, any third party can obtain the result of the election after termination.

Proof

By termination and agreement, all non-faulty processes eventually agree on the same set of plaintext values. Then, a third party can request these values from all processes. On receipt of $t+1$ identical sets of values, the third party can deduce that the set of values corresponds to the election result.

Lemma 17

ABE satisfies weak privacy. That is, a value proposed by a non-faulty process is only revealed after AVCP has terminated for a non-faulty process.

Proof

Each non-faulty process $p$ proposes a value $c$ s.t. $c\leftarrow\mathord{\sf Enc}(\mathord{\it ID},m)$ was invoked for some $m\in\{0,1\}^{*}$ (line 2). Encryption hiding implies that $m$ can only be revealed if either $p$ reveals $m$, which $p$ does not in the protocol, or if a valid call to $\mathord{\sf Dec}$ is made. By decryption security, $\mathord{\sf Dec}$ will only return $m$ if provided $k=t+1$ valid decryption shares. Now, no non-faulty process broadcasts a decryption share until after it terminates AVCP. Thus, a coalition of $t$ faulty processes cannot decrypt $m$ via $\mathord{\sf Dec}$, which is the only conceivable way for them to obtain $m$ in the model.

Lemma 18

ABE satisfies eligibility. That is, only processes in $P$ may propose a ballot that is decided.

Proof

By assumption, non-faulty processes only process messages sent over regular channels from processes in $P$. But, any party may anonymously broadcast a value $v$. AARBP satisfies AVC-Signing. That is, all AARB-delivered messages are of the form $(m,\sigma)$, where $\sigma\leftarrow\mathord{\sf Sign}(i,\mathord{\it ID},m)$. By assumption on the interface of $\mathord{\sf Sign}$, only a process in $P$ may call $\mathord{\sf Sign}$. By construction of AVCP, only messages that are AARB-delivered are decided by non-faulty processes. Thus, no non-faulty process will decide a value $v$ in AVCP from any party outside of $P$.

Lemma 19

ABE satisfies non-reusability. That is, at most one encrypted ballot signed by a particular process can be decided in the election.

Proof

By construction of AVCP, only messages that are AARB-delivered are decided by non-faulty processes. By AARB-Unicity, no non-faulty process will AARB-deliver more than one tuple $(m,\sigma)$ such that a process $p_{i}$ invoked $\sigma\leftarrow\mathord{\sf Sign}(i,\mathord{\it ID},m)$.

Appendix 0.E Further experiments

In this section, we present experimental results of our implementations of cryptographic and distributed protocols. To determine their influence in cost over our distributed protocols, we benchmark two cryptographic protocols which our distributed protocols rely on, namely Fujisaki's traceable ring signature (TRS) scheme [32] and Shoup and Gennaro's threshold encryption scheme [57]. With this information, we then benchmark and evaluate our three distributed protocols: Anonymised All-to-all Reliable Broadcast Protocol (AARBP), Anonymised Vector Consensus Protocol (AVCP), and our election scheme, Arbitrary Ballot Election (ABE).

0.E.1 Cryptography

Benchmarks of standalone cryptographic constructions were performed on a laptop with an Intel i5-7200U (quad-core) processor clocked at 3.1GHz and 8GB of memory. The operating system used was Ubuntu 18.04. Each cryptosystem was implemented in golang. All cryptographic schemes were implemented using Curve25519 [6]. To simulate a prime-order group we use the Ristretto technique [1], derived from the Decaf approach [40], via go-ristretto333https://github.com/bwesterb/go-ristretto. All cryptographic operations rely on constant-time arithmetic operations to prevent side-channel attacks [11]. Each data point represents a minimum of 100 and a maximum of 10000 iterations.

0.E.1.1 Ring signatures

To confirm that the implementation is competitive, we compare it to an implementation of Lui et al.'s linkable ring signature scheme [45]. The particular implementation we compare to was produced by EPFL's DEDIS group as part of kyber444 https://godoc.org/github.com/dedis/kyber/sign/anon. We note that the ring signature schemes naturally lend themselves towards parallelism. To this end, we provide an extension of our TRS implementation that takes advantage of concurrency.

We compared the two major operations. Firstly, the Sign() operation ($\mathord{\sf Sign}$'' in Section [2](#S2)) is that which forms a ring signature. Secondly, Verify() ($\mathord{\sf VerifySig}$'' in Section 2) takes a ring signature as input, and verifies the well-formedness of the signature, and (in implementation) outputs a tag which is used for linking/tracing.

Figure 2(a) represents the normalised speedup, as a percentage, afforded to the Sign() and Verify() operations in the TRS scheme. We note that Figure 2(a) involves purely sequential implementations. We vary $n$, the size of the ring. Performance of Sign() and Verify() in both schemes scales linearly with respect to $n$.

Let $T_{LRS}$ be the time an operation (signing or verification) takes in the TRS implementation, and similarly define $T_{TRS}$. Then, normalised speedup is given by:

[TABLE]

Indeed, this value hovers above 70 percent for all values of $n$ tested. In the LRS implementation, the Sign() operation took between 7.5 and 230.4ms to execute (for values $n=10$ and $n=310$ respectively). Sign() in the TRS implementation took between 4.3 and 132.0ms to execute. Similarly, Verify() took between 7.7 and 230.3ms to execute in the LRS implementation, and took between 4.4 and 134.6ms to execute in the TRS implementation.

To understand the performance increase, we count cryptographic operations. We use the notation presented in [62], adapted to represent elliptic curve operations. Let $E$ denote the cost of performing point multiplication, and $M$ denote the number of operations of the form $(aP+bQ)$, where $a$, $b$ are scalars, and $P,Q$ are points. Then, in the LRS scheme, Sign() requires $2(n-1)M+3E$ operations, and Verify() requires $2nM$ operations [62]. In the TRS scheme, Sign() requires the same $2(n-1)M$ and $3E$ operations, in addition to $nM$ other operations. Similarly, the TRS Verify() call requires $2nM+nM=3nM$ operations. With the same elliptic curve implementation, we should see a performance increase from an efficient LRS implementation, as the TRS scheme requires  1.5x $M$ operations by comparison to the LRS scheme. But, in the library we use for ECC, go-ristretto, base point multiplication is  2.8x faster, point multiplication is  2.3x faster, and point addition is  2.6x faster. Thus, we see an overall increase in performance in our TRS implementation by comparison.

Recall that in AARBP (and thus AVCP), ring signature tracing is performed iteratively. Suppose that some process has $x$ correct ring signatures that they have verified at some point in time. Then, upon receipt of another signature, they first execute Verify(), and then perform the Trace() operation between the new signature and each of the $x$ stored signatures. To model this behaviour, we perform a benchmark where signatures are processed one-by-one with a ring of size $n$ that is varied from 20 to 100 in increments of 20. As the linkable ring signature scheme admits very similar functionality, except it performs a linking operation, rather than a tracing operation, we benchmark similarly.

Figure 2(b) compares the average time taken to perform the aforementioned procedure, between a sequential implementation of the TRS scheme, the corresponding concurrent implementation (utilising four cores), and the (sequential) LRS implementation. Now, the time taken to perform Verify() is proportional to the size of the ring $n$. In addition, we perform more ($n$) Verify() operations as we increase $n$. Consequently, execution time grows quadratically in Figure 2(b) for each implementation. In addition to the previously outlined speedup, we roughly halve execution time of TRS operations by exploiting concurrency in our implementation. With $n=100$, our concurrent implementation is 2.25x faster than our sequential implementation, and is 3.86x faster than the sequential LRS implementation.

To perform Trace() between two signatures, $O(n)$ comparisons are performed in a naive implementation, whereas a single comparison is need to link in the TRS scheme. In implementation, we used a hash table, so each new signature required $O(n)$ lookups in the TRS scheme, and one lookup in the LRS scheme. As expected, we observe that the increased overhead of tracing is dominated by the time taken performing Verify() operations, and so speedup does not appear to be affected.

0.E.1.2 Threshold encryption

Our arbitrary ballot voting scheme, ABE, presented in Appendix 0.D, can be instantiated with Shoup and Gennaro's threshold encryption scheme [57]. To this end, we present results corresponding to our implementation of their construction.

Table 2 shows the performance of all operations in the threshold encryption scheme [57] as executed by one process, bar decryption itself. As can be seen, all operations can be executed in a reasonable amount of time (less than a millisecond). In our electronic voting protocol, each process performs a single encryption operation, but may perform $O(n)$ operations of the other forms over the protocol's execution. Even when $n$ is relatively large ($>100$), we can expect to see acceptable levels of performance.

Let $P$ be a group of $n$ processes. Then, the final operation, share combination, combines a group of $k$ valid decryption shares, where $k$ is the threshold required to reconstruct the secret. In our electronic voting protocols, for interoperability with our consensus algorithms, we set $k=t+1$, where $t$ is, at most, the largest value such that $t<\frac{n}{3}$.

Figure 3 represents the time taken to decrypt a message, varying $k$, the number of shares needed to reconstruct the message in increments of 10. As some steps of the reconstruction process can be performed concurrently, e.g. in the derivation of Lagrange coefficients [56], we provide an extension that takes advantage of a multi-core processor. To this end, Figure 3 graphs the time taken to perform share combination with both our sequential implementation, and the corresponding concurrent implementation utilising two to four cores.

Indeed, producing Lagrange coefficients requires a quadratic amount of work (with respect to $k$), and subsequently decrypting a message takes $O(k)$ effort, which dominates execution time. Both the quadratic and linear components of the share combination can be made concurrent. Consequently, we roughly double our performance with two to four cores running. It is worth noting that the effort required to spawn additional threads in the three and four core case does not translate to a very noticeable improvement in performance for our values of $k$.

0.E.2 Elections with arbitrary ballots

Arbitrary Ballot Election (ABE) essentially combines AVCP with a threshold encryption scheme. To perform our benchmarks for the election scheme, we used pre-generated keying material for threshold encryption. We use Shoup and Gennaro's threshold encryption scheme [57], which was benchmarked in the previous section. Our experiment differs from experiments with AVCP in that ring signatures must also contain valid encryptions as per the threshold encryption scheme, and because all processes perform threshold decryption with respect to all decided ballots.

Figure 4 compares the performance of AVCP with ABE as described above. As can be seen, there is some, but not a considerable amount, of overhead from introducing the election's necessary cryptographic machinery. The main factors here are an additional message step, additional message verifications, and, requiring the most additional effort, performing threshold decryption.

As can be seen (and was explored in Section 6), AVCP performance degrades when $t$ is non-optimal. Despite this, the election still takes longer to perform when $t$ is increased. Consider the case where $(n,t)=(100,33)$. As shown in Figure 3, combining $k=t+1=34$ (valid) partial decryptions together takes roughly 30ms. Since each run of the experiment decides on at least $n-t=67$ values, processes have to spend almost two seconds combining shares together. In the best case, each process has to verify that $(n-t)t=2211$ shares are well-formed, which takes roughly 750ms. Thus, in addition to other cryptographic overhead, it is clear that increasing $t$ affects election performance.

Notwithstanding, the election protocol performs well for reasonable values of $n$. At $n=100$, the election roughly takes between 7.5 and 9 seconds to execute from start to finish. Given that the latency provided by the anonymous channels used by processes is sufficiently low, we can expect to see comparable results in practice.