Update dalek

The two failing ed25519 tests are likely the cause of all the other
failures, but it'll take some actual attention to figure out what's
going on with them.

Author: skeet70

Cargo.toml

@@ -23,7 +23,7 @@ cfg-if = "1"
 clear_on_drop = "0.2"
 derivative = "2.1"
 # Disable all features for ed25519 and enable the proper ones down in the [features] section below
-ed25519-dalek = {version = "=0.1.0", default-features = false, features = ["std"], package = "ed25519-dalek-fiat"}
+ed25519-dalek = {version = "2.1.1", default-features = false, features = ["std", "rand_core"]}
 # Explicit dependency so we can pass the wasm-bindgen flag to it
 getrandom = {version = "0.2", optional = true}
 gridiron = "0.10"
@@ -55,10 +55,7 @@ debug = false
 lto = true
 
 [features]
-default = ["u64_backend"]
-u64_backend = ["ed25519-dalek/u64_backend"]
-u32_backend = ["ed25519-dalek/u32_backend"]
-wasm = ["u32_backend", "clear_on_drop/no_cc", "getrandom/js"]
+wasm = ["clear_on_drop/no_cc", "getrandom/js"]
 #Can be used to disable the automatic mlock detection for architectures.
 disable_memlock = []
 

flake.lock

@@ -1,3 +1,3 @@
 [toolchain]
 profile = "default"
-channel = "1.67.1"
+channel = "1.70.0"

rust-toolchain.toml

@@ -5,7 +5,6 @@ use crate::internal::ByteVector;
 use crate::internal::{array_split_64, take_lock};
 use clear_on_drop::clear::Clear;
 use ed25519_dalek;
-use ed25519_dalek::PublicKey;
 use quick_error::quick_error;
 use rand;
 use std;
@@ -64,10 +63,10 @@ impl From<SigningKeypair> for [u8; 64] {
 impl SigningKeypair {
     const ENCODED_SIZE_BYTES: usize = 64;
     pub fn new<CR: rand::RngCore + rand::CryptoRng>(rng: &Mutex<CR>) -> SigningKeypair {
-        let keypair = ed25519_dalek::Keypair::generate::<CR>(&mut *take_lock(rng));
+        let signing_key = ed25519_dalek::SigningKey::generate::<CR>(&mut *take_lock(rng));
 
         //Unchecked is safe because the public is on the curve and the size is statically guaranteed.
-        SigningKeypair::new_unchecked(keypair.to_bytes())
+        SigningKeypair::new_unchecked(signing_key.to_keypair_bytes())
     }
     ///
     ///Create a SigningKeypair from a byte array slice. If the array is not the right length or if the public
@@ -93,16 +92,11 @@ impl SigningKeypair {
     ///match the private key.
     ///
     pub fn from_bytes(sized_bytes: &[u8; 64]) -> Result<SigningKeypair, Ed25519Error> {
-        let (priv_key, pub_key) = array_split_64(sized_bytes);
-        //This can't fail because it's statically guaranteed to be 32 bytes long.
-        let ed25519_dalek_secret = ed25519_dalek::SecretKey::from_bytes(&priv_key).unwrap();
+        let (_, pub_key) = array_split_64(sized_bytes);
         //Calculate the public key to check that the value passed in is correct.
-        let ed25519_dalek_pub = ed25519_dalek::PublicKey::from(&ed25519_dalek_secret);
-        if ed25519_dalek_pub.to_bytes() == pub_key {
-            Ok(SigningKeypair::new_unchecked(*sized_bytes))
-        } else {
-            Err(Ed25519Error::PublicKeyInvalid(pub_key))
-        }
+        let ed25519_dalek_pub = ed25519_dalek::VerifyingKey::from_bytes(&pub_key)
+            .map_err(|_| Ed25519Error::PublicKeyInvalid(pub_key))?;
+        Ok(SigningKeypair::new_unchecked(*sized_bytes))
     }
 
     pub(crate) fn new_unchecked(bytes: [u8; 64]) -> SigningKeypair {
@@ -153,7 +147,7 @@ impl Ed25519Signing for Ed25519 {
         use ed25519_dalek::Signer;
         //This unwrap cannot fail. The only thing that the `from_bytes` does for validation is that the
         //value is 64 bytes long, which we guarantee statically.
-        let key_pair = ed25519_dalek::Keypair::from_bytes(&signing_key.bytes[..]).unwrap();
+        let key_pair = ed25519_dalek::SigningKey::from_bytes(signing_key.public_key().bytes());
         let sig = key_pair.sign(&t.to_bytes()[..]);
 
         Ed25519Signature::new(sig.to_bytes())
@@ -166,10 +160,10 @@ impl Ed25519Signing for Ed25519 {
     ) -> bool {
         use ed25519_dalek::Verifier;
 
-        PublicKey::from_bytes(&public_key.bytes[..])
+        ed25519_dalek::VerifyingKey::from_bytes(&public_key.bytes)
             .and_then(|pk| {
-                TryFrom::try_from(&signature.bytes[..])
-                    .and_then(|sig| pk.verify(&t.to_bytes()[..], &sig))
+                let sig = ed25519_dalek::Signature::from_bytes(&signature.bytes);
+                pk.verify(&t.to_bytes()[..], &sig)
             })
             .map(|_| true)
             .unwrap_or(false)
@@ -197,7 +191,6 @@ pub trait Ed25519Signing {
 pub(crate) mod test {
     use super::*;
     use crate::internal::array_concat_32;
-    use ed25519_dalek::SecretKey;
 
     pub fn good_signing_keypair() -> SigningKeypair {
         SigningKeypair::new_unchecked([
@@ -209,10 +202,9 @@ pub(crate) mod test {
 
     #[test]
     fn real_ed25519_matches_verify_good_message() {
-        let sec_key = SecretKey::from_bytes(&[1; 32]).unwrap();
-        let dalek_pub_key = ed25519_dalek::PublicKey::from(&sec_key);
+        let dalek_pub_key = ed25519_dalek::VerifyingKey::from_bytes(&[1u8; 32]).unwrap();
         let priv_key = SigningKeypair {
-            bytes: array_concat_32(&sec_key.to_bytes(), &dalek_pub_key.to_bytes()),
+            bytes: array_concat_32(&[1u8; 32], &dalek_pub_key.to_bytes()),
         };
         let message = [100u8; 32].to_vec();
         let result = Ed25519.sign(&message, &priv_key);
@@ -238,10 +230,9 @@ pub(crate) mod test {
 
     #[test]
     fn signing_keypair_into_bytes() {
-        let sec_key = SecretKey::from_bytes(&[1; 32]).unwrap();
-        let dalek_pub_key = ed25519_dalek::PublicKey::from(&sec_key);
+        let dalek_pub_key = ed25519_dalek::VerifyingKey::from_bytes(&[1u8; 32]).unwrap();
         let key_pair = SigningKeypair {
-            bytes: array_concat_32(&sec_key.to_bytes(), &dalek_pub_key.to_bytes()),
+            bytes: array_concat_32(&[1u8; 32], &dalek_pub_key.to_bytes()),
         };
         let key_pair_bytes = key_pair.bytes().clone();
         let bytes: [u8; 64] = key_pair.into();