chore(deps): bump rand_core to 0.10.0-rc-5

Author: baloo

Cargo.lock

@@ -12,3 +12,5 @@ debug = true
 
 [patch.crates-io]
 ml-kem = { path = "./ml-kem" }
+
+x25519-dalek = { git = "https://github.com/baloo/curve25519-dalek.git", branch = "baloo/push-lpxummypqqox" }

Cargo.toml

@@ -15,7 +15,7 @@ readme = "README.md"
 
 [dependencies]
 kem = "0.4.0-rc.2"
-rand_core = "0.10.0-rc-3"
+rand_core = "0.10.0-rc-5"
 
 # optional dependencies
 elliptic-curve = { version = "0.14.0-rc.21", optional = true, default-features = false }

dhkem/Cargo.toml

@@ -1,7 +1,7 @@
 use crate::{DhDecapsulator, DhEncapsulator, DhKem};
 use core::convert::Infallible;
 use kem::{Decapsulate, Encapsulate};
-use rand_core::{CryptoRng, TryCryptoRng};
+use rand_core::{CryptoRng, TryCryptoRng, UnwrapErr};
 use x25519::{PublicKey, ReusableSecret, SharedSecret};
 
 /// X22519 Diffie-Hellman KEM adapter.
@@ -17,7 +17,7 @@ impl Encapsulate<PublicKey, SharedSecret> for DhEncapsulator<PublicKey> {
         rng: &mut R,
     ) -> Result<(PublicKey, SharedSecret), Self::Error> {
         // ECDH encapsulation involves creating a new ephemeral key pair and then doing DH
-        let sk = ReusableSecret::random_from_rng(&mut rng.unwrap_mut());
+        let sk = ReusableSecret::random_from_rng(&mut UnwrapErr(rng));
         let pk = PublicKey::from(&sk);
         let ss = sk.diffie_hellman(&self.0);
 

dhkem/src/x25519_kem.rs

@@ -1,38 +1,42 @@
 #![cfg(feature = "p256")]
 
+use core::convert::Infallible;
 use dhkem::{DhKem, NistP256Kem};
 use elliptic_curve::sec1::ToEncodedPoint;
 use hex_literal::hex;
 use hkdf::Hkdf;
 use kem::{Decapsulate, Encapsulate};
-use rand_core::{CryptoRng, RngCore};
+use rand_core::{TryCryptoRng, TryRngCore};
 use sha2::Sha256;
 
 /// Constant RNG for testing purposes only.
 struct ConstantRng<'a>(pub &'a [u8]);
 
