refactor: migrate to rand 0.9 (#734)

* refactor: migrate to rand 0.9

* fix: enable wasm_js feature for getrandom

* fix: set getrandom cfg

* fix: clippy

* fix: notary server rand

* fix cargo config

Cargo.toml

@@ -121,9 +121,10 @@ opaque-debug = { version = "0.3" }
 p256 = { version = "0.13" }
 pkcs8 = { version = "0.10" }
 pin-project-lite = { version = "0.2" }
-rand = { version = "0.8" }
-rand_chacha = { version = "0.3" }
-rand_core = { version = "0.6" }
+rand = { version = "0.9" }
+rand_chacha = { version = "0.9" }
+rand_core = { version = "0.9" }
+rand06-compat = { version = "0.1" }
 rayon = { version = "1.10" }
 regex = { version = "1.10" }
 ring = { version = "0.17" }

crates/components/cipher/Cargo.toml

@@ -27,5 +27,6 @@ mpz-ot = { workspace = true }
 
 tokio = { version = "1", features = ["macros", "rt", "rt-multi-thread"] }
 rand = { workspace = true }
+rand06-compat = { workspace = true }
 ctr = { workspace = true }
 cipher = { workspace = true }

crates/components/cipher/src/aes/mod.rs

@@ -181,6 +181,7 @@ mod tests {
     use mpz_ot::ideal::cot::ideal_cot;
     use mpz_vm_core::{Execute, Vm};
     use rand::{rngs::StdRng, SeedableRng};
+    use rand06_compat::Rand0_6CompatExt;
 
     #[tokio::test]
     async fn test_aes_ctr() {
@@ -296,7 +297,7 @@ mod tests {
 
     fn mock_vm() -> (impl Vm<Binary>, impl Vm<Binary>) {
         let mut rng = StdRng::seed_from_u64(0);
-        let delta = Delta::random(&mut rng);
+        let delta = Delta::random(&mut rng.compat_by_ref());
 
         let (cot_send, cot_recv) = ideal_cot(delta.into_inner());
 

crates/components/deap/Cargo.toml

@@ -23,3 +23,4 @@ mpz-zk = { workspace = true }
 
 tokio = { workspace = true, features = ["macros", "rt", "rt-multi-thread"] }
 rand = { workspace = true }
+rand06-compat = { workspace = true }

crates/components/deap/src/lib.rs

@@ -368,14 +368,15 @@ mod tests {
     };
     use mpz_zk::{Prover, Verifier};
     use rand::{rngs::StdRng, SeedableRng};
+    use rand06_compat::Rand0_6CompatExt;
 
     use super::*;
 
     #[tokio::test]
     async fn test_deap() {
         let mut rng = StdRng::seed_from_u64(0);
-        let delta_mpc = Delta::random(&mut rng);
-        let delta_zk = Delta::random(&mut rng);
+        let delta_mpc = Delta::random(&mut rng.compat_by_ref());
+        let delta_zk = Delta::random(&mut rng.compat_by_ref());
 
         let (mut ctx_a, mut ctx_b) = test_st_context(8);
         let (rcot_send, rcot_recv) = ideal_rcot(Block::ZERO, delta_zk.into_inner());
@@ -456,8 +457,8 @@ mod tests {
     #[tokio::test]
     async fn test_malicious() {
         let mut rng = StdRng::seed_from_u64(0);
-        let delta_mpc = Delta::random(&mut rng);
-        let delta_zk = Delta::random(&mut rng);
+        let delta_mpc = Delta::random(&mut rng.compat_by_ref());
+        let delta_zk = Delta::random(&mut rng.compat_by_ref());
 
         let (mut ctx_a, mut ctx_b) = test_st_context(8);
         let (rcot_send, rcot_recv) = ideal_rcot(Block::ZERO, delta_zk.into_inner());

crates/components/hmac-sha256/Cargo.toml

@@ -36,6 +36,7 @@ mpz-common = { workspace = true, features = ["test-utils"] }
 criterion = { workspace = true, features = ["async_tokio"] }
 tokio = { workspace = true, features = ["macros", "rt", "rt-multi-thread"] }
 rand = { workspace = true }
+rand06-compat = { workspace = true }
 
 [[bench]]
 name = "prf"

crates/components/hmac-sha256/benches/prf.rs

@@ -11,6 +11,7 @@ use mpz_vm_core::{
     prelude::*,
 };
 use rand::{rngs::StdRng, SeedableRng};
+use rand06_compat::Rand0_6CompatExt;
 
 #[allow(clippy::unit_arg)]
 fn criterion_benchmark(c: &mut Criterion) {
@@ -35,7 +36,7 @@ async fn prf() {
     let mut leader_ctx = leader_exec.new_context().await.unwrap();
     let mut follower_ctx = follower_exec.new_context().await.unwrap();
 
-    let delta = Delta::random(&mut rng);
+    let delta = Delta::random(&mut rng.compat_by_ref());
     let (ot_send, ot_recv) = ideal_cot(delta.into_inner());
 
     let mut leader_vm = Generator::new(ot_send, [0u8; 16], delta);

crates/components/hmac-sha256/src/lib.rs

@@ -58,6 +58,7 @@ mod tests {
     use mpz_ot::ideal::cot::ideal_cot;
     use mpz_vm_core::{memory::correlated::Delta, prelude::*};
     use rand::{rngs::StdRng, SeedableRng};
+    use rand06_compat::Rand0_6CompatExt;
 
     use super::*;
 
@@ -90,7 +91,7 @@ mod tests {
 
         let (mut leader_ctx, mut follower_ctx) = test_st_context(128);
 
-        let delta = Delta::random(&mut rng);
+        let delta = Delta::random(&mut rng.compat_by_ref());
         let (ot_send, ot_recv) = ideal_cot(delta.into_inner());
 
         let mut leader_vm = Generator::new(ot_send, [0u8; 16], delta);

crates/components/key-exchange/Cargo.toml

@@ -31,6 +31,7 @@ serio = { workspace = true }
 derive_builder = { workspace = true }
 tracing = { workspace = true }
 rand = { workspace = true }
+rand06-compat = { workspace = true }
 tokio = { workspace = true, features = ["sync"] }
 
 [dev-dependencies]

crates/components/key-exchange/src/exchange.rs

@@ -4,6 +4,7 @@ use std::{fmt::Debug, sync::Arc};
 
 use async_trait::async_trait;
 use p256::{EncodedPoint, PublicKey, SecretKey};
+use rand06_compat::Rand0_6CompatExt;
 use serio::{sink::SinkExt, stream::IoStreamExt};
 use tokio::sync::Mutex;
 use tracing::instrument;
@@ -91,7 +92,7 @@ impl<C0, C1> MpcKeyExchange<C0, C1> {
     /// * `converter_0` - Share conversion protocol instance 0.
     /// * `converter_1` - Share conversion protocol instance 1.
     pub fn new(role: Role, converter_0: C0, converter_1: C1) -> Self {
-        let private_key = SecretKey::random(&mut rand::rngs::OsRng);
+        let private_key = SecretKey::random(&mut rand::rng().compat());
 
         Self {
             converter_0: Arc::new(Mutex::new(converter_0)),
@@ -456,6 +457,7 @@ mod tests {
     use crate::error::ErrorRepr;
     use mpz_common::context::test_st_context;
     use mpz_core::Block;
+    use mpz_fields::UniformRand;
     use mpz_garble::protocol::semihonest::{Evaluator, Generator};
     use mpz_memory_core::correlated::Delta;
     use mpz_ot::ideal::cot::{ideal_cot, IdealCOTReceiver, IdealCOTSender};
@@ -464,7 +466,7 @@ mod tests {
     };
     use mpz_vm_core::Execute;
     use p256::{NonZeroScalar, PublicKey, SecretKey};
-    use rand::{rngs::StdRng, Rng};
+    use rand::rngs::StdRng;
     use rand_core::SeedableRng;
     use rstest::*;
 
@@ -479,7 +481,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_key_exchange() {
-        let mut rng = StdRng::seed_from_u64(0);
+        let mut rng = StdRng::seed_from_u64(0).compat();
         let (mut ctx_a, mut ctx_b) = test_st_context(8);
         let (mut gen, mut ev) = mock_vm();
 
@@ -543,7 +545,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_compute_ec_shares() {
-        let mut rng = StdRng::seed_from_u64(0);
+        let mut rng = StdRng::seed_from_u64(0).compat();
         let (mut ctx_leader, mut ctx_follower) = test_st_context(8);
         let (leader_converter_0, follower_converter_0) = ideal_share_convert(Block::ZERO);
         let (follower_converter_1, leader_converter_1) = ideal_share_convert(Block::ZERO);
@@ -612,7 +614,7 @@ mod tests {
     #[case::malicious_follower(Malicious::Follower)]
     #[tokio::test]
     async fn test_malicious_key_exchange(#[case] malicious: Malicious) {
-        let mut rng = StdRng::seed_from_u64(0);
+        let mut rng = StdRng::seed_from_u64(0).compat();
         let (mut ctx_a, mut ctx_b) = test_st_context(8);
         let (mut gen, mut ev) = mock_vm();
 
@@ -638,7 +640,7 @@ mod tests {
         let client_public_key = leader.client_key().unwrap();
         assert_eq!(client_public_key, expected_client_public_key);
 
-        let bad_pms_share: P256 = rng.gen();
+        let bad_pms_share = P256::rand(&mut rng);
 
         let (leader_err, follower_err) = tokio::join!(
             async {
@@ -811,7 +813,7 @@ mod tests {
     }
 
     fn mock_vm() -> (Generator<IdealCOTSender>, Evaluator<IdealCOTReceiver>) {
-        let mut rng = StdRng::seed_from_u64(0);
+        let mut rng = StdRng::seed_from_u64(0).compat();
         let delta = Delta::random(&mut rng);
 
         let (cot_send, cot_recv) = ideal_cot(delta.into_inner());

crates/components/key-exchange/src/point_addition.rs

@@ -113,8 +113,8 @@ mod tests {
         let (mut ctx_a, mut ctx_b) = test_st_context(8);
         let mut rng = StdRng::seed_from_u64(0);
 
-        let p1: [u8; 32] = rng.gen();
-        let p2: [u8; 32] = rng.gen();
+        let p1: [u8; 32] = rng.random();
+        let p2: [u8; 32] = rng.random();
 
         let p1 = curve_point_from_be_bytes(p1);
         let p2 = curve_point_from_be_bytes(p2);
@@ -138,7 +138,7 @@ mod tests {
     fn test_decompose_point() {
         let mut rng = StdRng::seed_from_u64(0);
 
-        let p_expected: [u8; 32] = rng.gen();
+        let p_expected: [u8; 32] = rng.random();
         let p_expected = curve_point_from_be_bytes(p_expected);
 
         let p256: [P256; 2] = decompose_point(p_expected).unwrap();

crates/core/Cargo.toml

@@ -45,6 +45,7 @@ bincode = { workspace = true }
 hex = { workspace = true }
 rstest = { workspace = true }
 tlsn-data-fixtures = { workspace = true }
+rand06-compat = { workspace = true }
 
 [[test]]
 name = "api"

crates/core/src/attestation.rs

@@ -20,7 +20,7 @@ mod proof;
 
 use std::fmt;
 
-use rand::distributions::{Distribution, Standard};
+use rand::distr::{Distribution, StandardUniform};
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -51,7 +51,7 @@ impl From<[u8; 16]> for Uid {
     }
 }
 
-impl Distribution<Uid> for Standard {
+impl Distribution<Uid> for StandardUniform {
     fn sample<R: rand::Rng + ?Sized>(&self, rng: &mut R) -> Uid {
         Uid(self.sample(rng))
     }

crates/core/src/attestation/builder.rs

@@ -1,6 +1,6 @@
 use std::error::Error;
 
-use rand::{thread_rng, Rng};
+use rand::{rng, Rng};
 
 use crate::{
     attestation::{
@@ -173,7 +173,7 @@ impl AttestationBuilder<'_, Sign> {
         };
 
         let header = Header {
-            id: thread_rng().gen(),
+            id: rng().random(),
             version: VERSION,
             root: body.root(hasher),
         };

crates/core/src/hash.rs

@@ -2,7 +2,7 @@
 
 use std::{collections::HashMap, fmt::Display};
 
-use rand::{distributions::Standard, prelude::Distribution};
+use rand::{distr::StandardUniform, prelude::Distribution};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use crate::serialize::CanonicalSerialize;
@@ -256,7 +256,7 @@ pub(crate) struct Blinder([u8; 16]);
 
 opaque_debug::implement!(Blinder);
 
-impl Distribution<Blinder> for Standard {
+impl Distribution<Blinder> for StandardUniform {
     fn sample<R: rand::Rng + ?Sized>(&self, rng: &mut R) -> Blinder {
         let mut blinder = [0; 16];
         rng.fill(&mut blinder);

crates/core/src/signing.rs

@@ -509,7 +509,7 @@ mod test {
     use alloy_primitives::utils::eip191_message;
     use alloy_signer::SignerSync;
     use alloy_signer_local::PrivateKeySigner;
-    use rand_core::OsRng;
+    use rand06_compat::Rand0_6CompatExt;
     use rstest::{fixture, rstest};
 
     use super::*;
@@ -517,7 +517,7 @@ mod test {
     #[fixture]
     #[once]
     fn secp256k1_pair() -> (Box<dyn Signer>, Box<dyn SignatureVerifier>) {
-        let signing_key = k256::ecdsa::SigningKey::random(&mut OsRng);
+        let signing_key = k256::ecdsa::SigningKey::random(&mut rand::rng().compat());
         (
             Box::new(Secp256k1Signer::new(&signing_key.to_bytes()).unwrap()),
             Box::new(Secp256k1Verifier {}),
@@ -527,7 +527,7 @@ mod test {
     #[fixture]
     #[once]
     fn secp256r1_pair() -> (Box<dyn Signer>, Box<dyn SignatureVerifier>) {
-        let signing_key = p256::ecdsa::SigningKey::random(&mut OsRng);
+        let signing_key = p256::ecdsa::SigningKey::random(&mut rand::rng().compat());
         (
             Box::new(Secp256r1Signer::new(&signing_key.to_bytes()).unwrap()),
             Box::new(Secp256r1Verifier {}),
@@ -537,7 +537,7 @@ mod test {
     #[fixture]
     #[once]
     fn secp256k1eth_pair() -> (Box<dyn Signer>, Box<dyn SignatureVerifier>) {
-        let signing_key = k256::ecdsa::SigningKey::random(&mut OsRng);
+        let signing_key = k256::ecdsa::SigningKey::random(&mut rand::rng().compat());
         (
             Box::new(Secp256k1EthSigner::new(&signing_key.to_bytes()).unwrap()),
             Box::new(Secp256k1EthVerifier {}),

crates/mpc-tls/Cargo.toml

@@ -46,6 +46,7 @@ serde = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 rand = { workspace = true }
+rand06-compat = { workspace = true }
 opaque-debug = { workspace = true }
 aes = { workspace = true }
 aes-gcm = { workspace = true }

crates/mpc-tls/src/decode.rs

@@ -13,7 +13,7 @@ use mpz_memory_core::{
 };
 use mpz_vm_core::{prelude::*, Vm, VmError};
 use pin_project_lite::pin_project;
-use rand::{thread_rng, Rng};
+use rand::Rng;
 
 pin_project! {
     /// Supports decoding into additive shares.
@@ -35,8 +35,8 @@ impl<const N: usize> OneTimePadShared<[u8; N]> {
         value: Array<U8, N>,
         vm: &mut dyn Vm<Binary>,
     ) -> Result<Self, VmError> {
-        let mut rng = thread_rng();
-        let otp: [u8; N] = from_fn(|_| rng.gen());
+        let mut rng = rand::rng();
+        let otp: [u8; N] = from_fn(|_| rng.random());
         match role {
             Role::Leader => {
                 let masked = vm.mask_private(value, otp)?;

crates/mpc-tls/src/follower.rs

@@ -18,7 +18,7 @@ use mpz_ot::{
     },
 };
 use mpz_share_conversion::{ShareConversionReceiver, ShareConversionSender};
-use rand::{thread_rng, Rng};
+use rand06_compat::Rand0_6CompatExt;
 use serio::stream::IoStreamExt;
 use std::mem;
 use tls_core::msgs::{
@@ -51,7 +51,7 @@ impl MpcTlsFollower {
         CS: RCOTSender<Block> + Flush + Send + Sync + 'static,
         CR: RCOTReceiver<bool, Block> + Flush + Send + Sync + 'static,
     {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
 
         let ke = Box::new(MpcKeyExchange::new(
             key_exchange::Role::Follower,
@@ -59,7 +59,7 @@ impl MpcTlsFollower {
                 RandomizeRCOTReceiver::new(cot_recv.0),
             ))),
             ShareConversionSender::new(OLESender::new(
-                rng.gen(),
+                Block::random(&mut rng.compat_by_ref()),
                 AnySender::new(RandomizeRCOTSender::new(cot_send)),
             )),
         )) as Box<dyn KeyExchange + Send + Sync>;

crates/mpc-tls/src/leader.rs

@@ -28,7 +28,7 @@ use mpz_ot::{
 };
 use mpz_share_conversion::{ShareConversionReceiver, ShareConversionSender};
 use mpz_vm_core::prelude::*;
-use rand::{thread_rng, Rng};
+use rand06_compat::Rand0_6CompatExt;
 use serio::SinkExt;
 use tls_backend::{Backend, BackendError, BackendNotifier, BackendNotify};
 use tls_core::{
@@ -75,12 +75,12 @@ impl MpcTlsLeader {
         CS: RCOTSender<Block> + Flush + Send + Sync + 'static,
         CR: RCOTReceiver<bool, Block> + Flush + Send + Sync + 'static,
     {
-        let mut rng = thread_rng();
+        let mut rng = rand::rng();
 
         let ke = Box::new(MpcKeyExchange::new(
             key_exchange::Role::Leader,
             ShareConversionSender::new(OLESender::new(
-                rng.gen(),
+                Block::random(&mut rng.compat_by_ref()),
                 AnySender::new(RandomizeRCOTSender::new(cot_send.0)),
             )),
             ShareConversionReceiver::new(OLEReceiver::new(AnyReceiver::new(
@@ -97,14 +97,14 @@ impl MpcTlsLeader {
 
         let encrypter = MpcAesGcm::new(
             ShareConversionSender::new(OLESender::new(
-                rng.gen(),
+                Block::random(&mut rng.compat_by_ref()),
                 AnySender::new(RandomizeRCOTSender::new(cot_send.1)),
             )),
             Role::Leader,
         );
         let decrypter = MpcAesGcm::new(
             ShareConversionSender::new(OLESender::new(
-                rng.gen(),
+                Block::random(&mut rng.compat_by_ref()),
                 AnySender::new(RandomizeRCOTSender::new(cot_send.2)),
             )),
             Role::Leader,

crates/mpc-tls/src/record_layer.rs

@@ -15,7 +15,7 @@ use mpz_memory_core::{
     Array,
 };
 use mpz_vm_core::Vm as VmTrait;
-use rand::{thread_rng, RngCore};
+use rand::RngCore;
 use serde::{Deserialize, Serialize};
 use tls_core::{
     cipher::make_tls12_aad,
@@ -148,7 +148,7 @@ impl RecordLayer {
         let recv_otp = match self.role {
             Role::Leader => {
                 let mut recv_otp = vec![0u8; recv_len];
-                thread_rng().fill_bytes(&mut recv_otp);
+                rand::rng().fill_bytes(&mut recv_otp);
 
                 Some(recv_otp)
             }

crates/mpc-tls/src/record_layer/aead/aes_gcm.rs

@@ -449,7 +449,8 @@ mod tests {
     use mpz_memory_core::{binary::U8, correlated::Delta};
     use mpz_ot::ideal::cot::ideal_cot;
     use mpz_share_conversion::ideal::ideal_share_convert;
-    use rand::{rngs::StdRng, Rng, SeedableRng};
+    use rand::{rngs::StdRng, SeedableRng};
+    use rand06_compat::Rand0_6CompatExt;
     use rstest::*;
 
     static SHORT_MSG: &[u8] = b"hello world";
@@ -563,7 +564,7 @@ mod tests {
     }
 
     fn create_vm(key: [u8; 16], iv: [u8; 4]) -> ((impl Vm<Binary>, Vars), (impl Vm<Binary>, Vars)) {
-        let mut rng = StdRng::seed_from_u64(0);
+        let mut rng = StdRng::seed_from_u64(0).compat();
         let block = Block::random(&mut rng);
         let (sender, receiver) = ideal_cot(block);
 
@@ -611,7 +612,7 @@ mod tests {
 
     fn create_pair(vars_0: Vars, vars_1: Vars) -> (MpcAesGcm, MpcAesGcm) {
         let mut rng = StdRng::seed_from_u64(0);
-        let (c_0, c_1) = ideal_share_convert(rng.gen());
+        let (c_0, c_1) = ideal_share_convert(Block::random(&mut rng.compat_by_ref()));
         let mut leader = MpcAesGcm::new(c_0, Role::Leader);
         let mut follower = MpcAesGcm::new(c_1, Role::Follower);
 

crates/mpc-tls/src/record_layer/aead/ghash.rs

@@ -343,7 +343,7 @@ mod tests {
         ideal_share_convert, IdealShareConvertReceiver, IdealShareConvertSender,
     };
     use rand::{rngs::StdRng, Rng, SeedableRng};
-
+    use rand06_compat::Rand0_6CompatExt;
     fn create_pair() -> (
         MpcGhash<IdealShareConvertSender<Gf2_128>>,
         MpcGhash<IdealShareConvertReceiver<Gf2_128>>,
@@ -359,7 +359,7 @@ mod tests {
 
     #[test]
     fn test_compute_shares() {
-        let mut rng = StdRng::seed_from_u64(0);
+        let mut rng = StdRng::seed_from_u64(0).compat();
 
         let key = Gf2_128::rand(&mut rng);
         let expected_powers: Vec<_> = (0..MAX_POWER)
@@ -386,11 +386,11 @@ mod tests {
     async fn test_ghash_output() {
         let (mut ctx_a, mut ctx_b) = test_st_context(8);
         let mut rng = StdRng::seed_from_u64(0);
-        let h: u128 = rng.gen();
-        let sender_key: u128 = rng.gen();
+        let h: u128 = rng.random();
+        let sender_key: u128 = rng.random();
         let receiver_key: u128 = h ^ sender_key;
 
-        let message: Vec<u8> = (0..16).map(|_| rng.gen()).collect();
+        let message: Vec<u8> = (0..16).map(|_| rng.random()).collect();
 
         let (mut sender, mut receiver) = create_pair();
         sender.set_key(sender_key.to_be_bytes().to_vec()).unwrap();
@@ -416,12 +416,12 @@ mod tests {
     async fn test_ghash_output_padded() {
         let (mut ctx_a, mut ctx_b) = test_st_context(8);
         let mut rng = StdRng::seed_from_u64(0);
-        let h: u128 = rng.gen();
-        let sender_key: u128 = rng.gen();
+        let h: u128 = rng.random();
+        let sender_key: u128 = rng.random();
         let receiver_key: u128 = h ^ sender_key;
 
         // Message length is not a multiple of the block length
-        let message: Vec<u8> = (0..14).map(|_| rng.gen()).collect();
+        let message: Vec<u8> = (0..14).map(|_| rng.random()).collect();
 
         let (mut sender, mut receiver) = create_pair();
 
@@ -448,12 +448,12 @@ mod tests {
     async fn test_ghash_long_message() {
         let (mut ctx_a, mut ctx_b) = test_st_context(8);
         let mut rng = StdRng::seed_from_u64(0);
-        let h: u128 = rng.gen();
-        let sender_key: u128 = rng.gen();
+        let h: u128 = rng.random();
+        let sender_key: u128 = rng.random();
         let receiver_key: u128 = h ^ sender_key;
 
         // A longer message.
-        let long_message: Vec<u8> = (0..30).map(|_| rng.gen()).collect();
+        let long_message: Vec<u8> = (0..30).map(|_| rng.random()).collect();
 
         let (mut sender, mut receiver) = create_pair();
 
@@ -480,13 +480,13 @@ mod tests {
     async fn test_ghash_repeated() {
         let (mut ctx_a, mut ctx_b) = test_st_context(8);
         let mut rng = StdRng::seed_from_u64(0);
-        let h: u128 = rng.gen();
-        let sender_key: u128 = rng.gen();
+        let h: u128 = rng.random();
+        let sender_key: u128 = rng.random();
         let receiver_key: u128 = h ^ sender_key;
 
         // Two messages.
-        let first_message: Vec<u8> = (0..14).map(|_| rng.gen()).collect();
-        let second_message: Vec<u8> = (0..32).map(|_| rng.gen()).collect();
+        let first_message: Vec<u8> = (0..14).map(|_| rng.random()).collect();
+        let second_message: Vec<u8> = (0..32).map(|_| rng.random()).collect();
 
         let (mut sender, mut receiver) = create_pair();
 

crates/mpc-tls/src/record_layer/aes_ctr.rs

@@ -5,7 +5,7 @@ use mpz_memory_core::{
     Array, DecodeFutureTyped,
 };
 use mpz_vm_core::{prelude::*, Vm};
-use rand::{thread_rng, RngCore};
+use rand::RngCore;
 
 use crate::{MpcTlsError, Role};
 
@@ -77,9 +77,9 @@ impl AesCtr {
         let (masked_key, key_otp, masked_iv, iv_otp) = match self.role {
             Role::Leader => {
                 let mut key_otp = [0u8; 16];
-                thread_rng().fill_bytes(&mut key_otp);
+                rand::rng().fill_bytes(&mut key_otp);
                 let mut iv_otp = [0u8; 4];
-                thread_rng().fill_bytes(&mut iv_otp);
+                rand::rng().fill_bytes(&mut iv_otp);
                 let masked_key = vm
                     .mask_private(key, key_otp)
                     .map_err(MpcTlsError::record_layer)?;

crates/mpc-tls/tests/test.rs

@@ -3,6 +3,7 @@ use std::sync::Arc;
 use futures::{AsyncReadExt, AsyncWriteExt};
 use mpc_tls::{Config, MpcTlsFollower, MpcTlsLeader};
 use mpz_common::context::test_mt_context;
+use mpz_core::Block;
 use mpz_garble::protocol::semihonest::{Evaluator, Generator};
 use mpz_memory_core::correlated::Delta;
 use mpz_ot::{
@@ -11,6 +12,7 @@ use mpz_ot::{
     rcot::shared::{SharedRCOTReceiver, SharedRCOTSender},
 };
 use rand::{rngs::StdRng, Rng, SeedableRng};
+use rand06_compat::Rand0_6CompatExt;
 use tls_client::Certificate;
 use tls_client_async::bind_client;
 use tls_server_fixture::{bind_test_server_hyper, CA_CERT_DER, SERVER_DOMAIN};
@@ -114,18 +116,18 @@ async fn follower_task(mut follower: MpcTlsFollower) {
 }
 
 fn build_pair(config: Config) -> (MpcTlsLeader, MpcTlsFollower) {
-    let mut rng = StdRng::seed_from_u64(0);
+    let mut rng = StdRng::seed_from_u64(0).compat();
 
     let (mut mt_a, mut mt_b) = test_mt_context(8);
 
     let ctx_a = futures::executor::block_on(mt_a.new_context()).unwrap();
     let ctx_b = futures::executor::block_on(mt_b.new_context()).unwrap();
 
-    let delta_a = Delta::new(rng.gen());
-    let delta_b = Delta::new(rng.gen());
+    let delta_a = Delta::new(Block::random(&mut rng));
+    let delta_b = Delta::new(Block::random(&mut rng));
 
-    let (rcot_send_a, rcot_recv_b) = ideal_rcot(rng.gen(), delta_a.into_inner());
-    let (rcot_send_b, rcot_recv_a) = ideal_rcot(rng.gen(), delta_b.into_inner());
+    let (rcot_send_a, rcot_recv_b) = ideal_rcot(Block::random(&mut rng), delta_a.into_inner());
+    let (rcot_send_b, rcot_recv_a) = ideal_rcot(Block::random(&mut rng), delta_b.into_inner());
 
     let mut rcot_send_a = SharedRCOTSender::new(4, rcot_send_a);
     let mut rcot_send_b = SharedRCOTSender::new(1, rcot_send_b);
@@ -134,7 +136,7 @@ fn build_pair(config: Config) -> (MpcTlsLeader, MpcTlsFollower) {
 
     let mpc_a = Arc::new(Mutex::new(Generator::new(
         DerandCOTSender::new(rcot_send_a.next().unwrap()),
-        rng.gen(),
+        rand::rng().random(),
         delta_a,
     )));
     let mpc_b = Arc::new(Mutex::new(Evaluator::new(DerandCOTReceiver::new(

crates/notary/server/Cargo.toml

@@ -4,10 +4,12 @@ version = "0.1.0-alpha.9-pre"
 edition = "2021"
 
 [features]
+default = ["tee_quote"]
 tee_quote = [
 	"dep:mc-sgx-dcap-types",
 	"dep:hex",
-	"dep:rand_chacha",
+	"dep:rand",
+	"dep:rand06-compat",
 	"dep:once_cell",
 	"dep:simple_asn1",
 	"dep:pem",
@@ -59,7 +61,8 @@ zeroize = { workspace = true }
 
 mc-sgx-dcap-types = { version = "0.11.0", optional = true }
 hex = { workspace = true, optional = true }
-rand_chacha = { workspace = true, optional = true }
+rand = { workspace = true, optional = true }
+rand06-compat = { workspace = true, optional = true }
 once_cell = { workspace = true, optional = true }
 simple_asn1 = { version = "0.6.2", optional = true }
 pem = { version = "1.1.0", optional = true }

crates/notary/server/src/tee.rs

@@ -2,10 +2,7 @@ use k256::ecdsa::{SigningKey, VerifyingKey as PublicKey};
 use mc_sgx_dcap_types::{QlError, Quote3};
 use once_cell::sync::OnceCell;
 use pkcs8::{EncodePrivateKey, LineEnding};
-use rand_chacha::{
-    rand_core::{OsRng, SeedableRng},
-    ChaCha20Rng,
-};
+use rand06_compat::Rand0_6CompatExt;
 use serde::{Deserialize, Serialize};
 use std::{
     fs,
@@ -141,8 +138,7 @@ async fn gramine_quote() -> Result<Quote, QuoteError> {
 }
 
 pub fn generate_ephemeral_keypair(notary_private: &str, notary_public: &str) {
-    let mut rng = ChaCha20Rng::from_rng(OsRng).expect("os rng err!");
-    let signing_key = SigningKey::random(&mut rng);
+    let signing_key = SigningKey::random(&mut rand::rng().compat());
     let pem_string = signing_key
         .clone()
         .to_pkcs8_pem(LineEnding::LF)

crates/prover/Cargo.toml

@@ -39,6 +39,7 @@ derive_builder = { workspace = true }
 futures = { workspace = true }
 opaque-debug = { workspace = true }
 rand = { workspace = true }
+rand06-compat = { workspace = true }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 web-time = { workspace = true }

crates/prover/src/lib.rs

@@ -15,12 +15,14 @@ pub use config::{ProverConfig, ProverConfigBuilder, ProverConfigBuilderError};
 pub use error::ProverError;
 pub use future::ProverFuture;
 use mpz_common::Context;
+use mpz_core::Block;
 use mpz_garble_core::Delta;
+use rand06_compat::Rand0_6CompatExt;
 use state::{Notarize, Prove};
 
 use futures::{AsyncRead, AsyncWrite, TryFutureExt};
 use mpc_tls::{LeaderCtrl, MpcTlsLeader};
-use rand::{thread_rng, Rng};
+use rand::Rng;
 use serio::SinkExt;
 use std::sync::Arc;
 use tls_client::{ClientConnection, ServerName as TlsServerName};
@@ -342,8 +344,8 @@ impl Prover<state::Closed> {
 }
 
 fn build_mpc_tls(config: &ProverConfig, ctx: Context) -> (Arc<Mutex<Deap<Mpc, Zk>>>, MpcTlsLeader) {
-    let mut rng = thread_rng();
-    let delta = Delta::new(rng.gen());
+    let mut rng = rand::rng();
+    let delta = Delta::new(Block::random(&mut rng.compat_by_ref()));
 
     let base_ot_send = mpz_ot::chou_orlandi::Sender::default();
     let base_ot_recv = mpz_ot::chou_orlandi::Receiver::default();
@@ -359,7 +361,7 @@ fn build_mpc_tls(config: &ProverConfig, ctx: Context) -> (Arc<Mutex<Deap<Mpc, Zk
             .lpn_type(mpz_ot::ferret::LpnType::Regular)
             .build()
             .expect("ferret config is valid"),
-        rng.gen(),
+        Block::random(&mut rng.compat_by_ref()),
         rcot_recv,
     );
 
@@ -368,7 +370,7 @@ fn build_mpc_tls(config: &ProverConfig, ctx: Context) -> (Arc<Mutex<Deap<Mpc, Zk
 
     let mpc = Mpc::new(
         mpz_ot::cot::DerandCOTSender::new(rcot_send.next().expect("enough senders are available")),
-        rng.gen(),
+        rng.random(),
         delta,
     );
 

crates/tls/client/Cargo.toml

@@ -24,6 +24,7 @@ webpki = { workspace = true, features = ["alloc", "std"] }
 aes-gcm = { workspace = true }
 p256 = { workspace = true, features = ["ecdh"] }
 rand = { workspace = true }
+rand06-compat = { workspace = true }
 hmac = { workspace = true }
 sha2 = { workspace = true, features = ["compress"] }
 digest = { workspace = true }

crates/tls/client/src/backend/standard.rs

@@ -6,9 +6,10 @@ use aes_gcm::{
 };
 use async_trait::async_trait;
 use p256::{ecdh::EphemeralSecret, EncodedPoint, PublicKey as ECDHPublicKey};
-use rand::{rngs::OsRng, thread_rng, Rng};
+use rand::{rng, rngs::OsRng, Rng};
 
 use digest::Digest;
+use rand06_compat::Rand0_6CompatExt;
 use std::{any::Any, collections::VecDeque, convert::TryInto, mem::take};
 use tls_core::{
     cert::ServerCertDetails,
@@ -278,7 +279,7 @@ impl Backend for RustCryptoBackend {
 
     async fn get_client_random(&mut self) -> Result<Random, BackendError> {
         // generate client random and store it
-        let r = Random(thread_rng().gen());
+        let r = Random(rng().random());
         self.client_random = Some(r);
         Ok(r)
     }
@@ -286,7 +287,7 @@ impl Backend for RustCryptoBackend {
     async fn get_client_key_share(&mut self) -> Result<PublicKey, BackendError> {
         // TODO make sure this and other methods are not called twice/out of order
         // generate our ECDH keypair
-        let sk = EphemeralSecret::random(&mut OsRng);
+        let sk = EphemeralSecret::random(&mut rng().compat());
         let pk_bytes = EncodedPoint::from(sk.public_key()).to_bytes().to_vec();
         self.ecdh_pubkey = Some(pk_bytes.clone());
         self.ecdh_secret = Some(sk);

crates/tls/core/src/rand.rs

@@ -1,11 +1,10 @@
 use crate::{msgs::codec, Error};
-use rand::{thread_rng, Rng};
+use rand::{rng, Rng};
 
 /// Fill the whole slice with random material.
 pub fn fill_random(bytes: &mut [u8]) -> Result<(), Error> {
-    thread_rng()
-        .try_fill(bytes)
-        .map_err(|_| Error::General("failed to get random from system".to_string()))
+    rng().fill(bytes);
+    Ok(())
 }
 
 /// Make a Vec<u8> of the given size

crates/verifier/Cargo.toml

@@ -37,6 +37,7 @@ derive_builder = { workspace = true }
 futures = { workspace = true }
 opaque-debug = { workspace = true }
 rand = { workspace = true }
+rand06-compat = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true, features = ["sync"] }
 tracing = { workspace = true }

crates/verifier/src/lib.rs

@@ -18,8 +18,9 @@ pub use error::VerifierError;
 use futures::{AsyncRead, AsyncWrite};
 use mpc_tls::{FollowerData, MpcTlsFollower};
 use mpz_common::Context;
+use mpz_core::Block;
 use mpz_garble_core::Delta;
-use rand::{thread_rng, Rng};
+use rand06_compat::Rand0_6CompatExt;
 use serio::stream::IoStreamExt;
 use state::{Notarize, Verify};
 use tls_core::msgs::enums::ContentType;
@@ -106,7 +107,7 @@ impl Verifier<state::Initialized> {
             })
             .await?;
 
-        let delta = Delta::random(&mut thread_rng());
+        let delta = Delta::random(&mut rand::rng().compat());
         let (vm, mut mpc_tls) = build_mpc_tls(&self.config, &protocol_config, delta, ctx);
 
         // Allocate resources for MPC-TLS in VM.
@@ -331,7 +332,7 @@ fn build_mpc_tls(
     delta: Delta,
     ctx: Context,
 ) -> (Arc<Mutex<Deap<Mpc, Zk>>>, MpcTlsFollower) {
-    let mut rng = thread_rng();
+    let mut rng = rand::rng();
 
     let base_ot_send = mpz_ot::chou_orlandi::Sender::default();
     let base_ot_recv = mpz_ot::chou_orlandi::Receiver::default();
@@ -345,7 +346,7 @@ fn build_mpc_tls(
             .lpn_type(mpz_ot::ferret::LpnType::Regular)
             .build()
             .expect("ferret config is valid"),
-        rng.gen(),
+        Block::random(&mut rng.compat_by_ref()),
         rcot_send,
     );
     let rcot_recv =

crates/verifier/src/notarize.rs

@@ -4,7 +4,7 @@
 //! attestation but does not verify transcript data.
 
 use super::{state::Notarize, Verifier, VerifierError};
-use rand::{thread_rng, Rng};
+use rand::Rng;
 use serio::{stream::IoStreamExt, SinkExt as _};
 
 use tlsn_common::encoding;
@@ -35,7 +35,7 @@ impl Verifier<Notarize> {
             ..
         } = self.state;
 
-        let encoder_secret = EncoderSecret::new(thread_rng().gen(), delta.as_block().to_bytes());
+        let encoder_secret = EncoderSecret::new(rand::rng().random(), delta.as_block().to_bytes());
 
         let attestation = mux_fut
             .poll_with(async {

crates/wasm-test-runner/run.sh

@@ -3,7 +3,7 @@
 # Ensure the script runs in the folder that contains this script
 cd "$(dirname "$0")"
 
-RUSTFLAGS='-C target-feature=+atomics,+bulk-memory,+mutable-globals -C link-arg=--max-memory=4294967296' \
+RUSTFLAGS='-C target-feature=+atomics,+bulk-memory,+mutable-globals -C link-arg=--max-memory=4294967296 --cfg getrandom_backend="wasm_js"' \
     rustup run nightly \
     wasm-pack build ../wasm --target web --no-pack --out-dir=../wasm-test-runner/static/generated -- -Zbuild-std=panic_abort,std --features test,no-bundler &&
     RUST_LOG=debug cargo run --release

crates/wasm/.cargo/config.toml

@@ -11,4 +11,6 @@ rustflags = [
     "-C",
     # 4GB
     "link-arg=--max-memory=4294967296",
+    "--cfg",
+    'getrandom_backend="wasm_js"',
 ]

crates/wasm/Cargo.toml

@@ -57,3 +57,6 @@ ws_stream_wasm = { git = "https://github.com/tlsnotary/ws_stream_wasm", rev = "2
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 getrandom = { version = "0.2", features = ["js"] }
+getrandom_03 = { package = "getrandom", version = "0.3", features = [
+    "wasm_js",
+] }