Use SignatureBytes and PublicKeyBytes for deposits (#472)

* Replace deposit signatures with SignatureBytes, a struct which lazyly parsers signatures only on demand.

* check byte length when parsing SignatureBytes

* add comment to struct

* distinguish BadSignature and BadSignatureBytes in verify_deposit_signature

* add test for valid signature

* Implements TryInto<Signature> for &SignatureBytes and From<Signature> for &SignatureBytes

* add and use PublicKeyBytes + fix formatting

* fix compiler warning + docs for macro generated structs

* adds tests to ensure correct byte lengths

* small style improvement as suggested by michaelsproul

eth2/utils/bls/src/lib.rs

@@ -4,10 +4,14 @@ extern crate ssz;
 #[macro_use]
 mod macros;
 mod keypair;
+mod public_key_bytes;
 mod secret_key;
+mod signature_bytes;
 
 pub use crate::keypair::Keypair;
+pub use crate::public_key_bytes::PublicKeyBytes;
 pub use crate::secret_key::SecretKey;
+pub use crate::signature_bytes::SignatureBytes;
 pub use milagro_bls::{compress_g2, hash_on_g2};
 
 #[cfg(feature = "fake_crypto")]

eth2/utils/bls/src/macros.rs

@@ -84,3 +84,111 @@ macro_rules! impl_cached_tree_hash {
         }
     };
 }
+
+macro_rules! bytes_struct {
+    ($name: ident, $type: ty, $byte_size: expr, $small_name: expr, $ssz_type_size: ident,
+     $type_str: expr, $byte_size_str: expr) => {
+        #[doc = "Stores `"]
+        #[doc = $byte_size_str]
+        #[doc = "` bytes which may or may not represent a valid BLS "]
+        #[doc = $small_name]
+        #[doc = ".\n\nThe `"]
+        #[doc = $type_str]
+        #[doc = "` struct performs validation when it is instantiated, where as this struct does \
+                 not. This struct is suitable where we may wish to store bytes that are \
+                 potentially not a valid "]
+        #[doc = $small_name]
+        #[doc = " (e.g., from the deposit contract)."]
+        #[derive(Clone)]
+        pub struct $name([u8; $byte_size]);
+    };
+    ($name: ident, $type: ty, $byte_size: expr, $small_name: expr, $ssz_type_size: ident) => {
+        bytes_struct!($name, $type, $byte_size, $small_name, $ssz_type_size, stringify!($type),
+        stringify!($byte_size));
+
+        impl $name {
+            pub fn from_bytes(bytes: &[u8]) -> Result<Self, ssz::DecodeError> {
+                Ok(Self(Self::get_bytes(bytes)?))
+            }
+
+            pub fn empty() -> Self {
+                Self([0; $byte_size])
+            }
+
+            pub fn as_bytes(&self) -> Vec<u8> {
+                self.0.to_vec()
+            }
+
+            fn get_bytes(bytes: &[u8]) -> Result<[u8; $byte_size], ssz::DecodeError> {
+                let mut result = [0; $byte_size];
+                if bytes.len() != $byte_size {
+                    Err(ssz::DecodeError::InvalidByteLength {
+                        len: bytes.len(),
+                        expected: $byte_size,
+                    })
+                } else {
+                    result[..].copy_from_slice(bytes);
+                    Ok(result)
+                }
+            }
+        }
+
+        impl std::fmt::Debug for $name {
+            fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                self.0[..].fmt(formatter)
+            }
+        }
+
+        impl PartialEq for $name {
+            fn eq(&self, other: &Self) -> bool {
+                &self.0[..] == &other.0[..]
+            }
+        }
+
+        impl Eq for $name {}
+
+        impl std::convert::TryInto<$type> for &$name {
+            type Error = ssz::DecodeError;
+
+            fn try_into(self) -> Result<$type, Self::Error> {
+                <$type>::from_bytes(&self.0[..])
+            }
+        }
+
+        impl std::convert::From<$type> for $name {
+            fn from(obj: $type) -> Self {
+                // We know that obj.as_bytes() always has exactly $byte_size many bytes.
+                Self::from_bytes(obj.as_ssz_bytes().as_slice()).unwrap()
+            }
+        }
+
+        impl_ssz!($name, $byte_size, "$type");
+
+        impl_tree_hash!($name, $ssz_type_size);
+
+        impl_cached_tree_hash!($name, $ssz_type_size);
+
+        impl serde::ser::Serialize for $name {
+            /// Serde serialization is compliant the Ethereum YAML test format.
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: serde::ser::Serializer,
+            {
+                serializer.serialize_str(&hex::encode(ssz::ssz_encode(self)))
+            }
+        }
+
+        impl<'de> serde::de::Deserialize<'de> for $name {
+            /// Serde serialization is compliant the Ethereum YAML test format.
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+            where
+                D: serde::de::Deserializer<'de>,
+            {
+                let bytes = deserializer.deserialize_str(serde_hex::HexVisitor)?;
+                let signature = Self::from_ssz_bytes(&bytes[..])
+                    .map_err(|e| serde::de::Error::custom(format!("invalid ssz ({:?})", e)))?;
+                Ok(signature)
+            }
+        }
+    };
+}

