From a8fa845fa942cab6f103eee9f1d99593706cdee0 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Mon, 23 Mar 2026 15:23:59 -0400 Subject: [PATCH 01/20] Rust wrapper: ecc: fix possible resource leak in some error cases Fix F-1062. If wolfSSL returns an error after initializing ECC struct with wc_ecc_init_ex(), wc_ecc_free() might not have been called in all cases. Move construction of the ECC struct earlier ahead of further wolfSSL calls after wc_ecc_init_ex() so if those subsequent wolfSSL calls return an error the Drop impl for ECC will be called to deinitialize. --- wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs | 81 +++++++++++------------ 1 file changed, 38 insertions(+), 43 deletions(-) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs b/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs index 7504a1f944e..5e6d09bd3d3 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs @@ -427,15 +427,14 @@ impl ECC { if rc != 0 { return Err(rc); } - let mut wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let mut ecc = ECC { wc_ecc_key }; let rc = unsafe { - sys::wc_ecc_make_key(&mut rng.wc_rng, size, &mut wc_ecc_key) + sys::wc_ecc_make_key(&mut rng.wc_rng, size, &mut ecc.wc_ecc_key) }; if rc != 0 { - unsafe { sys::wc_ecc_free(&mut wc_ecc_key); } return Err(rc); } - let ecc = ECC { wc_ecc_key }; Ok(ecc) } @@ -485,15 +484,14 @@ impl ECC { if rc != 0 { return Err(rc); } - let mut wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let mut ecc = ECC { wc_ecc_key }; let rc = unsafe { - sys::wc_ecc_make_key_ex(&mut rng.wc_rng, size, &mut wc_ecc_key, curve_id) + sys::wc_ecc_make_key_ex(&mut rng.wc_rng, size, &mut ecc.wc_ecc_key, curve_id) }; if rc != 0 { - unsafe { sys::wc_ecc_free(&mut wc_ecc_key); } return Err(rc); } - let ecc = ECC { wc_ecc_key }; Ok(ecc) } @@ -544,15 +542,14 @@ impl ECC { if rc != 0 { return Err(rc); } - let mut wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let mut ecc = ECC { wc_ecc_key }; let rc = unsafe { - sys::wc_ecc_make_key_ex2(&mut rng.wc_rng, size, &mut wc_ecc_key, curve_id, flags) + sys::wc_ecc_make_key_ex2(&mut rng.wc_rng, size, &mut ecc.wc_ecc_key, curve_id, flags) }; if rc != 0 { - unsafe { sys::wc_ecc_free(&mut wc_ecc_key); } return Err(rc); } - let ecc = ECC { wc_ecc_key }; Ok(ecc) } @@ -632,16 +629,16 @@ impl ECC { if rc != 0 { return Err(rc); } - let mut wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let mut ecc = ECC { wc_ecc_key }; let mut idx = 0u32; let der_size = der.len() as u32; let rc = unsafe { - sys::wc_EccPrivateKeyDecode(der.as_ptr(), &mut idx, &mut wc_ecc_key, der_size) + sys::wc_EccPrivateKeyDecode(der.as_ptr(), &mut idx, &mut ecc.wc_ecc_key, der_size) }; if rc != 0 { return Err(rc); } - let ecc = ECC { wc_ecc_key }; Ok(ecc) } @@ -695,16 +692,16 @@ impl ECC { if rc != 0 { return Err(rc); } - let mut wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let mut ecc = ECC { wc_ecc_key }; let mut idx = 0u32; let der_size = der.len() as u32; let rc = unsafe { - sys::wc_EccPublicKeyDecode(der.as_ptr(), &mut idx, &mut wc_ecc_key, der_size) + sys::wc_EccPublicKeyDecode(der.as_ptr(), &mut idx, &mut ecc.wc_ecc_key, der_size) }; if rc != 0 { return Err(rc); } - let ecc = ECC { wc_ecc_key }; Ok(ecc) } @@ -764,18 +761,18 @@ impl ECC { if rc != 0 { return Err(rc); } - let mut wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let mut ecc = ECC { wc_ecc_key }; let priv_size = priv_buf.len() as u32; let pub_ptr = if pub_buf.is_empty() {core::ptr::null()} else {pub_buf.as_ptr()}; let pub_size = pub_buf.len() as u32; let rc = unsafe { sys::wc_ecc_import_private_key(priv_buf.as_ptr(), priv_size, - pub_ptr, pub_size, &mut wc_ecc_key) + pub_ptr, pub_size, &mut ecc.wc_ecc_key) }; if rc != 0 { return Err(rc); } - let ecc = ECC { wc_ecc_key }; Ok(ecc) } @@ -838,18 +835,18 @@ impl ECC { if rc != 0 { return Err(rc); } - let mut wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let mut ecc = ECC { wc_ecc_key }; let priv_size = priv_buf.len() as u32; let pub_ptr = if pub_buf.is_empty() {core::ptr::null()} else {pub_buf.as_ptr()}; let pub_size = pub_buf.len() as u32; let rc = unsafe { sys::wc_ecc_import_private_key_ex(priv_buf.as_ptr(), priv_size, - pub_ptr, pub_size, &mut wc_ecc_key, curve_id) + pub_ptr, pub_size, &mut ecc.wc_ecc_key, curve_id) }; if rc != 0 { return Err(rc); } - let ecc = ECC { wc_ecc_key }; Ok(ecc) } @@ -897,19 +894,19 @@ impl ECC { if rc != 0 { return Err(rc); } - let mut wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let mut ecc = ECC { wc_ecc_key }; let qx_ptr = qx.as_ptr() as *const core::ffi::c_char; let qy_ptr = qy.as_ptr() as *const core::ffi::c_char; let d_ptr = d.as_ptr() as *const core::ffi::c_char; let curve_name_ptr = curve_name.as_ptr() as *const core::ffi::c_char; let rc = unsafe { - sys::wc_ecc_import_raw(&mut wc_ecc_key, qx_ptr, qy_ptr, d_ptr, + sys::wc_ecc_import_raw(&mut ecc.wc_ecc_key, qx_ptr, qy_ptr, d_ptr, curve_name_ptr) }; if rc != 0 { return Err(rc); } - let ecc = ECC { wc_ecc_key }; Ok(ecc) } @@ -957,18 +954,18 @@ impl ECC { if rc != 0 { return Err(rc); } - let mut wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let mut ecc = ECC { wc_ecc_key }; let qx_ptr = qx.as_ptr() as *const core::ffi::c_char; let qy_ptr = qy.as_ptr() as *const core::ffi::c_char; let d_ptr = d.as_ptr() as *const core::ffi::c_char; let rc = unsafe { - sys::wc_ecc_import_raw_ex(&mut wc_ecc_key, qx_ptr, qy_ptr, d_ptr, - curve_id) + sys::wc_ecc_import_raw_ex(&mut ecc.wc_ecc_key, qx_ptr, qy_ptr, + d_ptr, curve_id) }; if rc != 0 { return Err(rc); } - let ecc = ECC { wc_ecc_key }; Ok(ecc) } @@ -1025,15 +1022,15 @@ impl ECC { if rc != 0 { return Err(rc); } - let mut wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let mut ecc = ECC { wc_ecc_key }; let rc = unsafe { - sys::wc_ecc_import_unsigned(&mut wc_ecc_key, qx.as_ptr(), qy.as_ptr(), - d.as_ptr(), curve_id) + sys::wc_ecc_import_unsigned(&mut ecc.wc_ecc_key, qx.as_ptr(), + qy.as_ptr(), d.as_ptr(), curve_id) }; if rc != 0 { return Err(rc); } - let ecc = ECC { wc_ecc_key }; Ok(ecc) } @@ -1084,15 +1081,14 @@ impl ECC { if rc != 0 { return Err(rc); } - let mut wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let mut ecc = ECC { wc_ecc_key }; let rc = unsafe { - sys::wc_ecc_import_x963(din.as_ptr(), din_size, &mut wc_ecc_key) + sys::wc_ecc_import_x963(din.as_ptr(), din_size, &mut ecc.wc_ecc_key) }; if rc != 0 { - unsafe { sys::wc_ecc_free(&mut wc_ecc_key); } return Err(rc); } - let ecc = ECC { wc_ecc_key }; Ok(ecc) } @@ -1148,15 +1144,14 @@ impl ECC { if rc != 0 { return Err(rc); } - let mut wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; + let mut ecc = ECC { wc_ecc_key }; let rc = unsafe { - sys::wc_ecc_import_x963_ex(din.as_ptr(), din_size, &mut wc_ecc_key, curve_id) + sys::wc_ecc_import_x963_ex(din.as_ptr(), din_size, &mut ecc.wc_ecc_key, curve_id) }; if rc != 0 { - unsafe { sys::wc_ecc_free(&mut wc_ecc_key); } return Err(rc); } - let ecc = ECC { wc_ecc_key }; Ok(ecc) } From 9843f0365a0143079320cc31066969186cc7fdf6 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Mon, 23 Mar 2026 22:09:13 -0400 Subject: [PATCH 02/20] Rust wrapper: avoid creating a MaybeUninit Fix F-1067 --- wrapper/rust/wolfssl-wolfcrypt/src/random.rs | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/random.rs b/wrapper/rust/wolfssl-wolfcrypt/src/random.rs index 7d3bb8a79ab..aca81f46037 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/random.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/random.rs @@ -96,7 +96,7 @@ impl RNG { return Err(rc); } } - let mut rng: MaybeUninit = MaybeUninit::uninit(); + let mut wc_rng: MaybeUninit = MaybeUninit::uninit(); let heap = match heap { Some(heap) => heap, None => core::ptr::null_mut(), @@ -106,10 +106,11 @@ impl RNG { None => sys::INVALID_DEVID, }; let rc = unsafe { - sys::wc_InitRng_ex(&mut (*rng.as_mut_ptr()).wc_rng, heap, dev_id) + sys::wc_InitRng_ex(wc_rng.as_mut_ptr(), heap, dev_id) }; if rc == 0 { - let rng = unsafe { rng.assume_init() }; + let wc_rng = unsafe { wc_rng.assume_init() }; + let rng = RNG {wc_rng}; Ok(rng) } else { Err(rc) @@ -157,7 +158,7 @@ impl RNG { } let ptr = nonce.as_mut_ptr() as *mut u8; let size: u32 = size_of_val(nonce) as u32; - let mut rng: MaybeUninit = MaybeUninit::uninit(); + let mut wc_rng: MaybeUninit = MaybeUninit::uninit(); let heap = match heap { Some(heap) => heap, None => core::ptr::null_mut(), @@ -167,10 +168,11 @@ impl RNG { None => sys::INVALID_DEVID, }; let rc = unsafe { - sys::wc_InitRngNonce_ex(&mut (*rng.as_mut_ptr()).wc_rng, ptr, size, heap, dev_id) + sys::wc_InitRngNonce_ex(wc_rng.as_mut_ptr(), ptr, size, heap, dev_id) }; if rc == 0 { - let rng = unsafe { rng.assume_init() }; + let wc_rng = unsafe { wc_rng.assume_init() }; + let rng = RNG {wc_rng}; Ok(rng) } else { Err(rc) From 337dfc323e481b72049e2e5ccb28612c004e2ac7 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Mon, 23 Mar 2026 22:13:35 -0400 Subject: [PATCH 03/20] Rust wrapper: avoid uninitialized sys::XtsAesStreamData Fix F-1066 --- wrapper/rust/wolfssl-wolfcrypt/src/aes.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs b/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs index 7b58b25f260..53f96039e99 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs @@ -2655,7 +2655,7 @@ impl XTSStream { /// wolfSSL library return code on failure. pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result { let ws_xtsaes = new_ws_xtsaes(heap, dev_id)?; - let ws_xtsaesstreamdata: MaybeUninit = MaybeUninit::uninit(); + let ws_xtsaesstreamdata: MaybeUninit = MaybeUninit::zeroed(); let ws_xtsaesstreamdata = unsafe { ws_xtsaesstreamdata.assume_init() }; let xtsstream = XTSStream {ws_xtsaes, ws_xtsaesstreamdata}; Ok(xtsstream) From 4f42ba9aa777baf9d66c3d1b0b6b73d063c650d2 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Mon, 23 Mar 2026 22:18:11 -0400 Subject: [PATCH 04/20] Rust wrapper: ed25519: add check for context buffers too long Fix F-1063 --- wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs b/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs index de834801425..21f30f6e5c8 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs @@ -716,6 +716,9 @@ impl Ed25519 { #[cfg(ed25519_sign)] pub fn sign_msg_ctx(&mut self, message: &[u8], context: &[u8], signature: &mut [u8]) -> Result { let message_size = message.len() as u32; + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } let context_size = context.len() as u8; let mut signature_size = signature.len() as u32; let rc = unsafe { @@ -777,6 +780,9 @@ impl Ed25519 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut signature_size = signature.len() as u32; @@ -830,6 +836,9 @@ impl Ed25519 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut signature_size = signature.len() as u32; @@ -883,6 +892,9 @@ impl Ed25519 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut signature_size = signature.len() as u32; @@ -976,6 +988,9 @@ impl Ed25519 { pub fn verify_msg_ctx(&mut self, signature: &[u8], message: &[u8], context: &[u8]) -> Result { let signature_size = signature.len() as u32; let message_size = message.len() as u32; + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } let context_size = context.len() as u8; let mut res = 0i32; let rc = unsafe { @@ -1040,6 +1055,9 @@ impl Ed25519 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut res = 0i32; @@ -1095,6 +1113,9 @@ impl Ed25519 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut res = 0i32; @@ -1150,6 +1171,9 @@ impl Ed25519 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut res = 0i32; @@ -1203,6 +1227,9 @@ impl Ed25519 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let rc = unsafe { From 5959aa2b58b2c419b104ee998c116808b134a7f7 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Mon, 23 Mar 2026 22:20:32 -0400 Subject: [PATCH 05/20] Rust wrapper: ed448: add check for context buffers too long Fix F-1064 --- wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs | 27 +++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs b/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs index a19caf35e5e..a4425bb945c 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs @@ -675,6 +675,9 @@ impl Ed448 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut signature_size = signature.len() as u32; @@ -737,6 +740,9 @@ impl Ed448 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut signature_size = signature.len() as u32; @@ -790,6 +796,9 @@ impl Ed448 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut signature_size = signature.len() as u32; @@ -843,6 +852,9 @@ impl Ed448 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut signature_size = signature.len() as u32; @@ -897,6 +909,9 @@ impl Ed448 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut res = 0i32; @@ -962,6 +977,9 @@ impl Ed448 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut res = 0i32; @@ -1017,6 +1035,9 @@ impl Ed448 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut res = 0i32; @@ -1072,6 +1093,9 @@ impl Ed448 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let mut res = 0i32; @@ -1126,6 +1150,9 @@ impl Ed448 { let mut context_size = 0u8; if let Some(context) = context { context_ptr = context.as_ptr(); + if context.len() > 255 { + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } context_size = context.len() as u8; } let rc = unsafe { From 56c20aeda0ddf5427f9e1b3112fec326db4a4401 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Mon, 23 Mar 2026 22:28:17 -0400 Subject: [PATCH 06/20] Rust wrapper: dilithium: remove unnecessary size define presence checks Fix F-1256 --- wrapper/rust/wolfssl-wolfcrypt/build.rs | 2 -- wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs | 6 ------ 2 files changed, 8 deletions(-) diff --git a/wrapper/rust/wolfssl-wolfcrypt/build.rs b/wrapper/rust/wolfssl-wolfcrypt/build.rs index da1b55d358a..6f275d3a3b5 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/build.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/build.rs @@ -461,8 +461,6 @@ fn scan_cfg() -> Result<()> { check_cfg(&binding, "DILITHIUM_LEVEL2_KEY_SIZE", "dilithium_level2"); check_cfg(&binding, "DILITHIUM_LEVEL3_KEY_SIZE", "dilithium_level3"); check_cfg(&binding, "DILITHIUM_LEVEL5_KEY_SIZE", "dilithium_level5"); - check_cfg(&binding, "DILITHIUM_SEED_SZ", "dilithium_make_key_seed_sz"); - check_cfg(&binding, "DILITHIUM_RND_SZ", "dilithium_rnd_sz"); /* mlkem / ML-KEM */ check_cfg(&binding, "wc_MlKemKey_Init", "mlkem"); diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs b/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs index e3ba4756ec0..cef8c44877a 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs @@ -84,13 +84,11 @@ impl Dilithium { /// Required size in bytes of the seed passed to /// [`Dilithium::generate_from_seed()`] (`DILITHIUM_SEED_SZ`). - #[cfg(dilithium_make_key_seed_sz)] pub const DILITHIUM_SEED_SZ: usize = sys::DILITHIUM_SEED_SZ as usize; /// Required size in bytes of the seed passed to signing-with-seed /// functions such as [`Dilithium::sign_msg_with_seed()`] /// (`DILITHIUM_RND_SZ`). - #[cfg(dilithium_rnd_sz)] pub const SIGN_SEED_SIZE: usize = sys::DILITHIUM_RND_SZ as usize; /// Private (secret) key size in bytes for ML-DSA-44. @@ -277,7 +275,6 @@ impl Dilithium { heap: Option<*mut core::ffi::c_void>, dev_id: Option, ) -> Result { - #[cfg(dilithium_make_key_seed_sz)] if seed.len() != Self::DILITHIUM_SEED_SZ { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } @@ -1032,7 +1029,6 @@ impl Dilithium { sig: &mut [u8], seed: &[u8], ) -> Result { - #[cfg(dilithium_rnd_sz)] if seed.len() != sys::DILITHIUM_RND_SZ as usize { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } @@ -1077,7 +1073,6 @@ impl Dilithium { if ctx.len() > 255 { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } - #[cfg(dilithium_rnd_sz)] if seed.len() != sys::DILITHIUM_RND_SZ as usize { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } @@ -1126,7 +1121,6 @@ impl Dilithium { if ctx.len() > 255 { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } - #[cfg(dilithium_rnd_sz)] if seed.len() != sys::DILITHIUM_RND_SZ as usize { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } From 5c10fe9a58e6683f49defe10074956179754078d Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Wed, 25 Mar 2026 14:58:28 -0400 Subject: [PATCH 07/20] Rust wrapper: BLAKE2: check for non-empty hash buffer in finalize() This is related to F-1070 but not the same. We do not need to check that hash_size being passed in matches the initialized digest size because the C function will use the passed-in size as long as it is non-zero. --- wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs b/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs index 3afef945971..c4b54cb081d 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs @@ -157,6 +157,12 @@ impl BLAKE2b { /// ``` pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> { let hash_size = hash.len() as u32; + if hash_size == 0 { + // The C function uses the internal state configured digest size + // if hash_size is passed in as 0. We do not want to allow a + // buffer overrun, so do not allow an empty hash buffer here. + return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); + } let rc = unsafe { sys::wc_Blake2bFinal(&mut self.wc_blake2b, hash.as_mut_ptr(), hash_size) }; @@ -434,6 +440,12 @@ impl BLAKE2s { /// ``` pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> { let hash_size = hash.len() as u32; + if hash_size == 0 { + // The C function uses the internal state configured digest size + // if hash_size is passed in as 0. We do not want to allow a + // buffer overrun, so do not allow an empty hash buffer here. + return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); + } let rc = unsafe { sys::wc_Blake2sFinal(&mut self.wc_blake2s, hash.as_mut_ptr(), hash_size) }; From f00636919e0008c3e1fbb0f76c17fbc4595a7549 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Wed, 25 Mar 2026 15:56:42 -0400 Subject: [PATCH 08/20] Rust wrapper: check kdr_index range in srtp_kdf() and srtcp_kdf() Fix F-1257 --- wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs b/wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs index 9f586730693..4fdecb7e6b5 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs @@ -584,6 +584,11 @@ pub fn ssh_kdf(typ: i32, key_id: u8, k: &[u8], h: &[u8], session_id: &[u8], key: #[cfg(kdf_srtp)] pub fn srtp_kdf(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], key1: &mut [u8], key2: &mut [u8], key3: &mut [u8]) -> Result<(), i32> { + if !(kdr_index == -1 || (0 <= kdr_index && (kdr_index as usize) <= idx.len() * 8)) { + // The kdr_index value must be either -1 or the number of bits that + // will be read from the idx slice. + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } let key_size = key.len() as u32; let salt_size = salt.len() as u32; let key1_size = key1.len() as u32; @@ -684,6 +689,11 @@ pub fn srtp_kdf_label(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], #[cfg(kdf_srtp)] pub fn srtcp_kdf(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], key1: &mut [u8], key2: &mut [u8], key3: &mut [u8]) -> Result<(), i32> { + if !(kdr_index == -1 || (0 <= kdr_index && (kdr_index as usize) <= idx.len() * 8)) { + // The kdr_index value must be either -1 or the number of bits that + // will be read from the idx slice. + return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); + } let key_size = key.len() as u32; let salt_size = salt.len() as u32; let key1_size = key1.len() as u32; From 2c981d67e6c8397b9a9fbf87227dc98aa8b0d7a3 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Thu, 26 Mar 2026 08:18:27 -0400 Subject: [PATCH 09/20] Rust wrapper: check all buffer lengths when converting to u32/i32 Fix F-1068 --- wrapper/rust/wolfssl-wolfcrypt/src/aes.rs | 230 ++++++++++-------- wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs | 12 +- .../src/chacha20_poly1305.rs | 18 +- wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs | 30 +-- .../rust/wolfssl-wolfcrypt/src/curve25519.rs | 58 ++--- wrapper/rust/wolfssl-wolfcrypt/src/dh.rs | 59 +++-- .../rust/wolfssl-wolfcrypt/src/dilithium.rs | 52 ++-- wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs | 72 +++--- wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs | 72 +++--- wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs | 64 ++--- wrapper/rust/wolfssl-wolfcrypt/src/hkdf.rs | 18 +- wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs | 6 +- wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs | 66 ++--- wrapper/rust/wolfssl-wolfcrypt/src/lib.rs | 10 + wrapper/rust/wolfssl-wolfcrypt/src/lms.rs | 16 +- wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs | 15 +- wrapper/rust/wolfssl-wolfcrypt/src/prf.rs | 6 +- wrapper/rust/wolfssl-wolfcrypt/src/random.rs | 16 +- wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs | 56 ++--- wrapper/rust/wolfssl-wolfcrypt/src/sha.rs | 34 +-- 20 files changed, 483 insertions(+), 427 deletions(-) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs b/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs index 53f96039e99..d5275c01c1a 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs @@ -44,8 +44,10 @@ use cipher::typenum::consts::U24; use cipher::{ BlockModeDecBackend, BlockModeDecClosure, BlockModeDecrypt, BlockModeEncBackend, BlockModeEncClosure, BlockModeEncrypt, - IvSizeUser, KeyIvInit, ParBlocksSizeUser, StreamCipher, StreamCipherError, + IvSizeUser, KeyIvInit, ParBlocksSizeUser, }; +#[cfg(all(any(aes_ctr, aes_ofb), feature = "cipher"))] +use cipher::{StreamCipher,StreamCipherError}; #[cfg(aes_wc_block_size)] pub const AES_BLOCK_SIZE: usize = sys::WC_AES_BLOCK_SIZE as usize; @@ -114,7 +116,7 @@ impl CBC { } fn init(&mut self, key: &[u8], iv: &[u8], dir: i32) -> Result<(), i32> { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; if iv.len() != AES_BLOCK_SIZE { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -183,9 +185,9 @@ impl CBC { /// library return code on failure. pub fn encrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -215,9 +217,9 @@ impl CBC { /// library return code on failure. pub fn decrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -331,7 +333,7 @@ impl CCM { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. pub fn init(&mut self, key: &[u8]) -> Result<(), i32> { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; let rc = unsafe { sys::wc_AesCcmSetKey(&mut self.ws_aes, key.as_ptr(), key_size) }; @@ -360,15 +362,15 @@ impl CCM { /// library return code on failure. pub fn encrypt(&mut self, din: &[I], dout: &mut [O], nonce: &[N], auth: &[A], auth_tag: &mut [A]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; let nonce_ptr = nonce.as_ptr() as *const u8; - let nonce_size = size_of_val(nonce) as u32; + let nonce_size = crate::buffer_len_to_u32(size_of_val(nonce))?; let auth_ptr = auth.as_ptr() as *const u8; - let auth_size = size_of_val(auth) as u32; + let auth_size = crate::buffer_len_to_u32(size_of_val(auth))?; let auth_tag_ptr = auth_tag.as_mut_ptr() as *mut u8; - let auth_tag_size = size_of_val(auth_tag) as u32; + let auth_tag_size = crate::buffer_len_to_u32(size_of_val(auth_tag))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -402,15 +404,15 @@ impl CCM { /// library return code on failure. pub fn decrypt(&mut self, din: &[I], dout: &mut [O], nonce: &[N], auth: &[A], auth_tag: &[A]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; let nonce_ptr = nonce.as_ptr() as *const u8; - let nonce_size = size_of_val(nonce) as u32; + let nonce_size = crate::buffer_len_to_u32(size_of_val(nonce))?; let auth_ptr = auth.as_ptr() as *const u8; - let auth_size = size_of_val(auth) as u32; + let auth_size = crate::buffer_len_to_u32(size_of_val(auth))?; let auth_tag_ptr = auth_tag.as_ptr() as *const u8; - let auth_tag_size = size_of_val(auth_tag) as u32; + let auth_tag_size = crate::buffer_len_to_u32(size_of_val(auth_tag))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -446,6 +448,10 @@ fn ccm_encrypt_in_place( buffer: &mut [u8], tag: &mut [u8], ) -> Result<(), aead::Error> { + if buffer.len() > u32::MAX as usize || nonce.len() > u32::MAX as usize + || tag.len() > u32::MAX as usize || aad.len() > u32::MAX as usize { + return Err(aead::Error); + } let mut ccm = CCM::new().map_err(|_| aead::Error)?; ccm.init(key).map_err(|_| aead::Error)?; // wolfCrypt CCM supports in-place operation (out == in). @@ -475,6 +481,10 @@ fn ccm_decrypt_in_place( buffer: &mut [u8], tag: &[u8], ) -> Result<(), aead::Error> { + if buffer.len() > u32::MAX as usize || nonce.len() > u32::MAX as usize + || tag.len() > u32::MAX as usize || aad.len() > u32::MAX as usize { + return Err(aead::Error); + } let mut ccm = CCM::new().map_err(|_| aead::Error)?; ccm.init(key).map_err(|_| aead::Error)?; let buf_ptr = buffer.as_mut_ptr(); @@ -692,7 +702,7 @@ impl CFB { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. pub fn init(&mut self, key: &[u8], iv: &[u8]) -> Result<(), i32> { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; if iv.len() != AES_BLOCK_SIZE { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -722,9 +732,9 @@ impl CFB { /// library return code on failure. pub fn encrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -753,9 +763,9 @@ impl CFB { /// library return code on failure. pub fn encrypt1(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -784,9 +794,9 @@ impl CFB { /// library return code on failure. pub fn encrypt8(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -816,9 +826,9 @@ impl CFB { #[cfg(aes_decrypt)] pub fn decrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -848,9 +858,9 @@ impl CFB { #[cfg(aes_decrypt)] pub fn decrypt1(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -880,9 +890,9 @@ impl CFB { #[cfg(aes_decrypt)] pub fn decrypt8(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -998,7 +1008,7 @@ impl CTR { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. pub fn init(&mut self, key: &[u8], iv: &[u8]) -> Result<(), i32> { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; if iv.len() != AES_BLOCK_SIZE { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -1014,9 +1024,9 @@ impl CTR { fn encrypt_decrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -1140,13 +1150,13 @@ impl EAX { pub fn encrypt(din: &[I], dout: &mut [O], key: &[u8], nonce: &[u8], auth: &[u8], auth_tag: &mut [u8]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; - let key_size = key.len() as u32; - let nonce_size = nonce.len() as u32; - let auth_size = auth.len() as u32; - let auth_tag_size = auth_tag.len() as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let key_size = crate::buffer_len_to_u32(key.len())?; + let nonce_size = crate::buffer_len_to_u32(nonce.len())?; + let auth_size = crate::buffer_len_to_u32(auth.len())?; + let auth_tag_size = crate::buffer_len_to_u32(auth_tag.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -1181,13 +1191,13 @@ impl EAX { pub fn decrypt(din: &[I], dout: &mut [O], key: &[u8], nonce: &[u8], auth: &[u8], auth_tag: &[u8]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; - let key_size = key.len() as u32; - let nonce_size = nonce.len() as u32; - let auth_size = auth.len() as u32; - let auth_tag_size = auth_tag.len() as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let key_size = crate::buffer_len_to_u32(key.len())?; + let nonce_size = crate::buffer_len_to_u32(nonce.len())?; + let auth_size = crate::buffer_len_to_u32(auth.len())?; + let auth_tag_size = crate::buffer_len_to_u32(auth_tag.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -1264,7 +1274,7 @@ impl ECB { } fn init(&mut self, key: &[u8], dir: i32) -> Result<(), i32> { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; let rc = unsafe { sys::wc_AesSetKey(&mut self.ws_aes, key.as_ptr(), key_size, core::ptr::null(), dir) @@ -1326,9 +1336,9 @@ impl ECB { /// library return code on failure. pub fn encrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -1358,9 +1368,9 @@ impl ECB { /// library return code on failure. pub fn decrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -1478,7 +1488,7 @@ impl GCM { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. pub fn init(&mut self, key: &[u8]) -> Result<(), i32> { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; let rc = unsafe { sys::wc_AesGcmSetKey(&mut self.ws_aes, key.as_ptr(), key_size) }; @@ -1508,12 +1518,12 @@ impl GCM { pub fn encrypt(&mut self, din: &[I], dout: &mut [O], iv: &[u8], auth: &[u8], auth_tag: &mut [u8]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; - let iv_size = iv.len() as u32; - let auth_size = auth.len() as u32; - let auth_tag_size = auth_tag.len() as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let iv_size = crate::buffer_len_to_u32(iv.len())?; + let auth_size = crate::buffer_len_to_u32(auth.len())?; + let auth_tag_size = crate::buffer_len_to_u32(auth_tag.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -1548,12 +1558,12 @@ impl GCM { pub fn decrypt(&mut self, din: &[I], dout: &mut [O], iv: &[u8], auth: &[u8], auth_tag: &[u8]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; - let iv_size = iv.len() as u32; - let auth_size = auth.len() as u32; - let auth_tag_size = auth_tag.len() as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let iv_size = crate::buffer_len_to_u32(iv.len())?; + let auth_size = crate::buffer_len_to_u32(auth.len())?; + let auth_tag_size = crate::buffer_len_to_u32(auth_tag.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -1591,6 +1601,10 @@ fn gcm_encrypt_in_place( buffer: &mut [u8], tag: &mut [u8], ) -> Result<(), aead::Error> { + if buffer.len() > u32::MAX as usize || nonce.len() > u32::MAX as usize + || tag.len() > u32::MAX as usize || aad.len() > u32::MAX as usize { + return Err(aead::Error); + } let mut gcm = GCM::new().map_err(|_| aead::Error)?; gcm.init(key).map_err(|_| aead::Error)?; let buf_ptr = buffer.as_mut_ptr(); @@ -1619,6 +1633,10 @@ fn gcm_decrypt_in_place( buffer: &mut [u8], tag: &[u8], ) -> Result<(), aead::Error> { + if buffer.len() > u32::MAX as usize || nonce.len() > u32::MAX as usize + || tag.len() > u32::MAX as usize || aad.len() > u32::MAX as usize { + return Err(aead::Error); + } let mut gcm = GCM::new().map_err(|_| aead::Error)?; gcm.init(key).map_err(|_| aead::Error)?; let buf_ptr = buffer.as_mut_ptr(); @@ -1867,8 +1885,8 @@ impl GCMStream { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. pub fn init(&mut self, key: &[u8], iv: &[u8]) -> Result<(), i32> { - let key_size = key.len() as u32; - let iv_size = iv.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; + let iv_size = crate::buffer_len_to_u32(iv.len())?; let rc = unsafe { sys::wc_AesGcmInit(&mut self.ws_aes, key.as_ptr(), key_size, iv.as_ptr(), iv_size) @@ -1903,10 +1921,10 @@ impl GCMStream { pub fn encrypt_update(&mut self, din: &[I], dout: &mut [O], auth: &[u8]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; - let auth_size = auth.len() as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let auth_size = crate::buffer_len_to_u32(auth.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -1936,7 +1954,7 @@ impl GCMStream { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. pub fn encrypt_final(&mut self, auth_tag: &mut [u8]) -> Result<(), i32> { - let auth_tag_size = auth_tag.len() as u32; + let auth_tag_size = crate::buffer_len_to_u32(auth_tag.len())?; let rc = unsafe { sys::wc_AesGcmEncryptFinal(&mut self.ws_aes, auth_tag.as_mut_ptr(), auth_tag_size) @@ -1971,10 +1989,10 @@ impl GCMStream { pub fn decrypt_update(&mut self, din: &[I], dout: &mut [O], auth: &[u8]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; - let auth_size = auth.len() as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let auth_size = crate::buffer_len_to_u32(auth.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2004,7 +2022,7 @@ impl GCMStream { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. pub fn decrypt_final(&mut self, auth_tag: &[u8]) -> Result<(), i32> { - let auth_tag_size = auth_tag.len() as u32; + let auth_tag_size = crate::buffer_len_to_u32(auth_tag.len())?; let rc = unsafe { sys::wc_AesGcmDecryptFinal(&mut self.ws_aes, auth_tag.as_ptr(), auth_tag_size) @@ -2119,7 +2137,7 @@ impl OFB { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. pub fn init(&mut self, key: &[u8], iv: &[u8]) -> Result<(), i32> { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; if iv.len() != AES_BLOCK_SIZE { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2149,9 +2167,9 @@ impl OFB { /// library return code on failure. pub fn encrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2181,9 +2199,9 @@ impl OFB { #[cfg(aes_decrypt)] pub fn decrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2298,7 +2316,7 @@ impl XTS { } fn init(&mut self, key: &[u8], dir: i32) -> Result<(), i32> { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; let rc = unsafe { sys::wc_AesXtsSetKeyNoInit(&mut self.ws_xtsaes, key.as_ptr(), key_size, dir) @@ -2360,10 +2378,10 @@ impl XTS { /// library return code on failure. pub fn encrypt(&mut self, din: &[I], dout: &mut [O], tweak: &[u8]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; - let tweak_size = tweak.len() as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let tweak_size = crate::buffer_len_to_u32(tweak.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2399,9 +2417,9 @@ impl XTS { /// library return code on failure. pub fn encrypt_sector(&mut self, din: &[I], dout: &mut [O], sector: u64) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2439,9 +2457,9 @@ impl XTS { pub fn encrypt_consecutive_sectors(&mut self, din: &[I], dout: &mut [O], sector: u64, sector_size: u32) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2472,10 +2490,10 @@ impl XTS { /// library return code on failure. pub fn decrypt(&mut self, din: &[I], dout: &mut [O], tweak: &[u8]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; - let tweak_size = tweak.len() as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let tweak_size = crate::buffer_len_to_u32(tweak.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2511,9 +2529,9 @@ impl XTS { /// library return code on failure. pub fn decrypt_sector(&mut self, din: &[I], dout: &mut [O], sector: u64) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2551,9 +2569,9 @@ impl XTS { pub fn decrypt_consecutive_sectors(&mut self, din: &[I], dout: &mut [O], sector: u64, sector_size: u32) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2676,7 +2694,7 @@ impl XTSStream { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. pub fn init_encrypt(&mut self, key: &[u8], tweak: &[u8]) -> Result<(), i32> { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; let rc = unsafe { sys::wc_AesXtsSetKeyNoInit(&mut self.ws_xtsaes, key.as_ptr(), key_size, sys::AES_ENCRYPTION as i32) @@ -2684,7 +2702,7 @@ impl XTSStream { if rc != 0 { return Err(rc); } - let tweak_size = tweak.len() as u32; + let tweak_size = crate::buffer_len_to_u32(tweak.len())?; let rc = unsafe { sys::wc_AesXtsEncryptInit(&mut self.ws_xtsaes, tweak.as_ptr(), tweak_size, &mut self.ws_xtsaesstreamdata) @@ -2710,7 +2728,7 @@ impl XTSStream { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. pub fn init_decrypt(&mut self, key: &[u8], tweak: &[u8]) -> Result<(), i32> { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; let rc = unsafe { sys::wc_AesXtsSetKeyNoInit(&mut self.ws_xtsaes, key.as_ptr(), key_size, sys::AES_DECRYPTION as i32) @@ -2718,7 +2736,7 @@ impl XTSStream { if rc != 0 { return Err(rc); } - let tweak_size = tweak.len() as u32; + let tweak_size = crate::buffer_len_to_u32(tweak.len())?; let rc = unsafe { sys::wc_AesXtsDecryptInit(&mut self.ws_xtsaes, tweak.as_ptr(), tweak_size, &mut self.ws_xtsaesstreamdata) @@ -2749,9 +2767,9 @@ impl XTSStream { /// library return code on failure. pub fn encrypt_update(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2784,9 +2802,9 @@ impl XTSStream { /// library return code on failure. pub fn encrypt_final(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2820,9 +2838,9 @@ impl XTSStream { /// library return code on failure. pub fn decrypt_update(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -2855,9 +2873,9 @@ impl XTSStream { /// library return code on failure. pub fn decrypt_final(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { let in_ptr = din.as_ptr() as *const u8; - let in_size = size_of_val(din) as u32; + let in_size = crate::buffer_len_to_u32(size_of_val(din))?; let out_ptr = dout.as_ptr() as *mut u8; - let out_size = size_of_val(dout) as u32; + let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -3254,6 +3272,7 @@ impl StreamCipher for Aes128Ctr { fn unchecked_apply_keystream_inout(&mut self, mut buf: cipher::InOutBuf<'_, '_, u8>) { let len = buf.len(); if len == 0 { return; } + assert!(len <= u32::MAX as usize, "buffer too large for wc_AesCtrEncrypt"); // wolfCrypt AES-CTR supports in-place operation (out == in). let in_ptr = buf.get_in().as_ptr(); let out_ptr = buf.get_out().as_mut_ptr(); @@ -3303,6 +3322,7 @@ impl StreamCipher for Aes192Ctr { fn unchecked_apply_keystream_inout(&mut self, mut buf: cipher::InOutBuf<'_, '_, u8>) { let len = buf.len(); if len == 0 { return; } + assert!(len <= u32::MAX as usize, "buffer too large for wc_AesCtrEncrypt"); let in_ptr = buf.get_in().as_ptr(); let out_ptr = buf.get_out().as_mut_ptr(); // SAFETY: CTR in-place is valid; C function called directly to avoid @@ -3351,6 +3371,7 @@ impl StreamCipher for Aes256Ctr { fn unchecked_apply_keystream_inout(&mut self, mut buf: cipher::InOutBuf<'_, '_, u8>) { let len = buf.len(); if len == 0 { return; } + assert!(len <= u32::MAX as usize, "buffer too large for wc_AesCtrEncrypt"); let in_ptr = buf.get_in().as_ptr(); let out_ptr = buf.get_out().as_mut_ptr(); // SAFETY: CTR in-place is valid; C function called directly to avoid @@ -3407,6 +3428,7 @@ impl StreamCipher for Aes128Ofb { fn unchecked_apply_keystream_inout(&mut self, mut buf: cipher::InOutBuf<'_, '_, u8>) { let len = buf.len(); if len == 0 { return; } + assert!(len <= u32::MAX as usize, "buffer too large for wc_AesOfbEncrypt"); // wolfCrypt AES-OFB supports in-place operation (out == in). let in_ptr = buf.get_in().as_ptr(); let out_ptr = buf.get_out().as_mut_ptr(); @@ -3456,6 +3478,7 @@ impl StreamCipher for Aes192Ofb { fn unchecked_apply_keystream_inout(&mut self, mut buf: cipher::InOutBuf<'_, '_, u8>) { let len = buf.len(); if len == 0 { return; } + assert!(len <= u32::MAX as usize, "buffer too large for wc_AesOfbEncrypt"); let in_ptr = buf.get_in().as_ptr(); let out_ptr = buf.get_out().as_mut_ptr(); // SAFETY: OFB in-place is valid; C function called directly to avoid @@ -3504,6 +3527,7 @@ impl StreamCipher for Aes256Ofb { fn unchecked_apply_keystream_inout(&mut self, mut buf: cipher::InOutBuf<'_, '_, u8>) { let len = buf.len(); if len == 0 { return; } + assert!(len <= u32::MAX as usize, "buffer too large for wc_AesOfbEncrypt"); let in_ptr = buf.get_in().as_ptr(); let out_ptr = buf.get_out().as_mut_ptr(); // SAFETY: OFB in-place is valid; C function called directly to avoid diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs b/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs index c4b54cb081d..06021de68c3 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs @@ -87,9 +87,9 @@ impl BLAKE2b { /// let blake2b = BLAKE2b::new_with_key(64, &key).expect("Error with new()"); /// ``` pub fn new_with_key(digest_size: usize, key: &[u8]) -> Result { + let key_size = crate::buffer_len_to_u32(key.len())?; let digest_size = digest_size as u32; let mut wc_blake2b: MaybeUninit = MaybeUninit::uninit(); - let key_size = key.len() as u32; let rc = unsafe { sys::wc_InitBlake2b_WithKey(wc_blake2b.as_mut_ptr(), digest_size, key.as_ptr(), key_size) @@ -124,7 +124,7 @@ impl BLAKE2b { /// blake2b.update(&[0u8; 16]).expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Blake2bUpdate(&mut self.wc_blake2b, data.as_ptr(), data_size) }; @@ -156,7 +156,7 @@ impl BLAKE2b { /// blake2b.finalize(&mut hash).expect("Error with finalize()"); /// ``` pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> { - let hash_size = hash.len() as u32; + let hash_size = crate::buffer_len_to_u32(hash.len())?; if hash_size == 0 { // The C function uses the internal state configured digest size // if hash_size is passed in as 0. We do not want to allow a @@ -370,9 +370,9 @@ impl BLAKE2s { /// let blake2s = BLAKE2s::new_with_key(32, &key).expect("Error with new()"); /// ``` pub fn new_with_key(digest_size: usize, key: &[u8]) -> Result { + let key_size = crate::buffer_len_to_u32(key.len())?; let digest_size = digest_size as u32; let mut wc_blake2s: MaybeUninit = MaybeUninit::uninit(); - let key_size = key.len() as u32; let rc = unsafe { sys::wc_InitBlake2s_WithKey(wc_blake2s.as_mut_ptr(), digest_size, key.as_ptr(), key_size) @@ -407,7 +407,7 @@ impl BLAKE2s { /// blake2s.update(&[0u8; 16]).expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Blake2sUpdate(&mut self.wc_blake2s, data.as_ptr(), data_size) }; @@ -439,7 +439,7 @@ impl BLAKE2s { /// blake2s.finalize(&mut hash).expect("Error with finalize()"); /// ``` pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> { - let hash_size = hash.len() as u32; + let hash_size = crate::buffer_len_to_u32(hash.len())?; if hash_size == 0 { // The C function uses the internal state configured digest size // if hash_size is passed in as 0. We do not want to allow a diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs b/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs index a7002eef0e0..61f4135786b 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs @@ -73,8 +73,8 @@ impl ChaCha20Poly1305 { if auth_tag.len() != Self::AUTH_TAG_SIZE { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } - let aad_size = aad.len() as u32; - let ciphertext_size = ciphertext.len() as u32; + let aad_size = crate::buffer_len_to_u32(aad.len())?; + let ciphertext_size = crate::buffer_len_to_u32(ciphertext.len())?; let rc = unsafe { sys::wc_ChaCha20Poly1305_Decrypt(key.as_ptr(), iv.as_ptr(), aad.as_ptr(), aad_size, ciphertext.as_ptr(), @@ -115,8 +115,8 @@ impl ChaCha20Poly1305 { if auth_tag.len() != Self::AUTH_TAG_SIZE { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } - let aad_size = aad.len() as u32; - let plaintext_size = plaintext.len() as u32; + let aad_size = crate::buffer_len_to_u32(aad.len())?; + let plaintext_size = crate::buffer_len_to_u32(plaintext.len())?; let rc = unsafe { sys::wc_ChaCha20Poly1305_Encrypt(key.as_ptr(), iv.as_ptr(), aad.as_ptr(), aad_size, plaintext.as_ptr(), plaintext_size, @@ -171,7 +171,7 @@ impl ChaCha20Poly1305 { /// Returns either Ok(()) on success or Err(e) containing the wolfSSL /// library error code value. pub fn update_aad(&mut self, aad: &[u8]) -> Result<(), i32> { - let aad_size = aad.len() as u32; + let aad_size = crate::buffer_len_to_u32(aad.len())?; let rc = unsafe { sys::wc_ChaCha20Poly1305_UpdateAad(&mut self.wc_ccp, aad.as_ptr(), aad_size) @@ -203,7 +203,7 @@ impl ChaCha20Poly1305 { if din.len() != dout.len() { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } - let din_size = din.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; let rc = unsafe { sys::wc_ChaCha20Poly1305_UpdateData(&mut self.wc_ccp, din.as_ptr(), dout.as_mut_ptr(), din_size) @@ -283,6 +283,9 @@ impl aead::AeadInPlace for ChaCha20Poly1305Aead { associated_data: &[u8], buffer: &mut [u8], ) -> Result, aead::Error> { + if associated_data.len() > u32::MAX as usize || buffer.len() > u32::MAX as usize { + return Err(aead::Error); + } let mut tag = aead::Tag::::default(); // wc_ChaCha20Poly1305_Encrypt supports in-place (out == in). let buf_ptr = buffer.as_mut_ptr(); @@ -310,6 +313,9 @@ impl aead::AeadInPlace for ChaCha20Poly1305Aead { buffer: &mut [u8], tag: &aead::Tag, ) -> Result<(), aead::Error> { + if associated_data.len() > u32::MAX as usize || buffer.len() > u32::MAX as usize { + return Err(aead::Error); + } let buf_ptr = buffer.as_mut_ptr(); let in_ptr = buf_ptr as *const u8; let nonce_bytes: &[u8] = nonce; diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs b/wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs index 6261f01eb2f..fa3ebebfd06 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs @@ -70,9 +70,9 @@ impl CMAC { /// ``` #[cfg(aes)] pub fn generate(key: &[u8], data: &[u8], dout: &mut [u8]) -> Result<(), i32> { - let key_size = key.len() as u32; - let data_size = data.len() as u32; - let mut dout_size = dout.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; + let data_size = crate::buffer_len_to_u32(data.len())?; + let mut dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_AesCmacGenerate(dout.as_mut_ptr(), &mut dout_size, data.as_ptr(), data_size, @@ -134,7 +134,7 @@ impl CMAC { /// let mut cmac = CMAC::new_ex(&key, None, None).expect("Error with new_ex()"); /// ``` pub fn new_ex(key: &[u8], heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; let mut ws_cmac: MaybeUninit = MaybeUninit::uninit(); let typ = sys::CmacType_WC_CMAC_AES as i32; let heap = match heap { @@ -193,9 +193,9 @@ impl CMAC { /// ``` #[cfg(aes)] pub fn verify(key: &[u8], data: &[u8], check: &[u8]) -> Result { - let key_size = key.len() as u32; - let data_size = data.len() as u32; - let check_size = check.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; + let data_size = crate::buffer_len_to_u32(data.len())?; + let check_size = crate::buffer_len_to_u32(check.len())?; let rc = unsafe { sys::wc_AesCmacVerify(check.as_ptr(), check_size, data.as_ptr(), data_size, @@ -243,9 +243,9 @@ impl CMAC { /// ``` #[cfg(aes)] pub fn generate_ex(&mut self, key: &[u8], data: &[u8], dout: &mut [u8], heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result<(), i32> { - let key_size = key.len() as u32; - let data_size = data.len() as u32; - let mut dout_size = dout.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; + let data_size = crate::buffer_len_to_u32(data.len())?; + let mut dout_size = crate::buffer_len_to_u32(dout.len())?; let heap = match heap { Some(heap) => heap, None => core::ptr::null_mut(), @@ -293,7 +293,7 @@ impl CMAC { /// cmac.update(&message).expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_CmacUpdate(&mut self.ws_cmac, data.as_ptr(), data_size) }; @@ -335,7 +335,7 @@ impl CMAC { /// cmac.finalize(&mut finalize_out).expect("Error with finalize()"); /// ``` pub fn finalize(mut self, dout: &mut [u8]) -> Result<(), i32> { - let mut dout_size = dout.len() as u32; + let mut dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_CmacFinalNoFree(&mut self.ws_cmac, dout.as_mut_ptr(), &mut dout_size) @@ -385,9 +385,9 @@ impl CMAC { /// ``` #[cfg(aes)] pub fn verify_ex(&mut self, key: &[u8], data: &[u8], check: &[u8], heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result { - let key_size = key.len() as u32; - let data_size = data.len() as u32; - let check_size = check.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; + let data_size = crate::buffer_len_to_u32(data.len())?; + let check_size = crate::buffer_len_to_u32(check.len())?; let heap = match heap { Some(heap) => heap, None => core::ptr::null_mut(), diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs b/wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs index 6a472e2c788..9a80fb573e3 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs @@ -50,7 +50,7 @@ impl Curve25519Key { /// Returns either Ok(()) on success or Err(e) containing the wolfSSL /// library error code value. pub fn check_public(public: &[u8], big_endian: bool) -> Result<(), i32> { - let public_size = public.len() as u32; + let public_size = crate::buffer_len_to_u32(public.len())?; let endian = if big_endian {sys::EC25519_BIG_ENDIAN} else {sys::EC25519_LITTLE_ENDIAN}; let rc = unsafe { sys::wc_curve25519_check_public(public.as_ptr(), public_size, @@ -128,6 +128,7 @@ impl Curve25519Key { /// Returns either Ok(curve25519key) on success or Err(e) containing the /// wolfSSL library error code value. pub fn import_private(private: &[u8]) -> Result { + let private_size = crate::buffer_len_to_u32(private.len())?; let mut wc_key: MaybeUninit = MaybeUninit::uninit(); let rc = unsafe { sys::wc_curve25519_init(wc_key.as_mut_ptr()) @@ -137,7 +138,6 @@ impl Curve25519Key { } let wc_key = unsafe { wc_key.assume_init() }; let mut curve25519key = Curve25519Key { wc_key }; - let private_size = private.len() as u32; let rc = unsafe { sys::wc_curve25519_import_private(private.as_ptr(), private_size, &mut curve25519key.wc_key) @@ -160,6 +160,7 @@ impl Curve25519Key { /// Returns either Ok(curve25519key) on success or Err(e) containing the /// wolfSSL library error code value. pub fn import_private_ex(private: &[u8], big_endian: bool) -> Result { + let private_size = crate::buffer_len_to_u32(private.len())?; let mut wc_key: MaybeUninit = MaybeUninit::uninit(); let rc = unsafe { sys::wc_curve25519_init(wc_key.as_mut_ptr()) @@ -169,7 +170,6 @@ impl Curve25519Key { } let wc_key = unsafe { wc_key.assume_init() }; let mut curve25519key = Curve25519Key { wc_key }; - let private_size = private.len() as u32; let endian = if big_endian {sys::EC25519_BIG_ENDIAN} else {sys::EC25519_LITTLE_ENDIAN}; let rc = unsafe { sys::wc_curve25519_import_private_ex(private.as_ptr(), @@ -193,6 +193,8 @@ impl Curve25519Key { /// Returns either Ok(curve25519key) on success or Err(e) containing the /// wolfSSL library error code value. pub fn import_private_raw(private: &[u8], public: &[u8]) -> Result { + let private_size = crate::buffer_len_to_u32(private.len())?; + let public_size = crate::buffer_len_to_u32(public.len())?; let mut wc_key: MaybeUninit = MaybeUninit::uninit(); let rc = unsafe { sys::wc_curve25519_init(wc_key.as_mut_ptr()) @@ -202,8 +204,6 @@ impl Curve25519Key { } let wc_key = unsafe { wc_key.assume_init() }; let mut curve25519key = Curve25519Key { wc_key }; - let private_size = private.len() as u32; - let public_size = public.len() as u32; let rc = unsafe { sys::wc_curve25519_import_private_raw(private.as_ptr(), private_size, public.as_ptr(), public_size, @@ -228,6 +228,8 @@ impl Curve25519Key { /// Returns either Ok(curve25519key) on success or Err(e) containing the /// wolfSSL library error code value. pub fn import_private_raw_ex(private: &[u8], public: &[u8], big_endian: bool) -> Result { + let private_size = crate::buffer_len_to_u32(private.len())?; + let public_size = crate::buffer_len_to_u32(public.len())?; let mut wc_key: MaybeUninit = MaybeUninit::uninit(); let rc = unsafe { sys::wc_curve25519_init(wc_key.as_mut_ptr()) @@ -237,8 +239,6 @@ impl Curve25519Key { } let wc_key = unsafe { wc_key.assume_init() }; let mut curve25519key = Curve25519Key { wc_key }; - let private_size = private.len() as u32; - let public_size = public.len() as u32; let endian = if big_endian {sys::EC25519_BIG_ENDIAN} else {sys::EC25519_LITTLE_ENDIAN}; let rc = unsafe { sys::wc_curve25519_import_private_raw_ex(private.as_ptr(), @@ -262,6 +262,7 @@ impl Curve25519Key { /// Returns either Ok(curve25519key) on success or Err(e) containing the /// wolfSSL library error code value. pub fn import_public(public: &[u8]) -> Result { + let public_size = crate::buffer_len_to_u32(public.len())?; let mut wc_key: MaybeUninit = MaybeUninit::uninit(); let rc = unsafe { sys::wc_curve25519_init(wc_key.as_mut_ptr()) @@ -271,7 +272,6 @@ impl Curve25519Key { } let wc_key = unsafe { wc_key.assume_init() }; let mut curve25519key = Curve25519Key { wc_key }; - let public_size = public.len() as u32; let rc = unsafe { sys::wc_curve25519_import_public(public.as_ptr(), public_size, &mut curve25519key.wc_key) @@ -294,6 +294,7 @@ impl Curve25519Key { /// Returns either Ok(curve25519key) on success or Err(e) containing the /// wolfSSL library error code value. pub fn import_public_ex(public: &[u8], big_endian: bool) -> Result { + let public_size = crate::buffer_len_to_u32(public.len())?; let mut wc_key: MaybeUninit = MaybeUninit::uninit(); let rc = unsafe { sys::wc_curve25519_init(wc_key.as_mut_ptr()) @@ -303,7 +304,6 @@ impl Curve25519Key { } let wc_key = unsafe { wc_key.assume_init() }; let mut curve25519key = Curve25519Key { wc_key }; - let public_size = public.len() as u32; let endian = if big_endian {sys::EC25519_BIG_ENDIAN} else {sys::EC25519_LITTLE_ENDIAN}; let rc = unsafe { sys::wc_curve25519_import_public_ex(public.as_ptr(), public_size, @@ -327,8 +327,8 @@ impl Curve25519Key { /// Returns either Ok(()) on success or Err(e) containing the wolfSSL /// library error code value. pub fn make_pub(private: &[u8], public: &mut [u8]) -> Result<(), i32> { - let private_size = private.len() as i32; - let public_size = public.len() as i32; + let private_size = crate::buffer_len_to_i32(private.len())?; + let public_size = crate::buffer_len_to_i32(public.len())?; let rc = unsafe { sys::wc_curve25519_make_pub(public_size, public.as_mut_ptr(), private_size, private.as_ptr()) @@ -354,8 +354,8 @@ impl Curve25519Key { /// library error code value. #[cfg(all(curve25519_blinding, random))] pub fn make_pub_blind(private: &[u8], public: &mut [u8], rng: &mut RNG) -> Result<(), i32> { - let private_size = private.len() as i32; - let public_size = public.len() as i32; + let private_size = crate::buffer_len_to_i32(private.len())?; + let public_size = crate::buffer_len_to_i32(public.len())?; let rc = unsafe { sys::wc_curve25519_make_pub_blind(public_size, public.as_mut_ptr(), private_size, private.as_ptr(), &mut rng.wc_rng) @@ -380,9 +380,9 @@ impl Curve25519Key { /// Returns either Ok(()) on success or Err(e) containing the wolfSSL /// library error code value. pub fn make_pub_generic(private: &[u8], public: &mut [u8], basepoint: &[u8]) -> Result<(), i32> { - let private_size = private.len() as i32; - let public_size = public.len() as i32; - let basepoint_size = basepoint.len() as i32; + let private_size = crate::buffer_len_to_i32(private.len())?; + let public_size = crate::buffer_len_to_i32(public.len())?; + let basepoint_size = crate::buffer_len_to_i32(basepoint.len())?; let rc = unsafe { sys::wc_curve25519_generic(public_size, public.as_mut_ptr(), private_size, private.as_ptr(), basepoint_size, basepoint.as_ptr()) @@ -409,9 +409,9 @@ impl Curve25519Key { /// library error code value. #[cfg(all(curve25519_blinding, random))] pub fn make_pub_generic_blind(private: &[u8], public: &mut [u8], basepoint: &[u8], rng: &mut RNG) -> Result<(), i32> { - let private_size = private.len() as i32; - let public_size = public.len() as i32; - let basepoint_size = basepoint.len() as i32; + let private_size = crate::buffer_len_to_i32(private.len())?; + let public_size = crate::buffer_len_to_i32(public.len())?; + let basepoint_size = crate::buffer_len_to_i32(basepoint.len())?; let rc = unsafe { sys::wc_curve25519_generic_blind(public_size, public.as_mut_ptr(), private_size, private.as_ptr(), basepoint_size, basepoint.as_ptr(), @@ -438,7 +438,7 @@ impl Curve25519Key { /// Returns either Ok(size) containing the number of bytes written to `out` /// on success or Err(e) containing the wolfSSL library error code value. pub fn shared_secret(private_key: &mut Curve25519Key, public_key: &mut Curve25519Key, out: &mut [u8]) -> Result { - let mut outlen = out.len() as u32; + let mut outlen = crate::buffer_len_to_u32(out.len())?; let rc = unsafe { sys::wc_curve25519_shared_secret(&mut private_key.wc_key, &mut public_key.wc_key, out.as_mut_ptr(), &mut outlen) @@ -491,7 +491,7 @@ impl Curve25519Key { /// Returns either Ok(size) containing the number of bytes written to `out` /// on success or Err(e) containing the wolfSSL library error code value. pub fn shared_secret_ex(private_key: &mut Curve25519Key, public_key: &mut Curve25519Key, out: &mut [u8], big_endian: bool) -> Result { - let mut outlen = out.len() as u32; + let mut outlen = crate::buffer_len_to_u32(out.len())?; let endian = if big_endian {sys::EC25519_BIG_ENDIAN} else {sys::EC25519_LITTLE_ENDIAN}; let rc = unsafe { sys::wc_curve25519_shared_secret_ex(&mut private_key.wc_key, @@ -516,8 +516,8 @@ impl Curve25519Key { /// Returns either Ok(()) on success or Err(e) containing the wolfSSL /// library error code value. pub fn export_key_raw(&mut self, private: &mut [u8], public: &mut [u8]) -> Result<(), i32> { - let mut private_size = private.len() as u32; - let mut public_size = public.len() as u32; + let mut private_size = crate::buffer_len_to_u32(private.len())?; + let mut public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_curve25519_export_key_raw(&mut self.wc_key, private.as_mut_ptr(), &mut private_size, @@ -543,8 +543,8 @@ impl Curve25519Key { /// Returns either Ok(()) on success or Err(e) containing the wolfSSL /// library error code value. pub fn export_key_raw_ex(&mut self, private: &mut [u8], public: &mut [u8], big_endian: bool) -> Result<(), i32> { - let mut private_size = private.len() as u32; - let mut public_size = public.len() as u32; + let mut private_size = crate::buffer_len_to_u32(private.len())?; + let mut public_size = crate::buffer_len_to_u32(public.len())?; let endian = if big_endian {sys::EC25519_BIG_ENDIAN} else {sys::EC25519_LITTLE_ENDIAN}; let rc = unsafe { sys::wc_curve25519_export_key_raw_ex(&mut self.wc_key, @@ -569,7 +569,7 @@ impl Curve25519Key { /// Returns either Ok(size) containing the number of bytes written to `out` /// on success or Err(e) containing the wolfSSL library error code value. pub fn export_private_raw(&mut self, out: &mut [u8]) -> Result { - let mut outlen = out.len() as u32; + let mut outlen = crate::buffer_len_to_u32(out.len())?; let rc = unsafe { sys::wc_curve25519_export_private_raw(&mut self.wc_key, out.as_mut_ptr(), &mut outlen) @@ -593,7 +593,7 @@ impl Curve25519Key { /// Returns either Ok(size) containing the number of bytes written to `out` /// on success or Err(e) containing the wolfSSL library error code value. pub fn export_private_raw_ex(&mut self, out: &mut [u8], big_endian: bool) -> Result { - let mut outlen = out.len() as u32; + let mut outlen = crate::buffer_len_to_u32(out.len())?; let endian = if big_endian {sys::EC25519_BIG_ENDIAN} else {sys::EC25519_LITTLE_ENDIAN}; let rc = unsafe { sys::wc_curve25519_export_private_raw_ex(&mut self.wc_key, @@ -617,7 +617,7 @@ impl Curve25519Key { /// Returns either Ok(size) containing the number of bytes written to `out` /// on success or Err(e) containing the wolfSSL library error code value. pub fn export_public(&mut self, out: &mut [u8]) -> Result { - let mut outlen = out.len() as u32; + let mut outlen = crate::buffer_len_to_u32(out.len())?; let rc = unsafe { sys::wc_curve25519_export_public(&mut self.wc_key, out.as_mut_ptr(), &mut outlen) @@ -641,7 +641,7 @@ impl Curve25519Key { /// Returns either Ok(size) containing the number of bytes written to `out` /// on success or Err(e) containing the wolfSSL library error code value. pub fn export_public_ex(&mut self, out: &mut [u8], big_endian: bool) -> Result { - let mut outlen = out.len() as u32; + let mut outlen = crate::buffer_len_to_u32(out.len())?; let endian = if big_endian {sys::EC25519_BIG_ENDIAN} else {sys::EC25519_LITTLE_ENDIAN}; let rc = unsafe { sys::wc_curve25519_export_public_ex(&mut self.wc_key, diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/dh.rs b/wrapper/rust/wolfssl-wolfcrypt/src/dh.rs index 022bd7a7556..ffb31fd223f 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/dh.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/dh.rs @@ -98,8 +98,8 @@ impl DH { /// } /// ``` pub fn check_pub_value(prime: &[u8], public: &[u8]) -> Result<(), i32> { - let prime_size = prime.len() as u32; - let public_size = public.len() as u32; + let prime_size = crate::buffer_len_to_u32(prime.len())?; + let public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_DhCheckPubValue(prime.as_ptr(), prime_size, public.as_ptr(), public_size) @@ -144,6 +144,13 @@ impl DH { /// } /// ``` pub fn compare_named_key(name: i32, p: &[u8], g: &[u8], q: Option<&[u8]>) -> bool { + if p.len() > u32::MAX as usize || g.len() > u32::MAX as usize { + return false; + } + if let Some(qv) = q + && qv.len() > u32::MAX as usize { + return false; + } let p_size = p.len() as u32; let g_size = g.len() as u32; let mut no_q = 1i32; @@ -556,8 +563,8 @@ impl DH { /// } /// ``` pub fn new_from_pg_ex(p: &[u8], g: &[u8], heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result { - let p_size = p.len() as u32; - let g_size = g.len() as u32; + let p_size = crate::buffer_len_to_u32(p.len())?; + let g_size = crate::buffer_len_to_u32(g.len())?; let mut wc_dhkey: MaybeUninit = MaybeUninit::uninit(); let heap = match heap { Some(heap) => heap, @@ -784,9 +791,9 @@ impl DH { /// } /// ``` pub fn new_from_pgq_ex(p: &[u8], g: &[u8], q: &[u8], heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result { - let p_size = p.len() as u32; - let g_size = g.len() as u32; - let q_size = q.len() as u32; + let p_size = crate::buffer_len_to_u32(p.len())?; + let g_size = crate::buffer_len_to_u32(g.len())?; + let q_size = crate::buffer_len_to_u32(q.len())?; let mut wc_dhkey: MaybeUninit = MaybeUninit::uninit(); let heap = match heap { Some(heap) => heap, @@ -1024,9 +1031,9 @@ impl DH { /// ``` #[cfg(random)] pub fn new_from_pgq_with_check_ex(p: &[u8], g: &[u8], q: &[u8], trusted: i32, rng: &mut RNG, heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result { - let p_size = p.len() as u32; - let g_size = g.len() as u32; - let q_size = q.len() as u32; + let p_size = crate::buffer_len_to_u32(p.len())?; + let g_size = crate::buffer_len_to_u32(g.len())?; + let q_size = crate::buffer_len_to_u32(q.len())?; let mut wc_dhkey: MaybeUninit = MaybeUninit::uninit(); let heap = match heap { Some(heap) => heap, @@ -1084,8 +1091,8 @@ impl DH { /// } /// ``` pub fn check_key_pair(&mut self, public: &[u8], private: &[u8]) -> Result<(), i32> { - let public_size = public.len() as u32; - let private_size = private.len() as u32; + let public_size = crate::buffer_len_to_u32(public.len())?; + let private_size = crate::buffer_len_to_u32(private.len())?; let rc = unsafe { sys::wc_DhCheckKeyPair(&mut self.wc_dhkey, public.as_ptr(), public_size, @@ -1129,7 +1136,7 @@ impl DH { /// } /// ``` pub fn check_priv_key(&mut self, private: &[u8]) -> Result<(), i32> { - let private_size = private.len() as u32; + let private_size = crate::buffer_len_to_u32(private.len())?; let rc = unsafe { sys::wc_DhCheckPrivKey(&mut self.wc_dhkey, private.as_ptr(), private_size) @@ -1249,12 +1256,12 @@ impl DH { /// } /// ``` pub fn check_priv_key_ex(&mut self, private: &[u8], prime: Option<&[u8]>) -> Result<(), i32> { - let private_size = private.len() as u32; + let private_size = crate::buffer_len_to_u32(private.len())?; let mut prime_ptr: *const u8 = core::ptr::null(); let mut prime_size = 0u32; if let Some(prime) = prime { prime_ptr = prime.as_ptr(); - prime_size = prime.len() as u32; + prime_size = crate::buffer_len_to_u32(prime.len())?; } let rc = unsafe { sys::wc_DhCheckPrivKey_ex(&mut self.wc_dhkey, @@ -1299,7 +1306,7 @@ impl DH { /// } /// ``` pub fn check_pub_key(&mut self, public: &[u8]) -> Result<(), i32> { - let public_size = public.len() as u32; + let public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_DhCheckPubKey(&mut self.wc_dhkey, public.as_ptr(), public_size) }; @@ -1423,8 +1430,8 @@ impl DH { /// } /// ``` pub fn check_pub_key_ex(&mut self, public: &[u8], prime: &[u8]) -> Result<(), i32> { - let public_size = public.len() as u32; - let prime_size = prime.len() as u32; + let public_size = crate::buffer_len_to_u32(public.len())?; + let prime_size = crate::buffer_len_to_u32(prime.len())?; let rc = unsafe { sys::wc_DhCheckPubKey_ex(&mut self.wc_dhkey, public.as_ptr(), public_size, @@ -1455,9 +1462,9 @@ impl DH { p: &mut [u8], p_size: &mut u32, q: &mut [u8], q_size: &mut u32, g: &mut [u8], g_size: &mut u32) -> Result<(), i32> { - *p_size = p.len() as u32; - *q_size = q.len() as u32; - *g_size = g.len() as u32; + *p_size = crate::buffer_len_to_u32(p.len())?; + *q_size = crate::buffer_len_to_u32(q.len())?; + *g_size = crate::buffer_len_to_u32(g.len())?; let rc = unsafe { sys::wc_DhExportParamsRaw(&mut self.wc_dhkey, p.as_mut_ptr(), p_size, @@ -1505,8 +1512,8 @@ impl DH { pub fn generate_key_pair(&mut self, rng: &mut RNG, private: &mut [u8], private_size: &mut u32, public: &mut [u8], public_size: &mut u32) -> Result<(), i32> { - *private_size = private.len() as u32; - *public_size = public.len() as u32; + *private_size = crate::buffer_len_to_u32(private.len())?; + *public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_DhGenerateKeyPair(&mut self.wc_dhkey, &mut rng.wc_rng, private.as_mut_ptr(), private_size, @@ -1556,9 +1563,9 @@ impl DH { /// } /// ``` pub fn shared_secret(&mut self, dout: &mut [u8], private: &[u8], other_pub: &[u8]) -> Result { - let mut dout_size = dout.len() as u32; - let private_size = private.len() as u32; - let other_pub_size = other_pub.len() as u32; + let mut dout_size = crate::buffer_len_to_u32(dout.len())?; + let private_size = crate::buffer_len_to_u32(private.len())?; + let other_pub_size = crate::buffer_len_to_u32(other_pub.len())?; let rc = unsafe { sys::wc_DhAgree(&mut self.wc_dhkey, dout.as_mut_ptr(), &mut dout_size, diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs b/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs index cef8c44877a..54fbd177c50 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs @@ -595,7 +595,7 @@ impl Dilithium { /// ``` #[cfg(dilithium_import)] pub fn import_public(&mut self, public: &[u8]) -> Result<(), i32> { - let public_size = public.len() as u32; + let public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_dilithium_import_public(public.as_ptr(), public_size, &mut self.ws_key) }; @@ -638,7 +638,7 @@ impl Dilithium { /// ``` #[cfg(dilithium_import)] pub fn import_private(&mut self, private: &[u8]) -> Result<(), i32> { - let private_size = private.len() as u32; + let private_size = crate::buffer_len_to_u32(private.len())?; let rc = unsafe { sys::wc_dilithium_import_private(private.as_ptr(), private_size, &mut self.ws_key) }; @@ -680,8 +680,8 @@ impl Dilithium { /// ``` #[cfg(dilithium_import)] pub fn import_key(&mut self, private: &[u8], public: &[u8]) -> Result<(), i32> { - let private_size = private.len() as u32; - let public_size = public.len() as u32; + let private_size = crate::buffer_len_to_u32(private.len())?; + let public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_dilithium_import_key( private.as_ptr(), private_size, @@ -724,7 +724,7 @@ impl Dilithium { /// ``` #[cfg(dilithium_export)] pub fn export_public(&mut self, public: &mut [u8]) -> Result { - let mut public_size = public.len() as u32; + let mut public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_dilithium_export_public(&mut self.ws_key, public.as_mut_ptr(), &mut public_size) }; @@ -763,7 +763,7 @@ impl Dilithium { /// ``` #[cfg(dilithium_export)] pub fn export_private(&mut self, private: &mut [u8]) -> Result { - let mut private_size = private.len() as u32; + let mut private_size = crate::buffer_len_to_u32(private.len())?; let rc = unsafe { sys::wc_dilithium_export_private( &mut self.ws_key, private.as_mut_ptr(), &mut private_size, @@ -807,8 +807,8 @@ impl Dilithium { /// ``` #[cfg(dilithium_export)] pub fn export_key(&mut self, private: &mut [u8], public: &mut [u8]) -> Result<(), i32> { - let mut private_size = private.len() as u32; - let mut public_size = public.len() as u32; + let mut private_size = crate::buffer_len_to_u32(private.len())?; + let mut public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_dilithium_export_key( &mut self.ws_key, @@ -861,8 +861,8 @@ impl Dilithium { sig: &mut [u8], rng: &mut RNG, ) -> Result { - let msg_len = msg.len() as u32; - let mut sig_len = sig.len() as u32; + let msg_len = crate::buffer_len_to_u32(msg.len())?; + let mut sig_len = crate::buffer_len_to_u32(sig.len())?; let rc = unsafe { sys::wc_dilithium_sign_ctx_msg( core::ptr::null(), 0, @@ -923,8 +923,8 @@ impl Dilithium { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } let ctx_len = ctx.len() as u8; - let msg_len = msg.len() as u32; - let mut sig_len = sig.len() as u32; + let msg_len = crate::buffer_len_to_u32(msg.len())?; + let mut sig_len = crate::buffer_len_to_u32(sig.len())?; let rc = unsafe { sys::wc_dilithium_sign_ctx_msg( ctx.as_ptr(), ctx_len, @@ -972,8 +972,8 @@ impl Dilithium { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } let ctx_len = ctx.len() as u8; - let hash_len = hash.len() as u32; - let mut sig_len = sig.len() as u32; + let hash_len = crate::buffer_len_to_u32(hash.len())?; + let mut sig_len = crate::buffer_len_to_u32(sig.len())?; let rc = unsafe { sys::wc_dilithium_sign_ctx_hash( ctx.as_ptr(), ctx_len, @@ -1032,8 +1032,8 @@ impl Dilithium { if seed.len() != sys::DILITHIUM_RND_SZ as usize { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } - let msg_len = msg.len() as u32; - let mut sig_len = sig.len() as u32; + let msg_len = crate::buffer_len_to_u32(msg.len())?; + let mut sig_len = crate::buffer_len_to_u32(sig.len())?; let rc = unsafe { sys::wc_dilithium_sign_ctx_msg_with_seed( core::ptr::null(), 0, @@ -1077,8 +1077,8 @@ impl Dilithium { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } let ctx_len = ctx.len() as u8; - let msg_len = msg.len() as u32; - let mut sig_len = sig.len() as u32; + let msg_len = crate::buffer_len_to_u32(msg.len())?; + let mut sig_len = crate::buffer_len_to_u32(sig.len())?; let rc = unsafe { sys::wc_dilithium_sign_ctx_msg_with_seed( ctx.as_ptr(), ctx_len, @@ -1125,8 +1125,8 @@ impl Dilithium { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } let ctx_len = ctx.len() as u8; - let hash_len = hash.len() as u32; - let mut sig_len = sig.len() as u32; + let hash_len = crate::buffer_len_to_u32(hash.len())?; + let mut sig_len = crate::buffer_len_to_u32(sig.len())?; let rc = unsafe { sys::wc_dilithium_sign_ctx_hash_with_seed( ctx.as_ptr(), ctx_len, @@ -1176,8 +1176,8 @@ impl Dilithium { /// ``` #[cfg(dilithium_verify)] pub fn verify_msg(&mut self, sig: &[u8], msg: &[u8]) -> Result { - let sig_len = sig.len() as u32; - let msg_len = msg.len() as u32; + let sig_len = crate::buffer_len_to_u32(sig.len())?; + let msg_len = crate::buffer_len_to_u32(msg.len())?; let mut res = 0i32; let rc = unsafe { sys::wc_dilithium_verify_ctx_msg( @@ -1232,9 +1232,9 @@ impl Dilithium { if ctx.len() > 255 { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } - let sig_len = sig.len() as u32; + let sig_len = crate::buffer_len_to_u32(sig.len())?; let ctx_len = ctx.len() as u8; - let msg_len = msg.len() as u32; + let msg_len = crate::buffer_len_to_u32(msg.len())?; let mut res = 0i32; let rc = unsafe { sys::wc_dilithium_verify_ctx_msg( @@ -1278,9 +1278,9 @@ impl Dilithium { if ctx.len() > 255 { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } - let sig_len = sig.len() as u32; + let sig_len = crate::buffer_len_to_u32(sig.len())?; let ctx_len = ctx.len() as u8; - let hash_len = hash.len() as u32; + let hash_len = crate::buffer_len_to_u32(hash.len())?; let mut res = 0i32; let rc = unsafe { sys::wc_dilithium_verify_ctx_hash( diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs b/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs index 5e6d09bd3d3..4dd639a1c01 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs @@ -85,7 +85,7 @@ impl ECCPoint { return Err(sys::wolfCrypt_ErrorCodes_MEMORY_E); } let eccpoint = ECCPoint { wc_ecc_point, heap }; - let din_size = din.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; let rc = unsafe { sys::wc_ecc_import_point_der(din.as_ptr(), din_size, curve_idx, eccpoint.wc_ecc_point) @@ -143,7 +143,7 @@ impl ECCPoint { return Err(sys::wolfCrypt_ErrorCodes_MEMORY_E); } let eccpoint = ECCPoint { wc_ecc_point, heap }; - let din_size = din.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; let rc = unsafe { sys::wc_ecc_import_point_der_ex(din.as_ptr(), din_size, curve_idx, wc_ecc_point, short_key_size) @@ -190,7 +190,7 @@ impl ECCPoint { if curve_idx < 0 { return Err(curve_idx); } - let mut dout_size = dout.len() as u32; + let mut dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_ecc_export_point_der(curve_idx, self.wc_ecc_point, dout.as_mut_ptr(), &mut dout_size) @@ -235,7 +235,7 @@ impl ECCPoint { if curve_idx < 0 { return Err(curve_idx); } - let mut dout_size = dout.len() as u32; + let mut dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_ecc_export_point_der_ex(curve_idx, self.wc_ecc_point, dout.as_mut_ptr(), &mut dout_size, 1) @@ -632,7 +632,7 @@ impl ECC { let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; let mut ecc = ECC { wc_ecc_key }; let mut idx = 0u32; - let der_size = der.len() as u32; + let der_size = crate::buffer_len_to_u32(der.len())?; let rc = unsafe { sys::wc_EccPrivateKeyDecode(der.as_ptr(), &mut idx, &mut ecc.wc_ecc_key, der_size) }; @@ -695,7 +695,7 @@ impl ECC { let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; let mut ecc = ECC { wc_ecc_key }; let mut idx = 0u32; - let der_size = der.len() as u32; + let der_size = crate::buffer_len_to_u32(der.len())?; let rc = unsafe { sys::wc_EccPublicKeyDecode(der.as_ptr(), &mut idx, &mut ecc.wc_ecc_key, der_size) }; @@ -763,9 +763,9 @@ impl ECC { } let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; let mut ecc = ECC { wc_ecc_key }; - let priv_size = priv_buf.len() as u32; + let priv_size = crate::buffer_len_to_u32(priv_buf.len())?; let pub_ptr = if pub_buf.is_empty() {core::ptr::null()} else {pub_buf.as_ptr()}; - let pub_size = pub_buf.len() as u32; + let pub_size = crate::buffer_len_to_u32(pub_buf.len())?; let rc = unsafe { sys::wc_ecc_import_private_key(priv_buf.as_ptr(), priv_size, pub_ptr, pub_size, &mut ecc.wc_ecc_key) @@ -837,9 +837,9 @@ impl ECC { } let wc_ecc_key = unsafe { wc_ecc_key.assume_init() }; let mut ecc = ECC { wc_ecc_key }; - let priv_size = priv_buf.len() as u32; + let priv_size = crate::buffer_len_to_u32(priv_buf.len())?; let pub_ptr = if pub_buf.is_empty() {core::ptr::null()} else {pub_buf.as_ptr()}; - let pub_size = pub_buf.len() as u32; + let pub_size = crate::buffer_len_to_u32(pub_buf.len())?; let rc = unsafe { sys::wc_ecc_import_private_key_ex(priv_buf.as_ptr(), priv_size, pub_ptr, pub_size, &mut ecc.wc_ecc_key, curve_id) @@ -1067,7 +1067,7 @@ impl ECC { /// ``` #[cfg(ecc_import)] pub fn import_x963(din: &[u8], heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result { - let din_size = din.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; let mut wc_ecc_key: MaybeUninit = MaybeUninit::uninit(); let heap = match heap { Some(heap) => heap, @@ -1130,7 +1130,7 @@ impl ECC { /// ``` #[cfg(ecc_import)] pub fn import_x963_ex(din: &[u8], curve_id: i32, heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result { - let din_size = din.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; let mut wc_ecc_key: MaybeUninit = MaybeUninit::uninit(); let heap = match heap { Some(heap) => heap, @@ -1211,7 +1211,7 @@ impl ECC { /// } /// ``` pub fn rs_hex_to_sig(r: &[u8], s: &[u8], dout: &mut [u8]) -> Result { - let mut dout_size = dout.len() as u32; + let mut dout_size = crate::buffer_len_to_u32(dout.len())?; let r_ptr = r.as_ptr() as *const core::ffi::c_char; let s_ptr = s.as_ptr() as *const core::ffi::c_char; let rc = unsafe { @@ -1268,9 +1268,9 @@ impl ECC { /// } /// ``` pub fn rs_bin_to_sig(r: &[u8], s: &[u8], dout: &mut [u8]) -> Result { - let r_size = r.len() as u32; - let s_size = s.len() as u32; - let mut dout_size = dout.len() as u32; + let r_size = crate::buffer_len_to_u32(r.len())?; + let s_size = crate::buffer_len_to_u32(s.len())?; + let mut dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_ecc_rs_raw_to_sig(r.as_ptr(), r_size, s.as_ptr(), s_size, dout.as_mut_ptr(), &mut dout_size) @@ -1321,9 +1321,9 @@ impl ECC { /// } /// ``` pub fn sig_to_rs(sig: &[u8], r: &mut [u8], r_size: &mut u32, s: &mut [u8], s_size: &mut u32) -> Result<(), i32> { - let sig_len = sig.len() as u32; - *r_size = r.len() as u32; - *s_size = s.len() as u32; + let sig_len = crate::buffer_len_to_u32(sig.len())?; + *r_size = crate::buffer_len_to_u32(r.len())?; + *s_size = crate::buffer_len_to_u32(s.len())?; let rc = unsafe { sys::wc_ecc_sig_to_rs(sig.as_ptr(), sig_len, r.as_mut_ptr(), r_size, s.as_mut_ptr(), s_size) @@ -1399,9 +1399,9 @@ impl ECC { #[cfg(ecc_import)] pub fn export(&mut self, qx: &mut [u8], qx_len: &mut u32, qy: &mut [u8], qy_len: &mut u32, d: &mut [u8], d_len: &mut u32) -> Result<(), i32> { - *qx_len = qx.len() as u32; - *qy_len = qy.len() as u32; - *d_len = d.len() as u32; + *qx_len = crate::buffer_len_to_u32(qx.len())?; + *qy_len = crate::buffer_len_to_u32(qy.len())?; + *d_len = crate::buffer_len_to_u32(d.len())?; let rc = unsafe { sys::wc_ecc_export_private_raw(&mut self.wc_ecc_key, qx.as_mut_ptr(), qx_len, @@ -1456,9 +1456,9 @@ impl ECC { pub fn export_ex(&mut self, qx: &mut [u8], qx_len: &mut u32, qy: &mut [u8], qy_len: &mut u32, d: &mut [u8], d_len: &mut u32, hex: bool) -> Result<(), i32> { - *qx_len = qx.len() as u32; - *qy_len = qy.len() as u32; - *d_len = d.len() as u32; + *qx_len = crate::buffer_len_to_u32(qx.len())?; + *qy_len = crate::buffer_len_to_u32(qy.len())?; + *d_len = crate::buffer_len_to_u32(d.len())?; let enc_type = if hex { sys::WC_TYPE_HEX_STR as i32 @@ -1505,7 +1505,7 @@ impl ECC { /// ``` #[cfg(ecc_export)] pub fn export_private(&mut self, d: &mut [u8]) -> Result { - let mut d_size = d.len() as u32; + let mut d_size = crate::buffer_len_to_u32(d.len())?; let rc = unsafe { sys::wc_ecc_export_private_only(&mut self.wc_ecc_key, d.as_mut_ptr(), &mut d_size) @@ -1549,8 +1549,8 @@ impl ECC { #[cfg(ecc_export)] pub fn export_public(&mut self, qx: &mut [u8], qx_len: &mut u32, qy: &mut [u8], qy_len: &mut u32) -> Result<(), i32> { - *qx_len = qx.len() as u32; - *qy_len = qy.len() as u32; + *qx_len = crate::buffer_len_to_u32(qx.len())?; + *qy_len = crate::buffer_len_to_u32(qy.len())?; let rc = unsafe { sys::wc_ecc_export_public_raw(&mut self.wc_ecc_key, qx.as_mut_ptr(), qx_len, @@ -1588,7 +1588,7 @@ impl ECC { /// ``` #[cfg(ecc_export)] pub fn export_x963(&mut self, dout: &mut [u8]) -> Result { - let mut out_len: u32 = dout.len() as u32; + let mut out_len = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_ecc_export_x963(&mut self.wc_ecc_key, dout.as_mut_ptr(), &mut out_len) }; @@ -1624,7 +1624,7 @@ impl ECC { /// ``` #[cfg(all(ecc_export, ecc_comp_key))] pub fn export_x963_compressed(&mut self, dout: &mut [u8]) -> Result { - let mut out_len: u32 = dout.len() as u32; + let mut out_len = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_ecc_export_x963_ex(&mut self.wc_ecc_key, dout.as_mut_ptr(), &mut out_len, 1) }; @@ -1807,7 +1807,7 @@ impl ECC { /// ``` #[cfg(ecc_dh)] pub fn shared_secret(&mut self, peer_key: &mut ECC, dout: &mut [u8]) -> Result { - let mut out_len = dout.len() as u32; + let mut out_len = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_ecc_shared_secret(&mut self.wc_ecc_key, &mut peer_key.wc_ecc_key, dout.as_mut_ptr(), &mut out_len) @@ -1857,7 +1857,7 @@ impl ECC { /// ``` #[cfg(ecc_dh)] pub fn shared_secret_ex(&mut self, peer: &ECCPoint, dout: &mut [u8]) -> Result { - let mut out_len = dout.len() as u32; + let mut out_len = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_ecc_shared_secret_ex(&mut self.wc_ecc_key, peer.wc_ecc_point, dout.as_mut_ptr(), &mut out_len) @@ -1900,8 +1900,8 @@ impl ECC { /// ``` #[cfg(all(ecc_sign, random))] pub fn sign_hash(&mut self, din: &[u8], dout: &mut [u8], rng: &mut RNG) -> Result { - let din_size = din.len() as u32; - let mut dout_size = dout.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; + let mut dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_ecc_sign_hash(din.as_ptr(), din_size, dout.as_mut_ptr(), &mut dout_size, &mut rng.wc_rng, &mut self.wc_ecc_key) @@ -1944,8 +1944,8 @@ impl ECC { #[cfg(ecc_verify)] pub fn verify_hash(&mut self, sig: &[u8], hash: &[u8]) -> Result { let mut res: i32 = 0; - let sig_len = sig.len() as u32; - let hash_len = hash.len() as u32; + let sig_len = crate::buffer_len_to_u32(sig.len())?; + let hash_len = crate::buffer_len_to_u32(hash.len())?; let rc = unsafe { sys::wc_ecc_verify_hash(sig.as_ptr(), sig_len, hash.as_ptr(), hash_len, &mut res, &mut self.wc_ecc_key) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs b/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs index 21f30f6e5c8..e6af212e4d7 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs @@ -242,8 +242,8 @@ impl Ed25519 { /// ``` #[cfg(ed25519_export)] pub fn export_key(&self, private: &mut [u8], public: &mut [u8]) -> Result<(), i32> { - let mut private_size = private.len() as u32; - let mut public_size = public.len() as u32; + let mut private_size = crate::buffer_len_to_u32(private.len())?; + let mut public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_ed25519_export_key(&self.ws_key, private.as_mut_ptr(), &mut private_size, @@ -283,7 +283,7 @@ impl Ed25519 { /// ``` #[cfg(ed25519_export)] pub fn export_public(&self, public: &mut [u8]) -> Result<(), i32> { - let mut public_size = public.len() as u32; + let mut public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_ed25519_export_public(&self.ws_key, public.as_mut_ptr(), &mut public_size) @@ -322,7 +322,7 @@ impl Ed25519 { /// ``` #[cfg(ed25519_export)] pub fn export_private(&self, keyout: &mut [u8]) -> Result<(), i32> { - let mut keyout_size = keyout.len() as u32; + let mut keyout_size = crate::buffer_len_to_u32(keyout.len())?; let rc = unsafe { sys::wc_ed25519_export_private(&self.ws_key, keyout.as_mut_ptr(), &mut keyout_size) @@ -361,7 +361,7 @@ impl Ed25519 { /// ``` #[cfg(ed25519_export)] pub fn export_private_only(&self, private: &mut [u8]) -> Result<(), i32> { - let mut private_size = private.len() as u32; + let mut private_size = crate::buffer_len_to_u32(private.len())?; let rc = unsafe { sys::wc_ed25519_export_private_only(&self.ws_key, private.as_mut_ptr(), &mut private_size) @@ -405,7 +405,7 @@ impl Ed25519 { /// ``` #[cfg(ed25519_import)] pub fn import_public(&mut self, public: &[u8]) -> Result<(), i32> { - let public_size = public.len() as u32; + let public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_ed25519_import_public(public.as_ptr(), public_size, &mut self.ws_key) }; @@ -449,7 +449,7 @@ impl Ed25519 { /// ``` #[cfg(ed25519_import)] pub fn import_public_ex(&mut self, public: &[u8], trusted: bool) -> Result<(), i32> { - let public_size = public.len() as u32; + let public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_ed25519_import_public_ex(public.as_ptr(), public_size, &mut self.ws_key, if trusted {1} else {0}) @@ -488,7 +488,7 @@ impl Ed25519 { /// ``` #[cfg(ed25519_import)] pub fn import_private_only(&mut self, private: &[u8]) -> Result<(), i32> { - let private_size = private.len() as u32; + let private_size = crate::buffer_len_to_u32(private.len())?; let rc = unsafe { sys::wc_ed25519_import_private_only(private.as_ptr(), private_size, &mut self.ws_key) @@ -533,12 +533,12 @@ impl Ed25519 { /// ``` #[cfg(ed25519_import)] pub fn import_private_key(&mut self, private: &[u8], public: Option<&[u8]>) -> Result<(), i32> { - let private_size = private.len() as u32; + let private_size = crate::buffer_len_to_u32(private.len())?; let mut public_ptr: *const u8 = core::ptr::null(); let mut public_size = 0u32; if let Some(public) = public { public_ptr = public.as_ptr(); - public_size = public.len() as u32; + public_size = crate::buffer_len_to_u32(public.len())?; } let rc = unsafe { sys::wc_ed25519_import_private_key(private.as_ptr(), private_size, @@ -584,12 +584,12 @@ impl Ed25519 { /// ``` #[cfg(ed25519_import)] pub fn import_private_key_ex(&mut self, private: &[u8], public: Option<&[u8]>, trusted: bool) -> Result<(), i32> { - let private_size = private.len() as u32; + let private_size = crate::buffer_len_to_u32(private.len())?; let mut public_ptr: *const u8 = core::ptr::null(); let mut public_size = 0u32; if let Some(public) = public { public_ptr = public.as_ptr(); - public_size = public.len() as u32; + public_size = crate::buffer_len_to_u32(public.len())?; } let rc = unsafe { sys::wc_ed25519_import_private_key_ex(private.as_ptr(), private_size, @@ -630,7 +630,7 @@ impl Ed25519 { /// ed.make_public(&mut public).expect("Error with make_public()"); /// ``` pub fn make_public(&mut self, pubkey: &mut [u8]) -> Result<(), i32> { - let pubkey_size = pubkey.len() as u32; + let pubkey_size = crate::buffer_len_to_u32(pubkey.len())?; let rc = unsafe { sys::wc_ed25519_make_public(&mut self.ws_key, pubkey.as_mut_ptr(), pubkey_size) @@ -670,8 +670,8 @@ impl Ed25519 { /// ``` #[cfg(ed25519_sign)] pub fn sign_msg(&mut self, message: &[u8], signature: &mut [u8]) -> Result { - let message_size = message.len() as u32; - let mut signature_size = signature.len() as u32; + let message_size = crate::buffer_len_to_u32(message.len())?; + let mut signature_size = crate::buffer_len_to_u32(signature.len())?; let rc = unsafe { sys::wc_ed25519_sign_msg(message.as_ptr(), message_size, signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key) @@ -715,12 +715,12 @@ impl Ed25519 { /// ``` #[cfg(ed25519_sign)] pub fn sign_msg_ctx(&mut self, message: &[u8], context: &[u8], signature: &mut [u8]) -> Result { - let message_size = message.len() as u32; + let message_size = crate::buffer_len_to_u32(message.len())?; if context.len() > 255 { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let context_size = context.len() as u8; - let mut signature_size = signature.len() as u32; + let mut signature_size = crate::buffer_len_to_u32(signature.len())?; let rc = unsafe { sys::wc_ed25519ctx_sign_msg(message.as_ptr(), message_size, signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key, @@ -775,7 +775,7 @@ impl Ed25519 { /// ``` #[cfg(ed25519_sign)] pub fn sign_hash_ph(&mut self, hash: &[u8], context: Option<&[u8]>, signature: &mut [u8]) -> Result { - let hash_size = hash.len() as u32; + let hash_size = crate::buffer_len_to_u32(hash.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -785,7 +785,7 @@ impl Ed25519 { } context_size = context.len() as u8; } - let mut signature_size = signature.len() as u32; + let mut signature_size = crate::buffer_len_to_u32(signature.len())?; let rc = unsafe { sys::wc_ed25519ph_sign_hash(hash.as_ptr(), hash_size, signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key, @@ -831,7 +831,7 @@ impl Ed25519 { /// ``` #[cfg(ed25519_sign)] pub fn sign_msg_ph(&mut self, message: &[u8], context: Option<&[u8]>, signature: &mut [u8]) -> Result { - let message_size = message.len() as u32; + let message_size = crate::buffer_len_to_u32(message.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -841,7 +841,7 @@ impl Ed25519 { } context_size = context.len() as u8; } - let mut signature_size = signature.len() as u32; + let mut signature_size = crate::buffer_len_to_u32(signature.len())?; let rc = unsafe { sys::wc_ed25519ph_sign_msg(message.as_ptr(), message_size, signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key, @@ -887,7 +887,7 @@ impl Ed25519 { /// ``` #[cfg(ed25519_sign)] pub fn sign_msg_ex(&mut self, din: &[u8], context: Option<&[u8]>, typ: u8, signature: &mut [u8]) -> Result { - let din_size = din.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -897,7 +897,7 @@ impl Ed25519 { } context_size = context.len() as u8; } - let mut signature_size = signature.len() as u32; + let mut signature_size = crate::buffer_len_to_u32(signature.len())?; let rc = unsafe { sys::wc_ed25519_sign_msg_ex(din.as_ptr(), din_size, signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key, @@ -939,8 +939,8 @@ impl Ed25519 { /// ``` #[cfg(ed25519_verify)] pub fn verify_msg(&mut self, signature: &[u8], message: &[u8]) -> Result { - let signature_size = signature.len() as u32; - let message_size = message.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; + let message_size = crate::buffer_len_to_u32(message.len())?; let mut res = 0i32; let rc = unsafe { sys::wc_ed25519_verify_msg(signature.as_ptr(), signature_size, @@ -986,8 +986,8 @@ impl Ed25519 { /// ``` #[cfg(ed25519_verify)] pub fn verify_msg_ctx(&mut self, signature: &[u8], message: &[u8], context: &[u8]) -> Result { - let signature_size = signature.len() as u32; - let message_size = message.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; + let message_size = crate::buffer_len_to_u32(message.len())?; if context.len() > 255 { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } @@ -1049,8 +1049,8 @@ impl Ed25519 { /// ``` #[cfg(ed25519_verify)] pub fn verify_hash_ph(&mut self, signature: &[u8], hash: &[u8], context: Option<&[u8]>) -> Result { - let signature_size = signature.len() as u32; - let hash_size = hash.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; + let hash_size = crate::buffer_len_to_u32(hash.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -1107,8 +1107,8 @@ impl Ed25519 { /// ``` #[cfg(ed25519_verify)] pub fn verify_msg_ph(&mut self, signature: &[u8], message: &[u8], context: Option<&[u8]>) -> Result { - let signature_size = signature.len() as u32; - let message_size = message.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; + let message_size = crate::buffer_len_to_u32(message.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -1165,8 +1165,8 @@ impl Ed25519 { /// ``` #[cfg(ed25519_verify)] pub fn verify_msg_ex(&mut self, signature: &[u8], din: &[u8], context: Option<&[u8]>, typ: u8) -> Result { - let signature_size = signature.len() as u32; - let din_size = din.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; + let din_size = crate::buffer_len_to_u32(din.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -1222,7 +1222,7 @@ impl Ed25519 { /// ``` #[cfg(ed25519_streaming_verify)] pub fn verify_msg_init(&mut self, signature: &[u8], context: Option<&[u8]>, typ: u8) -> Result<(), i32> { - let signature_size = signature.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -1274,7 +1274,7 @@ impl Ed25519 { /// ``` #[cfg(ed25519_streaming_verify)] pub fn verify_msg_update(&mut self, din: &[u8]) -> Result<(), i32> { - let din_size = din.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; let rc = unsafe { sys::wc_ed25519_verify_msg_update(din.as_ptr(), din_size, &mut self.ws_key) @@ -1317,7 +1317,7 @@ impl Ed25519 { /// ``` #[cfg(ed25519_streaming_verify)] pub fn verify_msg_final(&mut self, signature: &[u8]) -> Result { - let signature_size = signature.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; let mut res = 0i32; let rc = unsafe { sys::wc_ed25519_verify_msg_final(signature.as_ptr(), signature_size, diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs b/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs index a4425bb945c..851f963f08e 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs @@ -241,8 +241,8 @@ impl Ed448 { /// ``` #[cfg(ed448_export)] pub fn export_key(&self, private: &mut [u8], public: &mut [u8]) -> Result<(), i32> { - let mut private_size = private.len() as u32; - let mut public_size = public.len() as u32; + let mut private_size = crate::buffer_len_to_u32(private.len())?; + let mut public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_ed448_export_key(&self.ws_key, private.as_mut_ptr(), &mut private_size, @@ -281,7 +281,7 @@ impl Ed448 { /// ``` #[cfg(ed448_export)] pub fn export_public(&self, public: &mut [u8]) -> Result<(), i32> { - let mut public_size = public.len() as u32; + let mut public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_ed448_export_public(&self.ws_key, public.as_mut_ptr(), &mut public_size) @@ -319,7 +319,7 @@ impl Ed448 { /// ``` #[cfg(ed448_export)] pub fn export_private(&self, keyout: &mut [u8]) -> Result<(), i32> { - let mut keyout_size = keyout.len() as u32; + let mut keyout_size = crate::buffer_len_to_u32(keyout.len())?; let rc = unsafe { sys::wc_ed448_export_private(&self.ws_key, keyout.as_mut_ptr(), &mut keyout_size) @@ -357,7 +357,7 @@ impl Ed448 { /// ``` #[cfg(ed448_export)] pub fn export_private_only(&self, private: &mut [u8]) -> Result<(), i32> { - let mut private_size = private.len() as u32; + let mut private_size = crate::buffer_len_to_u32(private.len())?; let rc = unsafe { sys::wc_ed448_export_private_only(&self.ws_key, private.as_mut_ptr(), &mut private_size) @@ -401,7 +401,7 @@ impl Ed448 { /// ``` #[cfg(ed448_import)] pub fn import_public(&mut self, public: &[u8]) -> Result<(), i32> { - let public_size = public.len() as u32; + let public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_ed448_import_public(public.as_ptr(), public_size, &mut self.ws_key) }; @@ -445,7 +445,7 @@ impl Ed448 { /// ``` #[cfg(ed448_import)] pub fn import_public_ex(&mut self, public: &[u8], trusted: bool) -> Result<(), i32> { - let public_size = public.len() as u32; + let public_size = crate::buffer_len_to_u32(public.len())?; let rc = unsafe { sys::wc_ed448_import_public_ex(public.as_ptr(), public_size, &mut self.ws_key, if trusted {1} else {0}) @@ -484,7 +484,7 @@ impl Ed448 { /// ``` #[cfg(ed448_import)] pub fn import_private_only(&mut self, private: &[u8]) -> Result<(), i32> { - let private_size = private.len() as u32; + let private_size = crate::buffer_len_to_u32(private.len())?; let rc = unsafe { sys::wc_ed448_import_private_only(private.as_ptr(), private_size, &mut self.ws_key) @@ -529,12 +529,12 @@ impl Ed448 { /// ``` #[cfg(ed448_import)] pub fn import_private_key(&mut self, private: &[u8], public: Option<&[u8]>) -> Result<(), i32> { - let private_size = private.len() as u32; + let private_size = crate::buffer_len_to_u32(private.len())?; let mut public_ptr: *const u8 = core::ptr::null(); let mut public_size = 0u32; if let Some(public) = public { public_ptr = public.as_ptr(); - public_size = public.len() as u32; + public_size = crate::buffer_len_to_u32(public.len())?; } let rc = unsafe { sys::wc_ed448_import_private_key(private.as_ptr(), private_size, @@ -580,12 +580,12 @@ impl Ed448 { /// ``` #[cfg(ed448_import)] pub fn import_private_key_ex(&mut self, private: &[u8], public: Option<&[u8]>, trusted: bool) -> Result<(), i32> { - let private_size = private.len() as u32; + let private_size = crate::buffer_len_to_u32(private.len())?; let mut public_ptr: *const u8 = core::ptr::null(); let mut public_size = 0u32; if let Some(public) = public { public_ptr = public.as_ptr(); - public_size = public.len() as u32; + public_size = crate::buffer_len_to_u32(public.len())?; } let rc = unsafe { sys::wc_ed448_import_private_key_ex(private.as_ptr(), private_size, @@ -626,7 +626,7 @@ impl Ed448 { /// ed.make_public(&mut public).expect("Error with make_public()"); /// ``` pub fn make_public(&mut self, pubkey: &mut [u8]) -> Result<(), i32> { - let pubkey_size = pubkey.len() as u32; + let pubkey_size = crate::buffer_len_to_u32(pubkey.len())?; let rc = unsafe { sys::wc_ed448_make_public(&mut self.ws_key, pubkey.as_mut_ptr(), pubkey_size) @@ -670,7 +670,7 @@ impl Ed448 { /// ``` #[cfg(ed448_sign)] pub fn sign_msg(&mut self, message: &[u8], context: Option<&[u8]>, signature: &mut [u8]) -> Result { - let message_size = message.len() as u32; + let message_size = crate::buffer_len_to_u32(message.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -680,7 +680,7 @@ impl Ed448 { } context_size = context.len() as u8; } - let mut signature_size = signature.len() as u32; + let mut signature_size = crate::buffer_len_to_u32(signature.len())?; let rc = unsafe { sys::wc_ed448_sign_msg(message.as_ptr(), message_size, signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key, @@ -735,7 +735,7 @@ impl Ed448 { /// ``` #[cfg(ed448_sign)] pub fn sign_hash_ph(&mut self, hash: &[u8], context: Option<&[u8]>, signature: &mut [u8]) -> Result { - let hash_size = hash.len() as u32; + let hash_size = crate::buffer_len_to_u32(hash.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -745,7 +745,7 @@ impl Ed448 { } context_size = context.len() as u8; } - let mut signature_size = signature.len() as u32; + let mut signature_size = crate::buffer_len_to_u32(signature.len())?; let rc = unsafe { sys::wc_ed448ph_sign_hash(hash.as_ptr(), hash_size, signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key, @@ -791,7 +791,7 @@ impl Ed448 { /// ``` #[cfg(ed448_sign)] pub fn sign_msg_ph(&mut self, message: &[u8], context: Option<&[u8]>, signature: &mut [u8]) -> Result { - let message_size = message.len() as u32; + let message_size = crate::buffer_len_to_u32(message.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -801,7 +801,7 @@ impl Ed448 { } context_size = context.len() as u8; } - let mut signature_size = signature.len() as u32; + let mut signature_size = crate::buffer_len_to_u32(signature.len())?; let rc = unsafe { sys::wc_ed448ph_sign_msg(message.as_ptr(), message_size, signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key, @@ -847,7 +847,7 @@ impl Ed448 { /// ``` #[cfg(ed448_sign)] pub fn sign_msg_ex(&mut self, din: &[u8], context: Option<&[u8]>, typ: u8, signature: &mut [u8]) -> Result { - let din_size = din.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -857,7 +857,7 @@ impl Ed448 { } context_size = context.len() as u8; } - let mut signature_size = signature.len() as u32; + let mut signature_size = crate::buffer_len_to_u32(signature.len())?; let rc = unsafe { sys::wc_ed448_sign_msg_ex(din.as_ptr(), din_size, signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key, @@ -903,8 +903,8 @@ impl Ed448 { /// ``` #[cfg(ed448_verify)] pub fn verify_msg(&mut self, signature: &[u8], message: &[u8], context: Option<&[u8]>) -> Result { - let signature_size = signature.len() as u32; - let message_size = message.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; + let message_size = crate::buffer_len_to_u32(message.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -971,8 +971,8 @@ impl Ed448 { /// ``` #[cfg(ed448_verify)] pub fn verify_hash_ph(&mut self, signature: &[u8], hash: &[u8], context: Option<&[u8]>) -> Result { - let signature_size = signature.len() as u32; - let hash_size = hash.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; + let hash_size = crate::buffer_len_to_u32(hash.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -1029,8 +1029,8 @@ impl Ed448 { /// ``` #[cfg(ed448_verify)] pub fn verify_msg_ph(&mut self, signature: &[u8], message: &[u8], context: Option<&[u8]>) -> Result { - let signature_size = signature.len() as u32; - let message_size = message.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; + let message_size = crate::buffer_len_to_u32(message.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -1087,8 +1087,8 @@ impl Ed448 { /// ``` #[cfg(ed448_verify)] pub fn verify_msg_ex(&mut self, signature: &[u8], din: &[u8], context: Option<&[u8]>, typ: u8) -> Result { - let signature_size = signature.len() as u32; - let din_size = din.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; + let din_size = crate::buffer_len_to_u32(din.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -1145,7 +1145,7 @@ impl Ed448 { /// ``` #[cfg(ed448_streaming_verify)] pub fn verify_msg_init(&mut self, signature: &[u8], context: Option<&[u8]>, typ: u8) -> Result<(), i32> { - let signature_size = signature.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; let mut context_ptr: *const u8 = core::ptr::null(); let mut context_size = 0u8; if let Some(context) = context { @@ -1198,7 +1198,7 @@ impl Ed448 { /// ``` #[cfg(ed448_streaming_verify)] pub fn verify_msg_update(&mut self, din: &[u8]) -> Result<(), i32> { - let din_size = din.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; let rc = unsafe { sys::wc_ed448_verify_msg_update(din.as_ptr(), din_size, &mut self.ws_key) @@ -1242,7 +1242,7 @@ impl Ed448 { /// ``` #[cfg(ed448_streaming_verify)] pub fn verify_msg_final(&mut self, signature: &[u8]) -> Result { - let signature_size = signature.len() as u32; + let signature_size = crate::buffer_len_to_u32(signature.len())?; let mut res = 0i32; let rc = unsafe { sys::wc_ed448_verify_msg_final(signature.as_ptr(), signature_size, diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/hkdf.rs b/wrapper/rust/wolfssl-wolfcrypt/src/hkdf.rs index b1d26ec2551..ecccbf0f656 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/hkdf.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/hkdf.rs @@ -97,9 +97,9 @@ pub fn hkdf_extract_ex(typ: i32, salt: Option<&[u8]>, key: &[u8], out: &mut [u8] let mut salt_size = 0u32; if let Some(salt) = salt { salt_ptr = salt.as_ptr(); - salt_size = salt.len() as u32; + salt_size = crate::buffer_len_to_u32(salt.len())?; } - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; if out.len() != HMAC::get_hmac_size_by_type(typ)? { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } @@ -192,14 +192,14 @@ pub fn hkdf_expand(typ: i32, key: &[u8], info: Option<&[u8]>, out: &mut [u8]) -> /// hkdf_expand_ex(HMAC::TYPE_SHA256, &extract_out, Some(info), &mut expand_out, None, None).expect("Error with hkdf_expand_ex()"); /// ``` pub fn hkdf_expand_ex(typ: i32, key: &[u8], info: Option<&[u8]>, out: &mut [u8], heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result<(), i32> { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; let mut info_ptr = core::ptr::null(); let mut info_size = 0u32; if let Some(info) = info { info_ptr = info.as_ptr(); - info_size = info.len() as u32; + info_size = crate::buffer_len_to_u32(info.len())?; } - let out_size = out.len() as u32; + let out_size = crate::buffer_len_to_u32(out.len())?; let heap = match heap { Some(heap) => heap, None => core::ptr::null_mut(), @@ -250,20 +250,20 @@ pub fn hkdf_expand_ex(typ: i32, key: &[u8], info: Option<&[u8]>, out: &mut [u8], /// hkdf(HMAC::TYPE_SHA256, ikm, Some(salt), Some(info), &mut out).expect("Error with hkdf()"); /// ``` pub fn hkdf(typ: i32, key: &[u8], salt: Option<&[u8]>, info: Option<&[u8]>, out: &mut[u8]) -> Result<(), i32> { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; let mut salt_ptr = core::ptr::null(); let mut salt_size = 0u32; if let Some(salt) = salt { salt_ptr = salt.as_ptr(); - salt_size = salt.len() as u32; + salt_size = crate::buffer_len_to_u32(salt.len())?; } let mut info_ptr = core::ptr::null(); let mut info_size = 0u32; if let Some(info) = info { info_ptr = info.as_ptr(); - info_size = info.len() as u32; + info_size = crate::buffer_len_to_u32(info.len())?; } - let out_size = out.len() as u32; + let out_size = crate::buffer_len_to_u32(out.len())?; let rc = unsafe { sys::wc_HKDF(typ, key.as_ptr(), key_size, salt_ptr, salt_size, info_ptr, info_size, out.as_mut_ptr(), out_size) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs b/wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs index 24e53089fef..62e75d047e8 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs @@ -113,7 +113,7 @@ impl HMAC { /// let mut hmac = HMAC::new_ex(HMAC::TYPE_SHA256, &key, None, None).expect("Error with new_ex()"); /// ``` pub fn new_ex(typ: i32, key: &[u8], heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; let mut wc_hmac: MaybeUninit = MaybeUninit::uninit(); let heap = match heap { Some(heap) => heap, @@ -191,7 +191,7 @@ impl HMAC { /// ``` #[cfg(hmac_setkey_ex)] pub fn new_allow_short_key_ex(typ: i32, key: &[u8], heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result { - let key_size = key.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; let mut wc_hmac: MaybeUninit = MaybeUninit::uninit(); let heap = match heap { Some(heap) => heap, @@ -241,7 +241,7 @@ impl HMAC { /// hmac.update(b"input").expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_HmacUpdate(&mut self.wc_hmac, data.as_ptr(), data_size) }; diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs b/wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs index 4fdecb7e6b5..9d2ae3c53a1 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs @@ -126,9 +126,9 @@ pub fn pbkdf2(password: &[u8], salt: &[u8], iterations: i32, typ: i32, out: &mut /// ``` #[cfg(kdf_pbkdf2)] pub fn pbkdf2_ex(password: &[u8], salt: &[u8], iterations: i32, typ: i32, heap: Option<*mut core::ffi::c_void>, dev_id: Option, out: &mut [u8]) -> Result<(), i32> { - let password_size = password.len() as i32; - let salt_size = salt.len() as i32; - let out_size = out.len() as i32; + let password_size = crate::buffer_len_to_i32(password.len())?; + let salt_size = crate::buffer_len_to_i32(salt.len())?; + let out_size = crate::buffer_len_to_i32(out.len())?; let heap = match heap { Some(heap) => heap, None => core::ptr::null_mut(), @@ -248,9 +248,9 @@ pub fn pkcs12_pbkdf(password: &[u8], salt: &[u8], iterations: i32, typ: i32, id: /// ``` #[cfg(kdf_pkcs12)] pub fn pkcs12_pbkdf_ex(password: &[u8], salt: &[u8], iterations: i32, typ: i32, id: i32, heap: Option<*mut core::ffi::c_void>, out: &mut [u8]) -> Result<(), i32> { - let password_size = password.len() as i32; - let salt_size = salt.len() as i32; - let out_size = out.len() as i32; + let password_size = crate::buffer_len_to_i32(password.len())?; + let salt_size = crate::buffer_len_to_i32(salt.len())?; + let out_size = crate::buffer_len_to_i32(out.len())?; let heap = match heap { Some(heap) => heap, None => core::ptr::null_mut(), @@ -335,14 +335,14 @@ pub fn tls13_hkdf_extract_ex(typ: i32, salt: Option<&[u8]>, key: Option<&mut [u8 let mut salt_size = 0u32; if let Some(salt) = salt { salt_ptr = salt.as_ptr(); - salt_size = salt.len() as u32; + salt_size = crate::buffer_len_to_u32(salt.len())?; } let mut ikm_buf = [0u8; sys::WC_MAX_DIGEST_SIZE as usize]; let mut ikm_ptr = ikm_buf.as_mut_ptr(); let mut ikm_size = 0u32; if let Some(key) = key && !key.is_empty() { ikm_ptr = key.as_mut_ptr(); - ikm_size = key.len() as u32; + ikm_size = crate::buffer_len_to_u32(key.len())?; } if out.len() != HMAC::get_hmac_size_by_type(typ)? { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); @@ -474,11 +474,11 @@ pub fn tls13_hkdf_expand_label(typ: i32, key: &[u8], protocol: &[u8], label: &[u #[cfg(all(hmac, kdf_tls13))] #[allow(clippy::too_many_arguments)] pub fn tls13_hkdf_expand_label_ex(typ: i32, key: &[u8], protocol: &[u8], label: &[u8], info: &[u8], out: &mut [u8], heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result<(), i32> { - let key_size = key.len() as u32; - let protocol_size = protocol.len() as u32; - let label_size = label.len() as u32; - let info_size = info.len() as u32; - let out_size = out.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; + let protocol_size = crate::buffer_len_to_u32(protocol.len())?; + let label_size = crate::buffer_len_to_u32(label.len())?; + let info_size = crate::buffer_len_to_u32(info.len())?; + let out_size = crate::buffer_len_to_u32(out.len())?; let heap = match heap { Some(heap) => heap, None => core::ptr::null_mut(), @@ -531,10 +531,10 @@ pub fn tls13_hkdf_expand_label_ex(typ: i32, key: &[u8], protocol: &[u8], label: /// ``` #[cfg(kdf_ssh)] pub fn ssh_kdf(typ: i32, key_id: u8, k: &[u8], h: &[u8], session_id: &[u8], key: &mut [u8]) -> Result<(), i32> { - let key_size = key.len() as u32; - let k_size = k.len() as u32; - let h_size = h.len() as u32; - let session_size = session_id.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; + let k_size = crate::buffer_len_to_u32(k.len())?; + let h_size = crate::buffer_len_to_u32(h.len())?; + let session_size = crate::buffer_len_to_u32(session_id.len())?; let rc = unsafe { sys::wc_SSH_KDF(typ as u8, key_id, key.as_mut_ptr(), key_size, @@ -589,11 +589,11 @@ pub fn srtp_kdf(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], // will be read from the idx slice. return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } - let key_size = key.len() as u32; - let salt_size = salt.len() as u32; - let key1_size = key1.len() as u32; - let key2_size = key2.len() as u32; - let key3_size = key3.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; + let salt_size = crate::buffer_len_to_u32(salt.len())?; + let key1_size = crate::buffer_len_to_u32(key1.len())?; + let key2_size = crate::buffer_len_to_u32(key2.len())?; + let key3_size = crate::buffer_len_to_u32(key3.len())?; let rc = unsafe { sys::wc_SRTP_KDF(key.as_ptr(), key_size, salt.as_ptr(), salt_size, kdr_index, idx.as_ptr(), key1.as_mut_ptr(), key1_size, @@ -639,9 +639,9 @@ pub fn srtp_kdf(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], #[cfg(kdf_srtp)] pub fn srtp_kdf_label(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], label: u8, keyout: &mut [u8]) -> Result<(), i32> { - let key_size = key.len() as u32; - let salt_size = salt.len() as u32; - let keyout_size = keyout.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; + let salt_size = crate::buffer_len_to_u32(salt.len())?; + let keyout_size = crate::buffer_len_to_u32(keyout.len())?; let rc = unsafe { sys::wc_SRTP_KDF_label(key.as_ptr(), key_size, salt.as_ptr(), salt_size, kdr_index, idx.as_ptr(), label, keyout.as_mut_ptr(), keyout_size) @@ -694,11 +694,11 @@ pub fn srtcp_kdf(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], // will be read from the idx slice. return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } - let key_size = key.len() as u32; - let salt_size = salt.len() as u32; - let key1_size = key1.len() as u32; - let key2_size = key2.len() as u32; - let key3_size = key3.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; + let salt_size = crate::buffer_len_to_u32(salt.len())?; + let key1_size = crate::buffer_len_to_u32(key1.len())?; + let key2_size = crate::buffer_len_to_u32(key2.len())?; + let key3_size = crate::buffer_len_to_u32(key3.len())?; let rc = unsafe { sys::wc_SRTCP_KDF(key.as_ptr(), key_size, salt.as_ptr(), salt_size, kdr_index, idx.as_ptr(), key1.as_mut_ptr(), key1_size, @@ -744,9 +744,9 @@ pub fn srtcp_kdf(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], #[cfg(kdf_srtp)] pub fn srtcp_kdf_label(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], label: u8, keyout: &mut [u8]) -> Result<(), i32> { - let key_size = key.len() as u32; - let salt_size = salt.len() as u32; - let keyout_size = keyout.len() as u32; + let key_size = crate::buffer_len_to_u32(key.len())?; + let salt_size = crate::buffer_len_to_u32(salt.len())?; + let keyout_size = crate::buffer_len_to_u32(keyout.len())?; let rc = unsafe { sys::wc_SRTCP_KDF_label(key.as_ptr(), key_size, salt.as_ptr(), salt_size, kdr_index, idx.as_ptr(), label, keyout.as_mut_ptr(), keyout_size) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/lib.rs b/wrapper/rust/wolfssl-wolfcrypt/src/lib.rs index 7f1d1e3f96c..fff3be2e145 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/lib.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/lib.rs @@ -44,6 +44,16 @@ pub mod random; pub mod rsa; pub mod sha; +/// Convert a buffer length to `u32`, returning `BUFFER_E` if it overflows. +pub(crate) fn buffer_len_to_u32(len: usize) -> Result { + u32::try_from(len).map_err(|_| sys::wolfCrypt_ErrorCodes_BUFFER_E) +} + +/// Convert a buffer length to `i32`, returning `BUFFER_E` if it overflows. +pub(crate) fn buffer_len_to_i32(len: usize) -> Result { + i32::try_from(len).map_err(|_| sys::wolfCrypt_ErrorCodes_BUFFER_E) +} + /// Initialize resources used by wolfCrypt. /// /// # Returns diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs b/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs index dd12c2409e9..61665079c67 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs @@ -528,14 +528,15 @@ impl Lms { if sig.len() < expected_sig_len { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } - let mut sig_sz = sig.len() as u32; + let mut sig_sz = crate::buffer_len_to_u32(sig.len())?; + let msg_sz = crate::buffer_len_to_i32(msg.len())?; let rc = unsafe { sys::wc_LmsKey_Sign( &mut self.ws_key, sig.as_mut_ptr(), &mut sig_sz, msg.as_ptr(), - msg.len() as core::ffi::c_int, + msg_sz, ) }; if rc != 0 { @@ -670,7 +671,7 @@ impl Lms { /// } /// ``` pub fn export_pub_raw(&self, out: &mut [u8]) -> Result { - let mut out_len = out.len() as u32; + let mut out_len = crate::buffer_len_to_u32(out.len())?; let rc = unsafe { sys::wc_LmsKey_ExportPubRaw(&self.ws_key, out.as_mut_ptr(), &mut out_len) }; @@ -704,8 +705,9 @@ impl Lms { /// key.import_pub_raw(&pub_buf).expect("Error with import_pub_raw()"); /// ``` pub fn import_pub_raw(&mut self, data: &[u8]) -> Result<(), i32> { + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { - sys::wc_LmsKey_ImportPubRaw(&mut self.ws_key, data.as_ptr(), data.len() as u32) + sys::wc_LmsKey_ImportPubRaw(&mut self.ws_key, data.as_ptr(), data_size) }; if rc != 0 { return Err(rc); @@ -735,13 +737,15 @@ impl Lms { if sig.len() != expected_sig_len { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } + let sig_sz = crate::buffer_len_to_u32(sig.len())?; + let msg_sz = crate::buffer_len_to_i32(msg.len())?; let rc = unsafe { sys::wc_LmsKey_Verify( &mut self.ws_key, sig.as_ptr(), - sig.len() as u32, + sig_sz, msg.as_ptr(), - msg.len() as core::ffi::c_int, + msg_sz, ) }; if rc != 0 { diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs b/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs index c2615dffb0f..f07f55f7a1a 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs @@ -608,12 +608,13 @@ impl MlKem { if ss.len() != Self::SHARED_SECRET_SIZE { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } + let ct_size = crate::buffer_len_to_u32(ct.len())?; let rc = unsafe { sys::wc_MlKemKey_Decapsulate( self.ws_key, ss.as_mut_ptr(), ct.as_ptr(), - ct.len() as u32, + ct_size, ) }; if rc != 0 { @@ -653,8 +654,9 @@ impl MlKem { /// } /// ``` pub fn encode_public_key(&self, out: &mut [u8]) -> Result { + let out_size = crate::buffer_len_to_u32(out.len())?; let rc = unsafe { - sys::wc_MlKemKey_EncodePublicKey(self.ws_key, out.as_mut_ptr(), out.len() as u32) + sys::wc_MlKemKey_EncodePublicKey(self.ws_key, out.as_mut_ptr(), out_size) }; if rc != 0 { return Err(rc); @@ -693,8 +695,9 @@ impl MlKem { /// } /// ``` pub fn encode_private_key(&self, out: &mut [u8]) -> Result { + let out_size = crate::buffer_len_to_u32(out.len())?; let rc = unsafe { - sys::wc_MlKemKey_EncodePrivateKey(self.ws_key, out.as_mut_ptr(), out.len() as u32) + sys::wc_MlKemKey_EncodePrivateKey(self.ws_key, out.as_mut_ptr(), out_size) }; if rc != 0 { return Err(rc); @@ -731,8 +734,9 @@ impl MlKem { /// } /// ``` pub fn decode_public_key(&mut self, data: &[u8]) -> Result<(), i32> { + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { - sys::wc_MlKemKey_DecodePublicKey(self.ws_key, data.as_ptr(), data.len() as u32) + sys::wc_MlKemKey_DecodePublicKey(self.ws_key, data.as_ptr(), data_size) }; if rc != 0 { return Err(rc); @@ -769,8 +773,9 @@ impl MlKem { /// } /// ``` pub fn decode_private_key(&mut self, data: &[u8]) -> Result<(), i32> { + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { - sys::wc_MlKemKey_DecodePrivateKey(self.ws_key, data.as_ptr(), data.len() as u32) + sys::wc_MlKemKey_DecodePrivateKey(self.ws_key, data.as_ptr(), data_size) }; if rc != 0 { return Err(rc); diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/prf.rs b/wrapper/rust/wolfssl-wolfcrypt/src/prf.rs index a4deadc428f..2358c28f477 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/prf.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/prf.rs @@ -120,9 +120,9 @@ pub fn prf(secret: &[u8], seed: &[u8], hash_type: i32, dout: &mut [u8]) -> Resul /// } /// ``` pub fn prf_ex(secret: &[u8], seed: &[u8], hash_type: i32, heap: Option<*mut core::ffi::c_void>, dev_id: Option, dout: &mut [u8]) -> Result<(), i32> { - let secret_size = secret.len() as u32; - let seed_size = seed.len() as u32; - let dout_size = dout.len() as u32; + let secret_size = crate::buffer_len_to_u32(secret.len())?; + let seed_size = crate::buffer_len_to_u32(seed.len())?; + let dout_size = crate::buffer_len_to_u32(dout.len())?; let heap = match heap { Some(heap) => heap, None => core::ptr::null_mut(), diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/random.rs b/wrapper/rust/wolfssl-wolfcrypt/src/random.rs index aca81f46037..798ecc18252 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/random.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/random.rs @@ -157,7 +157,7 @@ impl RNG { } } let ptr = nonce.as_mut_ptr() as *mut u8; - let size: u32 = size_of_val(nonce) as u32; + let size = crate::buffer_len_to_u32(size_of_val(nonce))?; let mut wc_rng: MaybeUninit = MaybeUninit::uninit(); let heap = match heap { Some(heap) => heap, @@ -244,16 +244,16 @@ impl RNG { let mut nonce_size = 0u32; if let Some(nonce) = nonce { nonce_ptr = nonce.as_ptr(); - nonce_size = nonce.len() as u32; + nonce_size = crate::buffer_len_to_u32(nonce.len())?; } - let seed_a_size = seed_a.len() as u32; + let seed_a_size = crate::buffer_len_to_u32(seed_a.len())?; let mut seed_b_ptr = core::ptr::null(); let mut seed_b_size = 0u32; if let Some(seed_b) = seed_b { seed_b_ptr = seed_b.as_ptr(); - seed_b_size = seed_b.len() as u32; + seed_b_size = crate::buffer_len_to_u32(seed_b.len())?; } - let output_size = output.len() as u32; + let output_size = crate::buffer_len_to_u32(output.len())?; let heap = match heap { Some(heap) => heap, None => core::ptr::null_mut(), @@ -297,7 +297,7 @@ impl RNG { /// ``` #[cfg(random_hashdrbg)] pub fn test_seed(seed: &[u8]) -> Result<(), i32> { - let seed_size = seed.len() as u32; + let seed_size = crate::buffer_len_to_u32(seed.len())?; let rc = unsafe { sys::wc_RNG_TestSeed(seed.as_ptr(), seed_size) }; if rc != 0 { return Err(rc); @@ -340,7 +340,7 @@ impl RNG { /// library return code on failure. pub fn generate_block(&mut self, buf: &mut [T]) -> Result<(), i32> { let ptr = buf.as_mut_ptr() as *mut u8; - let size: u32 = size_of_val(buf) as u32; + let size = crate::buffer_len_to_u32(size_of_val(buf))?; let rc = unsafe { sys::wc_RNG_GenerateBlock(&mut self.wc_rng, ptr, size) }; if rc == 0 { Ok(()) @@ -371,7 +371,7 @@ impl RNG { /// ``` #[cfg(random_hashdrbg)] pub fn reseed(&mut self, seed: &[u8]) -> Result<(), i32> { - let seed_size = seed.len() as u32; + let seed_size = crate::buffer_len_to_u32(seed.len())?; let rc = unsafe { sys::wc_RNG_DRBG_Reseed(&mut self.wc_rng, seed.as_ptr(), seed_size) }; diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs b/wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs index 74b4d674046..24796e46fa0 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs @@ -218,6 +218,7 @@ impl RSA { /// } /// ``` pub fn new_from_der_ex(der: &[u8], heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result { + let der_size = crate::buffer_len_to_u32(der.len())?; let mut wc_rsakey: MaybeUninit = MaybeUninit::uninit(); let heap = match heap { Some(heap) => heap, @@ -232,7 +233,6 @@ impl RSA { return Err(rc); } let mut wc_rsakey = unsafe { wc_rsakey.assume_init() }; - let der_size = der.len() as u32; let mut idx: u32 = 0; let rc = unsafe { sys::wc_RsaPrivateKeyDecode(der.as_ptr(), &mut idx, &mut wc_rsakey, der_size) @@ -335,6 +335,7 @@ impl RSA { /// } /// ``` pub fn new_public_from_der_ex(der: &[u8], heap: Option<*mut core::ffi::c_void>, dev_id: Option) -> Result { + let der_size = crate::buffer_len_to_u32(der.len())?; let mut wc_rsakey: MaybeUninit = MaybeUninit::uninit(); let heap = match heap { Some(heap) => heap, @@ -349,7 +350,6 @@ impl RSA { return Err(rc); } let mut wc_rsakey = unsafe { wc_rsakey.assume_init() }; - let der_size = der.len() as u32; let mut idx: u32 = 0; let rc = unsafe { sys::wc_RsaPublicKeyDecode(der.as_ptr(), &mut idx, &mut wc_rsakey, der_size) @@ -527,11 +527,11 @@ impl RSA { d: &mut [u8], d_size: &mut u32, p: &mut [u8], p_size: &mut u32, q: &mut [u8], q_size: &mut u32) -> Result<(), i32> { - *e_size = e.len() as u32; - *n_size = n.len() as u32; - *d_size = d.len() as u32; - *p_size = p.len() as u32; - *q_size = q.len() as u32; + *e_size = crate::buffer_len_to_u32(e.len())?; + *n_size = crate::buffer_len_to_u32(n.len())?; + *d_size = crate::buffer_len_to_u32(d.len())?; + *p_size = crate::buffer_len_to_u32(p.len())?; + *q_size = crate::buffer_len_to_u32(q.len())?; #[cfg(rsa_const_api)] let key_ptr = &self.wc_rsakey; #[cfg(not(rsa_const_api))] @@ -584,8 +584,8 @@ impl RSA { pub fn export_public_key(&mut self, e: &mut [u8], e_size: &mut u32, n: &mut [u8], n_size: &mut u32) -> Result<(), i32> { - *e_size = e.len() as u32; - *n_size = n.len() as u32; + *e_size = crate::buffer_len_to_u32(e.len())?; + *n_size = crate::buffer_len_to_u32(n.len())?; #[cfg(rsa_const_api)] let key = &self.wc_rsakey; #[cfg(not(rsa_const_api))] @@ -705,8 +705,8 @@ impl RSA { /// ``` #[cfg(random)] pub fn public_encrypt(&mut self, din: &[u8], dout: &mut [u8], rng: &mut RNG) -> Result { - let din_size = din.len() as u32; - let dout_size = dout.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; + let dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_RsaPublicEncrypt(din.as_ptr(), din_size, dout.as_mut_ptr(), dout_size, &mut self.wc_rsakey, @@ -763,8 +763,8 @@ impl RSA { /// } /// ``` pub fn private_decrypt(&mut self, din: &[u8], dout: &mut [u8]) -> Result { - let din_size = din.len() as u32; - let dout_size = dout.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; + let dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_RsaPrivateDecrypt(din.as_ptr(), din_size, dout.as_mut_ptr(), dout_size, &mut self.wc_rsakey) @@ -829,8 +829,8 @@ impl RSA { /// ``` #[cfg(all(random, rsa_pss))] pub fn pss_sign(&mut self, din: &[u8], dout: &mut [u8], hash_algo: u32, mgf: i32, rng: &mut RNG) -> Result { - let din_size = din.len() as u32; - let dout_size = dout.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; + let dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_RsaPSS_Sign(din.as_ptr(), din_size, dout.as_mut_ptr(), dout_size, hash_algo, mgf, &mut self.wc_rsakey, &mut rng.wc_rng) @@ -892,8 +892,8 @@ impl RSA { /// ``` #[cfg(all(rsa_pss, rsa_const_api))] pub fn pss_check_padding(&mut self, din: &[u8], sig: &[u8], hash_algo: u32) -> Result<(), i32> { - let din_size = din.len() as u32; - let sig_size = sig.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; + let sig_size = crate::buffer_len_to_u32(sig.len())?; let rc = unsafe { sys::wc_RsaPSS_CheckPadding(din.as_ptr(), din_size, sig.as_ptr(), sig_size, hash_algo) @@ -958,8 +958,8 @@ impl RSA { /// ``` #[cfg(all(rsa_pss, rsa_const_api))] pub fn pss_verify(&mut self, din: &[u8], dout: &mut [u8], hash_algo: u32, mgf: i32) -> Result { - let din_size = din.len() as u32; - let dout_size = dout.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; + let dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_RsaPSS_Verify(din.as_ptr(), din_size, dout.as_mut_ptr(), dout_size, @@ -1029,9 +1029,9 @@ impl RSA { /// ``` #[cfg(all(rsa_pss, rsa_const_api))] pub fn pss_verify_check(&mut self, din: &[u8], dout: &mut [u8], digest: &[u8], hash_algo: u32, mgf: i32) -> Result { - let din_size = din.len() as u32; - let dout_size = dout.len() as u32; - let digest_size = digest.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; + let dout_size = crate::buffer_len_to_u32(dout.len())?; + let digest_size = crate::buffer_len_to_u32(digest.len())?; let rc = unsafe { sys::wc_RsaPSS_VerifyCheck(din.as_ptr(), din_size, dout.as_mut_ptr(), dout_size, digest.as_ptr(), digest_size, @@ -1092,8 +1092,8 @@ impl RSA { /// ``` #[cfg(all(rsa_direct, rsa_const_api))] pub fn rsa_direct(&mut self, din: &[u8], dout: &mut [u8], typ: i32, rng: &mut RNG) -> Result { - let din_size = din.len() as u32; - let mut dout_size = dout.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; + let mut dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_RsaDirect(din.as_ptr(), din_size, dout.as_mut_ptr(), &mut dout_size, @@ -1209,8 +1209,8 @@ impl RSA { /// ``` #[cfg(random)] pub fn ssl_sign(&mut self, din: &[u8], dout: &mut [u8], rng: &mut RNG) -> Result { - let din_size = din.len() as u32; - let dout_size = dout.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; + let dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_RsaSSL_Sign(din.as_ptr(), din_size, dout.as_mut_ptr(), dout_size, @@ -1270,8 +1270,8 @@ impl RSA { /// } /// ``` pub fn ssl_verify(&mut self, din: &[u8], dout: &mut [u8]) -> Result { - let din_size = din.len() as u32; - let dout_size = dout.len() as u32; + let din_size = crate::buffer_len_to_u32(din.len())?; + let dout_size = crate::buffer_len_to_u32(dout.len())?; let rc = unsafe { sys::wc_RsaSSL_Verify(din.as_ptr(), din_size, dout.as_mut_ptr(), dout_size, &mut self.wc_rsakey) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs b/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs index e8964a72f8a..9cbfcaf24c5 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs @@ -170,7 +170,7 @@ impl SHA { /// sha.update(b"input").expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_ShaUpdate(&mut self.wc_sha, data.as_ptr(), data_size) }; @@ -373,7 +373,7 @@ impl SHA224 { /// sha.update(b"input").expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Sha224Update(&mut self.wc_sha224, data.as_ptr(), data_size) }; @@ -576,7 +576,7 @@ impl SHA256 { /// sha.update(b"input").expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Sha256Update(&mut self.wc_sha256, data.as_ptr(), data_size) }; @@ -779,7 +779,7 @@ impl SHA384 { /// sha.update(b"input").expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Sha384Update(&mut self.wc_sha384, data.as_ptr(), data_size) }; @@ -982,7 +982,7 @@ impl SHA512 { /// sha.update(b"input").expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Sha512Update(&mut self.wc_sha512, data.as_ptr(), data_size) }; @@ -1185,7 +1185,7 @@ impl SHA3_224 { /// sha.update(b"input").expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Sha3_224_Update(&mut self.wc_sha3, data.as_ptr(), data_size) }; @@ -1388,7 +1388,7 @@ impl SHA3_256 { /// sha.update(b"input").expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Sha3_256_Update(&mut self.wc_sha3, data.as_ptr(), data_size) }; @@ -1591,7 +1591,7 @@ impl SHA3_384 { /// sha.update(b"input").expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Sha3_384_Update(&mut self.wc_sha3, data.as_ptr(), data_size) }; @@ -1794,7 +1794,7 @@ impl SHA3_512 { /// sha.update(b"input").expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Sha3_512_Update(&mut self.wc_sha3, data.as_ptr(), data_size) }; @@ -2001,7 +2001,7 @@ impl SHAKE128 { /// sha.update(b"input").expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Shake128_Update(&mut self.wc_shake, data.as_ptr(), data_size) }; @@ -2032,7 +2032,7 @@ impl SHAKE128 { /// sha.finalize(&mut hash).expect("Error with finalize()"); /// ``` pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> { - let hash_size = hash.len() as u32; + let hash_size = crate::buffer_len_to_u32(hash.len())?; let rc = unsafe { sys::wc_Shake128_Final(&mut self.wc_shake, hash.as_mut_ptr(), hash_size) }; @@ -2061,7 +2061,7 @@ impl SHAKE128 { /// sha.absorb(b"input").expect("Error with absorb()"); /// ``` pub fn absorb(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Shake128_Absorb(&mut self.wc_shake, data.as_ptr(), data_size) }; @@ -2094,7 +2094,7 @@ impl SHAKE128 { /// sha.squeeze_blocks(&mut buffer).expect("Error with squeeze_blocks()"); /// ``` pub fn squeeze_blocks(&mut self, dout: &mut [u8]) -> Result<(), i32> { - let dout_size = dout.len() as u32; + let dout_size = crate::buffer_len_to_u32(dout.len())?; if dout_size % (Self::SQUEEZE_BLOCK_SIZE as u32) != 0 { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } @@ -2271,7 +2271,7 @@ impl SHAKE256 { /// sha.update(b"input").expect("Error with update()"); /// ``` pub fn update(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Shake256_Update(&mut self.wc_shake, data.as_ptr(), data_size) }; @@ -2302,7 +2302,7 @@ impl SHAKE256 { /// sha.finalize(&mut hash).expect("Error with finalize()"); /// ``` pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> { - let hash_size = hash.len() as u32; + let hash_size = crate::buffer_len_to_u32(hash.len())?; let rc = unsafe { sys::wc_Shake256_Final(&mut self.wc_shake, hash.as_mut_ptr(), hash_size) }; @@ -2331,7 +2331,7 @@ impl SHAKE256 { /// sha.absorb(b"input").expect("Error with absorb()"); /// ``` pub fn absorb(&mut self, data: &[u8]) -> Result<(), i32> { - let data_size = data.len() as u32; + let data_size = crate::buffer_len_to_u32(data.len())?; let rc = unsafe { sys::wc_Shake256_Absorb(&mut self.wc_shake, data.as_ptr(), data_size) }; @@ -2364,7 +2364,7 @@ impl SHAKE256 { /// sha.squeeze_blocks(&mut buffer).expect("Error with squeeze_blocks()"); /// ``` pub fn squeeze_blocks(&mut self, dout: &mut [u8]) -> Result<(), i32> { - let dout_size = dout.len() as u32; + let dout_size = crate::buffer_len_to_u32(dout.len())?; if dout_size % (Self::SQUEEZE_BLOCK_SIZE as u32) != 0 { return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); } From f1a041a2161d5a2697f44f9e0edcdcba88c981a8 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Tue, 24 Mar 2026 11:35:38 -0400 Subject: [PATCH 10/20] Rust wrapper: add zeroizing Drop impl for ChaCha20Poly1305 Fix F-1069 --- .../rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs b/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs index 61f4135786b..303b2153784 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs @@ -243,6 +243,17 @@ impl ChaCha20Poly1305 { } } +impl Drop for ChaCha20Poly1305 { + fn drop(&mut self) { + unsafe { + let ptr = &mut self.wc_ccp as *mut sys::ChaChaPoly_Aead as *mut u8; + for i in 0..core::mem::size_of::() { + core::ptr::write_volatile(ptr.add(i), 0); + } + } + } +} + // --------------------------------------------------------------------------- // ChaCha20-Poly1305 aead trait implementations // --------------------------------------------------------------------------- From db1aab959c18d0116abd10872ff986c9efeca883 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Thu, 26 Mar 2026 15:03:46 -0400 Subject: [PATCH 11/20] Rust wrapper: zeroize structs on drop --- wrapper/rust/wolfssl-wolfcrypt/Cargo.lock | 21 +++++ wrapper/rust/wolfssl-wolfcrypt/Cargo.toml | 1 + wrapper/rust/wolfssl-wolfcrypt/src/aes.rs | 75 ++++++++++++++++ wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs | 57 ++++++++++++ .../src/chacha20_poly1305.rs | 16 ++-- wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs | 8 ++ .../rust/wolfssl-wolfcrypt/src/curve25519.rs | 8 ++ wrapper/rust/wolfssl-wolfcrypt/src/dh.rs | 8 ++ .../rust/wolfssl-wolfcrypt/src/dilithium.rs | 8 ++ wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs | 16 ++++ wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs | 8 ++ wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs | 8 ++ wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs | 8 ++ wrapper/rust/wolfssl-wolfcrypt/src/lib.rs | 17 ++++ wrapper/rust/wolfssl-wolfcrypt/src/lms.rs | 8 ++ wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs | 8 ++ wrapper/rust/wolfssl-wolfcrypt/src/random.rs | 8 ++ wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs | 8 ++ wrapper/rust/wolfssl-wolfcrypt/src/sha.rs | 89 +++++++++++++++++++ 19 files changed, 374 insertions(+), 6 deletions(-) diff --git a/wrapper/rust/wolfssl-wolfcrypt/Cargo.lock b/wrapper/rust/wolfssl-wolfcrypt/Cargo.lock index 3a6dbadd24d..9fe8a696815 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/Cargo.lock +++ b/wrapper/rust/wolfssl-wolfcrypt/Cargo.lock @@ -393,4 +393,25 @@ dependencies = [ "cipher", "rand_core 0.10.0", "regex", + "zeroize", +] + +[[package]] +name = "zeroize" +version = "1.8.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0" +dependencies = [ + "zeroize_derive", +] + +[[package]] +name = "zeroize_derive" +version = "1.4.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e" +dependencies = [ + "proc-macro2", + "quote", + "syn", ] diff --git a/wrapper/rust/wolfssl-wolfcrypt/Cargo.toml b/wrapper/rust/wolfssl-wolfcrypt/Cargo.toml index 7dca3510e0f..08ee5ac62b2 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/Cargo.toml +++ b/wrapper/rust/wolfssl-wolfcrypt/Cargo.toml @@ -20,6 +20,7 @@ cipher = ["dep:cipher"] rand_core = { version = "0.10", optional = true, default-features = false } aead = { version = "0.5", optional = true, default-features = false } cipher = { version = "0.5", optional = true, default-features = false } +zeroize = { version = "1.3", default-features = false, features = ["derive"] } [dev-dependencies] aead = { version = "0.5", features = ["alloc", "dev"] } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs b/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs index d5275c01c1a..d92f8911f9f 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs @@ -27,6 +27,7 @@ Encryption Standard (AES) functionality. use crate::sys; use core::mem::{size_of_val, MaybeUninit}; +use zeroize::{Zeroize, ZeroizeOnDrop}; #[cfg(feature = "aead")] use aead::{AeadCore, AeadInPlace, KeyInit, KeySizeUser}; @@ -233,10 +234,17 @@ impl CBC { } } #[cfg(aes_cbc)] +impl Zeroize for CBC { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_aes); } + } +} +#[cfg(aes_cbc)] impl Drop for CBC { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_AesFree(&mut self.ws_aes); } + self.zeroize(); } } @@ -428,10 +436,17 @@ impl CCM { } } #[cfg(aes_ccm)] +impl Zeroize for CCM { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_aes); } + } +} +#[cfg(aes_ccm)] impl Drop for CCM { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_AesFree(&mut self.ws_aes); } + self.zeroize(); } } @@ -506,6 +521,7 @@ fn ccm_decrypt_in_place( /// AES-128-CCM authenticated encryption (12-byte nonce, 16-byte tag). #[cfg(all(aes_ccm, feature = "aead"))] +#[derive(Zeroize, ZeroizeOnDrop)] pub struct Aes128Ccm { key: [u8; 16], } @@ -557,6 +573,7 @@ impl AeadInPlace for Aes128Ccm { /// AES-256-CCM authenticated encryption (12-byte nonce, 16-byte tag). #[cfg(all(aes_ccm, feature = "aead"))] +#[derive(Zeroize, ZeroizeOnDrop)] pub struct Aes256Ccm { key: [u8; 32], } @@ -906,10 +923,17 @@ impl CFB { } } #[cfg(aes_cfb)] +impl Zeroize for CFB { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_aes); } + } +} +#[cfg(aes_cfb)] impl Drop for CFB { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_AesFree(&mut self.ws_aes); } + self.zeroize(); } } @@ -1076,10 +1100,17 @@ impl CTR { } } #[cfg(aes_ctr)] +impl Zeroize for CTR { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_aes); } + } +} +#[cfg(aes_ctr)] impl Drop for CTR { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_AesFree(&mut self.ws_aes); } + self.zeroize(); } } @@ -1384,10 +1415,17 @@ impl ECB { } } #[cfg(aes_ecb)] +impl Zeroize for ECB { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_aes); } + } +} +#[cfg(aes_ecb)] impl Drop for ECB { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_AesFree(&mut self.ws_aes); } + self.zeroize(); } } @@ -1579,10 +1617,17 @@ impl GCM { } } #[cfg(aes_gcm)] +impl Zeroize for GCM { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_aes); } + } +} +#[cfg(aes_gcm)] impl Drop for GCM { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_AesFree(&mut self.ws_aes); } + self.zeroize(); } } @@ -1658,6 +1703,7 @@ fn gcm_decrypt_in_place( /// AES-128-GCM authenticated encryption (12-byte nonce, 16-byte tag). #[cfg(all(aes_gcm, feature = "aead"))] +#[derive(Zeroize, ZeroizeOnDrop)] pub struct Aes128Gcm { key: [u8; 16], } @@ -1709,6 +1755,7 @@ impl AeadInPlace for Aes128Gcm { /// AES-256-GCM authenticated encryption (12-byte nonce, 16-byte tag). #[cfg(all(aes_gcm, feature = "aead"))] +#[derive(Zeroize, ZeroizeOnDrop)] pub struct Aes256Gcm { key: [u8; 32], } @@ -2034,10 +2081,17 @@ impl GCMStream { } } #[cfg(aes_gcm_stream)] +impl Zeroize for GCMStream { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_aes); } + } +} +#[cfg(aes_gcm_stream)] impl Drop for GCMStream { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_AesFree(&mut self.ws_aes); } + self.zeroize(); } } @@ -2215,10 +2269,17 @@ impl OFB { } } #[cfg(aes_ofb)] +impl Zeroize for OFB { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_aes); } + } +} +#[cfg(aes_ofb)] impl Drop for OFB { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_AesFree(&mut self.ws_aes); } + self.zeroize(); } } @@ -2586,10 +2647,17 @@ impl XTS { } } #[cfg(aes_xts)] +impl Zeroize for XTS { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_xtsaes); } + } +} +#[cfg(aes_xts)] impl Drop for XTS { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_AesXtsFree(&mut self.ws_xtsaes); } + self.zeroize(); } } @@ -2890,10 +2958,17 @@ impl XTSStream { } } #[cfg(aes_xts_stream)] +impl Zeroize for XTSStream { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_xtsaes); } + } +} +#[cfg(aes_xts_stream)] impl Drop for XTSStream { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_AesXtsFree(&mut self.ws_xtsaes); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs b/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs index 06021de68c3..8b4ef5a3ae6 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs @@ -27,6 +27,7 @@ functionality. use crate::sys; use core::mem::MaybeUninit; +use zeroize::Zeroize; /// Context for BLAKE2b computation. #[cfg(blake2b)] @@ -174,6 +175,20 @@ impl BLAKE2b { } +#[cfg(blake2b)] +impl Zeroize for BLAKE2b { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_blake2b); } + } +} + +#[cfg(blake2b)] +impl Drop for BLAKE2b { + fn drop(&mut self) { + self.zeroize(); + } +} + /// Context for HMAC-BLAKE2b computation. #[cfg(blake2b_hmac)] pub struct BLAKE2bHmac { @@ -311,6 +326,20 @@ impl BLAKE2bHmac { } +#[cfg(blake2b_hmac)] +impl Zeroize for BLAKE2bHmac { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_blake2b); } + } +} + +#[cfg(blake2b_hmac)] +impl Drop for BLAKE2bHmac { + fn drop(&mut self) { + self.zeroize(); + } +} + /// Context for BLAKE2s computation. #[cfg(blake2s)] pub struct BLAKE2s { @@ -457,6 +486,20 @@ impl BLAKE2s { } +#[cfg(blake2s)] +impl Zeroize for BLAKE2s { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_blake2s); } + } +} + +#[cfg(blake2s)] +impl Drop for BLAKE2s { + fn drop(&mut self) { + self.zeroize(); + } +} + /// Context for HMAC-BLAKE2s computation. #[cfg(blake2s_hmac)] pub struct BLAKE2sHmac { @@ -592,3 +635,17 @@ impl BLAKE2sHmac { Ok(()) } } + +#[cfg(blake2s_hmac)] +impl Zeroize for BLAKE2sHmac { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_blake2s); } + } +} + +#[cfg(blake2s_hmac)] +impl Drop for BLAKE2sHmac { + fn drop(&mut self) { + self.zeroize(); + } +} diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs b/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs index 303b2153784..795363c0950 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs @@ -27,6 +27,7 @@ ChaCha20-Poly1305 functionality. use crate::sys; use core::mem::MaybeUninit; +use zeroize::{Zeroize, ZeroizeOnDrop}; pub struct ChaCha20Poly1305 { wc_ccp: sys::ChaChaPoly_Aead, @@ -243,14 +244,15 @@ impl ChaCha20Poly1305 { } } +impl Zeroize for ChaCha20Poly1305 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_ccp); } + } +} + impl Drop for ChaCha20Poly1305 { fn drop(&mut self) { - unsafe { - let ptr = &mut self.wc_ccp as *mut sys::ChaChaPoly_Aead as *mut u8; - for i in 0..core::mem::size_of::() { - core::ptr::write_volatile(ptr.add(i), 0); - } - } + self.zeroize(); } } @@ -261,6 +263,7 @@ impl Drop for ChaCha20Poly1305 { /// ChaCha20-Poly1305 AEAD instance holding a key for use with the /// `aead::KeyInit` and `aead::AeadInPlace` traits. #[cfg(feature = "aead")] +#[derive(Zeroize, ZeroizeOnDrop)] pub struct ChaCha20Poly1305Aead { key: [u8; 32], } @@ -449,6 +452,7 @@ impl XChaCha20Poly1305 { /// XChaCha20-Poly1305 AEAD instance holding a key for use with the /// `aead::KeyInit` and `aead::AeadInPlace` traits. #[cfg(all(xchacha20_poly1305, feature = "aead"))] +#[derive(Zeroize, ZeroizeOnDrop)] pub struct XChaCha20Poly1305Aead { key: [u8; 32], } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs b/wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs index fa3ebebfd06..63755ab677e 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs @@ -27,6 +27,7 @@ Message Authentication Code (CMAC) functionality. use crate::sys; use core::mem::MaybeUninit; +use zeroize::Zeroize; /// The `CMAC` struct manages the lifecycle of a wolfSSL `Cmac` object. /// @@ -408,9 +409,16 @@ impl CMAC { Ok(rc == 0) } } +impl Zeroize for CMAC { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_cmac); } + } +} + impl Drop for CMAC { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_CmacFree(&mut self.ws_cmac); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs b/wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs index 9a80fb573e3..d51f114b169 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs @@ -29,6 +29,7 @@ functionality. use crate::random::RNG; use crate::sys; use core::mem::MaybeUninit; +use zeroize::Zeroize; pub struct Curve25519Key { wc_key: sys::curve25519_key, @@ -654,6 +655,12 @@ impl Curve25519Key { } } +impl Zeroize for Curve25519Key { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_key); } + } +} + impl Drop for Curve25519Key { /// Safely free the underlying wolfSSL Curve25519Key context. /// @@ -664,5 +671,6 @@ impl Drop for Curve25519Key { /// preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_curve25519_free(&mut self.wc_key); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/dh.rs b/wrapper/rust/wolfssl-wolfcrypt/src/dh.rs index ffb31fd223f..047b84896d0 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/dh.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/dh.rs @@ -32,6 +32,7 @@ use crate::sys; #[cfg(random)] use crate::random::RNG; use core::mem::{MaybeUninit}; +use zeroize::Zeroize; pub struct DH { wc_dhkey: sys::DhKey, @@ -1579,6 +1580,12 @@ impl DH { } } +impl Zeroize for DH { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_dhkey); } + } +} + impl Drop for DH { /// Safely free the underlying wolfSSL DhKey context. /// @@ -1589,5 +1596,6 @@ impl Drop for DH { /// resources and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_FreeDhKey(&mut self.wc_dhkey); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs b/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs index 54fbd177c50..e57640aab7f 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs @@ -62,6 +62,7 @@ use crate::sys; #[cfg(all(random, any(dilithium_make_key, dilithium_sign)))] use crate::random::RNG; use core::mem::MaybeUninit; +use zeroize::Zeroize; /// Rust wrapper for a wolfSSL `dilithium_key` object. /// @@ -1299,6 +1300,12 @@ impl Dilithium { } } +impl Zeroize for Dilithium { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_key); } + } +} + impl Drop for Dilithium { /// Safely free the underlying wolfSSL Dilithium key context. /// @@ -1306,5 +1313,6 @@ impl Drop for Dilithium { /// is called when the `Dilithium` struct goes out of scope. fn drop(&mut self) { unsafe { sys::wc_dilithium_free(&mut self.ws_key); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs b/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs index 4dd639a1c01..4221e70f25d 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs @@ -32,6 +32,7 @@ use crate::sys; #[cfg(random)] use crate::random::RNG; use core::mem::{MaybeUninit}; +use zeroize::Zeroize; /// Rust wrapper for wolfSSL `ecc_point` object. pub struct ECCPoint { @@ -267,6 +268,13 @@ impl ECCPoint { } } +impl Zeroize for ECCPoint { + fn zeroize(&mut self) { + self.wc_ecc_point = core::ptr::null_mut(); + self.heap = core::ptr::null_mut(); + } +} + impl Drop for ECCPoint { /// Safely free the underlying wolfSSL ecc_point context. /// @@ -277,6 +285,7 @@ impl Drop for ECCPoint { /// resources and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_ecc_del_point_h(self.wc_ecc_point, self.heap); } + self.zeroize(); } } @@ -1957,6 +1966,12 @@ impl ECC { } } +impl Zeroize for ECC { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_ecc_key); } + } +} + impl Drop for ECC { /// Safely free the underlying wolfSSL ECC context. /// @@ -1967,5 +1982,6 @@ impl Drop for ECC { /// preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_ecc_free(&mut self.wc_ecc_key); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs b/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs index e6af212e4d7..26a2caa9374 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs @@ -28,6 +28,7 @@ This module provides a Rust wrapper for the wolfCrypt library's EdDSA Curve use crate::sys; use crate::random::RNG; use core::mem::MaybeUninit; +use zeroize::Zeroize; /// The `Ed25519` struct manages the lifecycle of a wolfSSL `ed25519_key` /// object. @@ -1430,9 +1431,16 @@ impl Ed25519 { } } +impl Zeroize for Ed25519 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_key); } + } +} + impl Drop for Ed25519 { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_ed25519_free(&mut self.ws_key); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs b/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs index 851f963f08e..b4a23db7cc7 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs @@ -28,6 +28,7 @@ This module provides a Rust wrapper for the wolfCrypt library's EdDSA Curve use crate::sys; use crate::random::RNG; use core::mem::MaybeUninit; +use zeroize::Zeroize; /// The `Ed448` struct manages the lifecycle of a wolfSSL `ed448_key` /// object. @@ -1355,9 +1356,16 @@ impl Ed448 { } } +impl Zeroize for Ed448 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_key); } + } +} + impl Drop for Ed448 { /// Safely free the wolfSSL resources. fn drop(&mut self) { unsafe { sys::wc_ed448_free(&mut self.ws_key); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs b/wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs index 62e75d047e8..893fe3e02cf 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs @@ -27,6 +27,7 @@ functionality. use crate::sys; use core::mem::MaybeUninit; +use zeroize::Zeroize; /// Rust wrapper for wolfSSL `Hmac` object. pub struct HMAC { @@ -324,6 +325,12 @@ impl HMAC { } } +impl Zeroize for HMAC { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_hmac); } + } +} + impl Drop for HMAC { /// Safely free the underlying wolfSSL Hmac context. /// @@ -334,5 +341,6 @@ impl Drop for HMAC { /// resources and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_HmacFree(&mut self.wc_hmac); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/lib.rs b/wrapper/rust/wolfssl-wolfcrypt/src/lib.rs index fff3be2e145..b4552ef4de5 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/lib.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/lib.rs @@ -23,6 +23,23 @@ /* bindgen-generated bindings to the C library */ pub mod sys; +/// Zeroize the raw bytes of a value. For use in `Zeroize` impls on C FFI +/// structs where `#[derive(Zeroize)]` cannot be used. +/// +/// # Safety +/// +/// `val` must be a valid, initialized value whose entire `size_of_val` byte +/// representation is safe to overwrite with zeroes. +pub(crate) unsafe fn zeroize_raw(val: &mut T) { + use zeroize::Zeroize; + unsafe { + core::slice::from_raw_parts_mut( + val as *mut T as *mut u8, + core::mem::size_of_val(val), + ).zeroize(); + } +} + pub mod aes; pub mod blake2; pub mod chacha20_poly1305; diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs b/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs index 61665079c67..4aa09a34dba 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs @@ -89,6 +89,7 @@ use crate::sys; use core::mem::MaybeUninit; #[cfg(all(lms_make_key, random))] use crate::random::RNG; +use zeroize::Zeroize; /// Rust wrapper for a wolfSSL `LmsKey` object (LMS/HSS, RFC 8554). /// @@ -776,6 +777,12 @@ impl Lms { } } +impl Zeroize for Lms { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.ws_key); } + } +} + impl Drop for Lms { /// Safely free the underlying wolfSSL LMS/HSS key context. /// @@ -785,5 +792,6 @@ impl Drop for Lms { unsafe { sys::wc_LmsKey_Free(&mut self.ws_key); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs b/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs index f07f55f7a1a..a7d903be332 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs @@ -64,6 +64,7 @@ assert_eq!(ss_alice, ss_bob); use crate::sys; #[cfg(random)] use crate::random::RNG; +use zeroize::Zeroize; /// Rust wrapper for a wolfSSL `MlKemKey` object. /// @@ -784,6 +785,12 @@ impl MlKem { } } +impl Zeroize for MlKem { + fn zeroize(&mut self) { + self.ws_key = core::ptr::null_mut(); + } +} + impl Drop for MlKem { /// Safely free the underlying wolfSSL ML-KEM key context. /// @@ -793,5 +800,6 @@ impl Drop for MlKem { unsafe { sys::wc_MlKemKey_Delete(self.ws_key, core::ptr::null_mut()); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/random.rs b/wrapper/rust/wolfssl-wolfcrypt/src/random.rs index 798ecc18252..94ef3d70c4f 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/random.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/random.rs @@ -46,6 +46,7 @@ rng.generate_block(&mut buffer).expect("Failed to generate a block"); use crate::sys; use core::mem::{size_of_val, MaybeUninit}; +use zeroize::Zeroize; /// A cryptographically secure random number generator based on the wolfSSL /// library. @@ -410,6 +411,12 @@ impl rand_core::TryRng for RNG { #[cfg(feature = "rand_core")] impl rand_core::TryCryptoRng for RNG {} +impl Zeroize for RNG { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_rng); } + } +} + impl Drop for RNG { /// Safely free the underlying wolfSSL RNG context. /// @@ -420,5 +427,6 @@ impl Drop for RNG { /// preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_FreeRng(&mut self.wc_rng); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs b/wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs index 24796e46fa0..19344b3bea6 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs @@ -63,6 +63,7 @@ use crate::sys; #[cfg(random)] use crate::random::RNG; use core::mem::{MaybeUninit}; +use zeroize::Zeroize; /// The `RSA` struct manages the lifecycle of a wolfSSL `RsaKey` object. /// @@ -1283,6 +1284,12 @@ impl RSA { } } +impl Zeroize for RSA { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_rsakey); } + } +} + impl Drop for RSA { /// Safely free the underlying wolfSSL RSA context. /// @@ -1293,5 +1300,6 @@ impl Drop for RSA { /// preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_FreeRsaKey(&mut self.wc_rsakey); } + self.zeroize(); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs b/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs index 9cbfcaf24c5..a2731904fa5 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs @@ -25,6 +25,7 @@ Algorithm (SHA) functionality. use crate::sys; use core::mem::MaybeUninit; +use zeroize::Zeroize; /// Context for SHA-1 computation. #[cfg(sha)] @@ -215,6 +216,13 @@ impl SHA { } } +#[cfg(sha)] +impl Zeroize for SHA { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_sha); } + } +} + #[cfg(sha)] impl Drop for SHA { /// Safely free the underlying wolfSSL SHA context. @@ -226,6 +234,7 @@ impl Drop for SHA { /// preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_ShaFree(&mut self.wc_sha); } + self.zeroize(); } } @@ -418,6 +427,13 @@ impl SHA224 { } } +#[cfg(sha224)] +impl Zeroize for SHA224 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_sha224); } + } +} + #[cfg(sha224)] impl Drop for SHA224 { /// Safely free the underlying wolfSSL SHA224 context. @@ -429,6 +445,7 @@ impl Drop for SHA224 { /// and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_Sha224Free(&mut self.wc_sha224); } + self.zeroize(); } } @@ -621,6 +638,13 @@ impl SHA256 { } } +#[cfg(sha256)] +impl Zeroize for SHA256 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_sha256); } + } +} + #[cfg(sha256)] impl Drop for SHA256 { /// Safely free the underlying wolfSSL SHA256 context. @@ -632,6 +656,7 @@ impl Drop for SHA256 { /// and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_Sha256Free(&mut self.wc_sha256); } + self.zeroize(); } } @@ -824,6 +849,13 @@ impl SHA384 { } } +#[cfg(sha384)] +impl Zeroize for SHA384 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_sha384); } + } +} + #[cfg(sha384)] impl Drop for SHA384 { /// Safely free the underlying wolfSSL SHA384 context. @@ -835,6 +867,7 @@ impl Drop for SHA384 { /// and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_Sha384Free(&mut self.wc_sha384); } + self.zeroize(); } } @@ -1027,6 +1060,13 @@ impl SHA512 { } } +#[cfg(sha512)] +impl Zeroize for SHA512 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_sha512); } + } +} + #[cfg(sha512)] impl Drop for SHA512 { /// Safely free the underlying wolfSSL SHA512 context. @@ -1038,6 +1078,7 @@ impl Drop for SHA512 { /// and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_Sha512Free(&mut self.wc_sha512); } + self.zeroize(); } } @@ -1230,6 +1271,13 @@ impl SHA3_224 { } } +#[cfg(sha3)] +impl Zeroize for SHA3_224 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_sha3); } + } +} + #[cfg(sha3)] impl Drop for SHA3_224 { /// Safely free the underlying wolfSSL SHA3_224 context. @@ -1241,6 +1289,7 @@ impl Drop for SHA3_224 { /// and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_Sha3_224_Free(&mut self.wc_sha3); } + self.zeroize(); } } @@ -1433,6 +1482,13 @@ impl SHA3_256 { } } +#[cfg(sha3)] +impl Zeroize for SHA3_256 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_sha3); } + } +} + #[cfg(sha3)] impl Drop for SHA3_256 { /// Safely free the underlying wolfSSL SHA3_256 context. @@ -1444,6 +1500,7 @@ impl Drop for SHA3_256 { /// and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_Sha3_256_Free(&mut self.wc_sha3); } + self.zeroize(); } } @@ -1636,6 +1693,13 @@ impl SHA3_384 { } } +#[cfg(sha3)] +impl Zeroize for SHA3_384 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_sha3); } + } +} + #[cfg(sha3)] impl Drop for SHA3_384 { /// Safely free the underlying wolfSSL SHA3_384 context. @@ -1647,6 +1711,7 @@ impl Drop for SHA3_384 { /// and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_Sha3_384_Free(&mut self.wc_sha3); } + self.zeroize(); } } @@ -1839,6 +1904,13 @@ impl SHA3_512 { } } +#[cfg(sha3)] +impl Zeroize for SHA3_512 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_sha3); } + } +} + #[cfg(sha3)] impl Drop for SHA3_512 { /// Safely free the underlying wolfSSL SHA3_512 context. @@ -1850,6 +1922,7 @@ impl Drop for SHA3_512 { /// and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_Sha3_512_Free(&mut self.wc_sha3); } + self.zeroize(); } } @@ -2109,6 +2182,13 @@ impl SHAKE128 { } } +#[cfg(shake128)] +impl Zeroize for SHAKE128 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_shake); } + } +} + #[cfg(shake128)] impl Drop for SHAKE128 { /// Safely free the underlying wolfSSL SHAKE128 context. @@ -2120,6 +2200,7 @@ impl Drop for SHAKE128 { /// and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_Shake128_Free(&mut self.wc_shake); } + self.zeroize(); } } @@ -2379,6 +2460,13 @@ impl SHAKE256 { } } +#[cfg(shake256)] +impl Zeroize for SHAKE256 { + fn zeroize(&mut self) { + unsafe { crate::zeroize_raw(&mut self.wc_shake); } + } +} + #[cfg(shake256)] impl Drop for SHAKE256 { /// Safely free the underlying wolfSSL SHAKE256 context. @@ -2390,5 +2478,6 @@ impl Drop for SHAKE256 { /// and preventing memory leaks. fn drop(&mut self) { unsafe { sys::wc_Shake256_Free(&mut self.wc_shake); } + self.zeroize(); } } From 884b882afe0d3bdda6de082dada972b08a050d4d Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Fri, 27 Mar 2026 15:10:15 -0400 Subject: [PATCH 12/20] Rust wrapper: remove generic types for AES buffers Fixes F-1071. This is an API-breaking change, so will lead to a new crate major version. --- wrapper/rust/wolfssl-wolfcrypt/src/aes.rs | 354 +++++++++------------- 1 file changed, 145 insertions(+), 209 deletions(-) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs b/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs index d92f8911f9f..2441e251ea8 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs @@ -26,7 +26,7 @@ Encryption Standard (AES) functionality. #![cfg(aes)] use crate::sys; -use core::mem::{size_of_val, MaybeUninit}; +use core::mem::MaybeUninit; use zeroize::{Zeroize, ZeroizeOnDrop}; #[cfg(feature = "aead")] @@ -184,16 +184,14 @@ impl CBC { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn encrypt(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesCbcEncrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesCbcEncrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -216,16 +214,14 @@ impl CBC { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn decrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn decrypt(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesCbcDecrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesCbcDecrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -368,24 +364,19 @@ impl CCM { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt(&mut self, din: &[I], dout: &mut [O], nonce: &[N], auth: &[A], auth_tag: &mut [A]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; - let nonce_ptr = nonce.as_ptr() as *const u8; - let nonce_size = crate::buffer_len_to_u32(size_of_val(nonce))?; - let auth_ptr = auth.as_ptr() as *const u8; - let auth_size = crate::buffer_len_to_u32(size_of_val(auth))?; - let auth_tag_ptr = auth_tag.as_mut_ptr() as *mut u8; - let auth_tag_size = crate::buffer_len_to_u32(size_of_val(auth_tag))?; + pub fn encrypt(&mut self, din: &[u8], dout: &mut [u8], nonce: &[u8], auth: &[u8], auth_tag: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; + let nonce_size = crate::buffer_len_to_u32(nonce.len())?; + let auth_size = crate::buffer_len_to_u32(auth.len())?; + let auth_tag_size = crate::buffer_len_to_u32(auth_tag.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesCcmEncrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size, - nonce_ptr, nonce_size, auth_tag_ptr, auth_tag_size, - auth_ptr, auth_size) + sys::wc_AesCcmEncrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size, + nonce.as_ptr(), nonce_size, auth_tag.as_mut_ptr(), auth_tag_size, + auth.as_ptr(), auth_size) }; if rc != 0 { return Err(rc); @@ -410,24 +401,19 @@ impl CCM { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn decrypt(&mut self, din: &[I], dout: &mut [O], nonce: &[N], auth: &[A], auth_tag: &[A]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; - let nonce_ptr = nonce.as_ptr() as *const u8; - let nonce_size = crate::buffer_len_to_u32(size_of_val(nonce))?; - let auth_ptr = auth.as_ptr() as *const u8; - let auth_size = crate::buffer_len_to_u32(size_of_val(auth))?; - let auth_tag_ptr = auth_tag.as_ptr() as *const u8; - let auth_tag_size = crate::buffer_len_to_u32(size_of_val(auth_tag))?; + pub fn decrypt(&mut self, din: &[u8], dout: &mut [u8], nonce: &[u8], auth: &[u8], auth_tag: &[u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; + let nonce_size = crate::buffer_len_to_u32(nonce.len())?; + let auth_size = crate::buffer_len_to_u32(auth.len())?; + let auth_tag_size = crate::buffer_len_to_u32(auth_tag.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesCcmDecrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size, - nonce_ptr, nonce_size, auth_tag_ptr, auth_tag_size, - auth_ptr, auth_size) + sys::wc_AesCcmDecrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size, + nonce.as_ptr(), nonce_size, auth_tag.as_ptr(), auth_tag_size, + auth.as_ptr(), auth_size) }; if rc != 0 { return Err(rc); @@ -747,16 +733,14 @@ impl CFB { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn encrypt(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesCfbEncrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesCfbEncrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -778,16 +762,14 @@ impl CFB { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt1(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn encrypt1(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesCfb1Encrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesCfb1Encrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -809,16 +791,14 @@ impl CFB { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt8(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn encrypt8(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesCfb8Encrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesCfb8Encrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -841,16 +821,14 @@ impl CFB { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. #[cfg(aes_decrypt)] - pub fn decrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn decrypt(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesCfbDecrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesCfbDecrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -873,16 +851,14 @@ impl CFB { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. #[cfg(aes_decrypt)] - pub fn decrypt1(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn decrypt1(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesCfb1Decrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesCfb1Decrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -905,16 +881,14 @@ impl CFB { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. #[cfg(aes_decrypt)] - pub fn decrypt8(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn decrypt8(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesCfb8Decrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesCfb8Decrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -1046,16 +1020,14 @@ impl CTR { Ok(()) } - fn encrypt_decrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + fn encrypt_decrypt(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesCtrEncrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesCtrEncrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -1077,7 +1049,7 @@ impl CTR { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { + pub fn encrypt(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { self.encrypt_decrypt(din, dout) } @@ -1095,7 +1067,7 @@ impl CTR { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn decrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { + pub fn decrypt(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { self.encrypt_decrypt(din, dout) } } @@ -1178,12 +1150,10 @@ impl EAX { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt(din: &[I], dout: &mut [O], key: &[u8], nonce: &[u8], + pub fn encrypt(din: &[u8], dout: &mut [u8], key: &[u8], nonce: &[u8], auth: &[u8], auth_tag: &mut [u8]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; let key_size = crate::buffer_len_to_u32(key.len())?; let nonce_size = crate::buffer_len_to_u32(nonce.len())?; let auth_size = crate::buffer_len_to_u32(auth.len())?; @@ -1192,8 +1162,8 @@ impl EAX { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesEaxEncryptAuth(key.as_ptr(), key_size, out_ptr, - in_ptr, in_size, nonce.as_ptr(), nonce_size, + sys::wc_AesEaxEncryptAuth(key.as_ptr(), key_size, dout.as_mut_ptr(), + din.as_ptr(), in_size, nonce.as_ptr(), nonce_size, auth_tag.as_mut_ptr(), auth_tag_size, auth.as_ptr(), auth_size) }; if rc != 0 { @@ -1219,12 +1189,10 @@ impl EAX { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn decrypt(din: &[I], dout: &mut [O], key: &[u8], nonce: &[u8], + pub fn decrypt(din: &[u8], dout: &mut [u8], key: &[u8], nonce: &[u8], auth: &[u8], auth_tag: &[u8]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; let key_size = crate::buffer_len_to_u32(key.len())?; let nonce_size = crate::buffer_len_to_u32(nonce.len())?; let auth_size = crate::buffer_len_to_u32(auth.len())?; @@ -1233,8 +1201,8 @@ impl EAX { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesEaxDecryptAuth(key.as_ptr(), key_size, out_ptr, - in_ptr, in_size, nonce.as_ptr(), nonce_size, + sys::wc_AesEaxDecryptAuth(key.as_ptr(), key_size, dout.as_mut_ptr(), + din.as_ptr(), in_size, nonce.as_ptr(), nonce_size, auth_tag.as_ptr(), auth_tag_size, auth.as_ptr(), auth_size) }; if rc != 0 { @@ -1365,16 +1333,14 @@ impl ECB { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn encrypt(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesEcbEncrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesEcbEncrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -1397,16 +1363,14 @@ impl ECB { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn decrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn decrypt(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesEcbDecrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesEcbDecrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -1553,12 +1517,10 @@ impl GCM { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt(&mut self, din: &[I], dout: &mut [O], iv: &[u8], + pub fn encrypt(&mut self, din: &[u8], dout: &mut [u8], iv: &[u8], auth: &[u8], auth_tag: &mut [u8]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; let iv_size = crate::buffer_len_to_u32(iv.len())?; let auth_size = crate::buffer_len_to_u32(auth.len())?; let auth_tag_size = crate::buffer_len_to_u32(auth_tag.len())?; @@ -1566,7 +1528,7 @@ impl GCM { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesGcmEncrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size, + sys::wc_AesGcmEncrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size, iv.as_ptr(), iv_size, auth_tag.as_mut_ptr(), auth_tag_size, auth.as_ptr(), auth_size) }; @@ -1593,12 +1555,10 @@ impl GCM { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn decrypt(&mut self, din: &[I], dout: &mut [O], iv: &[u8], + pub fn decrypt(&mut self, din: &[u8], dout: &mut [u8], iv: &[u8], auth: &[u8], auth_tag: &[u8]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; let iv_size = crate::buffer_len_to_u32(iv.len())?; let auth_size = crate::buffer_len_to_u32(auth.len())?; let auth_tag_size = crate::buffer_len_to_u32(auth_tag.len())?; @@ -1606,7 +1566,7 @@ impl GCM { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesGcmDecrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size, + sys::wc_AesGcmDecrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size, iv.as_ptr(), iv_size, auth_tag.as_ptr(), auth_tag_size, auth.as_ptr(), auth_size) }; @@ -1965,19 +1925,17 @@ impl GCMStream { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt_update(&mut self, din: &[I], dout: &mut [O], + pub fn encrypt_update(&mut self, din: &[u8], dout: &mut [u8], auth: &[u8]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; let auth_size = crate::buffer_len_to_u32(auth.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesGcmEncryptUpdate(&mut self.ws_aes, out_ptr, - in_ptr, in_size, auth.as_ptr(), auth_size) + sys::wc_AesGcmEncryptUpdate(&mut self.ws_aes, dout.as_mut_ptr(), + din.as_ptr(), in_size, auth.as_ptr(), auth_size) }; if rc != 0 { return Err(rc); @@ -2033,19 +1991,17 @@ impl GCMStream { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn decrypt_update(&mut self, din: &[I], dout: &mut [O], + pub fn decrypt_update(&mut self, din: &[u8], dout: &mut [u8], auth: &[u8]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; let auth_size = crate::buffer_len_to_u32(auth.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesGcmDecryptUpdate(&mut self.ws_aes, out_ptr, - in_ptr, in_size, auth.as_ptr(), auth_size) + sys::wc_AesGcmDecryptUpdate(&mut self.ws_aes, dout.as_mut_ptr(), + din.as_ptr(), in_size, auth.as_ptr(), auth_size) }; if rc != 0 { return Err(rc); @@ -2219,16 +2175,14 @@ impl OFB { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn encrypt(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesOfbEncrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesOfbEncrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -2251,16 +2205,14 @@ impl OFB { /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. #[cfg(aes_decrypt)] - pub fn decrypt(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn decrypt(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesOfbDecrypt(&mut self.ws_aes, out_ptr, in_ptr, in_size) + sys::wc_AesOfbDecrypt(&mut self.ws_aes, dout.as_mut_ptr(), din.as_ptr(), in_size) }; if rc != 0 { return Err(rc); @@ -2437,18 +2389,16 @@ impl XTS { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt(&mut self, din: &[I], dout: &mut [O], tweak: &[u8]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn encrypt(&mut self, din: &[u8], dout: &mut [u8], tweak: &[u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; let tweak_size = crate::buffer_len_to_u32(tweak.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesXtsEncrypt(&mut self.ws_xtsaes, out_ptr, - in_ptr, in_size, tweak.as_ptr(), tweak_size) + sys::wc_AesXtsEncrypt(&mut self.ws_xtsaes, dout.as_mut_ptr(), + din.as_ptr(), in_size, tweak.as_ptr(), tweak_size) }; if rc != 0 { return Err(rc); @@ -2476,17 +2426,15 @@ impl XTS { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt_sector(&mut self, din: &[I], dout: &mut [O], sector: u64) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn encrypt_sector(&mut self, din: &[u8], dout: &mut [u8], sector: u64) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesXtsEncryptSector(&mut self.ws_xtsaes, out_ptr, - in_ptr, in_size, sector) + sys::wc_AesXtsEncryptSector(&mut self.ws_xtsaes, dout.as_mut_ptr(), + din.as_ptr(), in_size, sector) }; if rc != 0 { return Err(rc); @@ -2515,18 +2463,16 @@ impl XTS { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt_consecutive_sectors(&mut self, din: &[I], dout: &mut [O], + pub fn encrypt_consecutive_sectors(&mut self, din: &[u8], dout: &mut [u8], sector: u64, sector_size: u32) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { sys::wc_AesXtsEncryptConsecutiveSectors(&mut self.ws_xtsaes, - out_ptr, in_ptr, in_size, sector, sector_size) + dout.as_mut_ptr(), din.as_ptr(), in_size, sector, sector_size) }; if rc != 0 { return Err(rc); @@ -2549,18 +2495,16 @@ impl XTS { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn decrypt(&mut self, din: &[I], dout: &mut [O], tweak: &[u8]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn decrypt(&mut self, din: &[u8], dout: &mut [u8], tweak: &[u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; let tweak_size = crate::buffer_len_to_u32(tweak.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesXtsDecrypt(&mut self.ws_xtsaes, out_ptr, - in_ptr, in_size, tweak.as_ptr(), tweak_size) + sys::wc_AesXtsDecrypt(&mut self.ws_xtsaes, dout.as_mut_ptr(), + din.as_ptr(), in_size, tweak.as_ptr(), tweak_size) }; if rc != 0 { return Err(rc); @@ -2588,17 +2532,15 @@ impl XTS { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn decrypt_sector(&mut self, din: &[I], dout: &mut [O], sector: u64) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + pub fn decrypt_sector(&mut self, din: &[u8], dout: &mut [u8], sector: u64) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesXtsDecryptSector(&mut self.ws_xtsaes, out_ptr, - in_ptr, in_size, sector) + sys::wc_AesXtsDecryptSector(&mut self.ws_xtsaes, dout.as_mut_ptr(), + din.as_ptr(), in_size, sector) }; if rc != 0 { return Err(rc); @@ -2627,18 +2569,16 @@ impl XTS { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn decrypt_consecutive_sectors(&mut self, din: &[I], dout: &mut [O], + pub fn decrypt_consecutive_sectors(&mut self, din: &[u8], dout: &mut [u8], sector: u64, sector_size: u32) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; - let out_ptr = dout.as_mut_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let in_size = crate::buffer_len_to_u32(din.len())?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { sys::wc_AesXtsDecryptConsecutiveSectors(&mut self.ws_xtsaes, - out_ptr, in_ptr, in_size, sector, sector_size) + dout.as_mut_ptr(), din.as_ptr(), in_size, sector, sector_size) }; if rc != 0 { return Err(rc); @@ -2833,17 +2773,16 @@ impl XTSStream { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt_update(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; + pub fn encrypt_update(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; let out_ptr = dout.as_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { sys::wc_AesXtsEncryptUpdate(&mut self.ws_xtsaes, out_ptr, - in_ptr, in_size, &mut self.ws_xtsaesstreamdata) + din.as_ptr(), in_size, &mut self.ws_xtsaesstreamdata) }; if rc != 0 { return Err(rc); @@ -2868,17 +2807,16 @@ impl XTSStream { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn encrypt_final(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; + pub fn encrypt_final(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; let out_ptr = dout.as_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { sys::wc_AesXtsEncryptFinal(&mut self.ws_xtsaes, out_ptr, - in_ptr, in_size, &mut self.ws_xtsaesstreamdata) + din.as_ptr(), in_size, &mut self.ws_xtsaesstreamdata) }; if rc != 0 { return Err(rc); @@ -2904,17 +2842,16 @@ impl XTSStream { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn decrypt_update(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; + pub fn decrypt_update(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; let out_ptr = dout.as_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { sys::wc_AesXtsDecryptUpdate(&mut self.ws_xtsaes, out_ptr, - in_ptr, in_size, &mut self.ws_xtsaesstreamdata) + din.as_ptr(), in_size, &mut self.ws_xtsaesstreamdata) }; if rc != 0 { return Err(rc); @@ -2939,17 +2876,16 @@ impl XTSStream { /// /// A Result which is Ok(()) on success or an Err containing the wolfSSL /// library return code on failure. - pub fn decrypt_final(&mut self, din: &[I], dout: &mut [O]) -> Result<(), i32> { - let in_ptr = din.as_ptr() as *const u8; - let in_size = crate::buffer_len_to_u32(size_of_val(din))?; + pub fn decrypt_final(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { + let in_size = crate::buffer_len_to_u32(din.len())?; let out_ptr = dout.as_ptr() as *mut u8; - let out_size = crate::buffer_len_to_u32(size_of_val(dout))?; + let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { sys::wc_AesXtsDecryptFinal(&mut self.ws_xtsaes, out_ptr, - in_ptr, in_size, &mut self.ws_xtsaesstreamdata) + din.as_ptr(), in_size, &mut self.ws_xtsaesstreamdata) }; if rc != 0 { return Err(rc); From 85ad08a50a8c96202dfa7a2c8b4af591e999160b Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Fri, 27 Mar 2026 15:21:07 -0400 Subject: [PATCH 13/20] Rust wrapper: avoid as_ptr() to *mut u8 casts Fixes F-1065. --- wrapper/rust/wolfssl-wolfcrypt/src/aes.rs | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs b/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs index 2441e251ea8..f4b3244fed7 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs @@ -2775,13 +2775,12 @@ impl XTSStream { /// library return code on failure. pub fn encrypt_update(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { let in_size = crate::buffer_len_to_u32(din.len())?; - let out_ptr = dout.as_ptr() as *mut u8; let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesXtsEncryptUpdate(&mut self.ws_xtsaes, out_ptr, + sys::wc_AesXtsEncryptUpdate(&mut self.ws_xtsaes, dout.as_mut_ptr(), din.as_ptr(), in_size, &mut self.ws_xtsaesstreamdata) }; if rc != 0 { @@ -2809,13 +2808,12 @@ impl XTSStream { /// library return code on failure. pub fn encrypt_final(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { let in_size = crate::buffer_len_to_u32(din.len())?; - let out_ptr = dout.as_ptr() as *mut u8; let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesXtsEncryptFinal(&mut self.ws_xtsaes, out_ptr, + sys::wc_AesXtsEncryptFinal(&mut self.ws_xtsaes, dout.as_mut_ptr(), din.as_ptr(), in_size, &mut self.ws_xtsaesstreamdata) }; if rc != 0 { @@ -2844,13 +2842,12 @@ impl XTSStream { /// library return code on failure. pub fn decrypt_update(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { let in_size = crate::buffer_len_to_u32(din.len())?; - let out_ptr = dout.as_ptr() as *mut u8; let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesXtsDecryptUpdate(&mut self.ws_xtsaes, out_ptr, + sys::wc_AesXtsDecryptUpdate(&mut self.ws_xtsaes, dout.as_mut_ptr(), din.as_ptr(), in_size, &mut self.ws_xtsaesstreamdata) }; if rc != 0 { @@ -2878,13 +2875,12 @@ impl XTSStream { /// library return code on failure. pub fn decrypt_final(&mut self, din: &[u8], dout: &mut [u8]) -> Result<(), i32> { let in_size = crate::buffer_len_to_u32(din.len())?; - let out_ptr = dout.as_ptr() as *mut u8; let out_size = crate::buffer_len_to_u32(dout.len())?; if in_size != out_size { return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); } let rc = unsafe { - sys::wc_AesXtsDecryptFinal(&mut self.ws_xtsaes, out_ptr, + sys::wc_AesXtsDecryptFinal(&mut self.ws_xtsaes, dout.as_mut_ptr(), din.as_ptr(), in_size, &mut self.ws_xtsaesstreamdata) }; if rc != 0 { From 10fbc952416ccd15251c6e6a3d3f9eb8416ebe98 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Fri, 27 Mar 2026 15:27:46 -0400 Subject: [PATCH 14/20] Rust wrapper: add comment to MlKem about not implementing Send/Sync Fixes F-1072. --- wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs b/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs index a7d903be332..0e2080c3b7b 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs @@ -73,6 +73,10 @@ use zeroize::Zeroize; /// /// An instance is created with [`MlKem::generate()`], /// [`MlKem::generate_with_random()`], or [`MlKem::new()`]. +/// +/// This struct does not implement Send or Sync because it is not safe in the +/// general case to access the underlying C API from multiple threads +/// concurrently. pub struct MlKem { ws_key: *mut sys::MlKemKey, } From 2f94121078cb3efa51e0b1606e8a8c9c910142fa Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Fri, 27 Mar 2026 15:37:32 -0400 Subject: [PATCH 15/20] Rust wrapper: require caller supplied buffer for Lms.get_kid() Fixes F-1073. --- wrapper/rust/wolfssl-wolfcrypt/src/lms.rs | 20 +++++++++++++------ .../rust/wolfssl-wolfcrypt/tests/test_lms.rs | 4 ++-- 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs b/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs index 4aa09a34dba..94f837caeec 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs @@ -757,13 +757,17 @@ impl Lms { /// Get the Key ID (I value) for this LMS/HSS key. /// - /// Returns a slice pointing into the key's internal storage. + /// Copies the key ID into the provided buffer. + /// + /// # Parameters + /// + /// * `kid`: Buffer in which to store the key ID. /// /// # Returns /// - /// Returns either Ok(&[u8]) containing the key ID on success, or Err(e) - /// containing the wolfSSL library error code value. - pub fn get_kid(&mut self) -> Result<&[u8], i32> { + /// Returns either Ok(usize) containing the key ID length on success, + /// or Err(e) containing the wolfSSL library error code value. + pub fn get_kid(&mut self, kid: &mut [u8]) -> Result { let mut kid_ptr: *const u8 = core::ptr::null(); let mut kid_sz: u32 = 0; let rc = unsafe { @@ -772,8 +776,12 @@ impl Lms { if rc != 0 { return Err(rc); } - let slice = unsafe { core::slice::from_raw_parts(kid_ptr, kid_sz as usize) }; - Ok(slice) + let src = unsafe { core::slice::from_raw_parts(kid_ptr, kid_sz as usize) }; + if kid.len() < src.len() { + return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E); + } + kid[..src.len()].copy_from_slice(src); + Ok(src.len()) } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/tests/test_lms.rs b/wrapper/rust/wolfssl-wolfcrypt/tests/test_lms.rs index 16a51c3c9e7..ccc30bd4b1d 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/tests/test_lms.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/tests/test_lms.rs @@ -386,8 +386,8 @@ fn test_get_kid() { setup_callbacks(&mut key, ctx); key.make_key(&mut rng).expect("Error with make_key()"); - let kid = key.get_kid().expect("Error with get_kid()"); - assert_eq!(kid.len(), Lms::KEY_ID_LEN, "kid must be KEY_ID_LEN bytes"); + let mut kid = [0u8; Lms::KEY_ID_LEN]; + key.get_kid(&mut kid).expect("Error with get_kid()"); let _ = store; } From 15ac0718a3f599c3746287bc2e3af7453b2528de Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Mon, 13 Apr 2026 15:45:28 -0400 Subject: [PATCH 16/20] Rust wrapper: make zeroize functions private --- wrapper/rust/wolfssl-wolfcrypt/src/aes.rs | 20 ++++++++-------- wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs | 9 ++++---- .../src/chacha20_poly1305.rs | 2 +- wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs | 3 +-- .../rust/wolfssl-wolfcrypt/src/curve25519.rs | 3 +-- wrapper/rust/wolfssl-wolfcrypt/src/dh.rs | 3 +-- .../rust/wolfssl-wolfcrypt/src/dilithium.rs | 3 +-- wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs | 5 ++-- wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs | 3 +-- wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs | 3 +-- wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs | 3 +-- wrapper/rust/wolfssl-wolfcrypt/src/lib.rs | 2 +- wrapper/rust/wolfssl-wolfcrypt/src/lms.rs | 3 +-- wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs | 3 +-- wrapper/rust/wolfssl-wolfcrypt/src/random.rs | 3 +-- wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs | 3 +-- wrapper/rust/wolfssl-wolfcrypt/src/sha.rs | 23 +++++++++---------- 17 files changed, 40 insertions(+), 54 deletions(-) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs b/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs index f4b3244fed7..9aede174186 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/aes.rs @@ -230,7 +230,7 @@ impl CBC { } } #[cfg(aes_cbc)] -impl Zeroize for CBC { +impl CBC { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_aes); } } @@ -422,7 +422,7 @@ impl CCM { } } #[cfg(aes_ccm)] -impl Zeroize for CCM { +impl CCM { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_aes); } } @@ -897,7 +897,7 @@ impl CFB { } } #[cfg(aes_cfb)] -impl Zeroize for CFB { +impl CFB { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_aes); } } @@ -1072,7 +1072,7 @@ impl CTR { } } #[cfg(aes_ctr)] -impl Zeroize for CTR { +impl CTR { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_aes); } } @@ -1379,7 +1379,7 @@ impl ECB { } } #[cfg(aes_ecb)] -impl Zeroize for ECB { +impl ECB { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_aes); } } @@ -1577,7 +1577,7 @@ impl GCM { } } #[cfg(aes_gcm)] -impl Zeroize for GCM { +impl GCM { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_aes); } } @@ -2037,7 +2037,7 @@ impl GCMStream { } } #[cfg(aes_gcm_stream)] -impl Zeroize for GCMStream { +impl GCMStream { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_aes); } } @@ -2221,7 +2221,7 @@ impl OFB { } } #[cfg(aes_ofb)] -impl Zeroize for OFB { +impl OFB { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_aes); } } @@ -2587,7 +2587,7 @@ impl XTS { } } #[cfg(aes_xts)] -impl Zeroize for XTS { +impl XTS { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_xtsaes); } } @@ -2890,7 +2890,7 @@ impl XTSStream { } } #[cfg(aes_xts_stream)] -impl Zeroize for XTSStream { +impl XTSStream { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_xtsaes); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs b/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs index 8b4ef5a3ae6..674b905d1bb 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs @@ -27,7 +27,6 @@ functionality. use crate::sys; use core::mem::MaybeUninit; -use zeroize::Zeroize; /// Context for BLAKE2b computation. #[cfg(blake2b)] @@ -176,7 +175,7 @@ impl BLAKE2b { #[cfg(blake2b)] -impl Zeroize for BLAKE2b { +impl BLAKE2b { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_blake2b); } } @@ -327,7 +326,7 @@ impl BLAKE2bHmac { #[cfg(blake2b_hmac)] -impl Zeroize for BLAKE2bHmac { +impl BLAKE2bHmac { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_blake2b); } } @@ -487,7 +486,7 @@ impl BLAKE2s { #[cfg(blake2s)] -impl Zeroize for BLAKE2s { +impl BLAKE2s { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_blake2s); } } @@ -637,7 +636,7 @@ impl BLAKE2sHmac { } #[cfg(blake2s_hmac)] -impl Zeroize for BLAKE2sHmac { +impl BLAKE2sHmac { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_blake2s); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs b/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs index 795363c0950..ae4e69b8334 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/chacha20_poly1305.rs @@ -244,7 +244,7 @@ impl ChaCha20Poly1305 { } } -impl Zeroize for ChaCha20Poly1305 { +impl ChaCha20Poly1305 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_ccp); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs b/wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs index 63755ab677e..f99c7c96878 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/cmac.rs @@ -27,7 +27,6 @@ Message Authentication Code (CMAC) functionality. use crate::sys; use core::mem::MaybeUninit; -use zeroize::Zeroize; /// The `CMAC` struct manages the lifecycle of a wolfSSL `Cmac` object. /// @@ -409,7 +408,7 @@ impl CMAC { Ok(rc == 0) } } -impl Zeroize for CMAC { +impl CMAC { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_cmac); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs b/wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs index d51f114b169..ef3c3ca8bd4 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/curve25519.rs @@ -29,7 +29,6 @@ functionality. use crate::random::RNG; use crate::sys; use core::mem::MaybeUninit; -use zeroize::Zeroize; pub struct Curve25519Key { wc_key: sys::curve25519_key, @@ -655,7 +654,7 @@ impl Curve25519Key { } } -impl Zeroize for Curve25519Key { +impl Curve25519Key { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_key); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/dh.rs b/wrapper/rust/wolfssl-wolfcrypt/src/dh.rs index 047b84896d0..36c4fca3fac 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/dh.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/dh.rs @@ -32,7 +32,6 @@ use crate::sys; #[cfg(random)] use crate::random::RNG; use core::mem::{MaybeUninit}; -use zeroize::Zeroize; pub struct DH { wc_dhkey: sys::DhKey, @@ -1580,7 +1579,7 @@ impl DH { } } -impl Zeroize for DH { +impl DH { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_dhkey); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs b/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs index e57640aab7f..00051478594 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/dilithium.rs @@ -62,7 +62,6 @@ use crate::sys; #[cfg(all(random, any(dilithium_make_key, dilithium_sign)))] use crate::random::RNG; use core::mem::MaybeUninit; -use zeroize::Zeroize; /// Rust wrapper for a wolfSSL `dilithium_key` object. /// @@ -1300,7 +1299,7 @@ impl Dilithium { } } -impl Zeroize for Dilithium { +impl Dilithium { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_key); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs b/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs index 4221e70f25d..e8a2e3700b8 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/ecc.rs @@ -32,7 +32,6 @@ use crate::sys; #[cfg(random)] use crate::random::RNG; use core::mem::{MaybeUninit}; -use zeroize::Zeroize; /// Rust wrapper for wolfSSL `ecc_point` object. pub struct ECCPoint { @@ -268,7 +267,7 @@ impl ECCPoint { } } -impl Zeroize for ECCPoint { +impl ECCPoint { fn zeroize(&mut self) { self.wc_ecc_point = core::ptr::null_mut(); self.heap = core::ptr::null_mut(); @@ -1966,7 +1965,7 @@ impl ECC { } } -impl Zeroize for ECC { +impl ECC { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_ecc_key); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs b/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs index 26a2caa9374..d0e7e4f1dfb 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.rs @@ -28,7 +28,6 @@ This module provides a Rust wrapper for the wolfCrypt library's EdDSA Curve use crate::sys; use crate::random::RNG; use core::mem::MaybeUninit; -use zeroize::Zeroize; /// The `Ed25519` struct manages the lifecycle of a wolfSSL `ed25519_key` /// object. @@ -1431,7 +1430,7 @@ impl Ed25519 { } } -impl Zeroize for Ed25519 { +impl Ed25519 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_key); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs b/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs index b4a23db7cc7..9191bed6880 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/ed448.rs @@ -28,7 +28,6 @@ This module provides a Rust wrapper for the wolfCrypt library's EdDSA Curve use crate::sys; use crate::random::RNG; use core::mem::MaybeUninit; -use zeroize::Zeroize; /// The `Ed448` struct manages the lifecycle of a wolfSSL `ed448_key` /// object. @@ -1356,7 +1355,7 @@ impl Ed448 { } } -impl Zeroize for Ed448 { +impl Ed448 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_key); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs b/wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs index 893fe3e02cf..b1d004006ce 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/hmac.rs @@ -27,7 +27,6 @@ functionality. use crate::sys; use core::mem::MaybeUninit; -use zeroize::Zeroize; /// Rust wrapper for wolfSSL `Hmac` object. pub struct HMAC { @@ -325,7 +324,7 @@ impl HMAC { } } -impl Zeroize for HMAC { +impl HMAC { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_hmac); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/lib.rs b/wrapper/rust/wolfssl-wolfcrypt/src/lib.rs index b4552ef4de5..729c7cff968 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/lib.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/lib.rs @@ -23,7 +23,7 @@ /* bindgen-generated bindings to the C library */ pub mod sys; -/// Zeroize the raw bytes of a value. For use in `Zeroize` impls on C FFI +/// Zeroize the raw bytes of a value. For use in `zeroize()` methods on C FFI /// structs where `#[derive(Zeroize)]` cannot be used. /// /// # Safety diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs b/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs index 94f837caeec..f76f82a7db5 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/lms.rs @@ -89,7 +89,6 @@ use crate::sys; use core::mem::MaybeUninit; #[cfg(all(lms_make_key, random))] use crate::random::RNG; -use zeroize::Zeroize; /// Rust wrapper for a wolfSSL `LmsKey` object (LMS/HSS, RFC 8554). /// @@ -785,7 +784,7 @@ impl Lms { } } -impl Zeroize for Lms { +impl Lms { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.ws_key); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs b/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs index 0e2080c3b7b..bedd6f2d8e2 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/mlkem.rs @@ -64,7 +64,6 @@ assert_eq!(ss_alice, ss_bob); use crate::sys; #[cfg(random)] use crate::random::RNG; -use zeroize::Zeroize; /// Rust wrapper for a wolfSSL `MlKemKey` object. /// @@ -789,7 +788,7 @@ impl MlKem { } } -impl Zeroize for MlKem { +impl MlKem { fn zeroize(&mut self) { self.ws_key = core::ptr::null_mut(); } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/random.rs b/wrapper/rust/wolfssl-wolfcrypt/src/random.rs index 94ef3d70c4f..5fb54294469 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/random.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/random.rs @@ -46,7 +46,6 @@ rng.generate_block(&mut buffer).expect("Failed to generate a block"); use crate::sys; use core::mem::{size_of_val, MaybeUninit}; -use zeroize::Zeroize; /// A cryptographically secure random number generator based on the wolfSSL /// library. @@ -411,7 +410,7 @@ impl rand_core::TryRng for RNG { #[cfg(feature = "rand_core")] impl rand_core::TryCryptoRng for RNG {} -impl Zeroize for RNG { +impl RNG { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_rng); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs b/wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs index 19344b3bea6..56526f34abd 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/rsa.rs @@ -63,7 +63,6 @@ use crate::sys; #[cfg(random)] use crate::random::RNG; use core::mem::{MaybeUninit}; -use zeroize::Zeroize; /// The `RSA` struct manages the lifecycle of a wolfSSL `RsaKey` object. /// @@ -1284,7 +1283,7 @@ impl RSA { } } -impl Zeroize for RSA { +impl RSA { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_rsakey); } } diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs b/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs index a2731904fa5..2de688b39d2 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs @@ -25,7 +25,6 @@ Algorithm (SHA) functionality. use crate::sys; use core::mem::MaybeUninit; -use zeroize::Zeroize; /// Context for SHA-1 computation. #[cfg(sha)] @@ -217,7 +216,7 @@ impl SHA { } #[cfg(sha)] -impl Zeroize for SHA { +impl SHA { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_sha); } } @@ -428,7 +427,7 @@ impl SHA224 { } #[cfg(sha224)] -impl Zeroize for SHA224 { +impl SHA224 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_sha224); } } @@ -639,7 +638,7 @@ impl SHA256 { } #[cfg(sha256)] -impl Zeroize for SHA256 { +impl SHA256 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_sha256); } } @@ -850,7 +849,7 @@ impl SHA384 { } #[cfg(sha384)] -impl Zeroize for SHA384 { +impl SHA384 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_sha384); } } @@ -1061,7 +1060,7 @@ impl SHA512 { } #[cfg(sha512)] -impl Zeroize for SHA512 { +impl SHA512 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_sha512); } } @@ -1272,7 +1271,7 @@ impl SHA3_224 { } #[cfg(sha3)] -impl Zeroize for SHA3_224 { +impl SHA3_224 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_sha3); } } @@ -1483,7 +1482,7 @@ impl SHA3_256 { } #[cfg(sha3)] -impl Zeroize for SHA3_256 { +impl SHA3_256 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_sha3); } } @@ -1694,7 +1693,7 @@ impl SHA3_384 { } #[cfg(sha3)] -impl Zeroize for SHA3_384 { +impl SHA3_384 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_sha3); } } @@ -1905,7 +1904,7 @@ impl SHA3_512 { } #[cfg(sha3)] -impl Zeroize for SHA3_512 { +impl SHA3_512 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_sha3); } } @@ -2183,7 +2182,7 @@ impl SHAKE128 { } #[cfg(shake128)] -impl Zeroize for SHAKE128 { +impl SHAKE128 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_shake); } } @@ -2461,7 +2460,7 @@ impl SHAKE256 { } #[cfg(shake256)] -impl Zeroize for SHAKE256 { +impl SHAKE256 { fn zeroize(&mut self) { unsafe { crate::zeroize_raw(&mut self.wc_shake); } } From e1a01926bcbc85b40fc057a68d6fb07a0d72ede2 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Mon, 13 Apr 2026 15:47:55 -0400 Subject: [PATCH 17/20] Rust wrapper: check length returned by Lms.get_kid() in unit test --- wrapper/rust/wolfssl-wolfcrypt/tests/test_lms.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/wrapper/rust/wolfssl-wolfcrypt/tests/test_lms.rs b/wrapper/rust/wolfssl-wolfcrypt/tests/test_lms.rs index ccc30bd4b1d..842c435669f 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/tests/test_lms.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/tests/test_lms.rs @@ -387,7 +387,9 @@ fn test_get_kid() { key.make_key(&mut rng).expect("Error with make_key()"); let mut kid = [0u8; Lms::KEY_ID_LEN]; - key.get_kid(&mut kid).expect("Error with get_kid()"); + let kid_len = key.get_kid(&mut kid).expect("Error with get_kid()"); + assert_eq!(kid_len, Lms::KEY_ID_LEN, "get_kid() must write KEY_ID_LEN bytes"); + assert!(kid.iter().any(|&b| b != 0), "get_kid() must populate the output buffer"); let _ = store; } From ca362a4e8fb872ddc29deacee72eb9ee73836067 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Mon, 13 Apr 2026 16:07:10 -0400 Subject: [PATCH 18/20] Rust wrapper: also check usize to u32 conversions for digest_size --- wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs b/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs index 674b905d1bb..a357088f1e2 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/blake2.rs @@ -54,7 +54,7 @@ impl BLAKE2b { /// let blake2b = BLAKE2b::new(64).expect("Error with new()"); /// ``` pub fn new(digest_size: usize) -> Result { - let digest_size = digest_size as u32; + let digest_size = crate::buffer_len_to_u32(digest_size)?; let mut wc_blake2b: MaybeUninit = MaybeUninit::uninit(); let rc = unsafe { sys::wc_InitBlake2b(wc_blake2b.as_mut_ptr(), digest_size) @@ -88,7 +88,7 @@ impl BLAKE2b { /// ``` pub fn new_with_key(digest_size: usize, key: &[u8]) -> Result { let key_size = crate::buffer_len_to_u32(key.len())?; - let digest_size = digest_size as u32; + let digest_size = crate::buffer_len_to_u32(digest_size)?; let mut wc_blake2b: MaybeUninit = MaybeUninit::uninit(); let rc = unsafe { sys::wc_InitBlake2b_WithKey(wc_blake2b.as_mut_ptr(), digest_size, @@ -365,7 +365,7 @@ impl BLAKE2s { /// let blake2s = BLAKE2s::new(32).expect("Error with new()"); /// ``` pub fn new(digest_size: usize) -> Result { - let digest_size = digest_size as u32; + let digest_size = crate::buffer_len_to_u32(digest_size)?; let mut wc_blake2s: MaybeUninit = MaybeUninit::uninit(); let rc = unsafe { sys::wc_InitBlake2s(wc_blake2s.as_mut_ptr(), digest_size) @@ -399,7 +399,7 @@ impl BLAKE2s { /// ``` pub fn new_with_key(digest_size: usize, key: &[u8]) -> Result { let key_size = crate::buffer_len_to_u32(key.len())?; - let digest_size = digest_size as u32; + let digest_size = crate::buffer_len_to_u32(digest_size)?; let mut wc_blake2s: MaybeUninit = MaybeUninit::uninit(); let rc = unsafe { sys::wc_InitBlake2s_WithKey(wc_blake2s.as_mut_ptr(), digest_size, From 4fb4b3c0c8f9378d3ea15633186c73f20b1a6675 Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Tue, 14 Apr 2026 10:40:53 -0400 Subject: [PATCH 19/20] Rust wrapper: test BLAKE2 finalize() returns error for empty output buffer --- .../wolfssl-wolfcrypt/tests/test_blake2.rs | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/wrapper/rust/wolfssl-wolfcrypt/tests/test_blake2.rs b/wrapper/rust/wolfssl-wolfcrypt/tests/test_blake2.rs index 4b8bff27feb..4f7126d14d5 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/tests/test_blake2.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/tests/test_blake2.rs @@ -1,5 +1,7 @@ #[cfg(any(blake2b, blake2s))] use wolfssl_wolfcrypt::blake2::*; +#[cfg(any(blake2b, blake2s))] +use wolfssl_wolfcrypt::sys; #[test] #[cfg(blake2b)] @@ -50,6 +52,15 @@ fn test_blake2b() { } } +#[test] +#[cfg(blake2b)] +fn test_blake2b_finalize_empty_buffer() { + let mut blake2b = BLAKE2b::new(64).expect("Error with new()"); + let mut hash: [u8; 0] = []; + let rc = blake2b.finalize(&mut hash).expect_err("finalize() should fail"); + assert_eq!(rc, sys::wolfCrypt_ErrorCodes_BUFFER_E); +} + #[test] #[cfg(blake2b_hmac)] fn test_blake2b_hmac() { @@ -151,6 +162,15 @@ fn test_blake2s() { } } +#[test] +#[cfg(blake2s)] +fn test_blake2s_finalize_empty_buffer() { + let mut blake2s = BLAKE2s::new(32).expect("Error with new()"); + let mut hash: [u8; 0] = []; + let rc = blake2s.finalize(&mut hash).expect_err("finalize() should fail"); + assert_eq!(rc, sys::wolfCrypt_ErrorCodes_BUFFER_E); +} + #[test] #[cfg(blake2s_hmac)] fn test_blake2s_hmac() { From 4f31ff95f7c68458e711c050bf401b3dd587626c Mon Sep 17 00:00:00 2001 From: Josh Holtrop Date: Tue, 14 Apr 2026 10:44:54 -0400 Subject: [PATCH 20/20] Rust wrapper: require fixed length index buffers for SRTP/SRTCP --- wolfcrypt/src/kdf.c | 8 +++---- wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs | 26 +++++++++-------------- 2 files changed, 14 insertions(+), 20 deletions(-) diff --git a/wolfcrypt/src/kdf.c b/wolfcrypt/src/kdf.c index c6be3afc992..d8fcafbeff6 100644 --- a/wolfcrypt/src/kdf.c +++ b/wolfcrypt/src/kdf.c @@ -984,7 +984,7 @@ static int wc_srtp_kdf_derive_key(byte* block, int idxSz, byte label, * @param [in] saltSz Size of random in bytes. * @param [in] kdrIdx Key derivation rate. kdr = 0 when -1, otherwise * kdr = 2^kdrIdx. - * @param [in] index Index value to XOR in. + * @param [in] idx Index value to XOR in. * @param [out] key1 First key. Label value of 0x00. * @param [in] key1Sz Size of first key in bytes. * @param [out] key2 Second key. Label value of 0x01. @@ -1069,7 +1069,7 @@ int wc_SRTP_KDF(const byte* key, word32 keySz, const byte* salt, word32 saltSz, * @param [in] saltSz Size of random in bytes. * @param [in] kdrIdx Key derivation rate index. kdr = 0 when -1, otherwise * kdr = 2^kdrIdx. See wc_SRTP_KDF_kdr_to_idx() - * @param [in] index Index value to XOR in. + * @param [in] idx Index value to XOR in. * @param [out] key1 First key. Label value of 0x03. * @param [in] key1Sz Size of first key in bytes. * @param [out] key2 Second key. Label value of 0x04. @@ -1171,7 +1171,7 @@ int wc_SRTCP_KDF(const byte* key, word32 keySz, const byte* salt, word32 saltSz, * @param [in] saltSz Size of random in bytes. * @param [in] kdrIdx Key derivation rate index. kdr = 0 when -1, otherwise * kdr = 2^kdrIdx. See wc_SRTP_KDF_kdr_to_idx() - * @param [in] index Index value to XOR in. + * @param [in] idx Index value to XOR in. * @param [in] label Label to use when deriving key. * @param [out] outKey Derived key. * @param [in] outKeySz Size of derived key in bytes. @@ -1244,7 +1244,7 @@ int wc_SRTP_KDF_label(const byte* key, word32 keySz, const byte* salt, * @param [in] saltSz Size of random in bytes. * @param [in] kdrIdx Key derivation rate index. kdr = 0 when -1, otherwise * kdr = 2^kdrIdx. See wc_SRTP_KDF_kdr_to_idx() - * @param [in] index Index value to XOR in. + * @param [in] idx Index value to XOR in. * @param [in] label Label to use when deriving key. * @param [out] outKey Derived key. * @param [in] outKeySz Size of derived key in bytes. diff --git a/wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs b/wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs index 9d2ae3c53a1..ab294f1a50a 100644 --- a/wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs +++ b/wrapper/rust/wolfssl-wolfcrypt/src/kdf.rs @@ -43,6 +43,10 @@ pub const SRTCP_LABEL_SALT: u8 = sys::WC_SRTCP_LABEL_SALT as u8; pub const SRTP_LABEL_HDR_ENCRYPTION: u8 = sys::WC_SRTP_LABEL_HDR_ENCRYPTION as u8; #[cfg(kdf_srtp)] pub const SRTP_LABEL_HDR_SALT: u8 = sys::WC_SRTP_LABEL_HDR_SALT as u8; +#[cfg(kdf_srtp)] +pub const SRTP_INDEX_LEN: usize = sys::WC_SRTP_INDEX_LEN as usize; +#[cfg(kdf_srtp)] +pub const SRTCP_INDEX_LEN: usize = sys::WC_SRTCP_INDEX_LEN as usize; /// Implement Password Based Key Derivation Function 2 (PBKDF2) converting an /// input password with a concatenated salt into a more secure key which is @@ -582,13 +586,8 @@ pub fn ssh_kdf(typ: i32, key_id: u8, k: &[u8], h: &[u8], session_id: &[u8], key: /// } /// ``` #[cfg(kdf_srtp)] -pub fn srtp_kdf(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], +pub fn srtp_kdf(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8; SRTP_INDEX_LEN], key1: &mut [u8], key2: &mut [u8], key3: &mut [u8]) -> Result<(), i32> { - if !(kdr_index == -1 || (0 <= kdr_index && (kdr_index as usize) <= idx.len() * 8)) { - // The kdr_index value must be either -1 or the number of bits that - // will be read from the idx slice. - return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); - } let key_size = crate::buffer_len_to_u32(key.len())?; let salt_size = crate::buffer_len_to_u32(salt.len())?; let key1_size = crate::buffer_len_to_u32(key1.len())?; @@ -637,7 +636,7 @@ pub fn srtp_kdf(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], /// } /// ``` #[cfg(kdf_srtp)] -pub fn srtp_kdf_label(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], +pub fn srtp_kdf_label(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8; SRTP_INDEX_LEN], label: u8, keyout: &mut [u8]) -> Result<(), i32> { let key_size = crate::buffer_len_to_u32(key.len())?; let salt_size = crate::buffer_len_to_u32(salt.len())?; @@ -679,7 +678,7 @@ pub fn srtp_kdf_label(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], /// 0x8e, 0x26, 0xad, 0xb5, 0x32, 0x12, 0x98, 0x90]; /// let salt = [0x0eu8, 0x23, 0x00, 0x6c, 0x6c, 0x04, 0x4f, 0x56, /// 0x62, 0x40, 0x0e, 0x9d, 0x1b, 0xd6]; -/// let index = [0x48u8, 0x71, 0x65, 0x64, 0x9c, 0xca]; +/// let index = [0x48u8, 0x71, 0x65, 0x64]; /// let mut key_e = [0u8; 16]; /// let mut key_a = [0u8; 20]; /// let mut key_s = [0u8; 14]; @@ -687,13 +686,8 @@ pub fn srtp_kdf_label(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], /// } /// ``` #[cfg(kdf_srtp)] -pub fn srtcp_kdf(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], +pub fn srtcp_kdf(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8; SRTCP_INDEX_LEN], key1: &mut [u8], key2: &mut [u8], key3: &mut [u8]) -> Result<(), i32> { - if !(kdr_index == -1 || (0 <= kdr_index && (kdr_index as usize) <= idx.len() * 8)) { - // The kdr_index value must be either -1 or the number of bits that - // will be read from the idx slice. - return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG); - } let key_size = crate::buffer_len_to_u32(key.len())?; let salt_size = crate::buffer_len_to_u32(salt.len())?; let key1_size = crate::buffer_len_to_u32(key1.len())?; @@ -736,13 +730,13 @@ pub fn srtcp_kdf(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], /// 0x8e, 0x26, 0xad, 0xb5, 0x32, 0x12, 0x98, 0x90]; /// let salt = [0x0eu8, 0x23, 0x00, 0x6c, 0x6c, 0x04, 0x4f, 0x56, /// 0x62, 0x40, 0x0e, 0x9d, 0x1b, 0xd6]; -/// let index = [0x48u8, 0x71, 0x65, 0x64, 0x9c, 0xca]; +/// let index = [0x48u8, 0x71, 0x65, 0x64]; /// let mut key_a = [0u8; 20]; /// srtcp_kdf_label(&key, &salt, -1, &index, SRTCP_LABEL_MSG_AUTH, &mut key_a).expect("Error with srtcp_kdf_label()"); /// } /// ``` #[cfg(kdf_srtp)] -pub fn srtcp_kdf_label(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8], +pub fn srtcp_kdf_label(key: &[u8], salt: &[u8], kdr_index: i32, idx: &[u8; SRTCP_INDEX_LEN], label: u8, keyout: &mut [u8]) -> Result<(), i32> { let key_size = crate::buffer_len_to_u32(key.len())?; let salt_size = crate::buffer_len_to_u32(salt.len())?;