-impl RngCore for ConstantRng<'_> {
-    fn next_u32(&mut self) -> u32 {
+impl TryRngCore for ConstantRng<'_> {
+    type Error = Infallible;
+
+    fn try_next_u32(&mut self) -> Result<u32, Self::Error> {
         let (head, tail) = self.0.split_at(4);
         self.0 = tail;
-        u32::from_be_bytes(head.try_into().unwrap())
+        Ok(u32::from_be_bytes(head.try_into().unwrap()))
     }
 
-    fn next_u64(&mut self) -> u64 {
+    fn try_next_u64(&mut self) -> Result<u64, Self::Error> {
         let (head, tail) = self.0.split_at(8);
         self.0 = tail;
-        u64::from_be_bytes(head.try_into().unwrap())
+        Ok(u64::from_be_bytes(head.try_into().unwrap()))
     }
 
-    fn fill_bytes(&mut self, dest: &mut [u8]) {
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Self::Error> {
         let (hd, tl) = self.0.split_at(dest.len());
         dest.copy_from_slice(hd);
         self.0 = tl;
+        Ok(())
     }
 }
 
 // this is only ever ok for testing
-impl CryptoRng for ConstantRng<'_> {}
+impl TryCryptoRng for ConstantRng<'_> {}
 
 fn labeled_extract(salt: &[u8], label: &[u8], ikm: &[u8]) -> Vec<u8> {
     let labeled_ikm = [b"HPKE-v1".as_slice(), b"KEM\x00\x10".as_slice(), label, ikm].concat();

dhkem/tests/hpke_p256_test.rs

@@ -58,7 +58,7 @@ serde = ["dep:hex", "dep:serde"]
 aes = { version = "0.9.0-rc.2", optional = true }
 hex = { version = "0.4", optional = true }
 openssl-sys = { version = "0.9.104", optional = true }
-rand_core = { version = "0.10.0-rc-3", features = [] }
+rand_core = { version = "0.10.0-rc-5", features = [] }
 serde = { version = "1.0", features = ["derive"], optional = true }
 serdect = "0.4"
 subtle = "2.6"
@@ -83,7 +83,7 @@ criterion = "0.7"
 getrandom = { version = "0.4.0-rc.0", features = ["sys_rng"] }
 hex = "0.4"
 hybrid-array = "0.4"
-chacha20 = { version = "0.10.0-rc.6", features = ["rng"] }
+chacha20 = { version = "0.10.0-rc.7", features = ["rng"] }
 rstest = "0.26"
 postcard = { version = "1.0", features = ["use-std"] }
 serde_bare = "0.5"

frodo-kem/Cargo.toml

@@ -4,8 +4,9 @@ use aes::{
     Aes256Enc, Block,
     cipher::{BlockCipherEncrypt, KeyInit},
 };
+use core::convert::Infallible;
 use hybrid_array::{Array, typenum::U48};
-use rand_core::{CryptoRng, RngCore, SeedableRng};
+use rand_core::{RngCore, SeedableRng, TryCryptoRng, TryRngCore};
 
 /// Seed type for the AES-CTR DRBG
 pub type RngSeed = Array<u8, U48>;
@@ -29,20 +30,22 @@ impl SeedableRng for AesCtrDrbg {
     }
 }
 
-impl RngCore for AesCtrDrbg {
-    fn next_u32(&mut self) -> u32 {
+impl TryRngCore for AesCtrDrbg {
+    type Error = Infallible;
+
+    fn try_next_u32(&mut self) -> Result<u32, Self::Error> {
         let mut int = [0u8; 4];
         self.fill_bytes(&mut int);
-        u32::from_le_bytes(int)
+        Ok(u32::from_le_bytes(int))
     }
 
-    fn next_u64(&mut self) -> u64 {
+    fn try_next_u64(&mut self) -> Result<u64, Self::Error> {
         let mut int = [0u8; 8];
         self.fill_bytes(&mut int);
-        u64::from_le_bytes(int)
+        Ok(u64::from_le_bytes(int))
     }
 
-    fn fill_bytes(&mut self, dest: &mut [u8]) {
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Self::Error> {
         let mut in_block = Block::default();
         let mut out_block = Block::default();
         let enc = Aes256Enc::new_from_slice(&self.key).unwrap();
@@ -64,10 +67,11 @@ impl RngCore for AesCtrDrbg {
 
         self.update(None);
         self.reseed_counter += 1;
+        Ok(())
     }
 }
 
-impl CryptoRng for AesCtrDrbg {}
+impl TryCryptoRng for AesCtrDrbg {}
 
 impl AesCtrDrbg {
     /// Reseed the DRBG with a new seed

frodo-kem/tests/rng.rs

@@ -27,7 +27,7 @@ zeroize = ["dep:zeroize"]
 [dependencies]
 kem = "0.4.0-rc.2"
 hybrid-array = { version = "0.4.4", features = ["extra-sizes", "subtle"] }
-rand_core = "0.10.0-rc-3"
+rand_core = "0.10.0-rc-5"
 sha3 = { version = "0.11.0-rc.3", default-features = false }
 subtle = { version = "2", default-features = false }
 

ml-kem/Cargo.toml

@@ -11,7 +11,7 @@ use pkcs8::{
         asn1::{ContextSpecific, OctetStringRef},
     },
 };
-use rand_core::{CryptoRng, TryRngCore};
+use rand_core::{RngCore, TryCryptoRng, TryRngCore};
 
 /// ML-KEM seed serialized as ASN.1.
 type SeedString<'a> = ContextSpecific<&'a OctetStringRef>;
@@ -111,28 +111,31 @@ where
         seed: [u8; SEED_LEN],
     }
 
-    impl rand_core::RngCore for SeedBasedRng {
-        fn next_u32(&mut self) -> u32 {
+    impl rand_core::TryRngCore for SeedBasedRng {
+        type Error = core::convert::Infallible;
+
+        fn try_next_u32(&mut self) -> Result<u32, Self::Error> {
             let mut buf = [0u8; 4];
             self.fill_bytes(&mut buf);
-            u32::from_be_bytes(buf)
+            Ok(u32::from_be_bytes(buf))
         }
 
-        fn next_u64(&mut self) -> u64 {
+        fn try_next_u64(&mut self) -> Result<u64, Self::Error> {
             let mut buf = [0u8; 8];
             self.fill_bytes(&mut buf);
-            u64::from_be_bytes(buf)
+            Ok(u64::from_be_bytes(buf))
         }
 
-        fn fill_bytes(&mut self, dst: &mut [u8]) {
+        fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Self::Error> {
             for item in dst {
                 *item = self.seed[self.index];
                 self.index = self.index.wrapping_add(1) & ((1 << SEED_LEN.ilog2()) - 1);
             }
+            Ok(())
         }
     }
 
-    impl CryptoRng for SeedBasedRng {}
+    impl TryCryptoRng for SeedBasedRng {}
 
     const SEED_LEN: usize = 64;
     assert_eq!(SEED_LEN & (SEED_LEN - 1), 0);

ml-kem/tests/pkcs8.rs

@@ -19,7 +19,7 @@ zeroize = ["dep:zeroize", "ml-kem/zeroize", "x25519-dalek/zeroize"]
 [dependencies]
 kem = "0.4.0-rc.2"
 ml-kem = { version = "=0.3.0-pre.3", default-features = false, features = ["deterministic"] }
-rand_core = { version = "0.10.0-rc-3", default-features = false }
+rand_core = { version = "0.10.0-rc-5", default-features = false }
 sha3 = { version = "0.11.0-rc.3", default-features = false }
 x25519-dalek = { version = "=3.0.0-pre.4", default-features = false, features = ["static_secrets"] }
 
@@ -29,7 +29,7 @@ zeroize = { version = "1.8.1", optional = true, default-features = true, feature
 [dev-dependencies]
 getrandom = { version = "0.4.0-rc.0", features = ["sys_rng"] }
 hex = { version = "0.4", features = ["serde"] }
-rand_core = "0.10.0-rc-3"
+rand_core = "0.10.0-rc-5"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"