Merge pull request #354 from vincenthz/coxide4

bump version of cryptoxide and ed25519-bip32

Author: vsubhuman

rust/Cargo.lock

@@ -15,9 +15,9 @@ exclude = [
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-cryptoxide = "0.3.2"
+cryptoxide = "0.4.2"
 cbor_event = "2.1.3"
-ed25519-bip32 = "0.3.2"
+ed25519-bip32 = "0.4.1"
 sha2 = "^0.9"
 digest = "^0.9"
 bech32 = "0.7.2"

rust/Cargo.toml

@@ -1,7 +1,9 @@
 use crate::chain_crypto::key::{
     AsymmetricKey, AsymmetricPublicKey, PublicKeyError, SecretKeyError, SecretKeySizeStatic,
 };
-use crate::chain_crypto::sign::{SignatureError, SigningAlgorithm, Verification, VerificationAlgorithm};
+use crate::chain_crypto::sign::{
+    SignatureError, SigningAlgorithm, Verification, VerificationAlgorithm,
+};
 use cryptoxide::ed25519;
 use rand_os::rand_core::{CryptoRng, RngCore};
 
@@ -11,7 +13,7 @@ use ed25519_bip32::XPub;
 pub struct Ed25519;
 
 #[derive(Clone)]
-pub struct Priv([u8; ed25519::SEED_LENGTH]);
+pub struct Priv([u8; ed25519::PRIVATE_KEY_LENGTH]);
 
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub struct Pub(pub(crate) [u8; ed25519::PUBLIC_KEY_LENGTH]);
@@ -68,7 +70,7 @@ impl AsymmetricKey for Ed25519 {
     const SECRET_BECH32_HRP: &'static str = "ed25519_sk";
 
     fn generate<T: RngCore + CryptoRng>(mut rng: T) -> Self::Secret {
-        let mut priv_bytes = [0u8; ed25519::SEED_LENGTH];
+        let mut priv_bytes = [0u8; ed25519::PRIVATE_KEY_LENGTH];
         rng.fill_bytes(&mut priv_bytes);
         Priv(priv_bytes)
     }
@@ -79,17 +81,17 @@ impl AsymmetricKey for Ed25519 {
     }
 
     fn secret_from_binary(data: &[u8]) -> Result<Self::Secret, SecretKeyError> {
-        if data.len() != ed25519::SEED_LENGTH {
+        if data.len() != ed25519::PRIVATE_KEY_LENGTH {
             return Err(SecretKeyError::SizeInvalid);
         }
-        let mut buf = [0; ed25519::SEED_LENGTH];
-        buf[0..ed25519::SEED_LENGTH].clone_from_slice(data);
+        let mut buf = [0; ed25519::PRIVATE_KEY_LENGTH];
+        buf[0..ed25519::PRIVATE_KEY_LENGTH].clone_from_slice(data);
         Ok(Priv(buf))
     }
 }
 
 impl SecretKeySizeStatic for Ed25519 {
-    const SECRET_KEY_SIZE: usize = ed25519::SEED_LENGTH;
+    const SECRET_KEY_SIZE: usize = ed25519::PRIVATE_KEY_LENGTH;
 }
 
 impl VerificationAlgorithm for Ed25519 {
@@ -115,7 +117,7 @@ impl VerificationAlgorithm for Ed25519 {
         signature: &Self::Signature,
         msg: &[u8],
     ) -> Verification {
-        ed25519::verify(msg, &pubkey.0, signature.as_ref()).into()
+        ed25519::verify(msg, &pubkey.0, &signature.0).into()
     }
 }
 

rust/src/chain_crypto/algorithms/ed25519.rs

@@ -1,4 +1,6 @@
-use crate::chain_crypto::key::{AsymmetricKey, AsymmetricPublicKey, SecretKeyError, SecretKeySizeStatic};
+use crate::chain_crypto::key::{
+    AsymmetricKey, AsymmetricPublicKey, SecretKeyError, SecretKeySizeStatic,
+};
 use crate::chain_crypto::sign::SigningAlgorithm;
 
 use super::ed25519 as ei;
@@ -12,7 +14,7 @@ use ed25519_bip32::{XPrv, XPRV_SIZE};
 pub struct Ed25519Extended;
 
 #[derive(Clone)]
-pub struct ExtendedPriv([u8; ed25519::PRIVATE_KEY_LENGTH]);
+pub struct ExtendedPriv([u8; ed25519::EXTENDED_KEY_LENGTH]);
 
 impl AsRef<[u8]> for ExtendedPriv {
     fn as_ref(&self) -> &[u8] {
@@ -22,7 +24,7 @@ impl AsRef<[u8]> for ExtendedPriv {
 
 impl ExtendedPriv {
     pub fn from_xprv(xprv: &XPrv) -> Self {
-        let mut buf = [0; ed25519::PRIVATE_KEY_LENGTH];
+        let mut buf = [0; ed25519::EXTENDED_KEY_LENGTH];
         xprv.get_extended_mut(&mut buf);
         ExtendedPriv(buf)
     }
@@ -39,22 +41,22 @@ impl AsymmetricKey for Ed25519Extended {
         rng.fill_bytes(&mut priv_bytes);
         let xprv = XPrv::normalize_bytes_force3rd(priv_bytes);
 
-        let mut out = [0u8; ed25519::PRIVATE_KEY_LENGTH];
+        let mut out = [0u8; ed25519::EXTENDED_KEY_LENGTH];
         xprv.get_extended_mut(&mut out);
         ExtendedPriv(out)
     }
 
     fn compute_public(key: &Self::Secret) -> <Self::PubAlg as AsymmetricPublicKey>::Public {
-        let pk = ed25519::to_public(&key.0);
+        let pk = ed25519::extended_to_public(&key.0);
         ei::Pub(pk)
     }
 
     fn secret_from_binary(data: &[u8]) -> Result<Self::Secret, SecretKeyError> {
-        if data.len() != ed25519::PRIVATE_KEY_LENGTH {
+        if data.len() != ed25519::EXTENDED_KEY_LENGTH {
             return Err(SecretKeyError::SizeInvalid);
         }
-        let mut buf = [0; ed25519::PRIVATE_KEY_LENGTH];
-        buf[0..ed25519::PRIVATE_KEY_LENGTH].clone_from_slice(data);
+        let mut buf = [0; ed25519::EXTENDED_KEY_LENGTH];
+        buf.clone_from_slice(data);
         // TODO structure check
         Ok(ExtendedPriv(buf))
     }

rust/src/chain_crypto/algorithms/ed25519_extended.rs

@@ -1,7 +1,9 @@
 use crate::chain_crypto::key::{
     AsymmetricKey, AsymmetricPublicKey, PublicKeyError, SecretKeyError, SecretKeySizeStatic,
 };
-use crate::chain_crypto::sign::{SignatureError, SigningAlgorithm, Verification, VerificationAlgorithm};
+use crate::chain_crypto::sign::{
+    SignatureError, SigningAlgorithm, Verification, VerificationAlgorithm,
+};
 
 use cryptoxide::digest::Digest;
 use cryptoxide::hmac::Hmac;
@@ -35,17 +37,15 @@ impl LegacyPriv {
         LegacyPriv(buf)
     }
 
-    pub fn inner_key(&self) -> [u8; ed25519::PRIVATE_KEY_LENGTH] {
-        let mut buf = [0; ed25519::PRIVATE_KEY_LENGTH];
-        buf[0..ed25519::PRIVATE_KEY_LENGTH]
-            .clone_from_slice(&self.0.as_ref()[0..ed25519::PRIVATE_KEY_LENGTH]);
+    pub fn inner_key(&self) -> [u8; ed25519::EXTENDED_KEY_LENGTH] {
+        let mut buf = [0; ed25519::EXTENDED_KEY_LENGTH];
+        buf.clone_from_slice(&self.0.as_ref()[0..ed25519::EXTENDED_KEY_LENGTH]);
         buf
     }
 
     pub fn chaincode(&self) -> [u8; CHAIN_CODE_SIZE] {
         let mut buf = [0; CHAIN_CODE_SIZE];
-        buf[0..CHAIN_CODE_SIZE]
-            .clone_from_slice(&self.0.as_ref()[ed25519::PRIVATE_KEY_LENGTH..XPRV_SIZE]);
+        buf.clone_from_slice(&self.0.as_ref()[ed25519::EXTENDED_KEY_LENGTH..XPRV_SIZE]);
         buf
     }
 }
@@ -94,7 +94,7 @@ impl AsymmetricKey for LegacyDaedalus {
 
     fn compute_public(key: &Self::Secret) -> <Self as AsymmetricPublicKey>::Public {
         let ed25519e = key.inner_key();
-        let pubkey = ed25519::to_public(&ed25519e);
+        let pubkey = ed25519::extended_to_public(&ed25519e);
         let chaincode = key.chaincode();
 
         let mut buf = [0; XPUB_SIZE];