Attempt 2 at fixing nostd tests

Author: roblabla

Cargo.toml

@@ -44,7 +44,6 @@ pem = "0.8"
 sha-1 = { default-features = false, version = "0.9.0" }
 sha2 = { default-features = false, version = "0.9.0" }
 sha3 = { default-features = false, version = "0.9.0" }
-rand = { version = "0.7.0" }
 
 [[bench]]
 name = "key"

src/key.rs

@@ -646,9 +646,10 @@ mod tests {
     use super::*;
     use crate::internals;
 
+    use std::time::SystemTime;
     use digest::{Digest, DynDigest};
     use num_traits::{FromPrimitive, ToPrimitive};
-    use rand::{distributions::Alphanumeric, rngs::ThreadRng, thread_rng};
+    use rand::{distributions::Alphanumeric, rngs::StdRng, SeedableRng};
     use sha1::Sha1;
     use sha2::{Sha224, Sha256, Sha384, Sha512};
     use sha3::{Sha3_256, Sha3_384, Sha3_512};
@@ -681,10 +682,11 @@ mod tests {
         let pub_key: RSAPublicKey = private_key.clone().into();
         let m = BigUint::from_u64(42).expect("invalid 42");
         let c = internals::encrypt(&pub_key, &m);
-        let m2 = internals::decrypt::<ThreadRng>(None, &private_key, &c)
+        let m2 = internals::decrypt::<StdRng>(None, &private_key, &c)
             .expect("unable to decrypt without blinding");
         assert_eq!(m, m2);
-        let mut rng = thread_rng();
+        let seed = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+        let mut rng = StdRng::seed_from_u64(seed.as_secs());
         let m3 = internals::decrypt(Some(&mut rng), &private_key, &c)
             .expect("unable to decrypt with blinding");
         assert_eq!(m, m3);
@@ -694,7 +696,8 @@ mod tests {
         ($name:ident, $multi:expr, $size:expr) => {
             #[test]
             fn $name() {
-                let mut rng = thread_rng();
+                let seed = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+                let mut rng = StdRng::seed_from_u64(seed.as_secs());
 
                 for _ in 0..10 {
                     let private_key = if $multi == 2 {
@@ -724,7 +727,8 @@ mod tests {
     #[test]
     fn test_impossible_keys() {
         // make sure not infinite loops are hit here.
-        let mut rng = thread_rng();
+        let seed = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+        let mut rng = StdRng::seed_from_u64(seed.as_secs());
         for i in 0..32 {
             let _ = RSAPrivateKey::new(&mut rng, i).is_err();
             let _ = generate_multi_prime_key(&mut rng, 3, i);
@@ -896,7 +900,8 @@ mod tests {
     }
 
     fn do_test_encrypt_decrypt_oaep<D: 'static + Digest + DynDigest>(prk: &RSAPrivateKey) {
-        let mut rng = thread_rng();
+        let seed = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+        let mut rng = StdRng::seed_from_u64(seed.as_secs());
 
         let k = prk.size();
 
@@ -907,7 +912,7 @@ mod tests {
             }
             let has_label: bool = rng.gen();
             let label: Option<String> = if has_label {
-                Some(rng.sample_iter(&Alphanumeric).take(30).collect())
+                Some(rng.clone().sample_iter(&Alphanumeric).take(30).collect())
             } else {
                 None
             };
@@ -943,7 +948,8 @@ mod tests {
 
     #[test]
     fn test_decrypt_oaep_invalid_hash() {
-        let mut rng = thread_rng();
+        let seed = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+        let mut rng = StdRng::seed_from_u64(seed.as_secs());
         let priv_key = get_private_key();
         let pub_key: RSAPublicKey = (&priv_key).into();
         let ciphertext = pub_key

src/lib.rs

@@ -7,9 +7,12 @@
 //! Using PKCS1v15.
 //! ```
 //! use rsa::{PublicKey, RSAPrivateKey, RSAPublicKey, PaddingScheme};
+//! # /*
 //! use rand::rngs::OsRng;
-//!
 //! let mut rng = OsRng;
+//! # */
+//! # use rand::{SeedableRng, rngs::StdRng};
+//! # let mut rng = rand::rngs::StdRng::seed_from_u64(0);
 //! let bits = 2048;
 //! let private_key = RSAPrivateKey::new(&mut rng, bits).expect("failed to generate a key");
 //! let public_key = RSAPublicKey::from(&private_key);
@@ -29,9 +32,13 @@
 //! Using OAEP.
 //! ```
 //! use rsa::{PublicKey, RSAPrivateKey, RSAPublicKey, PaddingScheme};
+//! # /*
 //! use rand::rngs::OsRng;
-//!
 //! let mut rng = OsRng;
+//! # */
+//! # use rand::{SeedableRng, rngs::StdRng};
+//! # let mut rng = rand::rngs::StdRng::seed_from_u64(0);
+//!
 //! let bits = 2048;
 //! let private_key = RSAPrivateKey::new(&mut rng, bits).expect("failed to generate a key");
 //! let public_key = RSAPublicKey::from(&private_key);

src/pkcs1v15.rs

@@ -217,15 +217,17 @@ mod tests {
     use num_bigint::BigUint;
     use num_traits::FromPrimitive;
     use num_traits::Num;
-    use rand::thread_rng;
+    use rand::{SeedableRng, rngs::StdRng};
     use sha1::{Digest, Sha1};
+    use std::time::SystemTime;
 
     use crate::{Hash, PaddingScheme, PublicKey, PublicKeyParts, RSAPrivateKey, RSAPublicKey};
 
     #[test]
     fn test_non_zero_bytes() {
         for _ in 0..10 {
-            let mut rng = thread_rng();
+            let seed = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+            let mut rng = StdRng::seed_from_u64(seed.as_secs());
             let mut b = vec![0u8; 512];
             non_zero_random_bytes(&mut rng, &mut b);
             for el in &b {
@@ -288,7 +290,8 @@ mod tests {
 
     #[test]
     fn test_encrypt_decrypt_pkcs1v15() {
-        let mut rng = thread_rng();
+        let seed = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+        let mut rng = StdRng::seed_from_u64(seed.as_secs());
         let priv_key = get_private_key();
         let k = priv_key.size();
 
@@ -326,7 +329,8 @@ mod tests {
             assert_ne!(out, digest);
             assert_eq!(out, expected);
 
-            let mut rng = thread_rng();
+            let seed = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+            let mut rng = StdRng::seed_from_u64(seed.as_secs());
             let out2 = priv_key
                 .sign_blinded(
                     &mut rng,

src/pss.rs

@@ -240,8 +240,9 @@ mod test {
 
     use num_bigint::BigUint;
     use num_traits::{FromPrimitive, Num};
-    use rand::thread_rng;
     use sha1::{Digest, Sha1};
+    use std::time::SystemTime;
+    use rand::{SeedableRng, rngs::StdRng};
 
     fn get_private_key() -> RSAPrivateKey {
         // In order to generate new test vectors you'll need the PEM form of this key:
@@ -279,9 +280,11 @@ mod test {
             let digest = Sha1::digest(test[0].as_bytes()).to_vec();
             let sig = hex::decode(test[1]).unwrap();
 
+            let seed = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+            let mut rng = StdRng::seed_from_u64(seed.as_secs());
             pub_key
                 .verify(
-                    PaddingScheme::new_pss::<Sha1, _>(thread_rng()),
+                    PaddingScheme::new_pss::<Sha1, _>(rng),
                     &digest,
                     &sig,
                 )
@@ -295,19 +298,22 @@ mod test {
 
         let tests = ["test\n"];
 
+        let seed = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+        let mut rng = StdRng::seed_from_u64(seed.as_secs());
+
         for test in &tests {
             let digest = Sha1::digest(test.as_bytes()).to_vec();
             let sig = priv_key
                 .sign_blinded(
-                    &mut thread_rng(),
-                    PaddingScheme::new_pss::<Sha1, _>(thread_rng()),
+                    &mut rng.clone(),
+                    PaddingScheme::new_pss::<Sha1, _>(rng.clone()),
                     &digest,
                 )
                 .expect("failed to sign");
 
             priv_key
                 .verify(
-                    PaddingScheme::new_pss::<Sha1, _>(thread_rng()),
+                    PaddingScheme::new_pss::<Sha1, _>(rng.clone()),
                     &digest,
                     &sig,
                 )