bump rand_core to 0.10.0-rc.2

Author: baloo

Cargo.toml

@@ -12,7 +12,7 @@ rust-version = "1.85"
 [dependencies]
 crypto-bigint = { version = "0.7.0-pre.5", default-features = false, features = ["rand_core"] }
 libm = { version = "0.2.13", default-features = false, features = ["arch"] }
-rand_core = { version = "0.9.2", default-features = false }
+rand_core = { version = "0.10.0-rc.2", default-features = false }
 rayon = { version = "1", optional = true, default-features = false }
 
 # Optional dependencies used in tests and benchmarks
@@ -21,10 +21,11 @@ rug = { version = "1.26", optional = true, default-features = false, features =
 glass_pumpkin = { version = "1", optional = true }
 
 [dev-dependencies]
-rand_core = { version = "0.9.2", default-features = false, features = ["os_rng"] }
+rand = "0.10.0-rc.1"
+rand_core = { version = "0.10.0-rc.2", default-features = false }
 # need `crypto-bigint` with `alloc` to test `BoxedUint`
 crypto-bigint = { version = "0.7.0-pre.5", default-features = false, features = ["alloc"] }
-rand_chacha = "0.9"
+rand_chacha = "0.10.0-rc.1"
 criterion = { version = "0.5", features = ["html_reports"] }
 num-modular = { version = "0.5", features = ["num-bigint"] }
 num-bigint = "0.4"
@@ -62,3 +63,6 @@ harness = false
 [[bench]]
 name = "cctv"
 harness = false
+
+[patch.crates-io]
+crypto-bigint = { git = "https://github.com/RustCrypto/crypto-bigint", branch = "rand_core/v0.10.0-rc-2" }

README.md

@@ -28,21 +28,19 @@ Find a 196 bit prime returned in a 256-bit long `crypto_bigint::U256`:
 
 ```rust
 use crypto_bigint::U256;
-use rand_core::{OsRng, TryRngCore};
 use crypto_primes::{Flavor, is_prime, random_prime};
 
-let prime = random_prime::<U256, _>(&mut OsRng.unwrap_mut(), Flavor::Any, 196);
+let prime = random_prime::<U256, _>(&mut rand::rng(), Flavor::Any, 196);
 assert!(is_prime(Flavor::Any, &prime));
 ```
 
 Find a 64 bit safe prime returned in a `crypto_bigint::U1024`:
 
 ```rust
 use crypto_bigint::U1024;
-use rand_core::{OsRng, TryRngCore};
 use crypto_primes::{Flavor, is_prime, random_prime};
 
-let prime = random_prime::<U1024, _>(&mut OsRng.unwrap_mut(), Flavor::Safe, 64);
+let prime = random_prime::<U1024, _>(&mut rand::rng(), Flavor::Safe, 64);
 assert!(is_prime(Flavor::Safe, &prime));
 ```
 
@@ -56,12 +54,11 @@ use crypto_primes::{
     is_prime, random_prime, sieve_and_find,
 };
 use crypto_bigint::U256;
-use rand_core::{OsRng, TryRngCore};
 
 let flavor = Flavor::Any;
 let factory = SmallFactorsSieveFactory::<U256>::new(flavor, 256, SetBits::TwoMsb).unwrap();
 let prime = sieve_and_find(
-    &mut OsRng.unwrap_mut(),
+    &mut rand::rng(),
     factory,
     |_rng, candidate| is_prime(flavor, candidate)
 ).unwrap().unwrap();

benches/bench.rs

@@ -3,7 +3,7 @@ use core::num::NonZero;
 use criterion::{BatchSize, Criterion, criterion_group, criterion_main};
 use crypto_bigint::{BoxedUint, Odd, RandomBits, U128, U256, U1024, Uint, Unsigned, nlimbs};
 use rand_chacha::ChaCha8Rng;
-use rand_core::{CryptoRng, OsRng, SeedableRng, TryRngCore};
+use rand_core::{CryptoRng, SeedableRng};
 
 #[cfg(feature = "tests-gmp")]
 use rug::{Integer as GmpInteger, integer::Order};
@@ -29,7 +29,7 @@ fn make_rng() -> ChaCha8Rng {
 
 #[cfg(feature = "multicore")]
 fn make_random_rng() -> ChaCha8Rng {
-    ChaCha8Rng::from_os_rng()
+    ChaCha8Rng::from_rng(&mut rand::rng())
 }
 
 fn random_odd_uint<T: RandomBits + Unsigned, R: CryptoRng + ?Sized>(rng: &mut R, bit_length: u32) -> Odd<T> {
@@ -48,14 +48,15 @@ fn make_presieved_num<const L: usize, R: CryptoRng + ?Sized>(rng: &mut R) -> Odd
 
 fn bench_sieve(c: &mut Criterion) {
     let mut group = c.benchmark_group("Sieve");
+    let mut rng = rand::rng();
 
     group.bench_function("(U128) random start", |b| {
-        b.iter(|| random_odd_uint::<U128, _>(&mut OsRng.unwrap_mut(), 128))
+        b.iter(|| random_odd_uint::<U128, _>(&mut rng, 128))
     });
 
     group.bench_function("(U128) creation", |b| {
         b.iter_batched(
-            || random_odd_uint::<U128, _>(&mut OsRng.unwrap_mut(), 128),
+            || random_odd_uint::<U128, _>(&mut rng, 128),
             |start| SmallFactorsSieve::new(start.get(), NonZero::new(128).unwrap(), false),
             BatchSize::SmallInput,
         )
@@ -64,19 +65,19 @@ fn bench_sieve(c: &mut Criterion) {
     // 5 is the average number of pre-sieved samples we need to take before we encounter a prime
     group.bench_function("(U128) average sieve samples for a prime (5)", |b| {
         b.iter_batched(
-            || make_sieve::<{ nlimbs!(128) }, _>(&mut OsRng.unwrap_mut()),
+            || make_sieve::<{ nlimbs!(128) }, _>(&mut rng),
             |sieve| sieve.take(5).for_each(drop),
             BatchSize::SmallInput,
         )
     });
 
     group.bench_function("(U1024) random start", |b| {
-        b.iter(|| random_odd_uint::<U1024, _>(&mut OsRng.unwrap_mut(), 1024))
+        b.iter(|| random_odd_uint::<U1024, _>(&mut rng, 1024))
     });
 
     group.bench_function("(U1024) creation", |b| {
         b.iter_batched(
-            || random_odd_uint::<U1024, _>(&mut OsRng.unwrap_mut(), 1024),
+            || random_odd_uint::<U1024, _>(&mut rng, 1024),
             |start| SmallFactorsSieve::new(start.get(), NonZero::new(1024).unwrap(), false),
             BatchSize::SmallInput,
         )
@@ -85,7 +86,7 @@ fn bench_sieve(c: &mut Criterion) {
     // 42 is the average number of pre-sieved samples we need to take before we encounter a prime
     group.bench_function("(U1024) average sieve samples for a prime (42)", |b| {
         b.iter_batched(
-            || make_sieve::<{ nlimbs!(1024) }, _>(&mut OsRng.unwrap_mut()),
+            || make_sieve::<{ nlimbs!(1024) }, _>(&mut rng),
             |sieve| sieve.take(42).for_each(drop),
             BatchSize::SmallInput,
         )
@@ -95,7 +96,7 @@ fn bench_sieve(c: &mut Criterion) {
     // before we encounter a safe prime
     group.bench_function("(U1024) average sieve samples for a safe prime (42^2)", |b| {
         b.iter_batched(
-            || make_sieve::<{ nlimbs!(1024) }, _>(&mut OsRng.unwrap_mut()),
+            || make_sieve::<{ nlimbs!(1024) }, _>(&mut rng),
             |sieve| sieve.take(42 * 42).for_each(drop),
             BatchSize::SmallInput,
         )
@@ -106,35 +107,36 @@ fn bench_sieve(c: &mut Criterion) {
 
 fn bench_miller_rabin(c: &mut Criterion) {
     let mut group = c.benchmark_group("Miller-Rabin");
+    let mut rng = rand::rng();
 
     group.bench_function("(U128) creation", |b| {
         b.iter_batched(
-            || random_odd_uint::<U128, _>(&mut OsRng.unwrap_mut(), 128),
+            || random_odd_uint::<U128, _>(&mut rng, 128),
             MillerRabin::<U128>::new,
             BatchSize::SmallInput,
         )
     });
 
     group.bench_function("(U128) random base test (pre-sieved)", |b| {
         b.iter_batched(
-            || MillerRabin::new(make_presieved_num::<{ nlimbs!(128) }, _>(&mut OsRng.unwrap_mut())),
-            |mr| mr.test_random_base(&mut OsRng.unwrap_mut()),
+            || MillerRabin::new(make_presieved_num::<{ nlimbs!(128) }, _>(&mut rng.clone())),
+            |mr| mr.test_random_base(&mut rng.clone()),
             BatchSize::SmallInput,
         )
     });
 
     group.bench_function("(U1024) creation", |b| {
         b.iter_batched(
-            || random_odd_uint::<U1024, _>(&mut OsRng.unwrap_mut(), 1024),
+            || random_odd_uint::<U1024, _>(&mut rng, 1024),
             MillerRabin::<U1024>::new,
             BatchSize::SmallInput,
         )
     });
 
     group.bench_function("(U1024) random base test (pre-sieved)", |b| {
         b.iter_batched(
-            || MillerRabin::new(make_presieved_num::<{ nlimbs!(1024) }, _>(&mut OsRng.unwrap_mut())),
-            |mr| mr.test_random_base(&mut OsRng.unwrap_mut()),
+            || MillerRabin::new(make_presieved_num::<{ nlimbs!(1024) }, _>(&mut rng.clone())),
+            |mr| mr.test_random_base(&mut rng.clone()),
             BatchSize::SmallInput,
         )
     });
@@ -212,18 +214,19 @@ fn bench_lucas(c: &mut Criterion) {
 
 fn bench_presets(c: &mut Criterion) {
     let mut group = c.benchmark_group("Presets");
+    let mut rng = rand::rng();
 
     group.bench_function("(U128) Prime test", |b| {
         b.iter_batched(
-            || random_odd_uint::<U128, _>(&mut OsRng.unwrap_mut(), 128),
+            || random_odd_uint::<U128, _>(&mut rng, 128),
             |num| is_prime(Flavor::Any, num.as_ref()),
             BatchSize::SmallInput,
         )
     });
 
     group.bench_function("(U1024) Prime test", |b| {
         b.iter_batched(
-            || random_odd_uint::<U1024, _>(&mut OsRng.unwrap_mut(), 1024),
+            || random_odd_uint::<U1024, _>(&mut rng, 1024),
             |num| is_prime(Flavor::Any, num.as_ref()),
             BatchSize::SmallInput,
         )
@@ -233,15 +236,15 @@ fn bench_presets(c: &mut Criterion) {
 
     group.bench_function("(U1024) Prime test (FIPS, 1/2^128 failure bound)", |b| {
         b.iter_batched(
-            || random_odd_uint::<U1024, _>(&mut OsRng.unwrap_mut(), 1024),
-            |num| fips::is_prime(&mut OsRng.unwrap_mut(), Flavor::Any, num.as_ref(), iters, false),
+            || random_odd_uint::<U1024, _>(&mut rng.clone(), 1024),
+            |num| fips::is_prime(&mut rng.clone(), Flavor::Any, num.as_ref(), iters, false),
             BatchSize::SmallInput,
         )
     });
 
     group.bench_function("(U128) Safe prime test", |b| {
         b.iter_batched(
-            || random_odd_uint::<U128, _>(&mut OsRng.unwrap_mut(), 128),
+            || random_odd_uint::<U128, _>(&mut rng, 128),
             |num| is_prime(Flavor::Safe, num.as_ref()),
             BatchSize::SmallInput,
         )
@@ -365,6 +368,7 @@ fn bench_multicore_presets(_c: &mut Criterion) {}
 #[cfg(feature = "tests-gmp")]
 fn bench_gmp(c: &mut Criterion) {
     let mut group = c.benchmark_group("GMP");
+    let mut rng = rand::rng();
 
     fn random<const L: usize, R: CryptoRng + ?Sized>(rng: &mut R) -> GmpInteger {
         let num = random_odd_uint::<Uint<L>, R>(rng, Uint::<L>::BITS).get();
@@ -373,15 +377,15 @@ fn bench_gmp(c: &mut Criterion) {
 
     group.bench_function("(U128) Random prime", |b| {
         b.iter_batched(
-            || random::<{ nlimbs!(128) }, _>(&mut OsRng.unwrap_mut()),
+            || random::<{ nlimbs!(128) }, _>(&mut rng),
             |n| n.next_prime(),
             BatchSize::SmallInput,
         )
     });
 
     group.bench_function("(U1024) Random prime", |b| {
         b.iter_batched(
-            || random::<{ nlimbs!(1024) }, _>(&mut OsRng.unwrap_mut()),
+            || random::<{ nlimbs!(1024) }, _>(&mut rng),
             |n| n.next_prime(),
             BatchSize::SmallInput,
         )

src/generic.rs

@@ -37,7 +37,7 @@ where
 
 #[cfg(test)]
 mod tests {
-    use rand_core::{CryptoRng, OsRng, TryRngCore};
+    use rand_core::CryptoRng;
 
     use super::sieve_and_find;
     use crate::{Error, hazmat::SieveFactory};
@@ -67,12 +67,14 @@ mod tests {
             }
         }
 
+        let mut rng = rand::rng();
+
         let factory = TestSieveFactory { count: 0 };
-        let result = sieve_and_find(&mut OsRng.unwrap_mut(), factory, |_rng, num| *num == 11);
+        let result = sieve_and_find(&mut rng, factory, |_rng, num| *num == 11);
         assert!(result.unwrap().is_some());
 
         let factory = TestSieveFactory { count: 0 };
-        let result = sieve_and_find(&mut OsRng.unwrap_mut(), factory, |_rng, num| *num == 20);
+        let result = sieve_and_find(&mut rng, factory, |_rng, num| *num == 20);
         assert!(result.unwrap().is_none());
     }
 }

src/hazmat/miller_rabin.rs

@@ -235,7 +235,7 @@ mod tests {
 
     use crypto_bigint::{Odd, RandomMod, U64, U128, U1024, U1536, Uint, Unsigned};
     use rand_chacha::ChaCha8Rng;
-    use rand_core::{CryptoRng, OsRng, SeedableRng, TryRngCore};
+    use rand_core::{CryptoRng, SeedableRng};
 
     #[cfg(feature = "tests-exhaustive")]
     use num_prime::nt_funcs::is_prime64;
@@ -252,11 +252,13 @@ mod tests {
 
     #[test]
     fn random_base_corner_cases() {
+        let mut rng = rand::rng();
+
         let mr = MillerRabin::new(Odd::new(U64::from(1u32)).unwrap());
-        assert!(mr.test_random_base(&mut OsRng.unwrap_mut()) == Primality::Composite);
+        assert!(mr.test_random_base(&mut rng) == Primality::Composite);
 
         let mr = MillerRabin::new(Odd::new(U64::from(3u32)).unwrap());
-        assert!(mr.test_random_base(&mut OsRng.unwrap_mut()) == Primality::Prime);
+        assert!(mr.test_random_base(&mut rng) == Primality::Prime);
     }
 
     fn is_spsp(num: u32) -> bool {

src/hazmat/precomputed.rs

@@ -143,19 +143,19 @@ pub(crate) static RECIPROCALS: [Reciprocal; SMALL_PRIMES.len()] = create_recipro
 #[cfg(test)]
 mod tests {
     use crypto_bigint::{NonZero, Random, U256};
-    use rand_core::{OsRng, TryRngCore};
 
     use super::{SMALL_PRIMES, create_reciprocals};
 
     #[test]
     fn correctness() {
+        let mut rng = rand::rng();
         let reciprocals = create_reciprocals();
 
         assert_eq!(reciprocals.len(), SMALL_PRIMES.len());
 
         for (reciprocal, prime) in reciprocals.iter().zip(SMALL_PRIMES.iter()) {
             for _ in 0..10 {
-                let x = U256::random(&mut OsRng.unwrap_mut());
+                let x = U256::random(&mut rng);
                 let r_ref = (x % NonZero::new(U256::from(*prime)).unwrap()).as_limbs()[0];
                 let r_test = x.rem_limb_with_reciprocal(reciprocal);
                 assert_eq!(r_ref, r_test);