scispace - formally typeset
Proceedings ArticleDOI

Fast byzantine agreement in dynamic networks

Reads0
Chats0
TLDR
In this paper, the authors studied Byzantine agreement in dynamic networks where 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), and they presented randomized distributed algorithms that achieve almost-everywhere Byzantine agreement with high probability even under a large number of adaptively chosen Byzantine nodes and continuous adversarial churn in a number of rounds that is polylogarithmic in n.
Abstract
We study Byzantine agreement in dynamic networks where 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). Our main contributions are randomized distributed algorithms that achieve almost-everywhere Byzantine agreement with high probability even under a large number of adaptively chosen Byzantine nodes and continuous adversarial churn in a number of rounds that is polylogarithmic in n (where n is the stable network size). We show that our algorithms are essentially optimal (up to polylogarithmic factors) with respect to the amount of Byzantine nodes and churn rate that they can tolerate by showing a lower bound. In particular, we present the following results:1. An O(log3n) round randomized algorithmto achieve almost everywhere Byzantine agreement with high probability under a presence of up to O(√n/polylog(n)) Byzantine nodes and up to a churn of O(√n/polylog(n)) nodes per round. We assume that the Byzantine nodes have knowledge about the entire state of network at every round (including random choices made by all the nodes) and can behave arbitrarily. We also assume that an adversary controls the churn - it has complete knowledge and control of what nodes join and leave and at what time and has unlimited computational power (but is oblivious to the topology changes from round to round). Our algorithm requires only polylogarithmic in n bits to be processed and sent (per round) by each node.2. We also present an O(log3n) round randomized algorithm that has same guarantees as the above algorithm, but works even when the connectivity of the network is controlled by an adaptive adversary (that can choose the topology based on the current states of the nodes). However, this algorithm requires up to polynomial in n bits to be processed and sent (per round) by each node.3. We show that the above bounds are essentially the best possible, if one wants fast (i.e., polylogarithmic run time) algorithms, by showing that any (randomized) algorithm to achieve agreement in a dynamic network controlled by an adversary that can churn up to Θ(√n log n) nodes per round should take at least a polynomial number of rounds.Our algorithms are the first-known, fully distributed, Byzantine agreement algorithms in highly dynamic networks. We view our results as a step towards understanding the possibilities and limitations of highly dynamic networks that are subject to malicious behavior by a large number of nodes.

read more

Citations
More filters
Journal ArticleDOI

Distributed Computing: Fundamentals, Simulations and Advanced Topics

TL;DR: Stephen J. Hartley first provides a complete explanation of the features of Java necessary to write concurrent programs, including topics such as exception handling, interfaces, and packages, and takes a different approach than most Java references.
Journal ArticleDOI

Scalable Dynamic Multi-Agent Practical Byzantine Fault-Tolerant Consensus in Permissioned Blockchain

TL;DR: A scalable dynamic multi-agent hierarchical PBFT algorithm (SDMA-PBFT), which reduces the communication costs from O(n2) to O( n × k × log k n ), which can be applied to the permissioned blockchain system effectively and efficiently.
Proceedings ArticleDOI

Enabling Robust and Efficient Distributed Computation in Dynamic Peer-to-Peer Networks

TL;DR: The main contribution is a randomized distributed protocol that guarantees with high probability the maintenance of a constant degree graph with high expansion even under continuous high adversarial churn.
Journal ArticleDOI

Distributed computation in dynamic networks via random walks

TL;DR: The random walk framework developed in this paper has also subsequently proved useful in developing efficient storage and search algorithms as well as developing fast byzantine agreement algorithms in dynamic networks.
Book ChapterDOI

Fast Byzantine Leader Election in Dynamic Networks

TL;DR: This work studies 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, and proposes a scalable solution that is scalable, fully-distributed, lightweight, and simple to implement.
References
More filters
Book

Distributed algorithms

Nancy Lynch
TL;DR: This book familiarizes readers with important problems, algorithms, and impossibility results in the area, and teaches readers how to reason carefully about distributed algorithms-to model them formally, devise precise specifications for their required behavior, prove their correctness, and evaluate their performance with realistic measures.
Book

Distributed Computing: Fundamentals, Simulations and Advanced Topics

TL;DR: This chapter discusses how to improve the Fault Tolerance of Algorithms in Message-Passing Systems andSimulating Synchrony, and some of the approaches taken in this chapter to achieve this aim.
Journal ArticleDOI

Authenticated Algorithms for Byzantine Agreement

TL;DR: This paper presents algorithms for reaching agreement based on authentication that require a total number of messages sent by correctly operating processors that is polynomial in both t and the number of processors, n.
Journal ArticleDOI

Distributed Computing: Fundamentals, Simulations and Advanced Topics

TL;DR: Stephen J. Hartley first provides a complete explanation of the features of Java necessary to write concurrent programs, including topics such as exception handling, interfaces, and packages, and takes a different approach than most Java references.
Journal ArticleDOI

A Lower Bound for the Time to Assure Interactive Consistency

TL;DR: It is shown that any algorithm which assures interactive consistency in the presence of m faulty processors requires at least m + 1 rounds of communication.