Address Clippy lints (#543)

.github/workflows/workspace.yml

@@ -65,7 +65,7 @@ jobs:
     - uses: dtolnay/rust-toolchain@nightly
       with:
         components: clippy
-    - run: cargo clippy --target x86_64-unknown-linux-gnu
+    - run: cargo clippy --target x86_64-unknown-linux-gnu --all-features
 
   rustfmt:
     name: Check formatting

curve25519-dalek-derive/tests/tests.rs

@@ -83,9 +83,7 @@ impl<T: Copy + core::ops::Sub> StructWithGenericsNoWhere<T> {
 #[unsafe_target_feature("sse2")]
 #[allow(dead_code)]
 impl<'a> From<&'a Struct> for () {
-    fn from(_: &'a Struct) -> Self {
+    fn from(_: &'a Struct) -> Self {}
-        ()
-    }
 }
 
 #[unsafe_target_feature("sse2")]
@@ -97,8 +95,6 @@ mod inner {
 
 #[unsafe_target_feature_specialize("sse2", "avx2", conditional("avx512ifma", disabled))]
 mod inner_spec {
-    use std;
-
     #[for_target_feature("sse2")]
     const CONST: u32 = 1;
 

curve25519-dalek/benches/dalek_benchmarks.rs

@@ -147,14 +147,14 @@ mod multiscalar_benches {
                     let static_size = total_size;
 
                     let static_points = construct_points(static_size);
-                    let precomp = VartimeEdwardsPrecomputation::new(&static_points);
+                    let precomp = VartimeEdwardsPrecomputation::new(static_points);
                     // Rerandomize the scalars for every call to prevent
                     // false timings from better caching (e.g., the CPU
                     // cache lifts exactly the right table entries for the
                     // benchmark into the highest cache levels).
                     b.iter_batched(
                         || construct_scalars(static_size),
-                        |scalars| precomp.vartime_multiscalar_mul(&scalars),
+                        |scalars| precomp.vartime_multiscalar_mul(scalars),
                         BatchSize::SmallInput,
                     );
                 },
@@ -182,7 +182,7 @@ mod multiscalar_benches {
 
                 let static_points = construct_points(static_size);
                 let dynamic_points = construct_points(dynamic_size);
-                let precomp = VartimeEdwardsPrecomputation::new(&static_points);
+                let precomp = VartimeEdwardsPrecomputation::new(static_points);
                 // Rerandomize the scalars for every call to prevent
                 // false timings from better caching (e.g., the CPU
                 // cache lifts exactly the right table entries for the

curve25519-dalek/src/edwards.rs

@@ -276,6 +276,7 @@ impl<'de> Deserialize<'de> for EdwardsPoint {
                 A: serde::de::SeqAccess<'de>,
             {
                 let mut bytes = [0u8; 32];
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?
@@ -311,6 +312,7 @@ impl<'de> Deserialize<'de> for CompressedEdwardsY {
                 A: serde::de::SeqAccess<'de>,
             {
                 let mut bytes = [0u8; 32];
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?

curve25519-dalek/src/ristretto.rs

@@ -388,6 +388,7 @@ impl<'de> Deserialize<'de> for RistrettoPoint {
                 A: serde::de::SeqAccess<'de>,
             {
                 let mut bytes = [0u8; 32];
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?
@@ -423,6 +424,7 @@ impl<'de> Deserialize<'de> for CompressedRistretto {
                 A: serde::de::SeqAccess<'de>,
             {
                 let mut bytes = [0u8; 32];
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?
@@ -1270,7 +1272,7 @@ mod test {
         let bp_compressed_ristretto = constants::RISTRETTO_BASEPOINT_POINT.compress();
         let bp_recaf = bp_compressed_ristretto.decompress().unwrap().0;
         // Check that bp_recaf differs from bp by a point of order 4
-        let diff = &constants::RISTRETTO_BASEPOINT_POINT.0 - bp_recaf;
+        let diff = constants::RISTRETTO_BASEPOINT_POINT.0 - bp_recaf;
         let diff4 = diff.mul_by_pow_2(2);
         assert_eq!(diff4.compress(), CompressedEdwardsY::identity());
     }
@@ -1681,7 +1683,7 @@ mod test {
         ];
         // Check that onewaymap(input) == output for all the above vectors
         for (input, output) in test_vectors {
-            let Q = RistrettoPoint::from_uniform_bytes(&input);
+            let Q = RistrettoPoint::from_uniform_bytes(input);
             assert_eq!(&Q.compress(), output);
         }
     }

curve25519-dalek/src/scalar.rs

@@ -436,13 +436,14 @@ impl<'de> Deserialize<'de> for Scalar {
                 A: serde::de::SeqAccess<'de>,
             {
                 let mut bytes = [0u8; 32];
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?
                         .ok_or_else(|| serde::de::Error::invalid_length(i, &"expected 32 bytes"))?;
                 }
                 Option::from(Scalar::from_canonical_bytes(bytes))
-                    .ok_or_else(|| serde::de::Error::custom(&"scalar was not canonically encoded"))
+                    .ok_or_else(|| serde::de::Error::custom("scalar was not canonically encoded"))
             }
         }
 
@@ -1476,13 +1477,13 @@ pub(crate) mod test {
     #[cfg(feature = "alloc")]
     fn impl_product() {
         // Test that product works for non-empty iterators
-        let X_Y_vector = vec![X, Y];
+        let X_Y_vector = [X, Y];
         let should_be_X_times_Y: Scalar = X_Y_vector.iter().product();
         assert_eq!(should_be_X_times_Y, X_TIMES_Y);
 
         // Test that product works for the empty iterator
         let one = Scalar::ONE;
-        let empty_vector = vec![];
+        let empty_vector = [];
         let should_be_one: Scalar = empty_vector.iter().product();
         assert_eq!(should_be_one, one);
 
@@ -1507,13 +1508,13 @@ pub(crate) mod test {
     fn impl_sum() {
         // Test that sum works for non-empty iterators
         let two = Scalar::from(2u64);
-        let one_vector = vec![Scalar::ONE, Scalar::ONE];
+        let one_vector = [Scalar::ONE, Scalar::ONE];
         let should_be_two: Scalar = one_vector.iter().sum();
         assert_eq!(should_be_two, two);
 
         // Test that sum works for the empty iterator
         let zero = Scalar::ZERO;
-        let empty_vector = vec![];
+        let empty_vector = [];
         let should_be_zero: Scalar = empty_vector.iter().sum();
         assert_eq!(should_be_zero, zero);
 

ed25519-dalek/benches/ed25519_benchmarks.rs

@@ -64,8 +64,7 @@ mod ed25519_benches {
                     .collect();
                 let msg: &[u8] = b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
                 let messages: Vec<&[u8]> = (0..size).map(|_| msg).collect();
-                let signatures: Vec<Signature> =
+                let signatures: Vec<Signature> = keypairs.iter().map(|key| key.sign(msg)).collect();
-                    keypairs.iter().map(|key| key.sign(&msg)).collect();
                 let verifying_keys: Vec<_> =
                     keypairs.iter().map(|key| key.verifying_key()).collect();
 

ed25519-dalek/src/batch.rs

@@ -176,7 +176,7 @@ pub fn verify_batch(
             let mut h: Sha512 = Sha512::default();
             h.update(signatures[i].r_bytes());
             h.update(verifying_keys[i].as_bytes());
-            h.update(&messages[i]);
+            h.update(messages[i]);
             *h.finalize().as_ref()
         })
         .collect();

ed25519-dalek/src/context.rs

@@ -80,6 +80,8 @@ impl<'k, 'v, K> Context<'k, 'v, K> {
 
 #[cfg(all(test, feature = "digest"))]
 mod test {
+    #![allow(clippy::unwrap_used)]
+
     use crate::{Signature, SigningKey, VerifyingKey};
     use curve25519_dalek::digest::Digest;
     use ed25519::signature::{DigestSigner, DigestVerifier};

ed25519-dalek/src/hazmat.rs

@@ -156,11 +156,11 @@ where
 /// [rfc8032]: https://tools.ietf.org/html/rfc8032#section-5.1
 #[cfg(feature = "digest")]
 #[allow(non_snake_case)]
-pub fn raw_sign_prehashed<'a, CtxDigest, MsgDigest>(
+pub fn raw_sign_prehashed<CtxDigest, MsgDigest>(
     esk: &ExpandedSecretKey,
     prehashed_message: MsgDigest,
     verifying_key: &VerifyingKey,
-    context: Option<&'a [u8]>,
+    context: Option<&[u8]>,
 ) -> Result<Signature, SignatureError>
 where
     MsgDigest: Digest<OutputSize = U64>,
@@ -204,6 +204,8 @@ where
 
 #[cfg(test)]
 mod test {
+    #![allow(clippy::unwrap_used)]
+
     use super::*;
 
     use rand::{rngs::OsRng, CryptoRng, RngCore};
@@ -226,8 +228,8 @@ mod test {
     #[test]
     fn sign_verify_nonspec() {
         // Generate the keypair
-        let mut rng = OsRng;
+        let rng = OsRng;
-        let esk = ExpandedSecretKey::random(&mut rng);
+        let esk = ExpandedSecretKey::random(rng);
         let vk = VerifyingKey::from(&esk);
 
         let msg = b"Then one day, a piano fell on my head";
@@ -245,8 +247,8 @@ mod test {
         use curve25519_dalek::digest::Digest;
 
         // Generate the keypair
-        let mut rng = OsRng;
+        let rng = OsRng;
-        let esk = ExpandedSecretKey::random(&mut rng);
+        let esk = ExpandedSecretKey::random(rng);
         let vk = VerifyingKey::from(&esk);
 
         // Hash the message

ed25519-dalek/src/signing.rs

@@ -700,7 +700,7 @@ impl<'d> Deserialize<'d> for SigningKey {
                 self,
                 bytes: &'de [u8],
             ) -> Result<Self::Value, E> {
-                SigningKey::try_from(bytes.as_ref()).map_err(E::custom)
+                SigningKey::try_from(bytes).map_err(E::custom)
             }
 
             fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
@@ -708,6 +708,7 @@ impl<'d> Deserialize<'d> for SigningKey {
                 A: serde::de::SeqAccess<'de>,
             {
                 let mut bytes = [0u8; 32];
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?
@@ -797,11 +798,11 @@ impl ExpandedSecretKey {
     #[cfg(feature = "digest")]
     #[allow(non_snake_case)]
     #[inline(always)]
-    pub(crate) fn raw_sign_prehashed<'a, CtxDigest, MsgDigest>(
+    pub(crate) fn raw_sign_prehashed<CtxDigest, MsgDigest>(
         &self,
         prehashed_message: MsgDigest,
         verifying_key: &VerifyingKey,
-        context: Option<&'a [u8]>,
+        context: Option<&[u8]>,
     ) -> Result<Signature, SignatureError>
     where
         CtxDigest: Digest<OutputSize = U64>,

ed25519-dalek/src/verifying.rs

@@ -640,7 +640,7 @@ impl<'d> Deserialize<'d> for VerifyingKey {
                 self,
                 bytes: &'de [u8],
             ) -> Result<Self::Value, E> {
-                VerifyingKey::try_from(bytes.as_ref()).map_err(E::custom)
+                VerifyingKey::try_from(bytes).map_err(E::custom)
             }
 
             fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
@@ -649,6 +649,7 @@ impl<'d> Deserialize<'d> for VerifyingKey {
             {
                 let mut bytes = [0u8; 32];
 
+                #[allow(clippy::needless_range_loop)]
                 for i in 0..32 {
                     bytes[i] = seq
                         .next_element()?

ed25519-dalek/tests/ed25519.rs

@@ -9,7 +9,7 @@
 
 //! Integration tests for ed25519-dalek.
 
-use curve25519_dalek;
+#![allow(clippy::items_after_test_module)]
 
 use ed25519_dalek::*;
 
@@ -63,10 +63,10 @@ mod vectors {
             let parts: Vec<&str> = line.split(':').collect();
             assert_eq!(parts.len(), 5, "wrong number of fields in line {}", lineno);
 
-            let sec_bytes: Vec<u8> = FromHex::from_hex(&parts[0]).unwrap();
+            let sec_bytes: Vec<u8> = FromHex::from_hex(parts[0]).unwrap();
-            let pub_bytes: Vec<u8> = FromHex::from_hex(&parts[1]).unwrap();
+            let pub_bytes: Vec<u8> = FromHex::from_hex(parts[1]).unwrap();
-            let msg_bytes: Vec<u8> = FromHex::from_hex(&parts[2]).unwrap();
+            let msg_bytes: Vec<u8> = FromHex::from_hex(parts[2]).unwrap();
-            let sig_bytes: Vec<u8> = FromHex::from_hex(&parts[3]).unwrap();
+            let sig_bytes: Vec<u8> = FromHex::from_hex(parts[3]).unwrap();
 
             let sec_bytes = &sec_bytes[..SECRET_KEY_LENGTH].try_into().unwrap();
             let pub_bytes = &pub_bytes[..PUBLIC_KEY_LENGTH].try_into().unwrap();
@@ -161,13 +161,13 @@ mod vectors {
         let mut h = Sha512::default();
         if let Some(c) = context {
             h.update(b"SigEd25519 no Ed25519 collisions");
-            h.update(&[1]);
+            h.update([1]);
-            h.update(&[c.len() as u8]);
+            h.update([c.len() as u8]);
             h.update(c);
         }
-        h.update(&signature_r.compress().as_bytes());
+        h.update(signature_r.compress().as_bytes());
         h.update(&pub_key.compress().as_bytes()[..]);
-        h.update(&message);
+        h.update(message);
         Scalar::from_hash(h)
     }
 
@@ -223,7 +223,7 @@ mod vectors {
         //        = R + H(R || A || M₂) · A
         // Check that this is true
         let signature = serialize_signature(&r, &s);
-        let vk = VerifyingKey::from_bytes(&pubkey.compress().as_bytes()).unwrap();
+        let vk = VerifyingKey::from_bytes(pubkey.compress().as_bytes()).unwrap();
         let sig = Signature::try_from(&signature[..]).unwrap();
         assert!(vk.verify(message1, &sig).is_ok());
         assert!(vk.verify(message2, &sig).is_ok());
@@ -265,7 +265,7 @@ mod vectors {
 
         // Check that verify_prehashed succeeds on both sigs
         let signature = serialize_signature(&r, &s);
-        let vk = VerifyingKey::from_bytes(&pubkey.compress().as_bytes()).unwrap();
+        let vk = VerifyingKey::from_bytes(pubkey.compress().as_bytes()).unwrap();
         let sig = Signature::try_from(&signature[..]).unwrap();
         assert!(vk
             .verify_prehashed(message1.clone(), context_str, &sig)
@@ -295,45 +295,42 @@ mod integrations {
     #[test]
     fn sign_verify() {
         // TestSignVerify
-        let signing_key: SigningKey;
-        let good_sig: Signature;
-        let bad_sig: Signature;
 
         let good: &[u8] = "test message".as_bytes();
         let bad: &[u8] = "wrong message".as_bytes();
 
         let mut csprng = OsRng;
 
-        signing_key = SigningKey::generate(&mut csprng);
+        let signing_key: SigningKey = SigningKey::generate(&mut csprng);
         let verifying_key = signing_key.verifying_key();
-        good_sig = signing_key.sign(&good);
+        let good_sig: Signature = signing_key.sign(good);
-        bad_sig = signing_key.sign(&bad);
+        let bad_sig: Signature = signing_key.sign(bad);
 
         // Check that an honestly generated public key is not weak
         assert!(!verifying_key.is_weak());
 
         assert!(
-            signing_key.verify(&good, &good_sig).is_ok(),
+            signing_key.verify(good, &good_sig).is_ok(),
             "Verification of a valid signature failed!"
         );
         assert!(
-            verifying_key.verify_strict(&good, &good_sig).is_ok(),
+            verifying_key.verify_strict(good, &good_sig).is_ok(),
             "Strict verification of a valid signature failed!"
         );
         assert!(
-            signing_key.verify(&good, &bad_sig).is_err(),
+            signing_key.verify(good, &bad_sig).is_err(),
             "Verification of a signature on a different message passed!"
         );
         assert!(
-            verifying_key.verify_strict(&good, &bad_sig).is_err(),
+            verifying_key.verify_strict(good, &bad_sig).is_err(),
             "Strict verification of a signature on a different message passed!"
         );
         assert!(
-            signing_key.verify(&bad, &good_sig).is_err(),
+            signing_key.verify(bad, &good_sig).is_err(),
             "Verification of a signature on a different message passed!"
         );
         assert!(
-            verifying_key.verify_strict(&bad, &good_sig).is_err(),
+            verifying_key.verify_strict(bad, &good_sig).is_err(),
             "Strict verification of a signature on a different message passed!"
         );
     }
@@ -341,10 +338,6 @@ mod integrations {
     #[cfg(feature = "digest")]
     #[test]
     fn ed25519ph_sign_verify() {
-        let signing_key: SigningKey;
-        let good_sig: Signature;
-        let bad_sig: Signature;
-
         let good: &[u8] = b"test message";
         let bad: &[u8] = b"wrong message";
 
@@ -365,12 +358,12 @@ mod integrations {
 
         let context: &[u8] = b"testing testing 1 2 3";
 
-        signing_key = SigningKey::generate(&mut csprng);
+        let signing_key: SigningKey = SigningKey::generate(&mut csprng);
         let verifying_key = signing_key.verifying_key();
-        good_sig = signing_key
+        let good_sig: Signature = signing_key
             .sign_prehashed(prehashed_good1, Some(context))
             .unwrap();
-        bad_sig = signing_key
+        let bad_sig: Signature = signing_key
             .sign_prehashed(prehashed_bad1, Some(context))
             .unwrap();
 
@@ -427,9 +420,9 @@ mod integrations {
         let mut signing_keys: Vec<SigningKey> = Vec::new();
         let mut signatures: Vec<Signature> = Vec::new();
 
-        for i in 0..messages.len() {
+        for msg in messages {
             let signing_key: SigningKey = SigningKey::generate(&mut csprng);
-            signatures.push(signing_key.sign(&messages[i]));
+            signatures.push(signing_key.sign(msg));
             signing_keys.push(signing_key);
         }
         let verifying_keys: Vec<VerifyingKey> =
@@ -477,6 +470,8 @@ struct Demo {
 
 #[cfg(all(test, feature = "serde"))]
 mod serialisation {
+    #![allow(clippy::zero_prefixed_literal)]
+
     use super::*;
 
     // The size for bincode to serialize the length of a byte array.
@@ -547,7 +542,7 @@ mod serialisation {
         // derived from `serialize_deserialize_verifying_key_json` test
         // trailing zero elements makes key too long (34 bytes)
         let encoded_verifying_key_too_long = "[130,39,155,15,62,76,188,63,124,122,26,251,233,253,225,220,14,41,166,120,108,35,254,77,160,83,172,58,219,42,86,120,0,0]";
-        let de_err = serde_json::from_str::<VerifyingKey>(&encoded_verifying_key_too_long)
+        let de_err = serde_json::from_str::<VerifyingKey>(encoded_verifying_key_too_long)
             .unwrap_err()
             .to_string();
         assert!(
@@ -560,7 +555,7 @@ mod serialisation {
     fn serialize_deserialize_verifying_key_json_too_short() {
         // derived from `serialize_deserialize_verifying_key_json` test
         let encoded_verifying_key_too_long = "[130,39,155,15]";
-        let de_err = serde_json::from_str::<VerifyingKey>(&encoded_verifying_key_too_long)
+        let de_err = serde_json::from_str::<VerifyingKey>(encoded_verifying_key_too_long)
             .unwrap_err()
             .to_string();
         assert!(
@@ -575,6 +570,7 @@ mod serialisation {
         let encoded_signing_key: Vec<u8> = bincode::serialize(&signing_key).unwrap();
         let decoded_signing_key: SigningKey = bincode::deserialize(&encoded_signing_key).unwrap();
 
+        #[allow(clippy::needless_range_loop)]
         for i in 0..SECRET_KEY_LENGTH {
             assert_eq!(SECRET_KEY_BYTES[i], decoded_signing_key.to_bytes()[i]);
         }
@@ -586,6 +582,7 @@ mod serialisation {
         let encoded_signing_key = serde_json::to_string(&signing_key).unwrap();
         let decoded_signing_key: SigningKey = serde_json::from_str(&encoded_signing_key).unwrap();
 
+        #[allow(clippy::needless_range_loop)]
         for i in 0..SECRET_KEY_LENGTH {
             assert_eq!(SECRET_KEY_BYTES[i], decoded_signing_key.to_bytes()[i]);
         }
@@ -596,7 +593,7 @@ mod serialisation {
         // derived from `serialize_deserialize_signing_key_json` test
         // trailing zero elements makes key too long (34 bytes)
         let encoded_signing_key_too_long = "[62,70,27,163,92,182,11,3,77,234,98,4,11,127,79,228,243,187,150,73,201,137,76,22,85,251,152,2,241,42,72,54,0,0]";
-        let de_err = serde_json::from_str::<SigningKey>(&encoded_signing_key_too_long)
+        let de_err = serde_json::from_str::<SigningKey>(encoded_signing_key_too_long)
             .unwrap_err()
             .to_string();
         assert!(
@@ -609,7 +606,7 @@ mod serialisation {
     fn serialize_deserialize_signing_key_json_too_short() {
         // derived from `serialize_deserialize_signing_key_json` test
         let encoded_signing_key_too_long = "[62,70,27,163]";
-        let de_err = serde_json::from_str::<SigningKey>(&encoded_signing_key_too_long)
+        let de_err = serde_json::from_str::<SigningKey>(encoded_signing_key_too_long)
             .unwrap_err()
             .to_string();
         assert!(

ed25519-dalek/tests/validation_criteria.rs

@@ -89,7 +89,7 @@ impl From<IntermediateTestVector> for TestVector {
         let msg = tv.msg.as_bytes().to_vec();
 
         // Unwrap the Option<Set<Flag>>
-        let flags = tv.flags.unwrap_or_else(Default::default);
+        let flags = tv.flags.unwrap_or_default();
 
         Self {
             number,

x25519-dalek/src/x25519.rs

@@ -164,7 +164,7 @@ impl ReusableSecret {
     /// Generate a new [`ReusableSecret`].
     #[cfg(feature = "getrandom")]
     pub fn random() -> Self {
-        Self::random_from_rng(&mut rand_core::OsRng)
+        Self::random_from_rng(rand_core::OsRng)
     }
 }
 
@@ -225,7 +225,7 @@ impl StaticSecret {
     /// Generate a new [`StaticSecret`].
     #[cfg(feature = "getrandom")]
     pub fn random() -> Self {
-        Self::random_from_rng(&mut rand_core::OsRng)
+        Self::random_from_rng(rand_core::OsRng)
     }
 
     /// Extract this key's bytes for serialization.