18 research outputs found
Scalable Byzantine Reliable Broadcast
Byzantine reliable broadcast is a powerful primitive that allows a set of processes to agree on a message from a designated sender, even if some processes (including the sender) are Byzantine. Existing broadcast protocols for this setting scale poorly, as they typically build on quorum systems with strong intersection guarantees, which results in linear per-process communication and computation complexity.
We generalize the Byzantine reliable broadcast abstraction to the probabilistic setting, allowing each of its properties to be violated with a fixed, arbitrarily small probability. We leverage these relaxed guarantees in a protocol where we replace quorums with stochastic samples. Compared to quorums, samples are significantly smaller in size, leading to a more scalable design. We obtain the first Byzantine reliable broadcast protocol with logarithmic per-process communication and computation complexity.
We conduct a complete and thorough analysis of our protocol, deriving bounds on the probability of each of its properties being compromised. During our analysis, we introduce a novel general technique that we call adversary decorators. Adversary decorators allow us to make claims about the optimal strategy of the Byzantine adversary without imposing any additional assumptions. We also introduce Threshold Contagion, a model of message propagation through a system with Byzantine processes. To the best of our knowledge, this is the first formal analysis of a probabilistic broadcast protocol in the Byzantine fault model. We show numerically that practically negligible failure probabilities can be achieved with realistic security parameters
Self-Healing Computation
In the problem of reliable multiparty computation (RC), there are
parties, each with an individual input, and the parties want to jointly compute
a function over inputs. The problem is complicated by the fact that an
omniscient adversary controls a hidden fraction of the parties.
We describe a self-healing algorithm for this problem. In particular, for a
fixed function , with parties and gates, we describe how to perform
RC repeatedly as the inputs to change. Our algorithm maintains the
following properties, even when an adversary controls up to parties, for any constant . First, our
algorithm performs each reliable computation with the following amortized
resource costs: messages, computational
operations, and latency, where is the depth of the circuit
that computes . Second, the expected total number of corruptions is , after which the adversarially controlled parties are
effectively quarantined so that they cause no more corruptions.Comment: 17 pages and 1 figure. It is submitted to SSS'1
Storage and Search in Dynamic Peer-to-Peer Networks
We study robust and efficient distributed algorithms for searching, storing,
and maintaining data in dynamic Peer-to-Peer (P2P) networks. P2P networks are
highly dynamic networks that experience heavy node churn (i.e., nodes join and
leave the network continuously over time). Our goal is to guarantee, despite
high node churn rate, that a large number of nodes in the network can store,
retrieve, and maintain a large number of data items. Our main contributions are
fast randomized distributed algorithms that guarantee the above with high
probability (whp) even under high adversarial churn:
1. A randomized distributed search algorithm that (whp) guarantees that
searches from as many as nodes ( is the stable network size)
succeed in -rounds despite churn, for
any small constant , per round. We assume that the churn is
controlled by an oblivious adversary (that has complete knowledge and control
of what nodes join and leave and at what time, but is oblivious to the random
choices made by the algorithm).
2. A storage and maintenance algorithm that guarantees (whp) data items can
be efficiently stored (with only copies of each data item)
and maintained in a dynamic P2P network with churn rate up to
per round. Our search algorithm together with our
storage and maintenance algorithm guarantees that as many as nodes
can efficiently store, maintain, and search even under churn per round. Our algorithms require only polylogarithmic in bits to
be processed and sent (per round) by each node.
To the best of our knowledge, our algorithms are the first-known,
fully-distributed storage and search algorithms that provably work under highly
dynamic settings (i.e., high churn rates per step).Comment: to appear at SPAA 201
Fast Byzantine Leader Election in Dynamic Networks
International audienceWe study the fundamental Byzantine leader election problem in dynamic networks where the topology can change from round to round and nodes can also experience heavy churn (i.e., nodes can join and leave the network continuously over time). We assume the full information model where the Byzantine nodes have complete knowledge about the entire state of the network at every round (including random choices made by all the nodes), have unbounded computational power and can deviate arbitrarily from the protocol. The churn is controlled by an adversary that has complete knowledge and control over which nodes join and leave and at what times and also may rewire the topology in every round and has unlimited computational power, but is oblivious to the random choices made by the algorithm.Our main contribution is an O(log^3 n) round algorithm that achieves Byzantine leader election under the presence of up to O(n^(1/2)−ε) Byzantinenodes (for a small constant ε > 0) and a churn of up to O( √n/ polylog(n)) nodes per round (where n is the stable network size). The algorithm elects a leader with probability at least 1 − n^(−Ω(1)) and guarantees that it is an honest node with probability at least 1 − n^(−Ω(1)); assuming the algorithm succeeds, the leader’s identity will be known to a 1 − o(1) fraction of the honest nodes. Our algorithm is fully-distributed, lightweight, and is simple to implement. It is also scalable, as it runs in polylogarithmic (in n) time and requires nodes to send and receive messages of only polylogarithmic size per round. To the best of our knowledge, our algorithm is the first scalable solution for Byzantine leader election in a dynamic network with a high rate of churn; our protocol can also be used to solve Byzantine agreement in a straightforward way. We also show how to implement an (almost-everywhere) public coin with constant bias in a dynamic network with Byzantine nodes and provide a mechanism for enabling honest nodes to store information reliably in the network, which might be of independent interest
Bankrupting Sybil Despite Churn
A Sybil attack occurs when an adversary pretends to be multiple identities
(IDs). Limiting the number of Sybil (bad) IDs to a minority permits the use of
well-established tools for tolerating malicious behavior, such as protocols for
Byzantine consensus and secure multiparty computation. A popular technique for
enforcing this minority is resource burning; that is, the verifiable
consumption of a network resource, such as computational power, bandwidth, or
memory.
Unfortunately, prior defenses require non-Sybil (good) IDs to consume at
least as many resources as the adversary, unless the rate of churn for good IDs
is sufficiently low. Since many systems exhibit high churn, this is a
significant barrier to deployment.
We present two algorithms that offer useful guarantees against Sybil
adversary under a broadly-applicable model of churn. The first is GoodJEst,
which estimates the number of good IDs that join the system over any window of
time, despite the adversary injecting bad IDs. GoodJEst applies to a broad
range of system settings, and we demonstrate its use in our second algorithm, a
new Sybil defense called ERGO. Even under high churn, ERGO guarantee (1) there
is always a minority of bad IDs in the system; and (2) when the system is under
attack, the good IDs burn resources at a total rate that is sublinear in the
adversary's consumption.
To evaluate the impact of our theoretical results, we investigate the
performance of ERGO alongside prior defenses that employ resource burning.
Based on our experiments, we design heuristics that further improve the
performance of ERGO by up to four orders of magnitude over these previous Sybil
defenses.Comment: 41 pages, 6 figures. arXiv admin note: text overlap with
arXiv:2006.02893, arXiv:1911.0646
Atum: Scalable Group Communication Using Volatile Groups
This paper presents Atum, a group communication middleware for a large, dynamic, and hostile environment. At the heart of Atum lies the novel concept of volatile groups: small, dynamic groups of nodes, each executing a state machine replication protocol, organized in a flexible overlay. Using volatile groups, Atum scatters faulty nodes evenly among groups, and then masks each individual fault inside its group. To broadcast messages among volatile groups, Atum runs a gossip protocol across the overlay. We report on our synchronous and asynchronous (eventually synchronous) implementations of Atum, as well as on three representative applications that we build on top of it: A publish/subscribe platform, a file sharing service, and a data streaming system. We show that (a) Atum can grow at an exponential rate beyond 1000 nodes and disseminate messages in polylogarithmic time (conveying good scalability); (b) it smoothly copes with 18% of nodes churning every minute; and (c) it is impervious to arbitrary faults, suffering no performance decay despite 5.8% Byzantine nodes in a system of 850 nodes