poanetwork
/
hbbft
mirror of https://github.com/poanetwork/hbbft.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Spam protection part 1: remote epoch tracking in HoneyBadger (#219) 

* spam protection part 1: remote epoch tracking in HoneyBadger

* moved handling of EpochStarted out of EpochState

* allowed EpochStarted from observers

* removed an unnecessary function call

* updated formatting to beta

* removed an unnecessary variable
This commit is contained in:
Vladimir Komendantskiy 2018-09-03 11:29:03 +01:00 committed by GitHub
parent fc3d578eea
commit b649dc6268
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 136 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
examples/simulation.rs
View File

@ -435,11 +435,16 @@ fn main() {
.map(|_| Transaction::new(args.flag_tx_size))
.collect();
let new_honey_badger = |netinfo: NetworkInfo<NodeId>| {
let dyn_hb = DynamicHoneyBadger::builder().build(netinfo);
QueueingHoneyBadger::builder(dyn_hb)
let (dhb, dhb_step) = DynamicHoneyBadger::builder()
.build(netinfo)
.expect("`DynamicHoneyBadger` builder failed");
let (qhb, qhb_step) = QueueingHoneyBadger::builder(dhb)
.batch_size(args.flag_b)
.build_with_transactions(txs.clone())
.expect("instantiate QueueingHoneyBadger")
.expect("instantiate QueueingHoneyBadger");
let mut step = dhb_step.convert();
step.extend(qhb_step);
(qhb, step)
};
let hw_quality = HwQuality {
latency: Duration::from_millis(args.flag_lag),

28
src/dynamic_honey_badger/builder.rs
View File

@ -48,12 +48,12 @@ where
}
/// Creates a new Dynamic Honey Badger instance with an empty buffer.
pub fn build(&self, netinfo: NetworkInfo<N>) -> DynamicHoneyBadger<C, N> {
pub fn build(&self, netinfo: NetworkInfo<N>) -> Result<(DynamicHoneyBadger<C, N>, Step<C, N>)> {
let arc_netinfo = Arc::new(netinfo.clone());
let honey_badger = HoneyBadger::builder(arc_netinfo.clone())
let (honey_badger, hb_step) = HoneyBadger::builder(arc_netinfo.clone())
.max_future_epochs(self.max_future_epochs)
.build();
DynamicHoneyBadger {
let mut dhb = DynamicHoneyBadger {
netinfo,
max_future_epochs: self.max_future_epochs,
start_epoch: 0,
@ -62,11 +62,13 @@ where
honey_badger,
key_gen_state: None,
incoming_queue: Vec::new(),
}
};
let step = dhb.process_output(hb_step)?;
Ok((dhb, step))
}
/// Creates a new `DynamicHoneyBadger` configured to start a new network as a single validator.
pub fn build_first_node(&self, our_id: N) -> Result<DynamicHoneyBadger<C, N>> {
pub fn build_first_node(&self, our_id: N) -> Result<(DynamicHoneyBadger<C, N>, Step<C, N>)> {
let mut rng = rand::thread_rng();
let sk_set = SecretKeySet::random(0, &mut rng)?;
let pk_set = sk_set.public_keys();
@ -74,7 +76,7 @@ where
let sk: SecretKey = rng.gen();
let pub_keys = once((our_id.clone(), sk.public_key())).collect();
let netinfo = NetworkInfo::new(our_id, sks, pk_set, sk, pub_keys);
Ok(self.build(netinfo))
self.build(netinfo)
}
/// Creates a new `DynamicHoneyBadger` configured to join the network at the epoch specified in
@ -93,22 +95,26 @@ where
join_plan.pub_keys,
);
let arc_netinfo = Arc::new(netinfo.clone());
let honey_badger = HoneyBadger::builder(arc_netinfo.clone())
let (honey_badger, hb_step) = HoneyBadger::builder(arc_netinfo.clone())
.max_future_epochs(self.max_future_epochs)
.build();
let start_epoch = join_plan.epoch;
let mut dhb = DynamicHoneyBadger {
netinfo,
max_future_epochs: self.max_future_epochs,
start_epoch: join_plan.epoch,
start_epoch,
vote_counter: VoteCounter::new(arc_netinfo, join_plan.epoch),
key_gen_msg_buffer: Vec::new(),
honey_badger,
key_gen_state: None,
incoming_queue: Vec::new(),
};
let step = match join_plan.change {
ChangeState::InProgress(ref change) => dhb.update_key_gen(join_plan.epoch, change)?,
ChangeState::None | ChangeState::Complete(..) => Step::default(),
let mut step = dhb.process_output(hb_step)?;
match join_plan.change {
ChangeState::InProgress(ref change) => {
step.extend(dhb.update_key_gen(join_plan.epoch, change)?)
}
ChangeState::None | ChangeState::Complete(..) => (),
};
Ok((dhb, step))
}

23
src/dynamic_honey_badger/dynamic_honey_badger.rs
View File

@ -169,10 +169,6 @@ where
sender_id: &N,
message: HbMessage<N>,
) -> Result<Step<C, N>> {
if !self.netinfo.is_node_validator(sender_id) {
info!("Unknown sender {:?} of message {:?}", sender_id, message);
return Err(ErrorKind::UnknownSender.into());
}
// Handle the message.
let step = self
.honey_badger
@ -226,7 +222,7 @@ where
}
/// Processes all pending batches output by Honey Badger.
fn process_output(
pub(super) fn process_output(
&mut self,
hb_step: honey_badger::Step<InternalContrib<C, N>, N>,
) -> Result<Step<C, N>> {
@ -275,7 +271,8 @@ where
// If DKG completed, apply the change, restart Honey Badger, and inform the user.
debug!("{:?} DKG for {:?} complete!", self.our_id(), kgs.change);
self.netinfo = kgs.key_gen.into_network_info()?;
self.restart_honey_badger(batch.epoch + 1);
let step_on_restart = self.restart_honey_badger(batch.epoch + 1)?;
step.extend(step_on_restart);
batch.set_change(ChangeState::Complete(kgs.change), &self.netinfo);
} else if let Some(change) = self.vote_counter.compute_winner().cloned() {
// If there is a new change, restart DKG. Inform the user about the current change.
@ -309,7 +306,7 @@ where
} {
info!("{:?} No-op change: {:?}", self.our_id(), change);
}
self.restart_honey_badger(epoch);
let mut step = self.restart_honey_badger(epoch)?;
// TODO: This needs to be the same as `num_faulty` will be in the _new_
// `NetworkInfo` if the change goes through. It would be safer to deduplicate.
let threshold = (pub_keys.len() - 1) / 3;
@ -318,22 +315,24 @@ where
let (key_gen, part) = SyncKeyGen::new(our_id, sk, pub_keys, threshold)?;
self.key_gen_state = Some(KeyGenState::new(key_gen, change.clone()));
if let Some(part) = part {
self.send_transaction(KeyGenMessage::Part(part))
} else {
Ok(Step::default())
let step_on_send = self.send_transaction(KeyGenMessage::Part(part))?;
step.extend(step_on_send);
}
Ok(step)
}
/// Starts a new `HoneyBadger` instance and resets the vote counter.
fn restart_honey_badger(&mut self, epoch: u64) {
fn restart_honey_badger(&mut self, epoch: u64) -> Result<Step<C, N>> {
self.start_epoch = epoch;
self.key_gen_msg_buffer.retain(|kg_msg| kg_msg.0 >= epoch);
let netinfo = Arc::new(self.netinfo.clone());
let counter = VoteCounter::new(netinfo.clone(), epoch);
mem::replace(&mut self.vote_counter, counter);
self.honey_badger = HoneyBadger::builder(netinfo)
let (hb, hb_step) = HoneyBadger::builder(netinfo)
.max_future_epochs(self.max_future_epochs)
.build();
self.honey_badger = hb;
self.process_output(hb_step)
}
/// Handles a `Part` message that was output by Honey Badger.

2
src/dynamic_honey_badger/error.rs
View File

@ -29,8 +29,6 @@ pub enum ErrorKind {
HandleHoneyBadgerMessageHoneyBadger(honey_badger::Error),
#[fail(display = "SyncKeyGen error: {}", _0)]
SyncKeyGen(sync_key_gen::Error),
#[fail(display = "Unknown sender")]
UnknownSender,
}
/// A dynamic honey badger error.

26
src/honey_badger/builder.rs
View File

@ -5,12 +5,15 @@ use std::sync::Arc;
use rand::Rand;
use serde::{Deserialize, Serialize};
use super::HoneyBadger;
use messaging::NetworkInfo;
use super::{HoneyBadger, Message, Step};
use messaging::{NetworkInfo, Target};
use traits::{Contribution, NodeIdT};
/// A Honey Badger builder, to configure the parameters and create new instances of `HoneyBadger`.
pub struct HoneyBadgerBuilder<C, N> {
pub struct HoneyBadgerBuilder<C, N>
where
N: Rand,
{
/// Shared network data.
netinfo: Arc<NetworkInfo<N>>,
/// The maximum number of future epochs for which we handle messages simultaneously.
@ -39,15 +42,24 @@ where
self
}
/// Creates a new Honey Badger instance.
pub fn build(&self) -> HoneyBadger<C, N> {
HoneyBadger {
/// Creates a new Honey Badger instance in epoch 0 and makes the initial `Step` on that
/// instance.
pub fn build(&self) -> (HoneyBadger<C, N>, Step<C, N>) {
let hb = HoneyBadger {
netinfo: self.netinfo.clone(),
epoch: 0,
has_input: false,
epochs: BTreeMap::new(),
max_future_epochs: self.max_future_epochs as u64,
incoming_queue: BTreeMap::new(),
}
remote_epochs: BTreeMap::new(),
};
let step = if self.netinfo.is_validator() {
// The first message in an epoch announces the epoch transition.
Target::All.message(Message::EpochStarted(0)).into()
} else {
Step::default()
};
(hb, step)
}
}

4
src/honey_badger/error.rs
View File

@ -19,8 +19,8 @@ pub enum ErrorKind {
HandleSubsetMessage(subset::Error),
#[fail(display = "Threshold decryption error: {}", _0)]
ThresholdDecryption(threshold_decryption::Error),
#[fail(display = "Unknown sender")]
UnknownSender,
#[fail(display = "HoneyBadger message sender is not a validator")]
SenderNotValidator,
}
/// A honey badger error.

43
src/honey_badger/honey_badger.rs
View File

@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
use super::epoch_state::EpochState;
use super::{Batch, Error, ErrorKind, HoneyBadgerBuilder, Message, MessageContent, Result};
use messaging::{self, DistAlgorithm, NetworkInfo};
use messaging::{self, DistAlgorithm, NetworkInfo, Target};
use traits::{Contribution, NodeIdT};
/// An instance of the Honey Badger Byzantine fault tolerant consensus algorithm.
@ -26,6 +26,8 @@ pub struct HoneyBadger<C, N: Rand> {
pub(super) max_future_epochs: u64,
/// Messages for future epochs that couldn't be handled yet.
pub(super) incoming_queue: BTreeMap<u64, Vec<(N, MessageContent<N>)>>,
/// Known current epochs of remote nodes.
pub(super) remote_epochs: BTreeMap<N, u64>,
}
pub type Step<C, N> = messaging::Step<HoneyBadger<C, N>>;
@ -86,10 +88,27 @@ where
/// Handles a message received from `sender_id`.
fn handle_message(&mut self, sender_id: &N, message: Message<N>) -> Result<Step<C, N>> {
if !self.netinfo.is_node_validator(sender_id) {
return Err(ErrorKind::UnknownSender.into());
match message {
Message::HoneyBadger { epoch, content } => {
if !self.netinfo.is_node_validator(sender_id) {
return Err(ErrorKind::SenderNotValidator.into());
}
self.handle_honey_badger_message(sender_id, epoch, content)
}
Message::EpochStarted(epoch) => {
self.handle_epoch_started(sender_id, epoch);
Ok(Step::default())
}
}
let Message { epoch, content } = message;
}
/// Handles a Honey Badger algorithm message in a given epoch.
fn handle_honey_badger_message(
&mut self,
sender_id: &N,
epoch: u64,
content: MessageContent<N>,
) -> Result<Step<C, N>> {
if epoch > self.epoch + self.max_future_epochs {
// Postpone handling this message.
self.incoming_queue
@ -106,6 +125,17 @@ where
Ok(Step::default())
}
/// Handles an epoch start announcement.
fn handle_epoch_started(&mut self, sender_id: &N, epoch: u64) {
self.remote_epochs
.entry(sender_id.clone())
.and_modify(|e| {
if *e < epoch {
*e = epoch;
}
}).or_insert(epoch);
}
/// Returns `true` if input for the current epoch has already been provided.
pub fn has_input(&self) -> bool {
!self.netinfo.is_validator() || self.has_input
@ -126,7 +156,10 @@ where
self.epoch += 1;
self.has_input = false;
let max_epoch = self.epoch + self.max_future_epochs;
let mut step = Step::default();
// The first message in an epoch announces the epoch transition.
let mut step: Step<C, N> = Target::All
.message(Message::EpochStarted(self.epoch))
.into();
if let Some(messages) = self.incoming_queue.remove(&max_epoch) {
let epoch_state = self.epoch_state_mut(max_epoch)?;
for (sender_id, content) in messages {

24
src/honey_badger/message.rs
View File

@ -4,7 +4,7 @@ use subset;
use threshold_decryption;
/// The content of a `HoneyBadger` message. It should be further annotated with an epoch.
#[derive(Clone, Debug, Deserialize, Rand, Serialize)]
#[derive(Clone, Debug, Deserialize, PartialEq, Rand, Serialize)]
pub enum MessageContent<N: Rand> {
/// A message belonging to the subset algorithm in the given epoch.
Subset(subset::Message<N>),
@ -17,7 +17,7 @@ pub enum MessageContent<N: Rand> {
impl<N: Rand> MessageContent<N> {
pub fn with_epoch(self, epoch: u64) -> Message<N> {
Message {
Message::HoneyBadger {
epoch,
content: self,
}
@ -26,13 +26,25 @@ impl<N: Rand> MessageContent<N> {
/// A message sent to or received from another node's Honey Badger instance.
#[derive(Clone, Debug, Deserialize, Rand, Serialize)]
pub struct Message<N: Rand> {
pub(super) epoch: u64,
pub(super) content: MessageContent<N>,
pub enum Message<N: Rand> {
/// A Honey Badger algorithm message annotated with the epoch number.
HoneyBadger {
epoch: u64,
content: MessageContent<N>,
},
/// A Honey Badger participant uses this message to announce its transition to the given
/// epoch. This message informs the recipients that this participant now accepts messages for
/// `max_future_epochs + 1` epochs counting from the given one, and drops any incoming messages
/// from earlier epochs.
EpochStarted(u64),
}
impl<N: Rand> Message<N> {
/// Returns the epoch from which the message originated.
pub fn epoch(&self) -> u64 {
self.epoch
match *self {
Message::HoneyBadger { epoch, .. } => epoch,
Message::EpochStarted(epoch) => epoch,
}
}
}

2
src/subset.rs
View File

@ -62,7 +62,7 @@ pub type Result<T> = ::std::result::Result<T, Error>;
type ProposedValue = Vec<u8>;
/// Message from Subset to remote nodes.
#[derive(Serialize, Deserialize, Clone, Debug, Rand)]
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Rand)]
pub enum Message<N: Rand> {
/// A message for the broadcast algorithm concerning the set element proposed by the given node.
Broadcast(N, broadcast::Message),

11
tests/dynamic_honey_badger.rs
View File

@ -23,7 +23,7 @@ use std::sync::Arc;
use itertools::Itertools;
use rand::Rng;
use hbbft::dynamic_honey_badger::{Batch, Change, ChangeState, DynamicHoneyBadger, Input};
use hbbft::dynamic_honey_badger::{Batch, Change, ChangeState, DynamicHoneyBadger, Input, Step};
use hbbft::messaging::NetworkInfo;
use hbbft::transaction_queue::TransactionQueue;
@ -122,8 +122,10 @@ where
// Allow passing `netinfo` by value. `TestNetwork` expects this function signature.
#[cfg_attr(feature = "cargo-clippy", allow(needless_pass_by_value))]
fn new_dynamic_hb(netinfo: Arc<NetworkInfo<NodeId>>) -> UsizeDhb {
DynamicHoneyBadger::builder().build((*netinfo).clone())
fn new_dynamic_hb(netinfo: Arc<NetworkInfo<NodeId>>) -> (UsizeDhb, Step<Vec<usize>, NodeId>) {
DynamicHoneyBadger::builder()
.build((*netinfo).clone())
.expect("`new_dynamic_hb` failed")
}
fn test_dynamic_honey_badger_different_sizes<A, F>(new_adversary: F, num_txs: usize)
@ -145,7 +147,8 @@ where
num_good_nodes, num_adv_nodes
);
let adversary = |adv_nodes| new_adversary(num_good_nodes, num_adv_nodes, adv_nodes);
let network = TestNetwork::new(num_good_nodes, num_adv_nodes, adversary, new_dynamic_hb);
let network =
TestNetwork::new_with_step(num_good_nodes, num_adv_nodes, adversary, new_dynamic_hb);
test_dynamic_honey_badger(network, num_txs);
}
}

9
tests/honey_badger.rs
View File

@ -23,7 +23,7 @@ use std::sync::Arc;
use itertools::Itertools;
use rand::Rng;
use hbbft::honey_badger::{self, Batch, HoneyBadger, MessageContent};
use hbbft::honey_badger::{self, Batch, HoneyBadger, MessageContent, Step};
use hbbft::messaging::{NetworkInfo, Target, TargetedMessage};
use hbbft::threshold_decryption;
use hbbft::transaction_queue::TransactionQueue;
@ -185,7 +185,9 @@ where
}
}
fn new_honey_badger(netinfo: Arc<NetworkInfo<NodeId>>) -> UsizeHoneyBadger {
fn new_honey_badger(
netinfo: Arc<NetworkInfo<NodeId>>,
) -> (UsizeHoneyBadger, Step<Vec<usize>, NodeId>) {
HoneyBadger::builder(netinfo).build()
}
@ -207,7 +209,8 @@ where
num_good_nodes, num_adv_nodes
);
let adversary = |adv_nodes| new_adversary(num_good_nodes, num_adv_nodes, adv_nodes);
let network = TestNetwork::new(num_good_nodes, num_adv_nodes, adversary, new_honey_badger);
let network =
TestNetwork::new_with_step(num_good_nodes, num_adv_nodes, adversary, new_honey_badger);
test_honey_badger(network, num_txs);
}
}

4
tests/net_dynamic_hb.rs
View File

@ -68,9 +68,9 @@ fn do_drop_and_readd(
let mut net = NetBuilder::new(0..total)
.num_faulty(num_faulty)
.message_limit(200_000) // Limited to 200k messages for now.
.using(move |node| {
.using_step(move |node| {
println!("Constructing new dynamic honey badger node #{}", node.id);
DynamicHoneyBadger::builder().build(node.netinfo)
DynamicHoneyBadger::builder().build(node.netinfo).expect("cannot build instance")
}).build()
.expect("could not construct test network");

9
tests/queueing_honey_badger.rs
View File

@ -107,8 +107,13 @@ where
fn new_queueing_hb(
netinfo: Arc<NetworkInfo<NodeId>>,
) -> (QueueingHoneyBadger<usize, NodeId>, Step<usize, NodeId>) {
let dyn_hb = DynamicHoneyBadger::builder().build((*netinfo).clone());
QueueingHoneyBadger::builder(dyn_hb).batch_size(3).build()
let (dhb, dhb_step) = DynamicHoneyBadger::builder()
.build((*netinfo).clone())
.expect("`new_queueing_hb` failed");
let (qhb, qhb_step) = QueueingHoneyBadger::builder(dhb).batch_size(3).build();
let mut step = dhb_step.convert();
step.extend(qhb_step);
(qhb, step)
}
fn test_queueing_honey_badger_different_sizes<A, F>(new_adversary: F, num_txs: usize)