From ab5252c750ef078c49879c737f4784ef1095160b Mon Sep 17 00:00:00 2001 From: Greg Fitzgerald Date: Mon, 26 Feb 2018 14:39:01 -0700 Subject: [PATCH 1/6] Move entry verification out of Entry impl --- src/log.rs | 60 +++++++++++++++++++++++++++--------------------------- 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/src/log.rs b/src/log.rs index 752f305d99..20210812c1 100644 --- a/src/log.rs +++ b/src/log.rs @@ -61,30 +61,6 @@ impl Entry { event: Event::Tick, } } - - /// Verifies self.end_hash is the result of hashing a 'start_hash' 'self.num_hashes' times. - /// If the event is not a Tick, then hash that as well. - pub fn verify(self: &Self, start_hash: &Sha256Hash) -> bool { - if let Event::Claim { key, data, sig } = self.event { - if !verify_signature(&key, &data, &sig) { - return false; - } - } - if let Event::Transaction { - from, - to, - data, - sig, - } = self.event - { - let mut sign_data = data.to_vec(); - sign_data.extend_from_slice(&to); - if !verify_signature(&from, &sign_data, &sig) { - return false; - } - } - self.end_hash == next_hash(start_hash, self.num_hashes, &self.event) - } } // Return a new ED25519 keypair @@ -192,19 +168,43 @@ pub fn next_tick(start_hash: &Sha256Hash, num_hashes: u64) -> Entry { next_entry(start_hash, num_hashes, Event::Tick) } +/// Verifies self.end_hash is the result of hashing a 'start_hash' 'self.num_hashes' times. +/// If the event is not a Tick, then hash that as well. +pub fn verify_entry(entry: &Entry, start_hash: &Sha256Hash) -> bool { + if let Event::Claim { key, data, sig } = entry.event { + if !verify_signature(&key, &data, &sig) { + return false; + } + } + if let Event::Transaction { + from, + to, + data, + sig, + } = entry.event + { + let mut sign_data = data.to_vec(); + sign_data.extend_from_slice(&to); + if !verify_signature(&from, &sign_data, &sig) { + return false; + } + } + entry.end_hash == next_hash(start_hash, entry.num_hashes, &entry.event) +} + /// Verifies the hashes and counts of a slice of events are all consistent. pub fn verify_slice(events: &[Entry], start_hash: &Sha256Hash) -> bool { use rayon::prelude::*; let genesis = [Entry::new_tick(Default::default(), start_hash)]; let event_pairs = genesis.par_iter().chain(events).zip(events); - event_pairs.all(|(x0, x1)| x1.verify(&x0.end_hash)) + event_pairs.all(|(x0, x1)| verify_entry(&x1, &x0.end_hash)) } /// Verifies the hashes and events serially. Exists only for reference. pub fn verify_slice_seq(events: &[Entry], start_hash: &Sha256Hash) -> bool { let genesis = [Entry::new_tick(0, start_hash)]; let mut event_pairs = genesis.iter().chain(events).zip(events); - event_pairs.all(|(x0, x1)| x1.verify(&x0.end_hash)) + event_pairs.all(|(x0, x1)| verify_entry(&x1, &x0.end_hash)) } /// Verify a signed message with the given public key. @@ -243,10 +243,10 @@ mod tests { fn test_event_verify() { let zero = Sha256Hash::default(); let one = hash(&zero); - assert!(Entry::new_tick(0, &zero).verify(&zero)); // base case - assert!(!Entry::new_tick(0, &zero).verify(&one)); // base case, bad - assert!(next_tick(&zero, 1).verify(&zero)); // inductive step - assert!(!next_tick(&zero, 1).verify(&one)); // inductive step, bad + assert!(verify_entry(&Entry::new_tick(0, &zero), &zero)); // base case + assert!(!verify_entry(&Entry::new_tick(0, &zero), &one)); // base case, bad + assert!(verify_entry(&next_tick(&zero, 1), &zero)); // inductive step + assert!(!verify_entry(&next_tick(&zero, 1), &one)); // inductive step, bad } #[test] From 97449cee43518c7537f4ea15412aec322e9d8c8f Mon Sep 17 00:00:00 2001 From: Greg Fitzgerald Date: Mon, 26 Feb 2018 15:31:01 -0700 Subject: [PATCH 2/6] Allow events to hold any kind of data --- src/bin/demo.rs | 2 +- src/historian.rs | 8 ++++---- src/log.rs | 40 ++++++++++++++++++++++++++++------------ 3 files changed, 33 insertions(+), 17 deletions(-) diff --git a/src/bin/demo.rs b/src/bin/demo.rs index f1b8b5b822..b158262556 100644 --- a/src/bin/demo.rs +++ b/src/bin/demo.rs @@ -6,7 +6,7 @@ use std::thread::sleep; use std::time::Duration; use std::sync::mpsc::SendError; -fn create_log(hist: &Historian) -> Result<(), SendError> { +fn create_log(hist: &Historian) -> Result<(), SendError>> { sleep(Duration::from_millis(15)); let data = Sha256Hash::default(); hist.sender.send(Event::Discovery { data })?; diff --git a/src/historian.rs b/src/historian.rs index d01c1b2231..52dccda910 100644 --- a/src/historian.rs +++ b/src/historian.rs @@ -11,7 +11,7 @@ use std::time::{Duration, SystemTime}; use log::{hash, hash_event, Entry, Event, Sha256Hash}; pub struct Historian { - pub sender: Sender, + pub sender: Sender>, pub receiver: Receiver, pub thread_hdl: JoinHandle<(Entry, ExitReason)>, } @@ -25,7 +25,7 @@ fn log_event( sender: &Sender, num_hashes: &mut u64, end_hash: &mut Sha256Hash, - event: Event, + event: Event, ) -> Result<(), (Entry, ExitReason)> { *end_hash = hash_event(end_hash, &event); let entry = Entry { @@ -41,7 +41,7 @@ fn log_event( } fn log_events( - receiver: &Receiver, + receiver: &Receiver>, sender: &Sender, num_hashes: &mut u64, end_hash: &mut Sha256Hash, @@ -82,7 +82,7 @@ fn log_events( pub fn create_logger( start_hash: Sha256Hash, ms_per_tick: Option, - receiver: Receiver, + receiver: Receiver>, sender: Sender, ) -> JoinHandle<(Entry, ExitReason)> { use std::thread; diff --git a/src/log.rs b/src/log.rs index 20210812c1..0739f51ea3 100644 --- a/src/log.rs +++ b/src/log.rs @@ -24,7 +24,7 @@ pub type Signature = GenericArray; pub struct Entry { pub num_hashes: u64, pub end_hash: Sha256Hash, - pub event: Event, + pub event: Event, } /// When 'event' is Tick, the event represents a simple clock tick, and exists for the @@ -33,20 +33,20 @@ pub struct Entry { /// a hash alongside the tick, each tick and be verified in parallel using the 'end_hash' /// of the preceding tick to seed its hashing. #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] -pub enum Event { +pub enum Event { Tick, Discovery { - data: Sha256Hash, + data: T, }, Claim { key: PublicKey, - data: Sha256Hash, + data: T, sig: Signature, }, Transaction { from: PublicKey, to: PublicKey, - data: Sha256Hash, + data: T, sig: Signature, }, } @@ -73,7 +73,7 @@ pub fn generate_keypair() -> Ed25519KeyPair { } /// Return a Claim Event for the given hash and key-pair. -pub fn sign_hash(data: &Sha256Hash, keypair: &Ed25519KeyPair) -> Event { +pub fn sign_hash(data: &Sha256Hash, keypair: &Ed25519KeyPair) -> Event { let sig = keypair.sign(data); let peer_public_key_bytes = keypair.public_key_bytes(); let sig_bytes = sig.as_ref(); @@ -85,7 +85,11 @@ pub fn sign_hash(data: &Sha256Hash, keypair: &Ed25519KeyPair) -> Event { } /// Return a Transaction Event that indicates a transfer in ownership of the given hash. -pub fn transfer_hash(data: &Sha256Hash, keypair: &Ed25519KeyPair, to: PublicKey) -> Event { +pub fn transfer_hash( + data: &Sha256Hash, + keypair: &Ed25519KeyPair, + to: PublicKey, +) -> Event { let from_public_key_bytes = keypair.public_key_bytes(); let mut sign_data = data.to_vec(); sign_data.extend_from_slice(&to); @@ -115,7 +119,7 @@ pub fn extend_and_hash(end_hash: &Sha256Hash, ty: u8, val: &[u8]) -> Sha256Hash hash(&hash_data) } -pub fn hash_event(end_hash: &Sha256Hash, event: &Event) -> Sha256Hash { +pub fn hash_event(end_hash: &Sha256Hash, event: &Event) -> Sha256Hash { match *event { Event::Tick => *end_hash, Event::Discovery { data } => extend_and_hash(end_hash, 1, &data), @@ -140,7 +144,11 @@ pub fn hash_event(end_hash: &Sha256Hash, event: &Event) -> Sha256Hash { } } -pub fn next_hash(start_hash: &Sha256Hash, num_hashes: u64, event: &Event) -> Sha256Hash { +pub fn next_hash( + start_hash: &Sha256Hash, + num_hashes: u64, + event: &Event, +) -> Sha256Hash { let mut end_hash = *start_hash; for _ in 0..num_hashes { end_hash = hash(&end_hash); @@ -149,7 +157,7 @@ pub fn next_hash(start_hash: &Sha256Hash, num_hashes: u64, event: &Event) -> Sha } /// Creates the next Tick Entry 'num_hashes' after 'start_hash'. -pub fn next_entry(start_hash: &Sha256Hash, num_hashes: u64, event: Event) -> Entry { +pub fn next_entry(start_hash: &Sha256Hash, num_hashes: u64, event: Event) -> Entry { Entry { num_hashes, end_hash: next_hash(start_hash, num_hashes, &event), @@ -157,7 +165,11 @@ pub fn next_entry(start_hash: &Sha256Hash, num_hashes: u64, event: Event) -> Ent } } -pub fn next_entry_mut(start_hash: &mut Sha256Hash, num_hashes: u64, event: Event) -> Entry { +pub fn next_entry_mut( + start_hash: &mut Sha256Hash, + num_hashes: u64, + event: Event, +) -> Entry { let entry = next_entry(start_hash, num_hashes, event); *start_hash = entry.end_hash; entry @@ -217,7 +229,11 @@ pub fn verify_signature(peer_public_key_bytes: &[u8], msg_bytes: &[u8], sig_byte signature::verify(&signature::ED25519, peer_public_key, msg, sig).is_ok() } -pub fn create_entries(start_hash: &Sha256Hash, num_hashes: u64, events: &[Event]) -> Vec { +pub fn create_entries( + start_hash: &Sha256Hash, + num_hashes: u64, + events: &[Event], +) -> Vec { let mut end_hash = *start_hash; events .iter() From 8b0b8efbcb6b50f81d8a98b896b06f1ae47798f4 Mon Sep 17 00:00:00 2001 From: Greg Fitzgerald Date: Mon, 26 Feb 2018 15:37:33 -0700 Subject: [PATCH 3/6] Allow Entry to hold events of any kind of data --- src/bin/demo.rs | 2 +- src/historian.rs | 18 +++++++++--------- src/log.rs | 32 ++++++++++++++++++++------------ 3 files changed, 30 insertions(+), 22 deletions(-) diff --git a/src/bin/demo.rs b/src/bin/demo.rs index b158262556..d29049f512 100644 --- a/src/bin/demo.rs +++ b/src/bin/demo.rs @@ -19,7 +19,7 @@ fn main() { let hist = Historian::new(&seed, Some(10)); create_log(&hist).expect("send error"); drop(hist.sender); - let entries: Vec = hist.receiver.iter().collect(); + let entries: Vec> = hist.receiver.iter().collect(); for entry in &entries { println!("{:?}", entry); } diff --git a/src/historian.rs b/src/historian.rs index 52dccda910..358d7f8821 100644 --- a/src/historian.rs +++ b/src/historian.rs @@ -12,8 +12,8 @@ use log::{hash, hash_event, Entry, Event, Sha256Hash}; pub struct Historian { pub sender: Sender>, - pub receiver: Receiver, - pub thread_hdl: JoinHandle<(Entry, ExitReason)>, + pub receiver: Receiver>, + pub thread_hdl: JoinHandle<(Entry, ExitReason)>, } #[derive(Debug, PartialEq, Eq)] @@ -22,11 +22,11 @@ pub enum ExitReason { SendDisconnected, } fn log_event( - sender: &Sender, + sender: &Sender>, num_hashes: &mut u64, end_hash: &mut Sha256Hash, event: Event, -) -> Result<(), (Entry, ExitReason)> { +) -> Result<(), (Entry, ExitReason)> { *end_hash = hash_event(end_hash, &event); let entry = Entry { end_hash: *end_hash, @@ -42,13 +42,13 @@ fn log_event( fn log_events( receiver: &Receiver>, - sender: &Sender, + sender: &Sender>, num_hashes: &mut u64, end_hash: &mut Sha256Hash, epoch: SystemTime, num_ticks: &mut u64, ms_per_tick: Option, -) -> Result<(), (Entry, ExitReason)> { +) -> Result<(), (Entry, ExitReason)> { use std::sync::mpsc::TryRecvError; loop { if let Some(ms) = ms_per_tick { @@ -83,8 +83,8 @@ pub fn create_logger( start_hash: Sha256Hash, ms_per_tick: Option, receiver: Receiver>, - sender: Sender, -) -> JoinHandle<(Entry, ExitReason)> { + sender: Sender>, +) -> JoinHandle<(Entry, ExitReason)> { use std::thread; thread::spawn(move || { let mut end_hash = start_hash; @@ -179,7 +179,7 @@ mod tests { ExitReason::RecvDisconnected ); - let entries: Vec = hist.receiver.iter().collect(); + let entries: Vec> = hist.receiver.iter().collect(); assert!(entries.len() > 1); assert!(verify_slice(&entries, &zero)); } diff --git a/src/log.rs b/src/log.rs index 0739f51ea3..d20457125f 100644 --- a/src/log.rs +++ b/src/log.rs @@ -21,10 +21,10 @@ pub type PublicKey = GenericArray; pub type Signature = GenericArray; #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)] -pub struct Entry { +pub struct Entry { pub num_hashes: u64, pub end_hash: Sha256Hash, - pub event: Event, + pub event: Event, } /// When 'event' is Tick, the event represents a simple clock tick, and exists for the @@ -51,7 +51,7 @@ pub enum Event { }, } -impl Entry { +impl Entry { /// Creates a Entry from the number of hashes 'num_hashes' since the previous event /// and that resulting 'end_hash'. pub fn new_tick(num_hashes: u64, end_hash: &Sha256Hash) -> Self { @@ -157,7 +157,11 @@ pub fn next_hash( } /// Creates the next Tick Entry 'num_hashes' after 'start_hash'. -pub fn next_entry(start_hash: &Sha256Hash, num_hashes: u64, event: Event) -> Entry { +pub fn next_entry( + start_hash: &Sha256Hash, + num_hashes: u64, + event: Event, +) -> Entry { Entry { num_hashes, end_hash: next_hash(start_hash, num_hashes, &event), @@ -169,20 +173,20 @@ pub fn next_entry_mut( start_hash: &mut Sha256Hash, num_hashes: u64, event: Event, -) -> Entry { +) -> Entry { let entry = next_entry(start_hash, num_hashes, event); *start_hash = entry.end_hash; entry } /// Creates the next Tick Entry 'num_hashes' after 'start_hash'. -pub fn next_tick(start_hash: &Sha256Hash, num_hashes: u64) -> Entry { +pub fn next_tick(start_hash: &Sha256Hash, num_hashes: u64) -> Entry { next_entry(start_hash, num_hashes, Event::Tick) } /// Verifies self.end_hash is the result of hashing a 'start_hash' 'self.num_hashes' times. /// If the event is not a Tick, then hash that as well. -pub fn verify_entry(entry: &Entry, start_hash: &Sha256Hash) -> bool { +pub fn verify_entry(entry: &Entry, start_hash: &Sha256Hash) -> bool { if let Event::Claim { key, data, sig } = entry.event { if !verify_signature(&key, &data, &sig) { return false; @@ -205,7 +209,7 @@ pub fn verify_entry(entry: &Entry, start_hash: &Sha256Hash) -> bool { } /// Verifies the hashes and counts of a slice of events are all consistent. -pub fn verify_slice(events: &[Entry], start_hash: &Sha256Hash) -> bool { +pub fn verify_slice(events: &[Entry], start_hash: &Sha256Hash) -> bool { use rayon::prelude::*; let genesis = [Entry::new_tick(Default::default(), start_hash)]; let event_pairs = genesis.par_iter().chain(events).zip(events); @@ -213,7 +217,7 @@ pub fn verify_slice(events: &[Entry], start_hash: &Sha256Hash) -> bool { } /// Verifies the hashes and events serially. Exists only for reference. -pub fn verify_slice_seq(events: &[Entry], start_hash: &Sha256Hash) -> bool { +pub fn verify_slice_seq(events: &[Entry], start_hash: &Sha256Hash) -> bool { let genesis = [Entry::new_tick(0, start_hash)]; let mut event_pairs = genesis.iter().chain(events).zip(events); event_pairs.all(|(x0, x1)| verify_entry(&x1, &x0.end_hash)) @@ -233,7 +237,7 @@ pub fn create_entries( start_hash: &Sha256Hash, num_hashes: u64, events: &[Event], -) -> Vec { +) -> Vec> { let mut end_hash = *start_hash; events .iter() @@ -242,7 +246,11 @@ pub fn create_entries( } /// Create a vector of Ticks of length 'len' from 'start_hash' hash and 'num_hashes'. -pub fn create_ticks(start_hash: &Sha256Hash, num_hashes: u64, len: usize) -> Vec { +pub fn create_ticks( + start_hash: &Sha256Hash, + num_hashes: u64, + len: usize, +) -> Vec> { use std::iter; let mut end_hash = *start_hash; iter::repeat(Event::Tick) @@ -271,7 +279,7 @@ mod tests { assert_eq!(next_tick(&zero, 1).num_hashes, 1) } - fn verify_slice_generic(verify_slice: fn(&[Entry], &Sha256Hash) -> bool) { + fn verify_slice_generic(verify_slice: fn(&[Entry], &Sha256Hash) -> bool) { let zero = Sha256Hash::default(); let one = hash(&zero); assert!(verify_slice(&vec![], &zero)); // base case From 0443b39264016a1754e173ec1a21a213ba6d70cf Mon Sep 17 00:00:00 2001 From: Greg Fitzgerald Date: Mon, 26 Feb 2018 16:42:31 -0700 Subject: [PATCH 4/6] Allow event log to hold events of any serializable (hashable) type --- Cargo.toml | 1 + src/lib.rs | 1 + src/log.rs | 115 ++++++++++++++++++++++++++++------------------------- 3 files changed, 62 insertions(+), 55 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 5f95ec68e7..9523e3f6e2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -31,3 +31,4 @@ serde = "1.0.27" serde_derive = "1.0.27" ring = "0.12.1" untrusted = "0.5.1" +bincode = "1.0.0" diff --git a/src/lib.rs b/src/lib.rs index 2765660520..82be8c1d28 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,6 +1,7 @@ #![cfg_attr(feature = "unstable", feature(test))] pub mod log; pub mod historian; +extern crate bincode; extern crate generic_array; extern crate rayon; extern crate ring; diff --git a/src/log.rs b/src/log.rs index d20457125f..666414bb8c 100644 --- a/src/log.rs +++ b/src/log.rs @@ -16,6 +16,8 @@ use generic_array::GenericArray; use generic_array::typenum::{U32, U64}; use ring::signature::Ed25519KeyPair; +use serde::Serialize; + pub type Sha256Hash = GenericArray; pub type PublicKey = GenericArray; pub type Signature = GenericArray; @@ -73,32 +75,30 @@ pub fn generate_keypair() -> Ed25519KeyPair { } /// Return a Claim Event for the given hash and key-pair. -pub fn sign_hash(data: &Sha256Hash, keypair: &Ed25519KeyPair) -> Event { - let sig = keypair.sign(data); +pub fn sign_hash(data: T, keypair: &Ed25519KeyPair) -> Event { + use bincode::serialize; + let sig = keypair.sign(&serialize(&data).unwrap()); let peer_public_key_bytes = keypair.public_key_bytes(); let sig_bytes = sig.as_ref(); Event::Claim { key: GenericArray::clone_from_slice(peer_public_key_bytes), - data: GenericArray::clone_from_slice(data), + data, sig: GenericArray::clone_from_slice(sig_bytes), } } /// Return a Transaction Event that indicates a transfer in ownership of the given hash. -pub fn transfer_hash( - data: &Sha256Hash, - keypair: &Ed25519KeyPair, - to: PublicKey, -) -> Event { +pub fn transfer_hash(data: T, keypair: &Ed25519KeyPair, to: PublicKey) -> Event { + use bincode::serialize; let from_public_key_bytes = keypair.public_key_bytes(); - let mut sign_data = data.to_vec(); + let mut sign_data = serialize(&data).unwrap(); sign_data.extend_from_slice(&to); let sig = keypair.sign(&sign_data); let sig_bytes = sig.as_ref(); Event::Transaction { from: GenericArray::clone_from_slice(from_public_key_bytes), to, - data: GenericArray::clone_from_slice(data), + data, sig: GenericArray::clone_from_slice(sig_bytes), } } @@ -119,12 +119,13 @@ pub fn extend_and_hash(end_hash: &Sha256Hash, ty: u8, val: &[u8]) -> Sha256Hash hash(&hash_data) } -pub fn hash_event(end_hash: &Sha256Hash, event: &Event) -> Sha256Hash { +pub fn hash_event(end_hash: &Sha256Hash, event: &Event) -> Sha256Hash { + use bincode::serialize; match *event { Event::Tick => *end_hash, - Event::Discovery { data } => extend_and_hash(end_hash, 1, &data), - Event::Claim { key, data, sig } => { - let mut event_data = data.to_vec(); + Event::Discovery { ref data } => extend_and_hash(end_hash, 1, &serialize(&data).unwrap()), + Event::Claim { key, ref data, sig } => { + let mut event_data = serialize(&data).unwrap(); event_data.extend_from_slice(&sig); event_data.extend_from_slice(&key); extend_and_hash(end_hash, 2, &event_data) @@ -132,10 +133,10 @@ pub fn hash_event(end_hash: &Sha256Hash, event: &Event) -> Sha256Has Event::Transaction { from, to, - data, + ref data, sig, } => { - let mut event_data = data.to_vec(); + let mut event_data = serialize(&data).unwrap(); event_data.extend_from_slice(&sig); event_data.extend_from_slice(&from); event_data.extend_from_slice(&to); @@ -144,10 +145,11 @@ pub fn hash_event(end_hash: &Sha256Hash, event: &Event) -> Sha256Has } } -pub fn next_hash( +/// Creates the hash 'num_hashes' after start_hash, plus an additional hash for any event data. +pub fn next_hash( start_hash: &Sha256Hash, num_hashes: u64, - event: &Event, + event: &Event, ) -> Sha256Hash { let mut end_hash = *start_hash; for _ in 0..num_hashes { @@ -157,11 +159,11 @@ pub fn next_hash( } /// Creates the next Tick Entry 'num_hashes' after 'start_hash'. -pub fn next_entry( +pub fn next_entry( start_hash: &Sha256Hash, num_hashes: u64, - event: Event, -) -> Entry { + event: Event, +) -> Entry { Entry { num_hashes, end_hash: next_hash(start_hash, num_hashes, &event), @@ -169,37 +171,40 @@ pub fn next_entry( } } -pub fn next_entry_mut( +/// Creates the next Tick Entry 'num_hashes' after 'start_hash'. +pub fn next_entry_mut( start_hash: &mut Sha256Hash, num_hashes: u64, - event: Event, -) -> Entry { + event: Event, +) -> Entry { let entry = next_entry(start_hash, num_hashes, event); *start_hash = entry.end_hash; entry } /// Creates the next Tick Entry 'num_hashes' after 'start_hash'. -pub fn next_tick(start_hash: &Sha256Hash, num_hashes: u64) -> Entry { +pub fn next_tick(start_hash: &Sha256Hash, num_hashes: u64) -> Entry { next_entry(start_hash, num_hashes, Event::Tick) } /// Verifies self.end_hash is the result of hashing a 'start_hash' 'self.num_hashes' times. /// If the event is not a Tick, then hash that as well. -pub fn verify_entry(entry: &Entry, start_hash: &Sha256Hash) -> bool { - if let Event::Claim { key, data, sig } = entry.event { - if !verify_signature(&key, &data, &sig) { +pub fn verify_entry(entry: &Entry, start_hash: &Sha256Hash) -> bool { + use bincode::serialize; + if let Event::Claim { key, ref data, sig } = entry.event { + let mut claim_data = serialize(&data).unwrap(); + if !verify_signature(&key, &claim_data, &sig) { return false; } } if let Event::Transaction { from, to, - data, + ref data, sig, } = entry.event { - let mut sign_data = data.to_vec(); + let mut sign_data = serialize(&data).unwrap(); sign_data.extend_from_slice(&to); if !verify_signature(&from, &sign_data, &sig) { return false; @@ -217,7 +222,7 @@ pub fn verify_slice(events: &[Entry], start_hash: &Sha256Hash) -> bo } /// Verifies the hashes and events serially. Exists only for reference. -pub fn verify_slice_seq(events: &[Entry], start_hash: &Sha256Hash) -> bool { +pub fn verify_slice_seq(events: &[Entry], start_hash: &Sha256Hash) -> bool { let genesis = [Entry::new_tick(0, start_hash)]; let mut event_pairs = genesis.iter().chain(events).zip(events); event_pairs.all(|(x0, x1)| verify_entry(&x1, &x0.end_hash)) @@ -233,15 +238,15 @@ pub fn verify_signature(peer_public_key_bytes: &[u8], msg_bytes: &[u8], sig_byte signature::verify(&signature::ED25519, peer_public_key, msg, sig).is_ok() } -pub fn create_entries( +pub fn create_entries( start_hash: &Sha256Hash, num_hashes: u64, - events: &[Event], -) -> Vec> { + events: Vec>, +) -> Vec> { let mut end_hash = *start_hash; events - .iter() - .map(|event| next_entry_mut(&mut end_hash, num_hashes, event.clone())) + .into_iter() + .map(|event| next_entry_mut(&mut end_hash, num_hashes, event)) .collect() } @@ -267,16 +272,16 @@ mod tests { fn test_event_verify() { let zero = Sha256Hash::default(); let one = hash(&zero); - assert!(verify_entry(&Entry::new_tick(0, &zero), &zero)); // base case - assert!(!verify_entry(&Entry::new_tick(0, &zero), &one)); // base case, bad - assert!(verify_entry(&next_tick(&zero, 1), &zero)); // inductive step - assert!(!verify_entry(&next_tick(&zero, 1), &one)); // inductive step, bad + assert!(verify_entry::(&Entry::new_tick(0, &zero), &zero)); // base case + assert!(!verify_entry::(&Entry::new_tick(0, &zero), &one)); // base case, bad + assert!(verify_entry::(&next_tick(&zero, 1), &zero)); // inductive step + assert!(!verify_entry::(&next_tick(&zero, 1), &one)); // inductive step, bad } #[test] fn test_next_tick() { let zero = Sha256Hash::default(); - assert_eq!(next_tick(&zero, 1).num_hashes, 1) + assert_eq!(next_tick::(&zero, 1).num_hashes, 1) } fn verify_slice_generic(verify_slice: fn(&[Entry], &Sha256Hash) -> bool) { @@ -299,7 +304,7 @@ mod tests { #[test] fn test_verify_slice_seq() { - verify_slice_generic(verify_slice_seq); + verify_slice_generic(verify_slice_seq::); } #[test] @@ -308,11 +313,11 @@ mod tests { let one = hash(&zero); // First, verify Discovery events - let events = [ + let events = vec![ Event::Discovery { data: zero }, Event::Discovery { data: one }, ]; - let mut entries = create_entries(&zero, 0, &events); + let mut entries = create_entries(&zero, 0, events); assert!(verify_slice(&entries, &zero)); // Next, swap two Discovery events and ensure verification fails. @@ -326,22 +331,22 @@ mod tests { #[test] fn test_claim() { let keypair = generate_keypair(); - let event0 = sign_hash(&hash(b"hello, world"), &keypair); + let event0 = sign_hash(hash(b"hello, world"), &keypair); let zero = Sha256Hash::default(); - let entries = create_entries(&zero, 0, &[event0]); + let entries = create_entries(&zero, 0, vec![event0]); assert!(verify_slice(&entries, &zero)); } #[test] fn test_wrong_data_claim_attack() { let keypair = generate_keypair(); - let mut event0 = sign_hash(&hash(b"hello, world"), &keypair); + let mut event0 = sign_hash(hash(b"hello, world"), &keypair); if let Event::Claim { key, sig, .. } = event0 { let data = hash(b"goodbye cruel world"); event0 = Event::Claim { key, data, sig }; } let zero = Sha256Hash::default(); - let entries = create_entries(&zero, 0, &[event0]); + let entries = create_entries(&zero, 0, vec![event0]); assert!(!verify_slice(&entries, &zero)); } @@ -350,9 +355,9 @@ mod tests { let keypair0 = generate_keypair(); let keypair1 = generate_keypair(); let pubkey1 = GenericArray::clone_from_slice(keypair1.public_key_bytes()); - let event0 = transfer_hash(&hash(b"hello, world"), &keypair0, pubkey1); + let event0 = transfer_hash(hash(b"hello, world"), &keypair0, pubkey1); let zero = Sha256Hash::default(); - let entries = create_entries(&zero, 0, &[event0]); + let entries = create_entries(&zero, 0, vec![event0]); assert!(verify_slice(&entries, &zero)); } @@ -361,7 +366,7 @@ mod tests { let keypair0 = generate_keypair(); let keypair1 = generate_keypair(); let pubkey1 = GenericArray::clone_from_slice(keypair1.public_key_bytes()); - let mut event0 = transfer_hash(&hash(b"hello, world"), &keypair0, pubkey1); + let mut event0 = transfer_hash(hash(b"hello, world"), &keypair0, pubkey1); if let Event::Transaction { from, to, sig, .. } = event0 { let data = hash(b"goodbye cruel world"); event0 = Event::Transaction { @@ -372,7 +377,7 @@ mod tests { }; } let zero = Sha256Hash::default(); - let entries = create_entries(&zero, 0, &[event0]); + let entries = create_entries(&zero, 0, vec![event0]); assert!(!verify_slice(&entries, &zero)); } @@ -381,7 +386,7 @@ mod tests { let keypair0 = generate_keypair(); let keypair1 = generate_keypair(); let pubkey1 = GenericArray::clone_from_slice(keypair1.public_key_bytes()); - let mut event0 = transfer_hash(&hash(b"hello, world"), &keypair0, pubkey1); + let mut event0 = transfer_hash(hash(b"hello, world"), &keypair0, pubkey1); if let Event::Transaction { from, data, sig, .. } = event0 @@ -396,7 +401,7 @@ mod tests { }; } let zero = Sha256Hash::default(); - let entries = create_entries(&zero, 0, &[event0]); + let entries = create_entries(&zero, 0, vec![event0]); assert!(!verify_slice(&entries, &zero)); } } @@ -421,7 +426,7 @@ mod bench { let start_hash = Default::default(); let events = create_ticks(&start_hash, 10_000, 8); bencher.iter(|| { - assert!(verify_slice_seq(&events, &start_hash)); + assert!(verify_slice(&events, &start_hash)); }); } } From c6134cc25be834413c606f6404aede34caf062f7 Mon Sep 17 00:00:00 2001 From: Greg Fitzgerald Date: Mon, 26 Feb 2018 17:01:22 -0700 Subject: [PATCH 5/6] Allow the historian to track ownership of any type of data --- src/bin/demo.rs | 2 +- src/historian.rs | 37 +++++++++++++++++++------------------ 2 files changed, 20 insertions(+), 19 deletions(-) diff --git a/src/bin/demo.rs b/src/bin/demo.rs index d29049f512..0787b3b305 100644 --- a/src/bin/demo.rs +++ b/src/bin/demo.rs @@ -6,7 +6,7 @@ use std::thread::sleep; use std::time::Duration; use std::sync::mpsc::SendError; -fn create_log(hist: &Historian) -> Result<(), SendError>> { +fn create_log(hist: &Historian) -> Result<(), SendError>> { sleep(Duration::from_millis(15)); let data = Sha256Hash::default(); hist.sender.send(Event::Discovery { data })?; diff --git a/src/historian.rs b/src/historian.rs index 358d7f8821..2612c3205f 100644 --- a/src/historian.rs +++ b/src/historian.rs @@ -9,11 +9,12 @@ use std::thread::JoinHandle; use std::sync::mpsc::{Receiver, Sender}; use std::time::{Duration, SystemTime}; use log::{hash, hash_event, Entry, Event, Sha256Hash}; +use serde::Serialize; -pub struct Historian { - pub sender: Sender>, - pub receiver: Receiver>, - pub thread_hdl: JoinHandle<(Entry, ExitReason)>, +pub struct Historian { + pub sender: Sender>, + pub receiver: Receiver>, + pub thread_hdl: JoinHandle<(Entry, ExitReason)>, } #[derive(Debug, PartialEq, Eq)] @@ -21,12 +22,12 @@ pub enum ExitReason { RecvDisconnected, SendDisconnected, } -fn log_event( - sender: &Sender>, +fn log_event( + sender: &Sender>, num_hashes: &mut u64, end_hash: &mut Sha256Hash, - event: Event, -) -> Result<(), (Entry, ExitReason)> { + event: Event, +) -> Result<(), (Entry, ExitReason)> { *end_hash = hash_event(end_hash, &event); let entry = Entry { end_hash: *end_hash, @@ -40,15 +41,15 @@ fn log_event( Ok(()) } -fn log_events( - receiver: &Receiver>, - sender: &Sender>, +fn log_events( + receiver: &Receiver>, + sender: &Sender>, num_hashes: &mut u64, end_hash: &mut Sha256Hash, epoch: SystemTime, num_ticks: &mut u64, ms_per_tick: Option, -) -> Result<(), (Entry, ExitReason)> { +) -> Result<(), (Entry, ExitReason)> { use std::sync::mpsc::TryRecvError; loop { if let Some(ms) = ms_per_tick { @@ -79,12 +80,12 @@ fn log_events( /// A background thread that will continue tagging received Event messages and /// sending back Entry messages until either the receiver or sender channel is closed. -pub fn create_logger( +pub fn create_logger( start_hash: Sha256Hash, ms_per_tick: Option, - receiver: Receiver>, - sender: Sender>, -) -> JoinHandle<(Entry, ExitReason)> { + receiver: Receiver>, + sender: Sender>, +) -> JoinHandle<(Entry, ExitReason)> { use std::thread; thread::spawn(move || { let mut end_hash = start_hash; @@ -109,7 +110,7 @@ pub fn create_logger( }) } -impl Historian { +impl Historian { pub fn new(start_hash: &Sha256Hash, ms_per_tick: Option) -> Self { use std::sync::mpsc::channel; let (sender, event_receiver) = channel(); @@ -157,7 +158,7 @@ mod tests { #[test] fn test_historian_closed_sender() { let zero = Sha256Hash::default(); - let hist = Historian::new(&zero, None); + let hist = Historian::::new(&zero, None); drop(hist.receiver); hist.sender.send(Event::Tick).unwrap(); assert_eq!( From f98e9a2ad7b5013625fc8860874124195c449e28 Mon Sep 17 00:00:00 2001 From: Greg Fitzgerald Date: Mon, 26 Feb 2018 17:03:50 -0700 Subject: [PATCH 6/6] Fix overuse of search-and-replace --- src/log.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/log.rs b/src/log.rs index 666414bb8c..47ac70ec39 100644 --- a/src/log.rs +++ b/src/log.rs @@ -426,7 +426,7 @@ mod bench { let start_hash = Default::default(); let events = create_ticks(&start_hash, 10_000, 8); bencher.iter(|| { - assert!(verify_slice(&events, &start_hash)); + assert!(verify_slice_seq(&events, &start_hash)); }); } }