diff --git a/src/bases/b58.rs b/src/bases/b58.rs index fea202ca5ebea468c46cefecea6866d2f52edcfc..1f8b08ded8c6671347bffa9dbab7ce55eb53abc6 100644 --- a/src/bases/b58.rs +++ b/src/bases/b58.rs @@ -25,7 +25,12 @@ pub trait ToBase58 { /// Create an array of 32 bytes from a Base58 string. pub fn str_base58_to_32bytes(base58_data: &str) -> Result<([u8; 32], usize), BaseConvertionError> { - match bs58::decode(base58_data).into_vec() { + let mut source = base58_data; + while !source.is_empty() && &source[0..1] == "1" { + source = &source[1..]; + } + + match bs58::decode(source).into_vec() { Ok(result) => { let len = result.len(); if len <= 32 { diff --git a/src/keys/ed25519.rs b/src/keys/ed25519.rs index 92f22dd9317aa3fe505c82c243632a5abbe3da01..0a7d84cec0b22d897a30a871f5b38ca1dfa50062 100644 --- a/src/keys/ed25519.rs +++ b/src/keys/ed25519.rs @@ -43,11 +43,9 @@ use unwrap::unwrap; use zeroize::Zeroize; /// Maximal size of a public key in bytes -pub static PUBKEY_SIZE_IN_BYTES: &usize = &32; -/// Minimal size of a public key in bytes -pub static PUBKEY_MIN_SIZE_IN_BYTES: &usize = &31; -/// Size of a signature in bytes -pub static SIG_SIZE_IN_BYTES: &usize = &64; +pub const PUBKEY_SIZE_IN_BYTES: usize = 32; +/// constf a signature in bytes +pub const SIG_SIZE_IN_BYTES: usize = 64; /// Store a ed25519 signature. #[derive(Clone, Copy)] @@ -167,7 +165,7 @@ impl Default for PublicKey { fn default() -> Self { PublicKey { datas: [0u8; 32], - len: 32, + len: 0, } } } @@ -182,9 +180,9 @@ impl TryFrom<&[u8]> for PublicKey { type Error = PubkeyFromBytesError; fn try_from(bytes: &[u8]) -> Result<Self, Self::Error> { - if bytes.len() > *PUBKEY_SIZE_IN_BYTES || bytes.len() < *PUBKEY_MIN_SIZE_IN_BYTES { + if bytes.len() > PUBKEY_SIZE_IN_BYTES { Err(PubkeyFromBytesError::InvalidBytesLen { - expected: *PUBKEY_SIZE_IN_BYTES, + expected: PUBKEY_SIZE_IN_BYTES, found: bytes.len(), }) } else { @@ -223,14 +221,7 @@ impl super::PublicKey for PublicKey { #[inline] fn from_base58(base58_data: &str) -> Result<Self, BaseConvertionError> { let (datas, len) = b58::str_base58_to_32bytes(base58_data)?; - if len < *PUBKEY_MIN_SIZE_IN_BYTES { - Err(BaseConvertionError::InvalidLength { - expected: *PUBKEY_SIZE_IN_BYTES, - found: len, - }) - } else { - Ok(PublicKey { datas, len }) - } + Ok(PublicKey { datas, len }) } fn to_bytes_vector(&self) -> Vec<u8> { @@ -489,6 +480,12 @@ mod tests { ); } + #[test] + fn test_pubkey_111_from_base58() { + let public58 = "11111111111111111111111111111111111111111111"; + let _ = unwrap!(super::PublicKey::from_base58(public58)); + } + #[test] fn base58_public_key() { let public58 = "DNann1Lh55eZMEDXeYt59bzHbA3NJR46DeQYCS2qQdLV"; @@ -578,7 +575,7 @@ mod tests { // Test signature serialization/deserialization let mut bin_sig = bincode::serialize(&signature).expect("Fail to serialize signature !"); - assert_eq!(*SIG_SIZE_IN_BYTES, bin_sig.len()); + assert_eq!(SIG_SIZE_IN_BYTES, bin_sig.len()); assert_eq!(signature.to_bytes_vector(), bin_sig); assert_eq!( signature, diff --git a/src/keys/mod.rs b/src/keys/mod.rs index a69823d2a20aff1fb95a1c824de3c686f79c0d95..3f31d9f374a5b3695b3293043c93026347a798f0 100644 --- a/src/keys/mod.rs +++ b/src/keys/mod.rs @@ -162,7 +162,7 @@ impl Sig { /// Get Sig size in bytes pub fn size_in_bytes(&self) -> usize { match *self { - Sig::Ed25519(_) => *ed25519::SIG_SIZE_IN_BYTES + 2, + Sig::Ed25519(_) => ed25519::SIG_SIZE_IN_BYTES + 2, Sig::Schnorr() => panic!("Schnorr algo not yet supported !"), } } @@ -494,7 +494,7 @@ mod tests { let sig_str_b64 = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==".to_owned(); let sig = Sig::Ed25519(ed25519::Signature(sig_bytes)); - assert_eq!(sig.size_in_bytes(), *ed25519::SIG_SIZE_IN_BYTES + 2); + assert_eq!(sig.size_in_bytes(), ed25519::SIG_SIZE_IN_BYTES + 2); assert_eq!(sig_str_b64, format!("{}", sig)); assert_eq!(KeysAlgo::Ed25519, sig.algo()); @@ -508,10 +508,7 @@ mod tests { #[test] fn pubkey() { let pubkey_default = PubKey::default(); - let pubkey_bytes = [ - 0u8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, - ]; + let pubkey_bytes = []; let pubkey = PubKey::Ed25519(unwrap!(ed25519::PublicKey::try_from(&pubkey_bytes[..]))); assert_eq!(pubkey_default, pubkey); @@ -521,15 +518,15 @@ mod tests { PubKey::from_str(&pubkey_str_b58).expect("Fail to parse pubkey !") ); - assert_eq!(pubkey.size_in_bytes(), *ed25519::PUBKEY_SIZE_IN_BYTES + 3); - assert_eq!(pubkey_str_b58, format!("{}", pubkey)); + assert_eq!(pubkey.size_in_bytes(), ed25519::PUBKEY_SIZE_IN_BYTES + 3); + assert_eq!("", &format!("{}", pubkey)); assert_eq!(KeysAlgo::Ed25519, pubkey.algo()); assert_eq!(KeysAlgo::Schnorr, PubKey::Schnorr().algo()); assert_eq!(pubkey_bytes.to_vec(), pubkey.to_bytes_vector()); - assert_eq!(pubkey_str_b58, pubkey.to_base58()); + assert_eq!("", &pubkey.to_base58()); assert_eq!( Err(SigError::InvalidSig), @@ -721,14 +718,7 @@ mod tests { fn pubkey_from_bytes() { assert_eq!( Err(PubkeyFromBytesError::InvalidBytesLen { - expected: *ed25519::PUBKEY_SIZE_IN_BYTES, - found: 2, - }), - PubKey::from_bytes(&[0u8, 1]), - ); - assert_eq!( - Err(PubkeyFromBytesError::InvalidBytesLen { - expected: *ed25519::PUBKEY_SIZE_IN_BYTES, + expected: ed25519::PUBKEY_SIZE_IN_BYTES, found: 33, }), PubKey::from_bytes(&[ @@ -738,7 +728,7 @@ mod tests { ); assert_eq!( Ok(PubKey::Ed25519(ed25519::PublicKey::default())), - PubKey::from_bytes(&[0u8; 32]), + PubKey::from_bytes(&[]), ); } }