From 0d0fee1ca18a8e66c2a9d02cb175776ecbf88ffd Mon Sep 17 00:00:00 2001 From: Greg Fitzgerald Date: Fri, 2 Mar 2018 11:46:19 -0700 Subject: [PATCH] Sign Claim's 'to' field Otherwise, the accountant will treat deposits of the same amount as duplicates. --- src/accountant.rs | 4 ++-- src/accountant_stub.rs | 4 ++-- src/bin/demo.rs | 4 ++-- src/event.rs | 39 ++++++++++++++++++++++++++++++++++++--- src/historian.rs | 4 ++-- src/log.rs | 8 ++++---- 6 files changed, 48 insertions(+), 15 deletions(-) diff --git a/src/accountant.rs b/src/accountant.rs index 62be90996..2fa5edb04 100644 --- a/src/accountant.rs +++ b/src/accountant.rs @@ -69,9 +69,9 @@ impl Accountant { } pub fn deposit(self: &mut Self, n: u64, keypair: &Ed25519KeyPair) -> Result { - use event::{get_pubkey, sign_serialized}; + use event::{get_pubkey, sign_claim_data}; let key = get_pubkey(keypair); - let sig = sign_serialized(&n, keypair); + let sig = sign_claim_data(&n, keypair); self.deposit_signed(key, n, sig).map(|_| sig) } diff --git a/src/accountant_stub.rs b/src/accountant_stub.rs index 57b9e6e36..b43ffd1ea 100644 --- a/src/accountant_stub.rs +++ b/src/accountant_stub.rs @@ -34,9 +34,9 @@ impl AccountantStub { } pub fn deposit(self: &mut Self, n: u64, keypair: &Ed25519KeyPair) -> io::Result { - use event::{get_pubkey, sign_serialized}; + use event::{get_pubkey, sign_claim_data}; let key = get_pubkey(keypair); - let sig = sign_serialized(&n, keypair); + let sig = sign_claim_data(&n, keypair); self.deposit_signed(key, n, sig).map(|_| sig) } diff --git a/src/bin/demo.rs b/src/bin/demo.rs index c0eaef222..4d9e12000 100644 --- a/src/bin/demo.rs +++ b/src/bin/demo.rs @@ -2,7 +2,7 @@ extern crate silk; use silk::historian::Historian; use silk::log::{verify_slice, Entry, Sha256Hash}; -use silk::event::{generate_keypair, get_pubkey, sign_serialized, Event}; +use silk::event::{generate_keypair, get_pubkey, sign_claim_data, Event}; use std::thread::sleep; use std::time::Duration; use std::sync::mpsc::SendError; @@ -11,7 +11,7 @@ fn create_log(hist: &Historian) -> Result<(), SendError { impl Event { pub fn new_claim(to: PublicKey, data: T, sig: Signature) -> Self { + // TODO: Change this to a Transaction Event::Claim { to, data, sig } + //Event::Transaction { + // from: None, + // to, + // data, + // sig, + //} } } @@ -63,7 +70,7 @@ pub fn get_pubkey(keypair: &Ed25519KeyPair) -> PublicKey { } /// Return a signature for the given data using the private key from the given keypair. -pub fn sign_serialized(data: &T, keypair: &Ed25519KeyPair) -> Signature { +fn sign_serialized(data: &T, keypair: &Ed25519KeyPair) -> Signature { use bincode::serialize; let serialized = serialize(data).unwrap(); GenericArray::clone_from_slice(keypair.sign(&serialized).as_ref()) @@ -78,6 +85,11 @@ pub fn sign_transaction_data( sign_serialized(&(data, to), keypair) } +/// Return a signature for the given data using the private key from the given keypair. +pub fn sign_claim_data(data: &T, keypair: &Ed25519KeyPair) -> Signature { + sign_transaction_data(data, keypair, &get_pubkey(keypair)) +} + /// Verify a signed message with the given public key. pub fn verify_signature(peer_public_key_bytes: &[u8], msg_bytes: &[u8], sig_bytes: &[u8]) -> bool { use untrusted; @@ -99,8 +111,8 @@ pub fn get_signature(event: &Event) -> Option { pub fn verify_event(event: &Event) -> bool { use bincode::serialize; if let Event::Claim { to, ref data, sig } = *event { - let mut claim_data = serialize(&data).unwrap(); - if !verify_signature(&to, &claim_data, &sig) { + let sign_data = serialize(&(&data, &to)).unwrap(); + if !verify_signature(&to, &sign_data, &sig) { return false; } } @@ -118,3 +130,24 @@ pub fn verify_event(event: &Event) -> bool { } true } + +#[cfg(test)] +mod tests { + use super::*; + use bincode::{deserialize, serialize}; + use log::{hash, Sha256Hash}; + + #[test] + fn test_serialize_claim() { + //let claim0 = Event::new_claim(Default::default(), 0u8, Default::default()); + let claim0 = Event::Transaction { + from: None, + to: Default::default(), + data: hash(b"hi"), + sig: Default::default(), + }; + let buf = serialize(&claim0).unwrap(); + let claim1: Event = deserialize(&buf).unwrap(); + assert_eq!(claim1, claim0); + } +} diff --git a/src/historian.rs b/src/historian.rs index 573e927b5..515a5746e 100644 --- a/src/historian.rs +++ b/src/historian.rs @@ -214,7 +214,7 @@ mod tests { #[test] fn test_bad_event_signature() { let keypair = generate_keypair(); - let sig = sign_serialized(&hash(b"hello, world"), &keypair); + let sig = sign_claim_data(&hash(b"hello, world"), &keypair); let event0 = Event::new_claim(get_pubkey(&keypair), hash(b"goodbye cruel world"), sig); let mut sigs = HashSet::new(); assert!(!verify_event_and_reserve_signature(&mut sigs, &event0)); @@ -226,7 +226,7 @@ mod tests { let keypair = generate_keypair(); let to = get_pubkey(&keypair); let data = &hash(b"hello, world"); - let sig = sign_serialized(data, &keypair); + let sig = sign_claim_data(data, &keypair); let event0 = Event::new_claim(to, data, sig); let mut sigs = HashSet::new(); assert!(verify_event_and_reserve_signature(&mut sigs, &event0)); diff --git a/src/log.rs b/src/log.rs index 300522800..c1a4a7ee4 100644 --- a/src/log.rs +++ b/src/log.rs @@ -211,8 +211,8 @@ mod tests { // First, verify entries let keypair = generate_keypair(); - let event0 = Event::new_claim(get_pubkey(&keypair), zero, sign_serialized(&zero, &keypair)); - let event1 = Event::new_claim(get_pubkey(&keypair), one, sign_serialized(&one, &keypair)); + let event0 = Event::new_claim(get_pubkey(&keypair), zero, sign_claim_data(&zero, &keypair)); + let event1 = Event::new_claim(get_pubkey(&keypair), one, sign_claim_data(&one, &keypair)); let events = vec![event0, event1]; let mut entries = create_entries(&zero, 0, events); assert!(verify_slice(&entries, &zero)); @@ -229,7 +229,7 @@ mod tests { fn test_claim() { let keypair = generate_keypair(); let data = hash(b"hello, world"); - let event0 = Event::new_claim(get_pubkey(&keypair), data, sign_serialized(&data, &keypair)); + let event0 = Event::new_claim(get_pubkey(&keypair), data, sign_claim_data(&data, &keypair)); let zero = Sha256Hash::default(); let entries = create_entries(&zero, 0, vec![event0]); assert!(verify_slice(&entries, &zero)); @@ -241,7 +241,7 @@ mod tests { let event0 = Event::new_claim( get_pubkey(&keypair), hash(b"goodbye cruel world"), - sign_serialized(&hash(b"hello, world"), &keypair), + sign_claim_data(&hash(b"hello, world"), &keypair), ); let zero = Sha256Hash::default(); let entries = create_entries(&zero, 0, vec![event0]);