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

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

This reverts commit b649dc6268.
This commit is contained in:
Vladimir Komendantskiy 2018-10-09 15:07:56 +01:00 committed by Andreas Fackler
parent 7002dad54c
commit af05c44659
13 changed files with 59 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
examples/simulation.rs
View File

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

34
src/dynamic_honey_badger/builder.rs
View File

@ -71,10 +71,7 @@ where
}
/// Creates a new Dynamic Honey Badger instance with an empty buffer.
pub fn build(
&mut self,
netinfo: NetworkInfo<N>,
) -> Result<(DynamicHoneyBadger<C, N>, Step<C, N>)> {
pub fn build(&mut self, netinfo: NetworkInfo<N>) -> DynamicHoneyBadger<C, N> {
let DynamicHoneyBadgerBuilder {
max_future_epochs,
rng,
@ -83,12 +80,12 @@ where
} = self;
let max_future_epochs = *max_future_epochs;
let arc_netinfo = Arc::new(netinfo.clone());
let (honey_badger, hb_step) = HoneyBadger::builder(arc_netinfo.clone())
let honey_badger = HoneyBadger::builder(arc_netinfo.clone())
.max_future_epochs(max_future_epochs)
.rng(rng.sub_rng())
.subset_handling_strategy(subset_handling_strategy.clone())
.build();
let mut dhb = DynamicHoneyBadger {
DynamicHoneyBadger {
netinfo,
max_future_epochs,
start_epoch: 0,
@ -98,23 +95,18 @@ where
key_gen_state: None,
incoming_queue: Vec::new(),
rng: Box::new(rng.sub_rng()),
};
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(
&mut self,
our_id: N,
) -> Result<(DynamicHoneyBadger<C, N>, Step<C, N>)> {
pub fn build_first_node(&mut self, our_id: N) -> Result<DynamicHoneyBadger<C, N>> {
let sk_set = SecretKeySet::random(0, &mut self.rng)?;
let pk_set = sk_set.public_keys();
let sks = sk_set.secret_key_share(0)?;
let sk: SecretKey = self.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);
self.build(netinfo)
Ok(self.build(netinfo))
}
/// Creates a new `DynamicHoneyBadger` configured to join the network at the epoch specified in
@ -133,14 +125,13 @@ where
join_plan.pub_keys,
);
let arc_netinfo = Arc::new(netinfo.clone());
let (honey_badger, hb_step) = HoneyBadger::builder(arc_netinfo.clone())
let honey_badger = 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,
start_epoch: join_plan.epoch,
vote_counter: VoteCounter::new(arc_netinfo, join_plan.epoch),
key_gen_msg_buffer: Vec::new(),
honey_badger,
@ -148,12 +139,9 @@ where
incoming_queue: Vec::new(),
rng: Box::new(self.rng.sub_rng()),
};
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(..) => (),
let step = match join_plan.change {
ChangeState::InProgress(ref change) => dhb.update_key_gen(join_plan.epoch, change)?,
ChangeState::None | ChangeState::Complete(..) => Step::default(),
};
Ok((dhb, step))
}

23
src/dynamic_honey_badger/dynamic_honey_badger.rs
View File

