From 7cbee46227fb51f581b9d9c9c8dfb4f058e9dd18 Mon Sep 17 00:00:00 2001 From: Paul Hauner Date: Fri, 22 Mar 2019 10:08:40 +1100 Subject: [PATCH] Add FakeSignature and FakeAggregateSignature They replace Signature and FakeAggregateSignature when compling with debug. Compiling with release uses the real structs. --- .travis.yml | 2 + .../utils/bls/src/fake_aggregate_signature.rs | 117 ++++++++++++++++++ eth2/utils/bls/src/fake_signature.rs | 117 ++++++++++++++++++ eth2/utils/bls/src/lib.rs | 20 ++- 4 files changed, 253 insertions(+), 3 deletions(-) create mode 100644 eth2/utils/bls/src/fake_aggregate_signature.rs create mode 100644 eth2/utils/bls/src/fake_signature.rs diff --git a/.travis.yml b/.travis.yml index d43d21a00..44e78ee04 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,7 +8,9 @@ before_install: - sudo chown -R $USER /usr/local/include/google script: - cargo build --verbose --all + - cargo build --verbose --release --all - cargo test --verbose --all + - cargo test --verbose --release --all - cargo fmt --all -- --check rust: - stable diff --git a/eth2/utils/bls/src/fake_aggregate_signature.rs b/eth2/utils/bls/src/fake_aggregate_signature.rs new file mode 100644 index 000000000..23e2b54ef --- /dev/null +++ b/eth2/utils/bls/src/fake_aggregate_signature.rs @@ -0,0 +1,117 @@ +use super::{fake_signature::FakeSignature, AggregatePublicKey}; +use serde::de::{Deserialize, Deserializer}; +use serde::ser::{Serialize, Serializer}; +use serde_hex::{encode as hex_encode, PrefixedHexVisitor}; +use ssz::{ + decode_ssz_list, hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash, +}; + +const SIGNATURE_LENGTH: usize = 48; + +/// A BLS aggregate signature. +/// +/// This struct is a wrapper upon a base type and provides helper functions (e.g., SSZ +/// serialization). +#[derive(Debug, PartialEq, Clone, Default, Eq)] +pub struct FakeAggregateSignature { + bytes: Vec, +} + +impl FakeAggregateSignature { + /// Creates a new all-zero's signature + pub fn new() -> Self { + Self::zero() + } + + /// Creates a new all-zero's signature + pub fn zero() -> Self { + Self { + bytes: vec![0; SIGNATURE_LENGTH], + } + } + + /// Does glorious nothing. + pub fn add(&mut self, _signature: &FakeSignature) { + // Do nothing. + } + + /// _Always_ returns `true`. + pub fn verify( + &self, + _msg: &[u8], + _domain: u64, + _aggregate_public_key: &AggregatePublicKey, + ) -> bool { + true + } + + /// _Always_ returns `true`. + pub fn verify_multiple( + &self, + _messages: &[&[u8]], + _domain: u64, + _aggregate_public_keys: &[&AggregatePublicKey], + ) -> bool { + true + } +} + +impl Encodable for FakeAggregateSignature { + fn ssz_append(&self, s: &mut SszStream) { + s.append_vec(&self.bytes); + } +} + +impl Decodable for FakeAggregateSignature { + fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { + let (sig_bytes, i) = decode_ssz_list(bytes, i)?; + Ok((FakeAggregateSignature { bytes: sig_bytes }, i)) + } +} + +impl Serialize for FakeAggregateSignature { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_str(&hex_encode(ssz_encode(self))) + } +} + +impl<'de> Deserialize<'de> for FakeAggregateSignature { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let bytes = deserializer.deserialize_str(PrefixedHexVisitor)?; + let (obj, _) = <_>::ssz_decode(&bytes[..], 0) + .map_err(|e| serde::de::Error::custom(format!("invalid ssz ({:?})", e)))?; + Ok(obj) + } +} + +impl TreeHash for FakeAggregateSignature { + fn hash_tree_root(&self) -> Vec { + hash(&self.bytes) + } +} + +#[cfg(test)] +mod tests { + use super::super::{Keypair, Signature}; + use super::*; + use ssz::ssz_encode; + + #[test] + pub fn test_ssz_round_trip() { + let keypair = Keypair::random(); + + let mut original = FakeAggregateSignature::new(); + original.add(&Signature::new(&[42, 42], 0, &keypair.sk)); + + let bytes = ssz_encode(&original); + let (decoded, _) = FakeAggregateSignature::ssz_decode(&bytes, 0).unwrap(); + + assert_eq!(original, decoded); + } +} diff --git a/eth2/utils/bls/src/fake_signature.rs b/eth2/utils/bls/src/fake_signature.rs new file mode 100644 index 000000000..81b7310c8 --- /dev/null +++ b/eth2/utils/bls/src/fake_signature.rs @@ -0,0 +1,117 @@ +use super::serde_vistors::HexVisitor; +use super::{PublicKey, SecretKey}; +use hex::encode as hex_encode; +use serde::de::{Deserialize, Deserializer}; +use serde::ser::{Serialize, Serializer}; +use ssz::{ + decode_ssz_list, hash, ssz_encode, Decodable, DecodeError, Encodable, SszStream, TreeHash, +}; + +const SIGNATURE_LENGTH: usize = 48; + +/// A single BLS signature. +/// +/// This struct is a wrapper upon a base type and provides helper functions (e.g., SSZ +/// serialization). +#[derive(Debug, PartialEq, Clone, Eq)] +pub struct FakeSignature { + bytes: Vec, +} + +impl FakeSignature { + /// Creates a new all-zero's signature + pub fn new(_msg: &[u8], _domain: u64, _sk: &SecretKey) -> Self { + FakeSignature::zero() + } + + /// Creates a new all-zero's signature + pub fn zero() -> Self { + Self { + bytes: vec![0; SIGNATURE_LENGTH], + } + } + + /// Creates a new all-zero's signature + pub fn new_hashed(_x_real_hashed: &[u8], _x_imaginary_hashed: &[u8], _sk: &SecretKey) -> Self { + FakeSignature::zero() + } + + /// _Always_ returns `true`. + pub fn verify(&self, _msg: &[u8], _domain: u64, _pk: &PublicKey) -> bool { + true + } + + /// _Always_ returns true. + pub fn verify_hashed( + &self, + _x_real_hashed: &[u8], + _x_imaginary_hashed: &[u8], + _pk: &PublicKey, + ) -> bool { + true + } + + /// Returns a new empty signature. + pub fn empty_signature() -> Self { + FakeSignature::zero() + } +} + +impl Encodable for FakeSignature { + fn ssz_append(&self, s: &mut SszStream) { + s.append_vec(&self.bytes); + } +} + +impl Decodable for FakeSignature { + fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), DecodeError> { + let (sig_bytes, i) = decode_ssz_list(bytes, i)?; + Ok((FakeSignature { bytes: sig_bytes }, i)) + } +} + +impl TreeHash for FakeSignature { + fn hash_tree_root(&self) -> Vec { + hash(&self.bytes) + } +} + +impl Serialize for FakeSignature { + fn serialize(&self, serializer: S) -> Result + where + S: Serializer, + { + serializer.serialize_str(&hex_encode(ssz_encode(self))) + } +} + +impl<'de> Deserialize<'de> for FakeSignature { + fn deserialize(deserializer: D) -> Result + where + D: Deserializer<'de>, + { + let bytes = deserializer.deserialize_str(HexVisitor)?; + let (pubkey, _) = <_>::ssz_decode(&bytes[..], 0) + .map_err(|e| serde::de::Error::custom(format!("invalid ssz ({:?})", e)))?; + Ok(pubkey) + } +} + +#[cfg(test)] +mod tests { + use super::super::Keypair; + use super::*; + use ssz::ssz_encode; + + #[test] + pub fn test_ssz_round_trip() { + let keypair = Keypair::random(); + + let original = FakeSignature::new(&[42, 42], 0, &keypair.sk); + + let bytes = ssz_encode(&original); + let (decoded, _) = FakeSignature::ssz_decode(&bytes, 0).unwrap(); + + assert_eq!(original, decoded); + } +} diff --git a/eth2/utils/bls/src/lib.rs b/eth2/utils/bls/src/lib.rs index 38a129908..32cce5471 100644 --- a/eth2/utils/bls/src/lib.rs +++ b/eth2/utils/bls/src/lib.rs @@ -2,19 +2,33 @@ extern crate bls_aggregates; extern crate ssz; mod aggregate_public_key; -mod aggregate_signature; mod keypair; mod public_key; mod secret_key; mod serde_vistors; + +#[cfg(not(debug_assertions))] +mod aggregate_signature; +#[cfg(not(debug_assertions))] mod signature; +#[cfg(not(debug_assertions))] +pub use crate::aggregate_signature::AggregateSignature; +#[cfg(not(debug_assertions))] +pub use crate::signature::Signature; + +#[cfg(debug_assertions)] +mod fake_aggregate_signature; +#[cfg(debug_assertions)] +mod fake_signature; +#[cfg(debug_assertions)] +pub use crate::fake_aggregate_signature::FakeAggregateSignature as AggregateSignature; +#[cfg(debug_assertions)] +pub use crate::fake_signature::FakeSignature as Signature; pub use crate::aggregate_public_key::AggregatePublicKey; -pub use crate::aggregate_signature::AggregateSignature; pub use crate::keypair::Keypair; pub use crate::public_key::PublicKey; pub use crate::secret_key::SecretKey; -pub use crate::signature::Signature; pub const BLS_AGG_SIG_BYTE_SIZE: usize = 96;