7.2 KiB
Honey Badger Byzantine Fault Tolerant (BFT) consensus algorithm
Welcome to a Rust library of the Honey Badger Byzantine Fault Tolerant (BFT) consensus algorithm. The research and protocols for this algorithm are explained in detail in "The Honey Badger of BFT Protocols" by Miller et al., 2016.
Following is an overview of HoneyBadger BFT and basic instructions for getting started.
Note: This library is a work in progress and parts of the algorithm are still in development.
What is Honey Badger?
The Honey Badger consensus algorithm allows nodes in a distributed, potentially asynchronous environment to achieve agreement on transactions. The agreement process does not require a leader node, tolerates corrupted nodes, and makes progress in adverse network conditions. Example use cases are decentralized databases and blockchains.
Honey Badger is Byzantine Fault Tolerant. The protocol can reach consensus with a number of failed nodes f (including complete takeover by an attacker), as long as the total number N of nodes is greater than 3 * f.
Honey Badger is asynchronous. It does not make timing assumptions about message delivery. An adversary can control network scheduling and delay messages without impacting consensus.
How does it work?
Honey Badger is a modular library composed of several independent algorithms. To reach consensus, Honey Badger proceeds in epochs. In each epoch, participating nodes broadcast a set of encrypted data transactions to one another and agree on the contents of those transactions.
In an optimal networking environment, output includes data sent from each node. In an adverse environment, the output is an agreed upon subset of data. Either way, the resulting output contains a batch of transactions which is guaranteed to be consistent across all nodes.
In addition to validators, the algorithms support observers: These don't actively participate, and don't need to be trusted, but they receive the output as well, and are able to verify it under the assumption that more than two thirds of the validators are correct.
Algorithms
-
Honey Badger: Each node inputs transactions. The protocol outputs a sequence of batches of transactions.
-
Dynamic Honey Badger: A modified Honey Badger where nodes can dynamically add and remove other nodes to/from the network.
-
Subset: Each node inputs data. The nodes agree on a subset of suggested data.
-
Broadcast: A proposer node inputs data and every node receives this output.
-
Binary Agreement: Each node inputs a binary value. The nodes agree on a value that was input by at least one correct node.
-
Coin: A pseudorandom binary value used by the Binary Agreement protocol.
-
Synchronous Key Generation A dealerless algorithm that generates keys for threshold encryption and signing. Unlike the other algorithms, this one is completely synchronous and should run on top of Honey Badger (or another consensus algorithm)
Getting Started
This library requires a distributed network environment to function. Details on network requirements TBD.
Note: Additional examples are currently in progress.
Build
Requires rust and cargo: installation instructions.
$ cargo build [--release]
Test
$ cargo test --release
Example Network Simulation
A basic example is included to run a network simulation.
$ cargo run --example simulation --release -- -h
Current TODOs
See Issues for all tasks.
- Dynamic Honey Badger (adding and removing nodes in a live network environment) (#47)
- Create additional adversarial scenarios and tests
- Networking example to detail Honey Badger implementation
Protocol Modifications
Our implementation modifies the protocols described in "The Honey Badger of BFT Protocols" in several ways:
- We use a pairing elliptic curve library to implement pairing-based cryptography rather than Gap Diffie-Hellman groups.
- We add a
Terminatemessage to the Binary Agreement algorithm. Termination occurs following output, preventing the algorithm from running (or staying in memory) indefinitely. (#53) - We add a
Confmessage to the Binary Agreement algorithm. An additional message phase prevents an attack if an adversary controls a network scheduler and a node. (#37) - We return additional information from the Subset and Honey Badger algorithms that specifies which node input which data. This allows for identification of potentially malicious nodes.
- We include a Distributed Key Generation (DKG) protocol which does not require a trusted dealer; nodes collectively generate a secret key. This addresses the problem of single point of failure. See Distributed Key Generation in the Wild.
Algorithm naming conventions
We have simplified algorithm naming conventions from the original paper.
| Algorithm Name | Original Name |
|---|---|
| Honey Badger | HoneyBadgerBFT |
| Subset | Asynchronous Common Subset (ACS) |
| Broadcast | Reliable Broadcast (RBC) |
| Binary Agreement | Binary Byzantine Agreement (BBA) |
| Coin | Common Coin |
License
This project is licensed under the GNU Lesser General Public License v3.0. See the LICENSE file for details.
References
-
Other language implementations