@ -193,6 +193,10 @@ 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
@ -246,7 +250,7 @@ where
}
/// Processes all pending batches output by Honey Badger.
pub(super) fn process_output(
fn process_output(
&mut self,
hb_step: honey_badger::Step<InternalContrib<C, N>, N>,
) -> Result<Step<C, N>> {
@ -295,8 +299,7 @@ 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()?;
let step_on_restart = self.restart_honey_badger(batch.epoch + 1)?;
step.extend(step_on_restart);
self.restart_honey_badger(batch.epoch + 1);
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.
@ -330,7 +333,7 @@ where
} {
info!("{:?} No-op change: {:?}", self.our_id(), change);
}
let mut step = self.restart_honey_badger(epoch)?;
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;
@ -339,25 +342,23 @@ where
let (key_gen, part) = SyncKeyGen::new(&mut self.rng, our_id, sk, pub_keys, threshold)?;
self.key_gen_state = Some(KeyGenState::new(key_gen, change.clone()));
if let Some(part) = part {
let step_on_send = self.send_transaction(KeyGenMessage::Part(part))?;
step.extend(step_on_send);
self.send_transaction(KeyGenMessage::Part(part))
} else {
Ok(Step::default())
}
Ok(step)
}
/// Starts a new `HoneyBadger` instance and resets the vote counter.
fn restart_honey_badger(&mut self, epoch: u64) -> Result<Step<C, N>> {
fn restart_honey_badger(&mut self, epoch: u64) {
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);
let (hb, hb_step) = HoneyBadger::builder(netinfo)
self.honey_badger = HoneyBadger::builder(netinfo)
.max_future_epochs(self.max_future_epochs)
.rng(self.rng.sub_rng())
.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,6 +29,8 @@ 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,17 +5,14 @@ use std::sync::Arc;
use rand::{self, Rand, Rng};
use serde::{Deserialize, Serialize};
use super::{HoneyBadger, Message, Step};
use super::HoneyBadger;
use honey_badger::SubsetHandlingStrategy;
use messaging::{NetworkInfo, Target};
use messaging::NetworkInfo;
use traits::{Contribution, NodeIdT};
use util::SubRng;
/// A Honey Badger builder, to configure the parameters and create new instances of `HoneyBadger`.
pub struct HoneyBadgerBuilder<C, N>
where
N: Rand,
{
pub struct HoneyBadgerBuilder<C, N> {
/// Shared network data.
netinfo: Arc<NetworkInfo<N>>,
/// The maximum number of future epochs for which we handle messages simultaneously.
@ -65,26 +62,17 @@ where
self
}
/// Creates a new Honey Badger instance in epoch 0 and makes the initial `Step` on that
/// instance.
pub fn build(&mut self) -> (HoneyBadger<C, N>, Step<C, N>) {
let hb = HoneyBadger {
/// Creates a new Honey Badger instance.
pub fn build(&mut self) -> HoneyBadger<C, N> {
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(),
rng: Box::new(self.rng.sub_rng()),
subset_handling_strategy: self.subset_handling_strategy.clone(),
};
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 = "HoneyBadger message sender is not a validator")]
SenderNotValidator,
#[fail(display = "Unknown sender")]
UnknownSender,
}
/// A honey badger error.

44
src/honey_badger/honey_badger.rs
View File

@ -9,7 +9,7 @@ use serde::{Deserialize, Serialize};
use super::epoch_state::EpochState;
use super::{Batch, Error, ErrorKind, HoneyBadgerBuilder, Message, MessageContent, Result};
use messaging::{self, DistAlgorithm, NetworkInfo, Target};
use messaging::{self, DistAlgorithm, NetworkInfo};
use traits::{Contribution, NodeIdT};
pub use super::epoch_state::SubsetHandlingStrategy;
@ -28,8 +28,6 @@ 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>,
/// A random number generator used for secret key generation.
// Boxed to avoid overloading the algorithm's type with more generics.
pub(super) rng: Box<dyn Rng + Send + Sync>,
@ -50,7 +48,6 @@ where
.field("epochs", &self.epochs)
.field("max_future_epochs", &self.max_future_epochs)
.field("incoming_queue", &self.incoming_queue)
.field("remote_epochs", &self.remote_epochs)
.field("rng", &"<RNG>")
.finish()
}
@ -118,27 +115,10 @@ where
/// Handles a message received from `sender_id`.
fn handle_message(&mut self, sender_id: &N, message: Message<N>) -> Result<Step<C, N>> {
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())
}
if !self.netinfo.is_node_validator(sender_id) {
return Err(ErrorKind::UnknownSender.into());
}
}
/// 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>> {
let Message { epoch, content } = message;
if epoch > self.epoch + self.max_future_epochs {
// Postpone handling this message.
self.incoming_queue
@ -155,17 +135,6 @@ 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
@ -186,10 +155,7 @@ where
self.epoch += 1;
self.has_input = false;
let max_epoch = self.epoch + self.max_future_epochs;
// The first message in an epoch announces the epoch transition.
let mut step: Step<C, N> = Target::All
.message(Message::EpochStarted(self.epoch))
.into();
let mut step = Step::default();
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, PartialEq, Rand, Serialize)]
#[derive(Clone, Debug, Deserialize, 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::HoneyBadger {
Message {
epoch,
content: self,
}
@ -26,25 +26,13 @@ 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 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),
pub struct Message<N: Rand> {
pub(super) epoch: u64,
pub(super) content: MessageContent<N>,
}
impl<N: Rand> Message<N> {
/// Returns the epoch from which the message originated.
pub fn epoch(&self) -> u64 {
match *self {
Message::HoneyBadger { epoch, .. } => epoch,
Message::EpochStarted(epoch) => epoch,
}
self.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, PartialEq, Rand)]
#[derive(Serialize, Deserialize, Clone, Debug, 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

