Rust wrapper: use Rc instead of Arc for RNG references

WC_RNG has no internal locking so it is not safe to share a single
WC_RNG across threads without locking.

wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs

@@ -513,7 +513,7 @@ impl Curve25519Key {
     /// Bind a shared `RNG` to this key. Available when the `alloc` feature
     /// is enabled.
     #[cfg(all(curve25519_blinding, random, feature = "alloc"))]
-    pub fn set_shared_rng(&mut self, rng: alloc::sync::Arc<RNG>) -> Result<(), i32> {
+    pub fn set_shared_rng(&mut self, rng: alloc::rc::Rc<RNG>) -> Result<(), i32> {
         let wc_rng = rng.wc_rng;
         let rc = unsafe {
             sys::wc_curve25519_set_rng(&mut self.wc_key, wc_rng)

wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs

@@ -1733,7 +1733,7 @@ impl ECC {
     /// Bind a shared `RNG` to this key. Available when the `alloc` feature
     /// is enabled.
     #[cfg(all(random, feature = "alloc"))]
-    pub fn set_shared_rng(&mut self, rng: alloc::sync::Arc<RNG>) -> Result<(), i32> {
+    pub fn set_shared_rng(&mut self, rng: alloc::rc::Rc<RNG>) -> Result<(), i32> {
         let wc_rng = rng.wc_rng;
         let rc = unsafe {
             sys::wc_ecc_set_rng(self.wc_ecc_key, wc_rng)
@@ -1774,16 +1774,16 @@ impl ECC {
     /// ```rust
     /// #[cfg(all(ecc_dh, random, feature = "alloc"))]
     /// {
-    /// use std::sync::Arc;
+    /// use std::rc::Rc;
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::ecc::ECC;
-    /// let rng = Arc::new(RNG::new().expect("Failed to create RNG"));
+    /// let rng = Rc::new(RNG::new().expect("Failed to create RNG"));
     /// let mut ecc0 = ECC::generate(32, &rng, None, None).expect("Error with generate()");
     /// let mut ecc1 = ECC::generate(32, &rng, None, None).expect("Error with generate()");
     /// let mut ss0 = [0u8; 128];
     /// let mut ss1 = [0u8; 128];
-    /// ecc0.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
-    /// ecc1.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// ecc0.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// ecc1.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let ss0_size = ecc0.shared_secret(&mut ecc1, &mut ss0).expect("Error with shared_secret()");
     /// let ss1_size = ecc1.shared_secret(&mut ecc0, &mut ss1).expect("Error with shared_secret()");
     /// assert_eq!(ss0_size, ss1_size);
@@ -1824,17 +1824,17 @@ impl ECC {
     /// ```rust
     /// #[cfg(all(ecc_dh, random, feature = "alloc"))]
     /// {
-    /// use std::sync::Arc;
+    /// use std::rc::Rc;
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::ecc::ECC;
-    /// let rng = Arc::new(RNG::new().expect("Failed to create RNG"));
+    /// let rng = Rc::new(RNG::new().expect("Failed to create RNG"));
     /// let mut ecc0 = ECC::generate(32, &rng, None, None).expect("Error with generate()");
     /// let mut ecc1 = ECC::generate(32, &rng, None, None).expect("Error with generate()");
     /// let ecc1_point = ecc1.make_pub_to_point(None, None).expect("Error with make_pub_to_point()");
     /// let mut ss0 = [0u8; 128];
     /// let mut ss1 = [0u8; 128];
-    /// ecc0.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
-    /// ecc1.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// ecc0.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// ecc1.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let ss0_size = ecc0.shared_secret_ex(&ecc1_point, &mut ss0).expect("Error with shared_secret_ex()");
     /// let ss1_size = ecc1.shared_secret(&mut ecc0, &mut ss1).expect("Error with shared_secret()");
     /// assert_eq!(ss0_size, ss1_size);

wrapper/rust/wolfssl-wolfcrypt/src/random.rs

@@ -71,8 +71,8 @@ unsafe impl Send for RNG {}
 
 // Note: `RNG` is intentionally not `Sync`. The underlying C `WC_RNG` state is
 // mutated by every call to a generation routine, with no internal locking.
-// Callers that need cross-thread sharing must wrap the RNG in a `Mutex`
-// (typically `Arc<Mutex<RNG>>`).
+// Callers that need cross-thread sharing of a single RNG struct must implement
+// their own locking.
 
 /// Storage for an RNG that a consumer (e.g. `RSA`, `ECC`) has been bound to
 /// via `set_rng`. The consumer keeps the `RngHandle` alive for as long as the
@@ -80,7 +80,7 @@ unsafe impl Send for RNG {}
 pub(crate) enum RngHandle {
     Owned(RNG),
     #[cfg(feature = "alloc")]
-    Shared(alloc::sync::Arc<RNG>),
+    Shared(alloc::rc::Rc<RNG>),
 }
 
 impl RNG {

wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs

@@ -35,11 +35,11 @@ use std::fs;
 use wolfssl_wolfcrypt::random::RNG;
 use wolfssl_wolfcrypt::rsa::RSA;
 
-let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
 let key_path = "../../../certs/client-keyPub.der";
 let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
 let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
 let plain: &[u8] = b"Test message";
 let mut enc: [u8; 512] = [0; 512];
 let enc_len = rsa.public_encrypt(plain, &mut enc, &rng).expect("Error with public_encrypt()");
@@ -48,7 +48,7 @@ assert!(enc_len > 0 && enc_len <= 512);
 let key_path = "../../../certs/client-key.der";
 let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
 let mut rsa = RSA::new_from_der(&der).expect("Error with new_from_der()");
-rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
 let mut plain_out: [u8; 512] = [0; 512];
 let dec_len = rsa.private_decrypt(&enc[0..enc_len], &mut plain_out).expect("Error with private_decrypt()");
 assert!(dec_len as usize == plain.len());
@@ -153,11 +153,11 @@ impl RSA {
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::rsa::RSA;
     ///
-    /// let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+    /// let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
     /// let key_path = "../../../certs/client-keyPub.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let plain: &[u8] = b"Test message";
     /// let mut enc: [u8; 512] = [0; 512];
     /// let enc_len = rsa.public_encrypt(plain, &mut enc, &rng).expect("Error with public_encrypt()");
@@ -166,7 +166,7 @@ impl RSA {
     /// let key_path = "../../../certs/client-key.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_from_der(&der).expect("Error with new_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let mut plain_out: [u8; 512] = [0; 512];
     /// let dec_len = rsa.private_decrypt(&enc[0..enc_len], &mut plain_out).expect("Error with private_decrypt()");
     /// assert!(dec_len as usize == plain.len());
@@ -201,11 +201,11 @@ impl RSA {
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::rsa::RSA;
     ///
-    /// let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+    /// let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
     /// let key_path = "../../../certs/client-keyPub.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let plain: &[u8] = b"Test message";
     /// let mut enc: [u8; 512] = [0; 512];
     /// let enc_len = rsa.public_encrypt(plain, &mut enc, &rng).expect("Error with public_encrypt()");
@@ -214,7 +214,7 @@ impl RSA {
     /// let key_path = "../../../certs/client-key.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_from_der_ex(&der, None, None).expect("Error with new_from_der_ex()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let mut plain_out: [u8; 512] = [0; 512];
     /// let dec_len = rsa.private_decrypt(&enc[0..enc_len], &mut plain_out).expect("Error with private_decrypt()");
     /// assert!(dec_len as usize == plain.len());
@@ -274,11 +274,11 @@ impl RSA {
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::rsa::RSA;
     ///
-    /// let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+    /// let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
     /// let key_path = "../../../certs/client-keyPub.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let plain: &[u8] = b"Test message";
     /// let mut enc: [u8; 512] = [0; 512];
     /// let enc_len = rsa.public_encrypt(plain, &mut enc, &rng).expect("Error with public_encrypt()");
@@ -287,7 +287,7 @@ impl RSA {
     /// let key_path = "../../../certs/client-key.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_from_der(&der).expect("Error with new_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let mut plain_out: [u8; 512] = [0; 512];
     /// let dec_len = rsa.private_decrypt(&enc[0..enc_len], &mut plain_out).expect("Error with private_decrypt()");
     /// assert!(dec_len as usize == plain.len());
@@ -322,11 +322,11 @@ impl RSA {
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::rsa::RSA;
     ///
-    /// let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+    /// let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
     /// let key_path = "../../../certs/client-keyPub.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_public_from_der_ex(&der, None, None).expect("Error with new_public_from_der_ex()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let plain: &[u8] = b"Test message";
     /// let mut enc: [u8; 512] = [0; 512];
     /// let enc_len = rsa.public_encrypt(plain, &mut enc, &rng).expect("Error with public_encrypt()");
@@ -335,7 +335,7 @@ impl RSA {
     /// let key_path = "../../../certs/client-key.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_from_der(&der).expect("Error with new_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let mut plain_out: [u8; 512] = [0; 512];
     /// let dec_len = rsa.private_decrypt(&enc[0..enc_len], &mut plain_out).expect("Error with private_decrypt()");
     /// assert!(dec_len as usize == plain.len());
@@ -755,11 +755,11 @@ impl RSA {
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::rsa::RSA;
     ///
-    /// let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+    /// let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
     /// let key_path = "../../../certs/client-keyPub.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let plain: &[u8] = b"Test message";
     /// let mut enc: [u8; 512] = [0; 512];
     /// let enc_len = rsa.public_encrypt(plain, &mut enc, &rng).expect("Error with public_encrypt()");
@@ -768,7 +768,7 @@ impl RSA {
     /// let key_path = "../../../certs/client-key.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_from_der(&der).expect("Error with new_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let mut plain_out: [u8; 512] = [0; 512];
     /// let dec_len = rsa.private_decrypt(&enc[0..enc_len], &mut plain_out).expect("Error with private_decrypt()");
     /// assert!(dec_len as usize == plain.len());
@@ -814,11 +814,11 @@ impl RSA {
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::rsa::RSA;
     ///
-    /// let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+    /// let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
     /// let key_path = "../../../certs/client-keyPub.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let plain: &[u8] = b"Test message";
     /// let mut enc: [u8; 512] = [0; 512];
     /// let enc_len = rsa.public_encrypt(plain, &mut enc, &rng).expect("Error with public_encrypt()");
@@ -827,7 +827,7 @@ impl RSA {
     /// let key_path = "../../../certs/client-key.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_from_der(&der).expect("Error with new_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let mut plain_out: [u8; 512] = [0; 512];
     /// let dec_len = rsa.private_decrypt(&enc[0..enc_len], &mut plain_out).expect("Error with private_decrypt()");
     /// assert!(dec_len as usize == plain.len());
@@ -875,7 +875,7 @@ impl RSA {
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::rsa::RSA;
     ///
-    /// let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+    /// let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
     ///
     /// let key_path = "../../../certs/client-key.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
@@ -888,7 +888,7 @@ impl RSA {
     /// let key_path = "../../../certs/client-keyPub.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let signature = &signature[0..sig_len];
     /// let mut verify_out: [u8; 512] = [0; 512];
     /// let verify_out_size = rsa.pss_verify(signature, &mut verify_out, RSA::HASH_TYPE_SHA256, RSA::MGF1SHA256).expect("Error with pss_verify()");
@@ -938,7 +938,7 @@ impl RSA {
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::rsa::RSA;
     ///
-    /// let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+    /// let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
     ///
     /// let key_path = "../../../certs/client-key.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
@@ -951,7 +951,7 @@ impl RSA {
     /// let key_path = "../../../certs/client-keyPub.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let signature = &signature[0..sig_len];
     /// let mut verify_out: [u8; 512] = [0; 512];
     /// let verify_out_size = rsa.pss_verify(signature, &mut verify_out, RSA::HASH_TYPE_SHA256, RSA::MGF1SHA256).expect("Error with pss_verify()");
@@ -1004,7 +1004,7 @@ impl RSA {
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::rsa::RSA;
     ///
-    /// let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+    /// let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
     ///
     /// let key_path = "../../../certs/client-key.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
@@ -1017,7 +1017,7 @@ impl RSA {
     /// let key_path = "../../../certs/client-keyPub.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let signature = &signature[0..sig_len];
     /// let mut verify_out: [u8; 512] = [0; 512];
     /// let verify_out_size = rsa.pss_verify(signature, &mut verify_out, RSA::HASH_TYPE_SHA256, RSA::MGF1SHA256).expect("Error with pss_verify()");
@@ -1075,7 +1075,7 @@ impl RSA {
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::rsa::RSA;
     ///
-    /// let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+    /// let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
     ///
     /// let key_path = "../../../certs/client-key.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
@@ -1088,7 +1088,7 @@ impl RSA {
     /// let key_path = "../../../certs/client-keyPub.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let signature = &signature[0..sig_len];
     /// let mut verify_out: [u8; 512] = [0; 512];
     /// let verify_out_size = rsa.pss_verify(signature, &mut verify_out, RSA::HASH_TYPE_SHA256, RSA::MGF1SHA256).expect("Error with pss_verify()");
@@ -1236,11 +1236,11 @@ impl RSA {
 
     /// Bind a shared `RNG` to this key for blinding during private operations.
     ///
-    /// Like `set_rng`, but takes an `Arc<RNG>` so the same RNG can be shared
+    /// Like `set_rng`, but takes an `Rc<RNG>` so the same RNG can be shared
     /// among multiple consumers and used directly by the caller. Available
     /// when the `alloc` feature is enabled.
     #[cfg(all(random, feature = "alloc"))]
-    pub fn set_shared_rng(&mut self, rng: alloc::sync::Arc<RNG>) -> Result<(), i32> {
+    pub fn set_shared_rng(&mut self, rng: alloc::rc::Rc<RNG>) -> Result<(), i32> {
         let wc_rng = rng.wc_rng;
         let rc = unsafe {
             sys::wc_RsaSetRNG(&mut self.wc_rsakey, wc_rng)
@@ -1289,7 +1289,7 @@ impl RSA {
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::rsa::RSA;
     ///
-    /// let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+    /// let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
     ///
     /// let key_path = "../../../certs/client-key.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
@@ -1302,7 +1302,7 @@ impl RSA {
     /// let key_path = "../../../certs/client-keyPub.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let signature = &signature[0..sig_len];
     /// let mut verify_out: [u8; 512] = [0; 512];
     /// let verify_out_size = rsa.ssl_verify(signature, &mut verify_out).expect("Error with ssl_verify()");
@@ -1351,7 +1351,7 @@ impl RSA {
     /// use wolfssl_wolfcrypt::random::RNG;
     /// use wolfssl_wolfcrypt::rsa::RSA;
     ///
-    /// let rng = std::sync::Arc::new(RNG::new().expect("Error creating RNG"));
+    /// let rng = std::rc::Rc::new(RNG::new().expect("Error creating RNG"));
     ///
     /// let key_path = "../../../certs/client-key.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
@@ -1364,7 +1364,7 @@ impl RSA {
     /// let key_path = "../../../certs/client-keyPub.der";
     /// let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     /// let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    /// rsa.set_shared_rng(std::sync::Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    /// rsa.set_shared_rng(std::rc::Rc::clone(&rng)).expect("Error with set_shared_rng()");
     /// let signature = &signature[0..sig_len];
     /// let mut verify_out: [u8; 512] = [0; 512];
     /// let verify_out_size = rsa.ssl_verify(signature, &mut verify_out).expect("Error with ssl_verify()");

wrapper/rust/wolfssl-wolfcrypt/tests/test_curve25519.rs

@@ -1,7 +1,7 @@
 #![cfg(all(curve25519, random))]
 
 #[cfg(curve25519_blinding)]
-use std::sync::Arc;
+use std::rc::Rc;
 use wolfssl_wolfcrypt::curve25519::*;
 use wolfssl_wolfcrypt::random::RNG;
 
@@ -100,16 +100,16 @@ fn test_make_pub_blind() {
 #[test]
 fn test_shared_secret() {
     #[cfg(curve25519_blinding)]
-    let rng = Arc::new(RNG::new().expect("Error with new()"));
+    let rng = Rc::new(RNG::new().expect("Error with new()"));
     #[cfg(not(curve25519_blinding))]
     let rng = RNG::new().expect("Error with new()");
     let mut key1 = Curve25519Key::generate(&rng).expect("Error with generate()");
     let mut key2 = Curve25519Key::generate(&rng).expect("Error with generate()");
 
     #[cfg(curve25519_blinding)]
-    key1.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    key1.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
     #[cfg(curve25519_blinding)]
-    key2.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    key2.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
 
     let mut public_buffer = [0u8; Curve25519Key::KEYSIZE];
     key1.export_public(&mut public_buffer).expect("Error with export_public()");
@@ -128,16 +128,16 @@ fn test_shared_secret() {
 #[test]
 fn test_shared_secret_ex() {
     #[cfg(curve25519_blinding)]
-    let rng = Arc::new(RNG::new().expect("Error with new()"));
+    let rng = Rc::new(RNG::new().expect("Error with new()"));
     #[cfg(not(curve25519_blinding))]
     let rng = RNG::new().expect("Error with new()");
     let mut key1 = Curve25519Key::generate(&rng).expect("Error with generate()");
     let mut key2 = Curve25519Key::generate(&rng).expect("Error with generate()");
 
     #[cfg(curve25519_blinding)]
-    key1.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    key1.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
     #[cfg(curve25519_blinding)]
-    key2.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    key2.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
 
     let mut public_buffer = [0u8; Curve25519Key::KEYSIZE];
     key1.export_public(&mut public_buffer).expect("Error with export_public()");

wrapper/rust/wolfssl-wolfcrypt/tests/test_ecc.rs

@@ -5,7 +5,7 @@ mod common;
 #[cfg(any(all(ecc_import, ecc_export, ecc_sign, ecc_verify, random), random))]
 use std::fs;
 #[cfg(all(ecc_dh, random))]
-use std::sync::Arc;
+use std::rc::Rc;
 use wolfssl_wolfcrypt::ecc::*;
 #[cfg(random)]
 use wolfssl_wolfcrypt::random::RNG;
@@ -144,13 +144,13 @@ fn test_ecc_import_export_sign_verify() {
 fn test_ecc_shared_secret() {
     common::setup();
 
-    let rng = Arc::new(RNG::new().expect("Failed to create RNG"));
+    let rng = Rc::new(RNG::new().expect("Failed to create RNG"));
     let mut ecc0 = ECC::generate(32, &rng, None, None).expect("Error with generate()");
     let mut ecc1 = ECC::generate(32, &rng, None, None).expect("Error with generate()");
     let mut ss0 = [0u8; 128];
     let mut ss1 = [0u8; 128];
-    ecc0.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
-    ecc1.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    ecc0.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
+    ecc1.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
     let ss0_size = ecc0.shared_secret(&mut ecc1, &mut ss0).expect("Error with shared_secret()");
     let ss1_size = ecc1.shared_secret(&mut ecc0, &mut ss1).expect("Error with shared_secret()");
     assert_eq!(ss0_size, ss1_size);

wrapper/rust/wolfssl-wolfcrypt/tests/test_rsa.rs

@@ -5,7 +5,7 @@ mod common;
 #[cfg(any(all(sha256, random, rsa_pss), random, rsa_direct))]
 use std::fs;
 #[cfg(random)]
-use std::sync::Arc;
+use std::rc::Rc;
 #[cfg(random)]
 use wolfssl_wolfcrypt::random::RNG;
 #[cfg(any(random, rsa_direct, rsa_keygen))]
@@ -60,11 +60,11 @@ fn test_rsa_generate() {
 #[test]
 #[cfg(random)]
 fn test_rsa_encrypt_decrypt() {
-    let rng = Arc::new(RNG::new().expect("Error creating RNG"));
+    let rng = Rc::new(RNG::new().expect("Error creating RNG"));
     let key_path = "../../../certs/client-keyPub.der";
     let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    rsa.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    rsa.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
     let plain: &[u8] = b"Test message";
     let mut enc: [u8; 512] = [0; 512];
     let enc_len = rsa.public_encrypt(plain, &mut enc, &rng).expect("Error with public_encrypt()");
@@ -73,7 +73,7 @@ fn test_rsa_encrypt_decrypt() {
     let key_path = "../../../certs/client-key.der";
     let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     let mut rsa = RSA::new_from_der(&der).expect("Error with new_from_der()");
-    rsa.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    rsa.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
     let mut plain_out: [u8; 512] = [0; 512];
     let dec_len = rsa.private_decrypt(&enc[0..enc_len], &mut plain_out).expect("Error with private_decrypt()");
     assert!(dec_len as usize == plain.len());
@@ -83,7 +83,7 @@ fn test_rsa_encrypt_decrypt() {
 #[test]
 #[cfg(all(sha256, random, rsa_pss))]
 fn test_rsa_pss() {
-    let rng = Arc::new(RNG::new().expect("Error creating RNG"));
+    let rng = Rc::new(RNG::new().expect("Error creating RNG"));
 
     let key_path = "../../../certs/client-key.der";
     let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
@@ -96,7 +96,7 @@ fn test_rsa_pss() {
     let key_path = "../../../certs/client-keyPub.der";
     let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    rsa.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    rsa.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
     let signature = &signature[0..sig_len];
     let mut verify_out: [u8; 512] = [0; 512];
     let verify_out_size = rsa.pss_verify(signature, &mut verify_out, RSA::HASH_TYPE_SHA256, RSA::MGF1SHA256).expect("Error with pss_verify()");
@@ -130,7 +130,7 @@ fn test_rsa_direct() {
 #[test]
 #[cfg(random)]
 fn test_rsa_ssl() {
-    let rng = Arc::new(RNG::new().expect("Error creating RNG"));
+    let rng = Rc::new(RNG::new().expect("Error creating RNG"));
 
     let key_path = "../../../certs/client-key.der";
     let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
@@ -143,7 +143,7 @@ fn test_rsa_ssl() {
     let key_path = "../../../certs/client-keyPub.der";
     let der: Vec<u8> = fs::read(key_path).expect("Error reading key file");
     let mut rsa = RSA::new_public_from_der(&der).expect("Error with new_public_from_der()");
-    rsa.set_shared_rng(Arc::clone(&rng)).expect("Error with set_shared_rng()");
+    rsa.set_shared_rng(Rc::clone(&rng)).expect("Error with set_shared_rng()");
     let signature = &signature[0..sig_len];
     let mut verify_out: [u8; 512] = [0; 512];
     let verify_out_size = rsa.ssl_verify(signature, &mut verify_out).expect("Error with ssl_verify()");