Bump edition to 2024; apply rustfmt

Cargo.toml

@@ -2,7 +2,7 @@
 name = "rsa"
 version = "0.10.0-rc.19"
 authors = ["RustCrypto Developers", "dignifiedquire <dignifiedquire@gmail.com>"]
-edition = "2021"
+edition = "2024"
 description = "Pure Rust RSA implementation"
 license = "MIT OR Apache-2.0"
 documentation = "https://docs.rs/rsa"

src/algorithms/generate.rs

@@ -5,8 +5,9 @@
 use alloc::vec::Vec;
 use crypto_bigint::{BoxedUint, Odd};
 use crypto_primes::{
+    Flavor,
     hazmat::{SetBits, SmallFactorsSieveFactory},
-    is_prime, sieve_and_find, Flavor,
+    is_prime, sieve_and_find,
 };
 use rand_core::CryptoRng;
 

src/algorithms/pkcs1v15/implicit_rejection.rs

@@ -122,10 +122,10 @@ mod tests {
     mod vectors {
         use super::*;
         use crate::{
+            RsaPrivateKey,
             algorithms::{pad::os2ip, pkcs1v15::eme_pkcs1v15_decode, rsa::rsa_decrypt_and_check},
             pkcs1v15::{DecryptingKey, Pkcs1v15Encrypt},
             traits::{Decryptor, PaddingScheme, PublicKeyParts, RandomizedDecryptor},
-            RsaPrivateKey,
         };
         use alloc::{collections::BTreeMap, string::String};
         use pkcs8::DecodePrivateKey;

src/algorithms/reduction.rs

@@ -1,8 +1,8 @@
 //! Reduction modulo an odd, potentially secret modulus using fixed-width Montgomery arithmetic.
 
 use crypto_bigint::{
-    modular::{BoxedMontyForm, BoxedMontyParams},
     BoxedUint, Resize,
+    modular::{BoxedMontyForm, BoxedMontyParams},
 };
 
 /// Convert any input precision to Montgomery form. Loop counts and allocations depend only on

src/algorithms/rsa.rs

@@ -7,8 +7,8 @@
 pub(crate) use super::reduction::to_monty;
 
 use crypto_bigint::{
-    modular::BoxedMontyParams, BoxedUint, ConcatenatingMul, ConcatenatingSquare, Gcd, NonZero, Odd,
-    RandomMod, Resize,
+    BoxedUint, ConcatenatingMul, ConcatenatingSquare, Gcd, NonZero, Odd, RandomMod, Resize,
+    modular::BoxedMontyParams,
 };
 use rand_core::TryCryptoRng;
 use zeroize::Zeroize;

src/encoding.rs

@@ -6,14 +6,14 @@
 #![cfg(feature = "encoding")]
 
 use crate::{
-    traits::{PrivateKeyParts, PublicKeyParts},
     RsaPrivateKey, RsaPublicKey,
+    traits::{PrivateKeyParts, PublicKeyParts},
 };
 use core::convert::{TryFrom, TryInto};
 use crypto_bigint::{BoxedUint, NonZero, Resize};
 use pkcs8::{
-    der::{asn1::AsUintRef, asn1::OctetStringRef, Decode},
     Document, EncodePrivateKey, EncodePublicKey, ObjectIdentifier, SecretDocument,
+    der::{Decode, asn1::AsUintRef, asn1::OctetStringRef},
 };
 use zeroize::Zeroizing;
 

src/key.rs

@@ -3,15 +3,15 @@ use core::fmt;
 use core::hash::{Hash, Hasher};
 
 use crypto_bigint::{
-    modular::{BoxedMontyForm, BoxedMontyParams},
     BoxedUint, ConcatenatingMul, Integer, NonZero, Odd, Resize,
+    modular::{BoxedMontyForm, BoxedMontyParams},
 };
 use rand_core::CryptoRng;
 use zeroize::{Zeroize, ZeroizeOnDrop};
 #[cfg(feature = "serde")]
 use {
     pkcs8::{DecodePrivateKey, EncodePrivateKey},
-    serdect::serde::{de, ser, Deserialize, Serialize},
+    serdect::serde::{Deserialize, Serialize, de, ser},
     spki::{DecodePublicKey, EncodePublicKey},
 };
 
@@ -1167,7 +1167,7 @@ mod tests {
     fn test_serde() {
         use rand::rngs::ChaCha8Rng;
         use rand_core::SeedableRng;
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
 
         let mut rng = ChaCha8Rng::from_seed([42; 32]);
         let priv_key = RsaPrivateKey::new_unchecked(&mut rng, 64).expect("failed to generate key");

src/oaep/decrypting_key.rs

@@ -2,8 +2,8 @@ use super::decrypt_digest;
 #[cfg(not(feature = "getrandom"))]
 use crate::dummy_rng::DummyRng;
 use crate::{
-    traits::{Decryptor, RandomizedDecryptor},
     Result, RsaPrivateKey,
+    traits::{Decryptor, RandomizedDecryptor},
 };
 use alloc::{boxed::Box, vec::Vec};
 use core::marker::PhantomData;
@@ -121,7 +121,7 @@ mod tests {
         use super::*;
         use rand::rngs::ChaCha8Rng;
         use rand_core::SeedableRng;
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
         use sha2::Sha256;
 
         let mut rng = ChaCha8Rng::from_seed([42; 32]);

src/oaep/encrypting_key.rs

@@ -1,5 +1,5 @@
 use super::encrypt_digest;
-use crate::{traits::RandomizedEncryptor, Result, RsaPublicKey};
+use crate::{Result, RsaPublicKey, traits::RandomizedEncryptor};
 use alloc::{boxed::Box, vec::Vec};
 use core::marker::PhantomData;
 use digest::{Digest, FixedOutputReset};
@@ -79,7 +79,7 @@ mod tests {
         use super::*;
         use rand::rngs::ChaCha8Rng;
         use rand_core::SeedableRng;
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
 
         let mut rng = ChaCha8Rng::from_seed([42; 32]);
         let priv_key =

src/pkcs1v15.rs

@@ -300,9 +300,9 @@ pub use oid::RsaSignatureAssociatedOid;
 mod tests {
     use super::*;
     use ::signature::{
-        hazmat::{PrehashSigner, PrehashVerifier},
         DigestSigner, DigestVerifier, Keypair, RandomizedDigestSigner, RandomizedSigner,
         SignatureEncoding, Signer, Verifier,
+        hazmat::{PrehashSigner, PrehashVerifier},
     };
     use base64ct::{Base64, Encoding};
     use crypto_bigint::BoxedUint;

src/pkcs1v15/decrypting_key.rs

@@ -1,9 +1,9 @@
-use super::{decrypt, EncryptingKey};
+use super::{EncryptingKey, decrypt};
 #[cfg(not(feature = "getrandom"))]
 use crate::dummy_rng::DummyRng;
 use crate::{
-    traits::{Decryptor, EncryptingKeypair, RandomizedDecryptor},
     Result, RsaPrivateKey,
+    traits::{Decryptor, EncryptingKeypair, RandomizedDecryptor},
 };
 use alloc::vec::Vec;
 use rand_core::CryptoRng;
@@ -82,7 +82,7 @@ mod tests {
         use super::*;
         use rand::rngs::ChaCha8Rng;
         use rand_core::SeedableRng;
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
 
         let mut rng = ChaCha8Rng::from_seed([42; 32]);
         let decrypting_key = DecryptingKey::new(

src/pkcs1v15/encrypting_key.rs

@@ -1,5 +1,5 @@
 use super::encrypt;
-use crate::{traits::RandomizedEncryptor, Result, RsaPublicKey};
+use crate::{Result, RsaPublicKey, traits::RandomizedEncryptor};
 use alloc::vec::Vec;
 use rand_core::CryptoRng;
 #[cfg(feature = "serde")]
@@ -37,7 +37,7 @@ mod tests {
         use crate::RsaPrivateKey;
         use rand::rngs::ChaCha8Rng;
         use rand_core::SeedableRng;
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
 
         let mut rng = ChaCha8Rng::from_seed([42; 32]);
         let priv_key = RsaPrivateKey::new_unchecked(&mut rng, 64).expect("failed to generate key");

src/pkcs1v15/signature.rs

@@ -5,11 +5,11 @@ use core::fmt::{Debug, Display, Formatter, LowerHex, UpperHex};
 use signature::SignatureEncoding;
 
 #[cfg(feature = "serde")]
-use serdect::serde::{de, Deserialize, Serialize};
+use serdect::serde::{Deserialize, Serialize, de};
 #[cfg(feature = "encoding")]
 use spki::{
-    der::{asn1::BitString, Result as DerResult},
     SignatureBitStringEncoding,
+    der::{Result as DerResult, asn1::BitString},
 };
 
 /// `RSASSA-PKCS1-v1_5` signatures as described in [RFC8017 § 8.2].
@@ -101,7 +101,7 @@ mod tests {
     #[cfg(feature = "serde")]
     fn test_serde() {
         use super::*;
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
         let signature = Signature {
             inner: Box::new([0, 0, 0, 0, 0, 0, 0, 42]),
         };

src/pkcs1v15/signing_key.rs

@@ -1,13 +1,13 @@
-use super::{pkcs1v15_generate_prefix, sign, Signature, VerifyingKey};
-use crate::{dummy_rng::DummyRng, Result, RsaPrivateKey};
+use super::{Signature, VerifyingKey, pkcs1v15_generate_prefix, sign};
+use crate::{Result, RsaPrivateKey, dummy_rng::DummyRng};
 use alloc::vec::Vec;
 use const_oid::AssociatedOid;
 use core::marker::PhantomData;
 use digest::{Digest, FixedOutput, HashMarker, Update};
 use rand_core::{CryptoRng, TryCryptoRng};
 use signature::{
-    hazmat::PrehashSigner, DigestSigner, Keypair, MultipartSigner, RandomizedDigestSigner,
-    RandomizedMultipartSigner, RandomizedSigner, Signer,
+    DigestSigner, Keypair, MultipartSigner, RandomizedDigestSigner, RandomizedMultipartSigner,
+    RandomizedSigner, Signer, hazmat::PrehashSigner,
 };
 use zeroize::ZeroizeOnDrop;
 
@@ -16,14 +16,14 @@ use {
     super::oid,
     pkcs8::{EncodePrivateKey, SecretDocument},
     spki::{
-        der::AnyRef, AlgorithmIdentifierRef, AssociatedAlgorithmIdentifier,
-        SignatureAlgorithmIdentifier,
+        AlgorithmIdentifierRef, AssociatedAlgorithmIdentifier, SignatureAlgorithmIdentifier,
+        der::AnyRef,
     },
 };
 #[cfg(feature = "serde")]
 use {
     pkcs8::DecodePrivateKey,
-    serdect::serde::{de, ser, Deserialize, Serialize},
+    serdect::serde::{Deserialize, Serialize, de, ser},
 };
 
 /// Signing key for `RSASSA-PKCS1-v1_5` signatures as described in [RFC8017 § 8.2].
@@ -344,7 +344,7 @@ mod tests {
         use crate::RsaPrivateKey;
         use rand::rngs::ChaCha8Rng;
         use rand_core::SeedableRng;
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
         use sha2::Sha256;
 
         let mut rng = ChaCha8Rng::from_seed([42; 32]);

src/pkcs1v15/verifying_key.rs

@@ -1,22 +1,22 @@
-use super::{pkcs1v15_generate_prefix, verify, Signature};
+use super::{Signature, pkcs1v15_generate_prefix, verify};
 use crate::RsaPublicKey;
 use alloc::vec::Vec;
 use const_oid::AssociatedOid;
 use core::marker::PhantomData;
 use digest::{Digest, FixedOutput, HashMarker, Update};
-use signature::{hazmat::PrehashVerifier, DigestVerifier, Verifier};
+use signature::{DigestVerifier, Verifier, hazmat::PrehashVerifier};
 
 #[cfg(feature = "encoding")]
 use {
     super::oid,
     spki::{
-        der::AnyRef, AlgorithmIdentifierRef, AssociatedAlgorithmIdentifier, Document,
-        EncodePublicKey, SignatureAlgorithmIdentifier,
+        AlgorithmIdentifierRef, AssociatedAlgorithmIdentifier, Document, EncodePublicKey,
+        SignatureAlgorithmIdentifier, der::AnyRef,
     },
 };
 #[cfg(feature = "serde")]
 use {
-    serdect::serde::{de, ser, Deserialize, Serialize},
+    serdect::serde::{Deserialize, Serialize, de, ser},
     spki::DecodePublicKey,
 };
 
@@ -255,7 +255,7 @@ mod tests {
         use crate::RsaPrivateKey;
         use rand::rngs::ChaCha8Rng;
         use rand_core::SeedableRng;
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
         use sha2::Sha256;
 
         let mut rng = ChaCha8Rng::from_seed([42; 32]);

src/pss.rs

@@ -39,8 +39,8 @@ use {
     const_oid::AssociatedOid,
     pkcs1::RsaPssParams,
     spki::{
-        der::{Any, ErrorKind},
         AlgorithmIdentifierOwned,
+        der::{Any, ErrorKind},
     },
 };
 

src/pss/blinded_signing_key.rs

@@ -1,11 +1,11 @@
-use super::{sign_digest, Signature, VerifyingKey};
+use super::{Signature, VerifyingKey, sign_digest};
 use crate::{Result, RsaPrivateKey};
 use core::marker::PhantomData;
 use digest::{Digest, FixedOutputReset, HashMarker, Update};
 use rand_core::{CryptoRng, TryCryptoRng};
 use signature::{
-    hazmat::RandomizedPrehashSigner, Keypair, RandomizedDigestSigner, RandomizedMultipartSigner,
-    RandomizedSigner,
+    Keypair, RandomizedDigestSigner, RandomizedMultipartSigner, RandomizedSigner,
+    hazmat::RandomizedPrehashSigner,
 };
 use zeroize::ZeroizeOnDrop;
 
@@ -15,14 +15,14 @@ use {
     const_oid::AssociatedOid,
     pkcs8::{EncodePrivateKey, SecretDocument},
     spki::{
-        der::AnyRef, AlgorithmIdentifierOwned, AlgorithmIdentifierRef,
-        AssociatedAlgorithmIdentifier, DynSignatureAlgorithmIdentifier,
+        AlgorithmIdentifierOwned, AlgorithmIdentifierRef, AssociatedAlgorithmIdentifier,
+        DynSignatureAlgorithmIdentifier, der::AnyRef,
     },
 };
 #[cfg(feature = "serde")]
 use {
     pkcs8::DecodePrivateKey,
-    serdect::serde::{de, ser, Deserialize, Serialize},
+    serdect::serde::{Deserialize, Serialize, de, ser},
 };
 
 /// Signing key for producing "blinded" RSASSA-PSS signatures as described in
@@ -294,7 +294,7 @@ mod tests {
         use super::*;
         use rand::rngs::ChaCha8Rng;
         use rand_core::SeedableRng;
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
         use sha2::Sha256;
 
         let mut rng = ChaCha8Rng::from_seed([42; 32]);

src/pss/signature.rs

@@ -5,11 +5,11 @@ use core::fmt::{Debug, Display, Formatter, LowerHex, UpperHex};
 use signature::SignatureEncoding;
 
 #[cfg(feature = "serde")]
-use serdect::serde::{de, Deserialize, Serialize};
+use serdect::serde::{Deserialize, Serialize, de};
 #[cfg(feature = "encoding")]
 use spki::{
-    der::{asn1::BitString, Result as DerResult},
     SignatureBitStringEncoding,
+    der::{Result as DerResult, asn1::BitString},
 };
 
 /// `RSASSA-PSS` signatures as described in [RFC8017 § 8.1].
@@ -101,7 +101,7 @@ mod tests {
     #[cfg(feature = "serde")]
     fn test_serde() {
         use super::*;
-        use serde_test::{assert_tokens, Configure, Token};
+        use serde_test::{Configure, Token, assert_tokens};
         let signature = Signature {
             inner: Box::new([0, 0, 0, 0, 0, 0, 0, 42]),
         };