@ -22,7 +22,7 @@ use std::sync::Arc;
use itertools::Itertools;
use rand::Rng;
use hbbft::dynamic_honey_badger::{Batch, Change, ChangeState, DynamicHoneyBadger, Input, Step};
use hbbft::dynamic_honey_badger::{Batch, Change, ChangeState, DynamicHoneyBadger, Input};
use hbbft::messaging::NetworkInfo;
use hbbft::transaction_queue::TransactionQueue;
@ -121,10 +121,8 @@ 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, Step<Vec<usize>, NodeId>) {
DynamicHoneyBadger::builder()
.build((*netinfo).clone())
.expect("`new_dynamic_hb` failed")
fn new_dynamic_hb(netinfo: Arc<NetworkInfo<NodeId>>) -> UsizeDhb {
DynamicHoneyBadger::builder().build((*netinfo).clone())
}
fn test_dynamic_honey_badger_different_sizes<A, F>(new_adversary: F, num_txs: usize)
@ -146,8 +144,7 @@ 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_with_step(num_good_nodes, num_adv_nodes, adversary, new_dynamic_hb);
let network = TestNetwork::new(num_good_nodes, num_adv_nodes, adversary, new_dynamic_hb);
test_dynamic_honey_badger(network, num_txs);
}
}

9
tests/honey_badger.rs
View File

@ -22,7 +22,7 @@ use std::sync::Arc;
use itertools::Itertools;
use rand::Rng;
use hbbft::honey_badger::{self, Batch, HoneyBadger, MessageContent, Step};
use hbbft::honey_badger::{self, Batch, HoneyBadger, MessageContent};
use hbbft::messaging::{NetworkInfo, Target, TargetedMessage};
use hbbft::threshold_decryption;
use hbbft::transaction_queue::TransactionQueue;
@ -184,9 +184,7 @@ where
}
}
fn new_honey_badger(
netinfo: Arc<NetworkInfo<NodeId>>,
) -> (UsizeHoneyBadger, Step<Vec<usize>, NodeId>) {
fn new_honey_badger(netinfo: Arc<NetworkInfo<NodeId>>) -> UsizeHoneyBadger {
HoneyBadger::builder(netinfo).build()
}
@ -208,8 +206,7 @@ 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_with_step(num_good_nodes, num_adv_nodes, adversary, new_honey_badger);
let network = TestNetwork::new(num_good_nodes, num_adv_nodes, adversary, new_honey_badger);
test_honey_badger(network, num_txs);
}
}

3
tests/net_dynamic_hb.rs
View File

@ -101,12 +101,11 @@ fn do_drop_and_readd(cfg: TestConfig) {
.time_limit(time::Duration::from_secs(30 * cfg.dimension.size() as u64))
// Ensure runs are reproducible.
.rng(rng.gen::<TestRng>())
.using_step(move |node| {
.using(move |node| {
println!("Constructing new dynamic honey badger node #{}", node.id);
DynamicHoneyBadger::builder()
.rng(node.rng)
.build(node.netinfo)
.expect("cannot build instance")
}).build()
.expect("could not construct test network");

9
tests/queueing_honey_badger.rs
View File

@ -106,13 +106,8 @@ where
fn new_queueing_hb(
netinfo: Arc<NetworkInfo<NodeId>>,
) -> (QueueingHoneyBadger<usize, NodeId>, Step<usize, NodeId>) {
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)
let dyn_hb = DynamicHoneyBadger::builder().build((*netinfo).clone());
QueueingHoneyBadger::builder(dyn_hb).batch_size(3).build()
}
fn test_queueing_honey_badger_different_sizes<A, F>(new_adversary: F, num_txs: usize)