Merge pull request #23 from garious/add-transaction

Generalize the event log

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"

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<Event>> {
+fn create_log(hist: &Historian<Sha256Hash>) -> Result<(), SendError<Event<Sha256Hash>>> {
     sleep(Duration::from_millis(15));
     let data = Sha256Hash::default();
     hist.sender.send(Event::Discovery { data })?;
@@ -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<Entry> = hist.receiver.iter().collect();
+    let entries: Vec<Entry<Sha256Hash>> = hist.receiver.iter().collect();
     for entry in &entries {
         println!("{:?}", entry);
     }

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 struct Historian<T> {
-    pub sender: Sender<Event>,
+    pub sender: Sender<Event<T>>,
-    pub receiver: Receiver<Entry>,
+    pub receiver: Receiver<Entry<T>>,
-    pub thread_hdl: JoinHandle<(Entry, ExitReason)>,
+    pub thread_hdl: JoinHandle<(Entry<T>, ExitReason)>,
 }
 
 #[derive(Debug, PartialEq, Eq)]
@@ -21,12 +22,12 @@ pub enum ExitReason {
     RecvDisconnected,
     SendDisconnected,
 }
-fn log_event(
+fn log_event<T: Serialize + Clone>(
-    sender: &Sender<Entry>,
+    sender: &Sender<Entry<T>>,
     num_hashes: &mut u64,
     end_hash: &mut Sha256Hash,
-    event: Event,
+    event: Event<T>,
-) -> Result<(), (Entry, ExitReason)> {
+) -> Result<(), (Entry<T>, 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(
+fn log_events<T: Serialize + Clone>(
-    receiver: &Receiver<Event>,
+    receiver: &Receiver<Event<T>>,
-    sender: &Sender<Entry>,
+    sender: &Sender<Entry<T>>,
     num_hashes: &mut u64,
     end_hash: &mut Sha256Hash,
     epoch: SystemTime,
     num_ticks: &mut u64,
     ms_per_tick: Option<u64>,
-) -> Result<(), (Entry, ExitReason)> {
+) -> Result<(), (Entry<T>, 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<T: 'static + Serialize + Clone + Send>(
     start_hash: Sha256Hash,
     ms_per_tick: Option<u64>,
-    receiver: Receiver<Event>,
+    receiver: Receiver<Event<T>>,
-    sender: Sender<Entry>,
+    sender: Sender<Entry<T>>,
-) -> JoinHandle<(Entry, ExitReason)> {
+) -> JoinHandle<(Entry<T>, ExitReason)> {
     use std::thread;
     thread::spawn(move || {
         let mut end_hash = start_hash;
@@ -109,7 +110,7 @@ pub fn create_logger(
     })
 }
 
-impl Historian {
+impl<T: 'static + Serialize + Clone + Send> Historian<T> {
     pub fn new(start_hash: &Sha256Hash, ms_per_tick: Option<u64>) -> 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::<u8>::new(&zero, None);
         drop(hist.receiver);
         hist.sender.send(Event::Tick).unwrap();
         assert_eq!(
@@ -179,7 +180,7 @@ mod tests {
             ExitReason::RecvDisconnected
         );
 
-        let entries: Vec<Entry> = hist.receiver.iter().collect();
+        let entries: Vec<Entry<Sha256Hash>> = hist.receiver.iter().collect();
         assert!(entries.len() > 1);
         assert!(verify_slice(&entries, &zero));
     }

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;

src/log.rs

@@ -16,15 +16,17 @@
 use generic_array::GenericArray;
 use generic_array::typenum::{U32, U64};
 use ring::signature::Ed25519KeyPair;
+use serde::Serialize;
+
 pub type Sha256Hash = GenericArray<u8, U32>;
 pub type PublicKey = GenericArray<u8, U32>;
 pub type Signature = GenericArray<u8, U64>;
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
-pub struct Entry {
+pub struct Entry<T> {
     pub num_hashes: u64,
     pub end_hash: Sha256Hash,
-    pub event: Event,
+    pub event: Event<T>,
 }
 
 /// When 'event' is Tick, the event represents a simple clock tick, and exists for the
@@ -33,25 +35,25 @@ 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<T> {
     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,
     },
 }
 
-impl Entry {
+impl<T> Entry<T> {
     /// 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 {
@@ -61,30 +63,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
@@ -97,28 +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 {
+pub fn sign_hash<T: Serialize>(data: T, keypair: &Ed25519KeyPair) -> Event<T> {
-    let sig = keypair.sign(data);
+    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<T: Serialize>(data: T, keypair: &Ed25519KeyPair, to: PublicKey) -> Event<T> {
+    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),
     }
 }
@@ -139,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<T: Serialize>(end_hash: &Sha256Hash, event: &Event<T>) -> Sha256Hash {
+    use bincode::serialize;
     match *event {
         Event::Tick => *end_hash,
-        Event::Discovery { data } => extend_and_hash(end_hash, 1, &data),
+        Event::Discovery { ref data } => extend_and_hash(end_hash, 1, &serialize(&data).unwrap()),
-        Event::Claim { key, data, sig } => {
+        Event::Claim { key, 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(&key);
             extend_and_hash(end_hash, 2, &event_data)
@@ -152,10 +133,10 @@ pub fn hash_event(end_hash: &Sha256Hash, event: &Event) -> Sha256Hash {
         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);
@@ -164,7 +145,12 @@ pub fn hash_event(end_hash: &Sha256Hash, event: &Event) -> Sha256Hash {
     }
 }
 
-pub fn next_hash(start_hash: &Sha256Hash, num_hashes: u64, event: &Event) -> Sha256Hash {
+/// Creates the hash 'num_hashes' after start_hash, plus an additional hash for any event data.
+pub fn next_hash<T: Serialize>(
+    start_hash: &Sha256Hash,
+    num_hashes: u64,
+    event: &Event<T>,
+) -> Sha256Hash {
     let mut end_hash = *start_hash;
     for _ in 0..num_hashes {
         end_hash = hash(&end_hash);
@@ -173,7 +159,11 @@ 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<T: Serialize>(
+    start_hash: &Sha256Hash,
+    num_hashes: u64,
+    event: Event<T>,
+) -> Entry<T> {
     Entry {
         num_hashes,
         end_hash: next_hash(start_hash, num_hashes, &event),
@@ -181,30 +171,61 @@ 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 {
+/// Creates the next Tick Entry 'num_hashes' after 'start_hash'.
+pub fn next_entry_mut<T: Serialize>(
+    start_hash: &mut Sha256Hash,
+    num_hashes: u64,
+    event: Event<T>,
+) -> Entry<T> {
     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<T: Serialize>(start_hash: &Sha256Hash, num_hashes: u64) -> Entry<T> {
     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<T: Serialize>(entry: &Entry<T>, 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,
+        ref data,
+        sig,
+    } = entry.event
+    {
+        let mut sign_data = serialize(&data).unwrap();
+        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 {
+pub fn verify_slice(events: &[Entry<Sha256Hash>], 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 {
+pub fn verify_slice_seq<T: Serialize>(events: &[Entry<T>], 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.
@@ -217,16 +238,24 @@ 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<Entry> {
+pub fn create_entries<T: Serialize>(
+    start_hash: &Sha256Hash,
+    num_hashes: u64,
+    events: Vec<Event<T>>,
+) -> Vec<Entry<T>> {
     let mut end_hash = *start_hash;
     events
-        .iter()
+        .into_iter()
-        .map(|event| next_entry_mut(&mut end_hash, num_hashes, event.clone()))
+        .map(|event| next_entry_mut(&mut end_hash, num_hashes, event))
         .collect()
 }
 
 /// 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<Entry> {
+pub fn create_ticks(
+    start_hash: &Sha256Hash,
+    num_hashes: u64,
+    len: usize,
+) -> Vec<Entry<Sha256Hash>> {
     use std::iter;
     let mut end_hash = *start_hash;
     iter::repeat(Event::Tick)
@@ -243,19 +272,19 @@ 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!(verify_entry::<u8>(&Entry::new_tick(0, &zero), &zero)); // base case
-        assert!(!Entry::new_tick(0, &zero).verify(&one)); // base case, bad
+        assert!(!verify_entry::<u8>(&Entry::new_tick(0, &zero), &one)); // base case, bad
-        assert!(next_tick(&zero, 1).verify(&zero)); // inductive step
+        assert!(verify_entry::<u8>(&next_tick(&zero, 1), &zero)); // inductive step
-        assert!(!next_tick(&zero, 1).verify(&one)); // inductive step, bad
+        assert!(!verify_entry::<u8>(&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::<Sha256Hash>(&zero, 1).num_hashes, 1)
     }
 
-    fn verify_slice_generic(verify_slice: fn(&[Entry], &Sha256Hash) -> bool) {
+    fn verify_slice_generic(verify_slice: fn(&[Entry<Sha256Hash>], &Sha256Hash) -> bool) {
         let zero = Sha256Hash::default();
         let one = hash(&zero);
         assert!(verify_slice(&vec![], &zero)); // base case
@@ -275,7 +304,7 @@ mod tests {
 
     #[test]
     fn test_verify_slice_seq() {
-        verify_slice_generic(verify_slice_seq);
+        verify_slice_generic(verify_slice_seq::<Sha256Hash>);
     }
 
     #[test]
@@ -284,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.
@@ -302,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));
     }
 
@@ -326,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));
     }
 
@@ -337,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 {
@@ -348,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));
     }
 
@@ -357,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
@@ -372,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));
     }
 }