eth2/utils/bls/src/public_key.rs

@@ -150,6 +150,15 @@ mod tests {
         assert_eq!(original, decoded);
     }
 
+    #[test]
+    pub fn test_byte_size() {
+        let sk = SecretKey::random();
+        let original = PublicKey::from_secret_key(&sk);
+
+        let bytes = ssz_encode(&original);
+        assert_eq!(bytes.len(), BLS_PUBLIC_KEY_BYTE_SIZE);
+    }
+
     #[test]
     // TODO: once `CachedTreeHash` is fixed, this test should _not_ panic.
     #[should_panic]

eth2/utils/bls/src/public_key_bytes.rs

@@ -0,0 +1,43 @@
+use ssz::{Decode, DecodeError, Encode};
+
+use super::{PublicKey, BLS_PUBLIC_KEY_BYTE_SIZE};
+
+bytes_struct!(
+    PublicKeyBytes,
+    PublicKey,
+    BLS_PUBLIC_KEY_BYTE_SIZE,
+    "public key",
+    U48
+);
+
+#[cfg(test)]
+mod tests {
+    use std::convert::TryInto;
+
+    use ssz::ssz_encode;
+
+    use super::super::Keypair;
+    use super::*;
+
+    #[test]
+    pub fn test_valid_public_key() {
+        let keypair = Keypair::random();
+
+        let bytes = ssz_encode(&keypair.pk);
+        let public_key_bytes = PublicKeyBytes::from_bytes(&bytes).unwrap();
+        let public_key: Result<PublicKey, _> = (&public_key_bytes).try_into();
+        assert!(public_key.is_ok());
+        assert_eq!(keypair.pk, public_key.unwrap());
+    }
+
+    #[test]
+    pub fn test_invalid_public_key() {
+        let mut public_key_bytes = [0; BLS_PUBLIC_KEY_BYTE_SIZE];
+        public_key_bytes[0] = 255; //a_flag1 == b_flag1 == c_flag1 == 1 and x1 = 0 shouldn't be allowed
+        let public_key_bytes = PublicKeyBytes::from_bytes(&public_key_bytes[..]);
+        assert!(public_key_bytes.is_ok());
+
+        let public_key: Result<PublicKey, _> = public_key_bytes.as_ref().unwrap().try_into();
+        assert!(public_key.is_err());
+    }
+}

eth2/utils/bls/src/signature.rs

@@ -155,6 +155,15 @@ mod tests {
         assert_eq!(original, decoded);
     }
 
+    #[test]
+    pub fn test_byte_size() {
+        let keypair = Keypair::random();
+
+        let signature = Signature::new(&[42, 42], 0, &keypair.sk);
+        let bytes = ssz_encode(&signature);
+        assert_eq!(bytes.len(), BLS_SIG_BYTE_SIZE);
+    }
+
     #[test]
     // TODO: once `CachedTreeHash` is fixed, this test should _not_ panic.
     #[should_panic]

eth2/utils/bls/src/signature_bytes.rs

@@ -0,0 +1,44 @@
+use ssz::{Decode, DecodeError, Encode};
+
+use super::{Signature, BLS_SIG_BYTE_SIZE};
+
+bytes_struct!(
+    SignatureBytes,
+    Signature,
+    BLS_SIG_BYTE_SIZE,
+    "signature",
+    U96
+);
+
+#[cfg(test)]
+mod tests {
+    use std::convert::TryInto;
+
+    use ssz::ssz_encode;
+
+    use super::super::Keypair;
+    use super::*;
+
+    #[test]
+    pub fn test_valid_signature() {
+        let keypair = Keypair::random();
+        let original = Signature::new(&[42, 42], 0, &keypair.sk);
+
+        let bytes = ssz_encode(&original);
+        let signature_bytes = SignatureBytes::from_bytes(&bytes).unwrap();
+        let signature: Result<Signature, _> = (&signature_bytes).try_into();
+        assert!(signature.is_ok());
+        assert_eq!(original, signature.unwrap());
+    }
+
+    #[test]
+    pub fn test_invalid_signature() {
+        let mut signature_bytes = [0; BLS_SIG_BYTE_SIZE];
+        signature_bytes[0] = 255; //a_flag1 == b_flag1 == c_flag1 == 1 and x1 = 0 shouldn't be allowed
+        let signature_bytes = SignatureBytes::from_bytes(&signature_bytes[..]);
+        assert!(signature_bytes.is_ok());
+
+        let signature: Result<Signature, _> = signature_bytes.as_ref().unwrap().try_into();
+        assert!(signature.is_err());
+    }
+}