Upgraded rand to v0.9

Author: rozbb

Cargo.toml

@@ -8,20 +8,20 @@ keywords = ["cryptography", "crypto", "post-quantum", "encapsulation", "kem"]
 categories = ["cryptography", "no-std"]
 
 [dependencies]
-rand_core = "0.6.4"
-sha3 = { version = "0.10.8", default-features = false }
-subtle = { version = "2.6.0", default-features = false, features = [
+rand_core = "0.9"
+sha3 = { version = "0.10", default-features = false }
+subtle = { version = "2.6", default-features = false, features = [
     "const-generics",
 ] }
-zeroize = { version = "1.8.1", default-features = false, features = ["derive"] }
+zeroize = { version = "1", default-features = false, features = ["derive"] }
 
 [dev-dependencies]
-rand = "0.8.5"
-criterion = "0.3"
+rand = "0.9"
+criterion = "0.5"
 aes_ctr_drbg = "0.0.2"
-serde = { version = "1.0.203", features = ["derive"] }
-serde_json = "1.0.117"
-hex = "0.4.3"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+hex = "0.4"
 
 [features]
 default = ["asm"]

benches/all.rs

@@ -7,7 +7,7 @@ use criterion::{criterion_group, criterion_main, Criterion};
 macro_rules! bench_variant {
     ($bench_name:ident, $privkey_name:ident) => {
         fn $bench_name(c: &mut Criterion) {
-            let mut rng = rand::thread_rng();
+            let mut rng = rand::rng();
 
             let gen_bench_name = format!("{}-gen-keypair", stringify!($bench_name));
             c.bench_function(&gen_bench_name, |b| {

examples/simple.rs

@@ -3,7 +3,7 @@ use saber_kem::lightsaber::{
 };
 
 fn main() {
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
 
     // Generate a keypair
     let sk = LightsaberSecretKey::generate(&mut rng);

src/arithmetic/matrix_arith.rs

@@ -16,7 +16,7 @@ impl<const X: usize, const Y: usize> Default for Matrix<X, Y> {
 
 impl<const X: usize, const Y: usize> Matrix<X, Y> {
     #[cfg(test)]
-    pub fn rand(rng: &mut impl rand_core::CryptoRngCore) -> Self {
+    pub fn rand(rng: &mut impl rand_core::CryptoRng) -> Self {
         let mut mat = Matrix::default();
         for i in 0..X {
             for j in 0..Y {
@@ -150,7 +150,7 @@ mod test {
         const X: usize = 4;
         const Y: usize = 7;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         // Test mul_transpose
         let mat = Matrix::<X, Y>::rand(&mut rng);
@@ -182,7 +182,7 @@ mod test {
         const Y: usize = 7;
         const Z: usize = 13;
 
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
 
         // Check that A^T B == (B^T A)^T
         let mat1 = Matrix::<X, Y>::rand(&mut rng);

src/arithmetic/ring_arith.rs

@@ -27,7 +27,7 @@ impl Default for RingElem {
 impl RingElem {
     /// Creates a random ring element
     #[cfg(test)]
-    pub(crate) fn rand(rng: &mut impl rand_core::CryptoRngCore) -> Self {
+    pub(crate) fn rand(rng: &mut impl rand_core::CryptoRng) -> Self {
         let modulus = 1 << crate::consts::MODULUS_Q_BITS as u32;
 
         let mut result = [0; RING_DEG];
@@ -231,12 +231,12 @@ mod test {
     use super::*;
     use crate::consts::RING_DEG;
 
-    use rand::{thread_rng, Rng, RngCore};
+    use rand::{rng, Rng, RngCore};
 
     // Checks that a * b == b * a and a + b == b + a for ring elements a, b
     #[test]
     fn commutativity() {
-        let mut rng = thread_rng();
+        let mut rng = rng();
 
         for _ in 0..100 {
             let a = RingElem::rand(&mut rng);
@@ -256,7 +256,7 @@ mod test {
     // Tests equivalence of karatsuba and schoolbook multiplication
     #[test]
     fn karatsuba() {
-        let mut rng = thread_rng();
+        let mut rng = rng();
 
         for _ in 0..100 {
             let a = RingElem::rand(&mut rng);
@@ -272,7 +272,7 @@ mod test {
     // Tests serialization and deserialization of ring elements
     #[test]
     fn from_bytes() {
-        let mut rng = thread_rng();
+        let mut rng = rng();
 
         // The largest buffer we'll need for the following tests. We make 2 because we need to
         // compare values in some places
@@ -327,7 +327,7 @@ mod test {
 
             // Pick a random bits_per_elem
             for _ in 0..10 {
-                let bits_per_elem = rng.gen_range(1..=13);
+                let bits_per_elem = rng.random_range(1..=13);
                 let bitmask = (1 << bits_per_elem) - 1;
 
                 // Generate a random element and make sure none of the values exceed 2^bits_per_elem

src/impls.rs

@@ -6,7 +6,7 @@ use crate::{
     pke::ciphertext_len,
 };
 
-use rand_core::CryptoRngCore;
+use rand_core::CryptoRng;
 use zeroize::{Zeroize, ZeroizeOnDrop};
 
 /// A shared secret of a KEM execution. This is just a `[u8; 32]` that zeroes itself from memory
@@ -60,7 +60,7 @@ macro_rules! variant_impl {
                 pub const SERIALIZED_LEN: usize = KemSecretKey::<$variant_ell>::SERIALIZED_LEN;
 
                 /// Generate a fresh secret key
-                pub fn generate(rng: &mut impl CryptoRngCore) -> Self {
+                pub fn generate(rng: &mut impl CryptoRng) -> Self {
                     Self(KemSecretKey::generate::<$variant_mu>(rng))
                 }
 
@@ -99,7 +99,7 @@ macro_rules! variant_impl {
                 /// Encapsulates a fresh shared secret
                 pub fn encapsulate(
                     &self,
-                    rng: &mut impl CryptoRngCore,
+                    rng: &mut impl CryptoRng,
                 ) -> ($ciphertext_name, SharedSecret) {
                     let mut ct = [0u8; $ciphertext_len_name];
                     let ss = self.encapsulate_in_place(rng, &mut ct);
@@ -112,7 +112,7 @@ macro_rules! variant_impl {
                 /// buffer
                 pub fn encapsulate_in_place(
                     &self,
-                    rng: &mut impl CryptoRngCore,
+                    rng: &mut impl CryptoRng,
                     ct_out: &mut $ciphertext_name,
                 ) -> SharedSecret {
                     let shared_secret =
@@ -140,7 +140,7 @@ macro_rules! variant_impl {
             /// Basic test that keygen, encap, decap, ser, and deser work
             #[test]
             fn test_api() {
-                let mut rng = rand::thread_rng();
+                let mut rng = rand::rng();
                 let sk = $privkey_name::generate(&mut rng);
                 let pk = sk.public_key();
 

src/kem.rs

@@ -5,7 +5,7 @@ use crate::pke::{
     PkeSecretKey,
 };
 
-use rand_core::CryptoRngCore;
+use rand_core::CryptoRng;
 use sha3::{digest::Digest, Sha3_256};
 use subtle::{ConditionallySelectable, ConstantTimeEq};
 
@@ -59,7 +59,7 @@ impl<const L: usize> KemSecretKey<L> {
 
     // Algorithm 20, Saber.KEM.KeyGen
     /// Generate a fresh secret key
-    pub fn generate<const MU: usize>(rng: &mut impl CryptoRngCore) -> KemSecretKey<L> {
+    pub fn generate<const MU: usize>(rng: &mut impl CryptoRng) -> KemSecretKey<L> {
         let (pke_sk, pke_pk) = pke::gen_keypair::<L, MU>(rng);
 
         // Hash the public key
@@ -147,7 +147,7 @@ impl<const L: usize> KemSecretKey<L> {
 /// Encapsulate a shared secret to the given public key. Returns the shared secret.
 /// `out_buf` MUST have length `ciphertext_len::<L>()`.
 pub(crate) fn encap<const L: usize, const MU: usize, const MODULUS_T_BITS: usize>(
-    rng: &mut impl CryptoRngCore,
+    rng: &mut impl CryptoRng,
     kem_pk: &KemPublicKey<L>,
     out_buf: &mut [u8],
 ) -> SharedSecret {
@@ -284,15 +284,15 @@ mod test {
     }
 
     fn test_encap_decap<const L: usize, const MU: usize, const MODULUS_T_BITS: usize>() {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let mut backing_buf = [0u8; max_ciphertext_len()];
 
         for _ in 0..100 {
             let sk = KemSecretKey::<L>::generate::<MU>(&mut rng);
             let pk = sk.public_key();
             let ct_buf = &mut backing_buf[..ciphertext_len::<L, MODULUS_T_BITS>()];
 
-            let m: [u8; 32] = rng.gen();
+            let m: [u8; 32] = rng.random();
             let ss1 = encap_deterministic::<L, MU, MODULUS_T_BITS>(&m, &pk, ct_buf);
             let ss2 = decap::<L, MU, MODULUS_T_BITS>(&sk, &ct_buf);
             assert_eq!(ss1, ss2);
@@ -302,9 +302,9 @@ mod test {
             // encapsulator
             let perturbed_ct = ct_buf;
             // XOR the ciphertext with a random (nonzero) byte in a random location
-            let idx = (rng.gen::<u32>() as usize) % perturbed_ct.len();
+            let idx = (rng.random::<u32>() as usize) % perturbed_ct.len();
             let byte = loop {
-                let b = rng.gen::<u8>();
+                let b = rng.random::<u8>();
                 if b != 0 {
                     break b;
                 }

src/pke.rs

@@ -9,7 +9,7 @@ use crate::{
     ser::deserialize,
 };
 
-use rand_core::CryptoRngCore;
+use rand_core::CryptoRng;
 use sha3::{digest::ExtendableOutput, Shake128};
 
 const H1_VAL: u16 = 1 << (MODULUS_Q_BITS - MODULUS_P_BITS - 1);
@@ -91,7 +91,7 @@ pub const fn ciphertext_len<const L: usize, const MODULUS_T_BITS: usize>() -> us
 // Algorithm 17, Saber.PKE.KeyGen
 /// Generates a keypair with a secret from R^ℓ with bionimal parameter μ
 pub(crate) fn gen_keypair<const L: usize, const MU: usize>(
-    rng: &mut impl CryptoRngCore,
+    rng: &mut impl CryptoRng,
 ) -> (PkeSecretKey<L>, PkePublicKey<L>) {
     let mut matrix_seed = [0u8; 32];
     let mut matrix_seed_unhashed = [0u8; 32];
@@ -213,7 +213,7 @@ mod test {
 
     // Helper function that encrypts and decrypts a random 32-byte message
     fn test_enc_dec<const L: usize, const MODULUS_T_BITS: usize, const MU: usize>() {
-        let mut rng = rand::thread_rng();
+        let mut rng = rand::rng();
         let mut backing_buf =
             [0u8; MAX_MODULUS_T_BITS * RING_DEG / 8 + MAX_L * MODULUS_P_BITS * RING_DEG / 8];
 

tests/kat.rs

@@ -50,10 +50,6 @@ impl RngCore for KatRng {
     fn fill_bytes(&mut self, dest: &mut [u8]) {
         self.0.get_random(dest)
     }
-    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core::Error> {
-        self.fill_bytes(dest);
-        Ok(())
-    }
 
     fn next_u32(&mut self) -> u32 {
         unimplemented!()