diff --git a/wrapper/rust/include.am b/wrapper/rust/include.am index bb115a5d6..5d898f4e7 100644 --- a/wrapper/rust/include.am +++ b/wrapper/rust/include.am @@ -17,10 +17,12 @@ EXTRA_DIST += wrapper/rust/wolfssl/build.rs EXTRA_DIST += wrapper/rust/wolfssl/src/lib.rs EXTRA_DIST += wrapper/rust/wolfssl/src/wolfcrypt.rs EXTRA_DIST += wrapper/rust/wolfssl/src/wolfcrypt/aes.rs +EXTRA_DIST += wrapper/rust/wolfssl/src/wolfcrypt/dh.rs EXTRA_DIST += wrapper/rust/wolfssl/src/wolfcrypt/ecc.rs EXTRA_DIST += wrapper/rust/wolfssl/src/wolfcrypt/random.rs EXTRA_DIST += wrapper/rust/wolfssl/src/wolfcrypt/rsa.rs EXTRA_DIST += wrapper/rust/wolfssl/tests/test_aes.rs +EXTRA_DIST += wrapper/rust/wolfssl/tests/test_dh.rs EXTRA_DIST += wrapper/rust/wolfssl/tests/test_ecc.rs EXTRA_DIST += wrapper/rust/wolfssl/tests/test_random.rs EXTRA_DIST += wrapper/rust/wolfssl/tests/test_rsa.rs diff --git a/wrapper/rust/wolfssl/src/wolfcrypt.rs b/wrapper/rust/wolfssl/src/wolfcrypt.rs index 90d883fa8..06374438a 100644 --- a/wrapper/rust/wolfssl/src/wolfcrypt.rs +++ b/wrapper/rust/wolfssl/src/wolfcrypt.rs @@ -19,6 +19,7 @@ */ pub mod aes; +pub mod dh; pub mod ecc; pub mod random; pub mod rsa; diff --git a/wrapper/rust/wolfssl/src/wolfcrypt/dh.rs b/wrapper/rust/wolfssl/src/wolfcrypt/dh.rs new file mode 100644 index 000000000..9a9a6445e --- /dev/null +++ b/wrapper/rust/wolfssl/src/wolfcrypt/dh.rs @@ -0,0 +1,1109 @@ +/* + * Copyright (C) 2025 wolfSSL Inc. + * + * This file is part of wolfSSL. + * + * wolfSSL is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 3 of the License, or + * (at your option) any later version. + * + * wolfSSL is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA + */ + +/*! +This module provides a Rust wrapper for the wolfCrypt library's Diffie-Hellman +(DH) functionality. + +It leverages the `wolfssl-sys` crate for low-level FFI bindings, encapsulating +the raw C functions in a memory-safe and easy-to-use Rust API. + +The primary component is the `DH` struct, which manages the lifecycle of a +wolfSSL `DhKey` object. It ensures proper initialization and deallocation. +*/ + +use wolfssl_sys as ws; + +use std::mem::{MaybeUninit}; +use std::ptr::null; +use crate::wolfcrypt::random::RNG; + +pub struct DH { + wc_dhkey: ws::DhKey, +} + +impl DH { + pub const FFDHE_2048: i32 = ws::WC_FFDHE_2048 as i32; + pub const FFDHE_3072: i32 = ws::WC_FFDHE_2048 as i32; + pub const FFDHE_4096: i32 = ws::WC_FFDHE_2048 as i32; + pub const FFDHE_6144: i32 = ws::WC_FFDHE_2048 as i32; + pub const FFDHE_8192: i32 = ws::WC_FFDHE_2048 as i32; + + /// Perform quick validity check of public key value against prime. + /// + /// This checks that: + /// * Public key is not 0 or 1. + /// * Public key is not equal to prime or prime - 1. + /// * Public key is not bigger than prime. + /// + /// # Parameters + /// + /// * `prime`: Buffer containing prime value. + /// * `public`: Buffer containing public key. + /// + /// # Returns + /// + /// Returns either Ok(()) on success or Err(e) containing the wolfSSL + /// library error code value. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let mut rng = RNG::new().expect("Failed to create RNG"); + /// let mut dh = DH::new_named(DH::FFDHE_2048).expect("Error with new_named()"); + /// let mut private = [0u8; 256]; + /// let mut private_size = 0u32; + /// let mut public = [0u8; 256]; + /// let mut public_size = 0u32; + /// dh.generate_key_pair(&mut rng, &mut private, &mut private_size, &mut public, &mut public_size).expect("Error with generate_key_pair()"); + /// let public = &public[0..(public_size as usize)]; + /// let mut p = [0u8; 256]; + /// let mut q = [0u8; 256]; + /// let mut g = [0u8; 256]; + /// let mut p_size = 0u32; + /// let mut g_size = 0u32; + /// let mut q_size = 0u32; + /// dh.export_params_raw(&mut p, &mut p_size, &mut q, &mut q_size, &mut g, &mut g_size).expect("Error with export_params_raw()"); + /// let p = &p[0..(p_size as usize)]; + /// DH::check_pub_value(p, public).expect("Error with check_pub_value()"); + /// ``` + 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 rc = unsafe { + ws::wc_DhCheckPubValue(prime.as_ptr(), prime_size, + public.as_ptr(), public_size) + }; + if rc != 0 { + return Err(rc); + } + Ok(()) + } + + /// Compare given DH parameters to named parameter set. + /// + /// # Parameters + /// + /// * `name`: DH parameters name, one of DH::FFDHE_*. + /// * `p`: DH `p` parameter value. + /// * `g`: DH `g` parameter value. + /// * `q`: DH `q` parameter value (optional). + /// + /// # Returns + /// + /// Returns whether the parameters match the named parameters. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let mut dh = DH::new_named(DH::FFDHE_2048).expect("Error with new_named()"); + /// let mut p = [0u8; 256]; + /// let mut q = [0u8; 256]; + /// let mut g = [0u8; 256]; + /// let mut p_size = 0u32; + /// let mut q_size = 0u32; + /// let mut g_size = 0u32; + /// dh.export_params_raw(&mut p, &mut p_size, &mut q, &mut q_size, &mut g, &mut g_size).expect("Error with export_params_raw()"); + /// let p = &p[0..(p_size as usize)]; + /// let g = &g[0..(g_size as usize)]; + /// assert!(DH::compare_named_key(DH::FFDHE_2048, p, g, None)); + /// ``` + pub fn compare_named_key(name: i32, p: &[u8], g: &[u8], q: Option<&[u8]>) -> bool { + let p_size = p.len() as u32; + let g_size = g.len() as u32; + let mut no_q = 1i32; + let mut q_ptr: *const u8 = null(); + let mut q_size = 0u32; + if let Some(q) = q { + no_q = 0; + q_ptr = q.as_ptr(); + q_size = q.len() as u32; + } + let rc = unsafe { + ws::wc_DhCmpNamedKey(name, no_q, + p.as_ptr(), p_size, + g.as_ptr(), g_size, + q_ptr, q_size) + }; + rc != 0 + } + + /// Create a new DH context by generating parameters. + /// + /// # Parameters + /// + /// * `rng`: `RNG` struct instance to use for random number generation. + /// * `modulus_size`: Modulus size in bits. + /// + /// # Returns + /// + /// Returns either Ok(dh) containing the DH struct instance or Err(e) + /// containing the wolfSSL library error code value. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let mut rng = RNG::new().expect("Error with RNG::new()"); + /// let mut dh = DH::generate(&mut rng, 2048).expect("Error with generate()"); + /// ``` + pub fn generate(rng: &mut RNG, modulus_size: i32) -> Result { + let mut wc_dhkey: MaybeUninit = MaybeUninit::uninit(); + let rc = unsafe { ws::wc_InitDhKey(wc_dhkey.as_mut_ptr()) }; + if rc != 0 { + return Err(rc); + } + let wc_dhkey = unsafe { wc_dhkey.assume_init() }; + let mut dh = DH { wc_dhkey }; + let rc = unsafe { + ws::wc_DhGenerateParams(&mut rng.wc_rng, modulus_size, &mut dh.wc_dhkey) + }; + if rc != 0 { + return Err(rc); + } + Ok(dh) + } + + /// Get minimum key size for DH named parameter set. + /// + /// # Parameters + /// + /// * `name`: DH parameters name, one of DH::FFDHE_*. + /// + /// # Returns + /// + /// Minimum key size for the DH named parameter set. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let min_key_size = DH::get_min_key_size_for_named_parameters(DH::FFDHE_2048); + /// assert_eq!(min_key_size, 29); + /// ``` + pub fn get_min_key_size_for_named_parameters(name: i32) -> u32 { + unsafe { ws::wc_DhGetNamedKeyMinSize(name) } + } + + /// Get parameter sizes for a named parameter set. + /// + /// # Parameters + /// + /// * `name`: DH parameters name, one of DH::FFDHE_*. + /// * `p_size`: Output parameter containing size of DH `p` parameter. + /// * `g_size`: Output parameter containing size of DH `g` parameter. + /// * `q_size`: Output parameter containing size of DH `q` parameter. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let mut p_size = 0u32; + /// let mut g_size = 0u32; + /// let mut q_size = 0u32; + /// DH::get_named_parameter_sizes(DH::FFDHE_2048, &mut p_size, &mut g_size, &mut q_size); + /// ``` + pub fn get_named_parameter_sizes(name: i32, p_size: &mut u32, g_size: &mut u32, q_size: &mut u32) { + unsafe { + ws::wc_DhGetNamedKeyParamSize(name, p_size, g_size, q_size) + }; + } + + /// Create a new DH context using the named parameter set. + /// + /// # Parameters + /// + /// * `name`: DH parameters name, one of DH::FFDHE_*. + /// + /// # Returns + /// + /// Returns either Ok(dh) containing the DH struct instance or Err(e) + /// containing the wolfSSL library error code value. + pub fn new_named(name: i32) -> Result { + let mut wc_dhkey: MaybeUninit = MaybeUninit::uninit(); + let rc = unsafe { ws::wc_InitDhKey(wc_dhkey.as_mut_ptr()) }; + if rc != 0 { + return Err(rc); + } + let wc_dhkey = unsafe { wc_dhkey.assume_init() }; + let mut dh = DH { wc_dhkey }; + let rc = unsafe { ws::wc_DhSetNamedKey(&mut dh.wc_dhkey, name) }; + if rc != 0 { + return Err(rc); + } + Ok(dh) + } + + /// Create a new DH context using the given p and g parameters. + /// + /// # Parameters + /// + /// * `p`: DH 'p' parameter value. + /// * `g`: DH 'g' parameter value. + /// + /// # Returns + /// + /// Returns either Ok(dh) containing the DH struct instance or Err(e) + /// containing the wolfSSL library error code value. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let p = [ + /// 0xc5u8, 0x7c, 0xa2, 0x4f, 0x4b, 0xd6, 0x8c, 0x3c, + /// 0xda, 0xc7, 0xba, 0xaa, 0xea, 0x2e, 0x5c, 0x1e, + /// 0x18, 0xb2, 0x7b, 0x8c, 0x55, 0x65, 0x9f, 0xea, + /// 0xe0, 0xa1, 0x36, 0x53, 0x2b, 0x36, 0xe0, 0x4e, + /// 0x3e, 0x64, 0xa9, 0xe4, 0xfc, 0x8f, 0x32, 0x62, + /// 0x97, 0xe4, 0xbe, 0xf7, 0xc1, 0xde, 0x07, 0x5a, + /// 0x89, 0x28, 0xf3, 0xfe, 0x4f, 0xfe, 0x68, 0xbc, + /// 0xfb, 0x0a, 0x7c, 0xa4, 0xb3, 0x14, 0x48, 0x89, + /// 0x9f, 0xaf, 0xb8, 0x43, 0xe2, 0xa0, 0x62, 0x5c, + /// 0xb4, 0x88, 0x3f, 0x06, 0x50, 0x11, 0xfe, 0x65, + /// 0x8d, 0x49, 0xd2, 0xf5, 0x4b, 0x74, 0x79, 0xdb, + /// 0x06, 0x62, 0x92, 0x89, 0xed, 0xda, 0xcb, 0x87, + /// 0x37, 0x16, 0xd2, 0xa1, 0x7a, 0xe8, 0xde, 0x92, + /// 0xee, 0x3e, 0x41, 0x4a, 0x91, 0x5e, 0xed, 0xf3, + /// 0x6c, 0x6b, 0x7e, 0xfd, 0x15, 0x92, 0x18, 0xfc, + /// 0xa7, 0xac, 0x42, 0x85, 0x57, 0xe9, 0xdc, 0xda, + /// 0x55, 0xc9, 0x8b, 0x28, 0x9e, 0xc1, 0xc4, 0x46, + /// 0x4d, 0x88, 0xed, 0x62, 0x8e, 0xdb, 0x3f, 0xb9, + /// 0xd7, 0xc8, 0xe3, 0xcf, 0xb8, 0x34, 0x2c, 0xd2, + /// 0x6f, 0x28, 0x06, 0x41, 0xe3, 0x66, 0x8c, 0xfc, + /// 0x72, 0xff, 0x26, 0x3b, 0x6b, 0x6c, 0x6f, 0x73, + /// 0xde, 0xf2, 0x90, 0x29, 0xe0, 0x61, 0x32, 0xc4, + /// 0x12, 0x74, 0x09, 0x52, 0xec, 0xf3, 0x1b, 0xa6, + /// 0x45, 0x98, 0xac, 0xf9, 0x1c, 0x65, 0x8e, 0x3a, + /// 0x91, 0x84, 0x4b, 0x23, 0x8a, 0xb2, 0x3c, 0xc9, + /// 0xfa, 0xea, 0xf1, 0x38, 0xce, 0xd8, 0x05, 0xe0, + /// 0xfa, 0x44, 0x68, 0x1f, 0xeb, 0xd9, 0x57, 0xb8, + /// 0x4a, 0x97, 0x5b, 0x88, 0xc5, 0xf1, 0xbb, 0xb0, + /// 0x49, 0xc3, 0x91, 0x7c, 0xd3, 0x13, 0xb9, 0x47, + /// 0xbb, 0x91, 0x8f, 0xe5, 0x26, 0x07, 0xab, 0xa9, + /// 0xc5, 0xd0, 0x3d, 0x95, 0x41, 0x26, 0x92, 0x9d, + /// 0x13, 0x67, 0xf2, 0x7e, 0x11, 0x88, 0xdc, 0x2d + /// ]; + /// let g = [ + /// 0x4au8, 0x1a, 0xf3, 0xa4, 0x92, 0xe9, 0xee, 0x74, + /// 0x6e, 0x57, 0xd5, 0x8c, 0x2c, 0x5b, 0x41, 0x41, + /// 0x5e, 0xd4, 0x55, 0x19, 0xdc, 0xd9, 0x32, 0x91, + /// 0xf7, 0xfd, 0xc2, 0x57, 0xff, 0x03, 0x14, 0xdb, + /// 0xf1, 0xb7, 0x60, 0x0c, 0x43, 0x59, 0x3f, 0xff, + /// 0xac, 0xf1, 0x80, 0x9a, 0x15, 0x6f, 0xd8, 0x6e, + /// 0xb7, 0x85, 0x18, 0xc8, 0xec, 0x4e, 0x59, 0x4a, + /// 0xe2, 0x91, 0x43, 0x4c, 0xeb, 0x95, 0xb6, 0x2e, + /// 0x9a, 0xea, 0x53, 0x68, 0x80, 0x64, 0x69, 0x40, + /// 0xf9, 0xec, 0xbd, 0x85, 0x89, 0x26, 0x97, 0x67, + /// 0xaf, 0xb0, 0xad, 0x00, 0x1b, 0xd4, 0xfd, 0x94, + /// 0xd3, 0xe9, 0x92, 0xb1, 0xb4, 0xbc, 0x5a, 0xaa, + /// 0x92, 0x80, 0x89, 0x3b, 0x39, 0x05, 0x6c, 0x22, + /// 0x26, 0xfe, 0x5a, 0x28, 0x6c, 0x37, 0x50, 0x5a, + /// 0x38, 0x99, 0xcf, 0xf3, 0xc1, 0x96, 0x45, 0xdc, + /// 0x01, 0xcb, 0x20, 0x87, 0xa5, 0x00, 0x8c, 0xf5, + /// 0x4d, 0xc2, 0xef, 0xb8, 0x9b, 0xd1, 0x87, 0xbe, + /// 0xed, 0xd5, 0x0a, 0x29, 0x15, 0x34, 0x59, 0x4c, + /// 0x3a, 0x05, 0x22, 0x05, 0x44, 0x4f, 0x9f, 0xc8, + /// 0x47, 0x12, 0x24, 0x8e, 0xa8, 0x79, 0xe4, 0x67, + /// 0xba, 0x4d, 0x5b, 0x75, 0x56, 0x95, 0xeb, 0xe8, + /// 0x8a, 0xfa, 0x8e, 0x01, 0x8c, 0x1b, 0x74, 0x63, + /// 0xd9, 0x2f, 0xf7, 0xd3, 0x44, 0x8f, 0xa8, 0xf5, + /// 0xaf, 0x6c, 0x4f, 0xdb, 0xe7, 0xc9, 0x6c, 0x71, + /// 0x22, 0xa3, 0x1d, 0xf1, 0x40, 0xb2, 0xe0, 0x9a, + /// 0xb6, 0x72, 0xc9, 0xc0, 0x13, 0x16, 0xa2, 0x4a, + /// 0xe1, 0x92, 0xc7, 0x54, 0x23, 0xab, 0x9d, 0xa1, + /// 0xa1, 0xe5, 0x0b, 0xed, 0xba, 0xe8, 0x84, 0x37, + /// 0xb2, 0xe7, 0xfe, 0x32, 0x8d, 0xfa, 0x1c, 0x53, + /// 0x77, 0x97, 0xc7, 0xf3, 0x48, 0xc9, 0xdb, 0x2d, + /// 0x75, 0x52, 0x9d, 0x42, 0x51, 0x78, 0x62, 0x68, + /// 0x05, 0x45, 0x15, 0xf8, 0xa2, 0x4e, 0xf3, 0x0b + /// ]; + /// let dh = DH::new_from_pg(&p, &g).expect("Error with new_from_pg()"); + /// ``` + pub fn new_from_pg(p: &[u8], g: &[u8]) -> Result { + let p_size = p.len() as u32; + let g_size = g.len() as u32; + let mut wc_dhkey: MaybeUninit = MaybeUninit::uninit(); + let rc = unsafe { ws::wc_InitDhKey(wc_dhkey.as_mut_ptr()) }; + if rc != 0 { + return Err(rc); + } + let wc_dhkey = unsafe { wc_dhkey.assume_init() }; + let mut dh = DH { wc_dhkey }; + let rc = unsafe { + ws::wc_DhSetKey(&mut dh.wc_dhkey, p.as_ptr(), p_size, g.as_ptr(), g_size) + }; + if rc != 0 { + return Err(rc); + } + Ok(dh) + } + + /// Create a new DH context using the given p, g, and q parameters. + /// + /// # Parameters + /// + /// * `p`: DH 'p' parameter value. + /// * `g`: DH 'g' parameter value. + /// * `q`: DH 'q' parameter value. + /// + /// # Returns + /// + /// Returns either Ok(dh) containing the DH struct instance or Err(e) + /// containing the wolfSSL library error code value. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let p = [ + /// 0xc5u8, 0x7c, 0xa2, 0x4f, 0x4b, 0xd6, 0x8c, 0x3c, + /// 0xda, 0xc7, 0xba, 0xaa, 0xea, 0x2e, 0x5c, 0x1e, + /// 0x18, 0xb2, 0x7b, 0x8c, 0x55, 0x65, 0x9f, 0xea, + /// 0xe0, 0xa1, 0x36, 0x53, 0x2b, 0x36, 0xe0, 0x4e, + /// 0x3e, 0x64, 0xa9, 0xe4, 0xfc, 0x8f, 0x32, 0x62, + /// 0x97, 0xe4, 0xbe, 0xf7, 0xc1, 0xde, 0x07, 0x5a, + /// 0x89, 0x28, 0xf3, 0xfe, 0x4f, 0xfe, 0x68, 0xbc, + /// 0xfb, 0x0a, 0x7c, 0xa4, 0xb3, 0x14, 0x48, 0x89, + /// 0x9f, 0xaf, 0xb8, 0x43, 0xe2, 0xa0, 0x62, 0x5c, + /// 0xb4, 0x88, 0x3f, 0x06, 0x50, 0x11, 0xfe, 0x65, + /// 0x8d, 0x49, 0xd2, 0xf5, 0x4b, 0x74, 0x79, 0xdb, + /// 0x06, 0x62, 0x92, 0x89, 0xed, 0xda, 0xcb, 0x87, + /// 0x37, 0x16, 0xd2, 0xa1, 0x7a, 0xe8, 0xde, 0x92, + /// 0xee, 0x3e, 0x41, 0x4a, 0x91, 0x5e, 0xed, 0xf3, + /// 0x6c, 0x6b, 0x7e, 0xfd, 0x15, 0x92, 0x18, 0xfc, + /// 0xa7, 0xac, 0x42, 0x85, 0x57, 0xe9, 0xdc, 0xda, + /// 0x55, 0xc9, 0x8b, 0x28, 0x9e, 0xc1, 0xc4, 0x46, + /// 0x4d, 0x88, 0xed, 0x62, 0x8e, 0xdb, 0x3f, 0xb9, + /// 0xd7, 0xc8, 0xe3, 0xcf, 0xb8, 0x34, 0x2c, 0xd2, + /// 0x6f, 0x28, 0x06, 0x41, 0xe3, 0x66, 0x8c, 0xfc, + /// 0x72, 0xff, 0x26, 0x3b, 0x6b, 0x6c, 0x6f, 0x73, + /// 0xde, 0xf2, 0x90, 0x29, 0xe0, 0x61, 0x32, 0xc4, + /// 0x12, 0x74, 0x09, 0x52, 0xec, 0xf3, 0x1b, 0xa6, + /// 0x45, 0x98, 0xac, 0xf9, 0x1c, 0x65, 0x8e, 0x3a, + /// 0x91, 0x84, 0x4b, 0x23, 0x8a, 0xb2, 0x3c, 0xc9, + /// 0xfa, 0xea, 0xf1, 0x38, 0xce, 0xd8, 0x05, 0xe0, + /// 0xfa, 0x44, 0x68, 0x1f, 0xeb, 0xd9, 0x57, 0xb8, + /// 0x4a, 0x97, 0x5b, 0x88, 0xc5, 0xf1, 0xbb, 0xb0, + /// 0x49, 0xc3, 0x91, 0x7c, 0xd3, 0x13, 0xb9, 0x47, + /// 0xbb, 0x91, 0x8f, 0xe5, 0x26, 0x07, 0xab, 0xa9, + /// 0xc5, 0xd0, 0x3d, 0x95, 0x41, 0x26, 0x92, 0x9d, + /// 0x13, 0x67, 0xf2, 0x7e, 0x11, 0x88, 0xdc, 0x2d + /// ]; + /// let g = [ + /// 0x4au8, 0x1a, 0xf3, 0xa4, 0x92, 0xe9, 0xee, 0x74, + /// 0x6e, 0x57, 0xd5, 0x8c, 0x2c, 0x5b, 0x41, 0x41, + /// 0x5e, 0xd4, 0x55, 0x19, 0xdc, 0xd9, 0x32, 0x91, + /// 0xf7, 0xfd, 0xc2, 0x57, 0xff, 0x03, 0x14, 0xdb, + /// 0xf1, 0xb7, 0x60, 0x0c, 0x43, 0x59, 0x3f, 0xff, + /// 0xac, 0xf1, 0x80, 0x9a, 0x15, 0x6f, 0xd8, 0x6e, + /// 0xb7, 0x85, 0x18, 0xc8, 0xec, 0x4e, 0x59, 0x4a, + /// 0xe2, 0x91, 0x43, 0x4c, 0xeb, 0x95, 0xb6, 0x2e, + /// 0x9a, 0xea, 0x53, 0x68, 0x80, 0x64, 0x69, 0x40, + /// 0xf9, 0xec, 0xbd, 0x85, 0x89, 0x26, 0x97, 0x67, + /// 0xaf, 0xb0, 0xad, 0x00, 0x1b, 0xd4, 0xfd, 0x94, + /// 0xd3, 0xe9, 0x92, 0xb1, 0xb4, 0xbc, 0x5a, 0xaa, + /// 0x92, 0x80, 0x89, 0x3b, 0x39, 0x05, 0x6c, 0x22, + /// 0x26, 0xfe, 0x5a, 0x28, 0x6c, 0x37, 0x50, 0x5a, + /// 0x38, 0x99, 0xcf, 0xf3, 0xc1, 0x96, 0x45, 0xdc, + /// 0x01, 0xcb, 0x20, 0x87, 0xa5, 0x00, 0x8c, 0xf5, + /// 0x4d, 0xc2, 0xef, 0xb8, 0x9b, 0xd1, 0x87, 0xbe, + /// 0xed, 0xd5, 0x0a, 0x29, 0x15, 0x34, 0x59, 0x4c, + /// 0x3a, 0x05, 0x22, 0x05, 0x44, 0x4f, 0x9f, 0xc8, + /// 0x47, 0x12, 0x24, 0x8e, 0xa8, 0x79, 0xe4, 0x67, + /// 0xba, 0x4d, 0x5b, 0x75, 0x56, 0x95, 0xeb, 0xe8, + /// 0x8a, 0xfa, 0x8e, 0x01, 0x8c, 0x1b, 0x74, 0x63, + /// 0xd9, 0x2f, 0xf7, 0xd3, 0x44, 0x8f, 0xa8, 0xf5, + /// 0xaf, 0x6c, 0x4f, 0xdb, 0xe7, 0xc9, 0x6c, 0x71, + /// 0x22, 0xa3, 0x1d, 0xf1, 0x40, 0xb2, 0xe0, 0x9a, + /// 0xb6, 0x72, 0xc9, 0xc0, 0x13, 0x16, 0xa2, 0x4a, + /// 0xe1, 0x92, 0xc7, 0x54, 0x23, 0xab, 0x9d, 0xa1, + /// 0xa1, 0xe5, 0x0b, 0xed, 0xba, 0xe8, 0x84, 0x37, + /// 0xb2, 0xe7, 0xfe, 0x32, 0x8d, 0xfa, 0x1c, 0x53, + /// 0x77, 0x97, 0xc7, 0xf3, 0x48, 0xc9, 0xdb, 0x2d, + /// 0x75, 0x52, 0x9d, 0x42, 0x51, 0x78, 0x62, 0x68, + /// 0x05, 0x45, 0x15, 0xf8, 0xa2, 0x4e, 0xf3, 0x0b + /// ]; + /// let q = [ + /// 0xe0u8, 0x35, 0x37, 0xaf, 0xb2, 0x50, 0x91, 0x8e, + /// 0xf2, 0x62, 0x2b, 0xd9, 0x9f, 0x6c, 0x11, 0x75, + /// 0xec, 0x24, 0x5d, 0x78, 0x59, 0xe7, 0x8d, 0xb5, + /// 0x40, 0x52, 0xed, 0x41 + /// ]; + /// let dh = DH::new_from_pgq(&p, &g, &q).expect("Error with new_from_pgq()"); + /// ``` + pub fn new_from_pgq(p: &[u8], g: &[u8], q: &[u8]) -> Result { + let p_size = p.len() as u32; + let g_size = g.len() as u32; + let q_size = q.len() as u32; + let mut wc_dhkey: MaybeUninit = MaybeUninit::uninit(); + let rc = unsafe { ws::wc_InitDhKey(wc_dhkey.as_mut_ptr()) }; + if rc != 0 { + return Err(rc); + } + let wc_dhkey = unsafe { wc_dhkey.assume_init() }; + let mut dh = DH { wc_dhkey }; + let rc = unsafe { + ws::wc_DhSetKey_ex(&mut dh.wc_dhkey, p.as_ptr(), p_size, g.as_ptr(), g_size, q.as_ptr(), q_size) + }; + if rc != 0 { + return Err(rc); + } + Ok(dh) + } + + /// Create a new DH context using the given p, g, and q parameters. + /// + /// # Parameters + /// + /// * `p`: DH 'p' parameter value. + /// * `g`: DH 'g' parameter value. + /// * `q`: DH 'q' parameter value. + /// * `trusted`: Whether to skip the prime check for `p` parameter and mark + /// the DH context as trusted. + /// * `rng`: `RNG` instance to use for random number generation. + /// + /// # Returns + /// + /// Returns either Ok(dh) containing the DH struct instance or Err(e) + /// containing the wolfSSL library error code value. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let p = [ + /// 0xc5u8, 0x7c, 0xa2, 0x4f, 0x4b, 0xd6, 0x8c, 0x3c, + /// 0xda, 0xc7, 0xba, 0xaa, 0xea, 0x2e, 0x5c, 0x1e, + /// 0x18, 0xb2, 0x7b, 0x8c, 0x55, 0x65, 0x9f, 0xea, + /// 0xe0, 0xa1, 0x36, 0x53, 0x2b, 0x36, 0xe0, 0x4e, + /// 0x3e, 0x64, 0xa9, 0xe4, 0xfc, 0x8f, 0x32, 0x62, + /// 0x97, 0xe4, 0xbe, 0xf7, 0xc1, 0xde, 0x07, 0x5a, + /// 0x89, 0x28, 0xf3, 0xfe, 0x4f, 0xfe, 0x68, 0xbc, + /// 0xfb, 0x0a, 0x7c, 0xa4, 0xb3, 0x14, 0x48, 0x89, + /// 0x9f, 0xaf, 0xb8, 0x43, 0xe2, 0xa0, 0x62, 0x5c, + /// 0xb4, 0x88, 0x3f, 0x06, 0x50, 0x11, 0xfe, 0x65, + /// 0x8d, 0x49, 0xd2, 0xf5, 0x4b, 0x74, 0x79, 0xdb, + /// 0x06, 0x62, 0x92, 0x89, 0xed, 0xda, 0xcb, 0x87, + /// 0x37, 0x16, 0xd2, 0xa1, 0x7a, 0xe8, 0xde, 0x92, + /// 0xee, 0x3e, 0x41, 0x4a, 0x91, 0x5e, 0xed, 0xf3, + /// 0x6c, 0x6b, 0x7e, 0xfd, 0x15, 0x92, 0x18, 0xfc, + /// 0xa7, 0xac, 0x42, 0x85, 0x57, 0xe9, 0xdc, 0xda, + /// 0x55, 0xc9, 0x8b, 0x28, 0x9e, 0xc1, 0xc4, 0x46, + /// 0x4d, 0x88, 0xed, 0x62, 0x8e, 0xdb, 0x3f, 0xb9, + /// 0xd7, 0xc8, 0xe3, 0xcf, 0xb8, 0x34, 0x2c, 0xd2, + /// 0x6f, 0x28, 0x06, 0x41, 0xe3, 0x66, 0x8c, 0xfc, + /// 0x72, 0xff, 0x26, 0x3b, 0x6b, 0x6c, 0x6f, 0x73, + /// 0xde, 0xf2, 0x90, 0x29, 0xe0, 0x61, 0x32, 0xc4, + /// 0x12, 0x74, 0x09, 0x52, 0xec, 0xf3, 0x1b, 0xa6, + /// 0x45, 0x98, 0xac, 0xf9, 0x1c, 0x65, 0x8e, 0x3a, + /// 0x91, 0x84, 0x4b, 0x23, 0x8a, 0xb2, 0x3c, 0xc9, + /// 0xfa, 0xea, 0xf1, 0x38, 0xce, 0xd8, 0x05, 0xe0, + /// 0xfa, 0x44, 0x68, 0x1f, 0xeb, 0xd9, 0x57, 0xb8, + /// 0x4a, 0x97, 0x5b, 0x88, 0xc5, 0xf1, 0xbb, 0xb0, + /// 0x49, 0xc3, 0x91, 0x7c, 0xd3, 0x13, 0xb9, 0x47, + /// 0xbb, 0x91, 0x8f, 0xe5, 0x26, 0x07, 0xab, 0xa9, + /// 0xc5, 0xd0, 0x3d, 0x95, 0x41, 0x26, 0x92, 0x9d, + /// 0x13, 0x67, 0xf2, 0x7e, 0x11, 0x88, 0xdc, 0x2d + /// ]; + /// let g = [ + /// 0x4au8, 0x1a, 0xf3, 0xa4, 0x92, 0xe9, 0xee, 0x74, + /// 0x6e, 0x57, 0xd5, 0x8c, 0x2c, 0x5b, 0x41, 0x41, + /// 0x5e, 0xd4, 0x55, 0x19, 0xdc, 0xd9, 0x32, 0x91, + /// 0xf7, 0xfd, 0xc2, 0x57, 0xff, 0x03, 0x14, 0xdb, + /// 0xf1, 0xb7, 0x60, 0x0c, 0x43, 0x59, 0x3f, 0xff, + /// 0xac, 0xf1, 0x80, 0x9a, 0x15, 0x6f, 0xd8, 0x6e, + /// 0xb7, 0x85, 0x18, 0xc8, 0xec, 0x4e, 0x59, 0x4a, + /// 0xe2, 0x91, 0x43, 0x4c, 0xeb, 0x95, 0xb6, 0x2e, + /// 0x9a, 0xea, 0x53, 0x68, 0x80, 0x64, 0x69, 0x40, + /// 0xf9, 0xec, 0xbd, 0x85, 0x89, 0x26, 0x97, 0x67, + /// 0xaf, 0xb0, 0xad, 0x00, 0x1b, 0xd4, 0xfd, 0x94, + /// 0xd3, 0xe9, 0x92, 0xb1, 0xb4, 0xbc, 0x5a, 0xaa, + /// 0x92, 0x80, 0x89, 0x3b, 0x39, 0x05, 0x6c, 0x22, + /// 0x26, 0xfe, 0x5a, 0x28, 0x6c, 0x37, 0x50, 0x5a, + /// 0x38, 0x99, 0xcf, 0xf3, 0xc1, 0x96, 0x45, 0xdc, + /// 0x01, 0xcb, 0x20, 0x87, 0xa5, 0x00, 0x8c, 0xf5, + /// 0x4d, 0xc2, 0xef, 0xb8, 0x9b, 0xd1, 0x87, 0xbe, + /// 0xed, 0xd5, 0x0a, 0x29, 0x15, 0x34, 0x59, 0x4c, + /// 0x3a, 0x05, 0x22, 0x05, 0x44, 0x4f, 0x9f, 0xc8, + /// 0x47, 0x12, 0x24, 0x8e, 0xa8, 0x79, 0xe4, 0x67, + /// 0xba, 0x4d, 0x5b, 0x75, 0x56, 0x95, 0xeb, 0xe8, + /// 0x8a, 0xfa, 0x8e, 0x01, 0x8c, 0x1b, 0x74, 0x63, + /// 0xd9, 0x2f, 0xf7, 0xd3, 0x44, 0x8f, 0xa8, 0xf5, + /// 0xaf, 0x6c, 0x4f, 0xdb, 0xe7, 0xc9, 0x6c, 0x71, + /// 0x22, 0xa3, 0x1d, 0xf1, 0x40, 0xb2, 0xe0, 0x9a, + /// 0xb6, 0x72, 0xc9, 0xc0, 0x13, 0x16, 0xa2, 0x4a, + /// 0xe1, 0x92, 0xc7, 0x54, 0x23, 0xab, 0x9d, 0xa1, + /// 0xa1, 0xe5, 0x0b, 0xed, 0xba, 0xe8, 0x84, 0x37, + /// 0xb2, 0xe7, 0xfe, 0x32, 0x8d, 0xfa, 0x1c, 0x53, + /// 0x77, 0x97, 0xc7, 0xf3, 0x48, 0xc9, 0xdb, 0x2d, + /// 0x75, 0x52, 0x9d, 0x42, 0x51, 0x78, 0x62, 0x68, + /// 0x05, 0x45, 0x15, 0xf8, 0xa2, 0x4e, 0xf3, 0x0b + /// ]; + /// let q = [ + /// 0xe0u8, 0x35, 0x37, 0xaf, 0xb2, 0x50, 0x91, 0x8e, + /// 0xf2, 0x62, 0x2b, 0xd9, 0x9f, 0x6c, 0x11, 0x75, + /// 0xec, 0x24, 0x5d, 0x78, 0x59, 0xe7, 0x8d, 0xb5, + /// 0x40, 0x52, 0xed, 0x41 + /// ]; + /// let mut rng = RNG::new().expect("Failed to create RNG"); + /// let dh = DH::new_from_pgq_with_check(&p, &g, &q, 0, &mut rng).expect("Error with new_from_pgq_with_check()"); + /// ``` + pub fn new_from_pgq_with_check(p: &[u8], g: &[u8], q: &[u8], trusted: i32, rng: &mut RNG) -> Result { + let p_size = p.len() as u32; + let g_size = g.len() as u32; + let q_size = q.len() as u32; + let mut wc_dhkey: MaybeUninit = MaybeUninit::uninit(); + let rc = unsafe { ws::wc_InitDhKey(wc_dhkey.as_mut_ptr()) }; + if rc != 0 { + return Err(rc); + } + let wc_dhkey = unsafe { wc_dhkey.assume_init() }; + let mut dh = DH { wc_dhkey }; + let rc = unsafe { + ws::wc_DhSetCheckKey(&mut dh.wc_dhkey, p.as_ptr(), p_size, g.as_ptr(), g_size, q.as_ptr(), q_size, trusted, &mut rng.wc_rng) + }; + if rc != 0 { + return Err(rc); + } + Ok(dh) + } + + /// Check public/private key pair for pair-wise consistency per process in + /// SP 800-56Ar3, section 5.6.2.1.4, method (b) for FFC. + /// + /// # Parameters + /// + /// * `public`: Buffer containing public key. + /// * `private`: Buffer containing private key. + /// + /// # Returns + /// + /// Returns either Ok(()) on success or Err(e) containing the wolfSSL + /// library error code value. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let mut rng = RNG::new().expect("Error with RNG::new()"); + /// let mut dh = DH::new_named(DH::FFDHE_2048).expect("Error with new_named()"); + /// let mut private = [0u8; 256]; + /// let mut private_size = 0u32; + /// let mut public = [0u8; 256]; + /// let mut public_size = 0u32; + /// dh.generate_key_pair(&mut rng, &mut private, &mut private_size, &mut public, &mut public_size).expect("Error with generate_key_pair()"); + /// let private = &private[0..(private_size as usize)]; + /// let public = &public[0..(public_size as usize)]; + /// dh.check_key_pair(public, private).expect("Error with check_key_pair()"); + /// ``` + 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 rc = unsafe { + ws::wc_DhCheckKeyPair(&mut self.wc_dhkey, + public.as_ptr(), public_size, + private.as_ptr(), private_size) + }; + if rc != 0 { + return Err(rc); + } + Ok(()) + } + + /// Check private key for invalid numbers. + /// + /// The check is per process in SP 800-56Ar3, section 5.6.2.1.2. + /// + /// # Parameters + /// + /// * `private`: Buffer containing private key. + /// + /// # Returns + /// + /// Returns either Ok(()) on success or Err(e) containing the wolfSSL + /// library error code value. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let mut rng = RNG::new().expect("Error with RNG::new()"); + /// let mut dh = DH::new_named(DH::FFDHE_2048).expect("Error with new_named()"); + /// let mut private = [0u8; 256]; + /// let mut private_size = 0u32; + /// let mut public = [0u8; 256]; + /// let mut public_size = 0u32; + /// dh.generate_key_pair(&mut rng, &mut private, &mut private_size, &mut public, &mut public_size).expect("Error with generate_key_pair()"); + /// let private = &private[0..(private_size as usize)]; + /// dh.check_priv_key(private).expect("Error with check_priv_key()"); + /// ``` + pub fn check_priv_key(&mut self, private: &[u8]) -> Result<(), i32> { + let private_size = private.len() as u32; + let rc = unsafe { + ws::wc_DhCheckPrivKey(&mut self.wc_dhkey, + private.as_ptr(), private_size) + }; + if rc != 0 { + return Err(rc); + } + Ok(()) + } + + /// Check private key for invalid numbers with optional prime value. + /// + /// This optionally allows the private key to be checked against the large + /// prime (q). + /// The check is per process in SP 800-56Ar3, section 5.6.2.1.2. + /// + /// # Parameters + /// + /// * `private`: Buffer containing private key. + /// * `prime`: Buffer containing prime value (optional). + /// + /// # Returns + /// + /// Returns either Ok(()) on success or Err(e) containing the wolfSSL + /// library error code value. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let p = [ + /// 0xc5u8, 0x7c, 0xa2, 0x4f, 0x4b, 0xd6, 0x8c, 0x3c, + /// 0xda, 0xc7, 0xba, 0xaa, 0xea, 0x2e, 0x5c, 0x1e, + /// 0x18, 0xb2, 0x7b, 0x8c, 0x55, 0x65, 0x9f, 0xea, + /// 0xe0, 0xa1, 0x36, 0x53, 0x2b, 0x36, 0xe0, 0x4e, + /// 0x3e, 0x64, 0xa9, 0xe4, 0xfc, 0x8f, 0x32, 0x62, + /// 0x97, 0xe4, 0xbe, 0xf7, 0xc1, 0xde, 0x07, 0x5a, + /// 0x89, 0x28, 0xf3, 0xfe, 0x4f, 0xfe, 0x68, 0xbc, + /// 0xfb, 0x0a, 0x7c, 0xa4, 0xb3, 0x14, 0x48, 0x89, + /// 0x9f, 0xaf, 0xb8, 0x43, 0xe2, 0xa0, 0x62, 0x5c, + /// 0xb4, 0x88, 0x3f, 0x06, 0x50, 0x11, 0xfe, 0x65, + /// 0x8d, 0x49, 0xd2, 0xf5, 0x4b, 0x74, 0x79, 0xdb, + /// 0x06, 0x62, 0x92, 0x89, 0xed, 0xda, 0xcb, 0x87, + /// 0x37, 0x16, 0xd2, 0xa1, 0x7a, 0xe8, 0xde, 0x92, + /// 0xee, 0x3e, 0x41, 0x4a, 0x91, 0x5e, 0xed, 0xf3, + /// 0x6c, 0x6b, 0x7e, 0xfd, 0x15, 0x92, 0x18, 0xfc, + /// 0xa7, 0xac, 0x42, 0x85, 0x57, 0xe9, 0xdc, 0xda, + /// 0x55, 0xc9, 0x8b, 0x28, 0x9e, 0xc1, 0xc4, 0x46, + /// 0x4d, 0x88, 0xed, 0x62, 0x8e, 0xdb, 0x3f, 0xb9, + /// 0xd7, 0xc8, 0xe3, 0xcf, 0xb8, 0x34, 0x2c, 0xd2, + /// 0x6f, 0x28, 0x06, 0x41, 0xe3, 0x66, 0x8c, 0xfc, + /// 0x72, 0xff, 0x26, 0x3b, 0x6b, 0x6c, 0x6f, 0x73, + /// 0xde, 0xf2, 0x90, 0x29, 0xe0, 0x61, 0x32, 0xc4, + /// 0x12, 0x74, 0x09, 0x52, 0xec, 0xf3, 0x1b, 0xa6, + /// 0x45, 0x98, 0xac, 0xf9, 0x1c, 0x65, 0x8e, 0x3a, + /// 0x91, 0x84, 0x4b, 0x23, 0x8a, 0xb2, 0x3c, 0xc9, + /// 0xfa, 0xea, 0xf1, 0x38, 0xce, 0xd8, 0x05, 0xe0, + /// 0xfa, 0x44, 0x68, 0x1f, 0xeb, 0xd9, 0x57, 0xb8, + /// 0x4a, 0x97, 0x5b, 0x88, 0xc5, 0xf1, 0xbb, 0xb0, + /// 0x49, 0xc3, 0x91, 0x7c, 0xd3, 0x13, 0xb9, 0x47, + /// 0xbb, 0x91, 0x8f, 0xe5, 0x26, 0x07, 0xab, 0xa9, + /// 0xc5, 0xd0, 0x3d, 0x95, 0x41, 0x26, 0x92, 0x9d, + /// 0x13, 0x67, 0xf2, 0x7e, 0x11, 0x88, 0xdc, 0x2d + /// ]; + /// let g = [ + /// 0x4au8, 0x1a, 0xf3, 0xa4, 0x92, 0xe9, 0xee, 0x74, + /// 0x6e, 0x57, 0xd5, 0x8c, 0x2c, 0x5b, 0x41, 0x41, + /// 0x5e, 0xd4, 0x55, 0x19, 0xdc, 0xd9, 0x32, 0x91, + /// 0xf7, 0xfd, 0xc2, 0x57, 0xff, 0x03, 0x14, 0xdb, + /// 0xf1, 0xb7, 0x60, 0x0c, 0x43, 0x59, 0x3f, 0xff, + /// 0xac, 0xf1, 0x80, 0x9a, 0x15, 0x6f, 0xd8, 0x6e, + /// 0xb7, 0x85, 0x18, 0xc8, 0xec, 0x4e, 0x59, 0x4a, + /// 0xe2, 0x91, 0x43, 0x4c, 0xeb, 0x95, 0xb6, 0x2e, + /// 0x9a, 0xea, 0x53, 0x68, 0x80, 0x64, 0x69, 0x40, + /// 0xf9, 0xec, 0xbd, 0x85, 0x89, 0x26, 0x97, 0x67, + /// 0xaf, 0xb0, 0xad, 0x00, 0x1b, 0xd4, 0xfd, 0x94, + /// 0xd3, 0xe9, 0x92, 0xb1, 0xb4, 0xbc, 0x5a, 0xaa, + /// 0x92, 0x80, 0x89, 0x3b, 0x39, 0x05, 0x6c, 0x22, + /// 0x26, 0xfe, 0x5a, 0x28, 0x6c, 0x37, 0x50, 0x5a, + /// 0x38, 0x99, 0xcf, 0xf3, 0xc1, 0x96, 0x45, 0xdc, + /// 0x01, 0xcb, 0x20, 0x87, 0xa5, 0x00, 0x8c, 0xf5, + /// 0x4d, 0xc2, 0xef, 0xb8, 0x9b, 0xd1, 0x87, 0xbe, + /// 0xed, 0xd5, 0x0a, 0x29, 0x15, 0x34, 0x59, 0x4c, + /// 0x3a, 0x05, 0x22, 0x05, 0x44, 0x4f, 0x9f, 0xc8, + /// 0x47, 0x12, 0x24, 0x8e, 0xa8, 0x79, 0xe4, 0x67, + /// 0xba, 0x4d, 0x5b, 0x75, 0x56, 0x95, 0xeb, 0xe8, + /// 0x8a, 0xfa, 0x8e, 0x01, 0x8c, 0x1b, 0x74, 0x63, + /// 0xd9, 0x2f, 0xf7, 0xd3, 0x44, 0x8f, 0xa8, 0xf5, + /// 0xaf, 0x6c, 0x4f, 0xdb, 0xe7, 0xc9, 0x6c, 0x71, + /// 0x22, 0xa3, 0x1d, 0xf1, 0x40, 0xb2, 0xe0, 0x9a, + /// 0xb6, 0x72, 0xc9, 0xc0, 0x13, 0x16, 0xa2, 0x4a, + /// 0xe1, 0x92, 0xc7, 0x54, 0x23, 0xab, 0x9d, 0xa1, + /// 0xa1, 0xe5, 0x0b, 0xed, 0xba, 0xe8, 0x84, 0x37, + /// 0xb2, 0xe7, 0xfe, 0x32, 0x8d, 0xfa, 0x1c, 0x53, + /// 0x77, 0x97, 0xc7, 0xf3, 0x48, 0xc9, 0xdb, 0x2d, + /// 0x75, 0x52, 0x9d, 0x42, 0x51, 0x78, 0x62, 0x68, + /// 0x05, 0x45, 0x15, 0xf8, 0xa2, 0x4e, 0xf3, 0x0b + /// ]; + /// let q = [ + /// 0xe0u8, 0x35, 0x37, 0xaf, 0xb2, 0x50, 0x91, 0x8e, + /// 0xf2, 0x62, 0x2b, 0xd9, 0x9f, 0x6c, 0x11, 0x75, + /// 0xec, 0x24, 0x5d, 0x78, 0x59, 0xe7, 0x8d, 0xb5, + /// 0x40, 0x52, 0xed, 0x41 + /// ]; + /// let mut rng = RNG::new().expect("Error with RNG::new()"); + /// let mut dh = DH::new_from_pgq_with_check(&p, &g, &q, 0, &mut rng).expect("Error with new_from_pgq()"); + /// let mut private = [0u8; 256]; + /// let mut private_size = 0u32; + /// let mut public = [0u8; 256]; + /// let mut public_size = 0u32; + /// dh.generate_key_pair(&mut rng, &mut private, &mut private_size, &mut public, &mut public_size).expect("Error with generate_key_pair()"); + /// let private = &private[0..(private_size as usize)]; + /// dh.check_priv_key_ex(private, Some(&q)).expect("Error with check_priv_key_ex()"); + /// ``` + pub fn check_priv_key_ex(&mut self, private: &[u8], prime: Option<&[u8]>) -> Result<(), i32> { + let private_size = private.len() as u32; + let mut prime_ptr: *const u8 = null(); + let mut prime_size = 0u32; + if let Some(prime) = prime { + prime_ptr = prime.as_ptr(); + prime_size = prime.len() as u32; + } + let rc = unsafe { + ws::wc_DhCheckPrivKey_ex(&mut self.wc_dhkey, + private.as_ptr(), private_size, + prime_ptr, prime_size) + }; + if rc != 0 { + return Err(rc); + } + Ok(()) + } + + /// Check public key for invalid numbers (partial check). + /// + /// This performs a partial public-key validation routine. + /// + /// # Parameters + /// + /// * `public`: Buffer containing public key. + /// + /// # Returns + /// + /// Returns either Ok(()) on success or Err(e) containing the wolfSSL + /// library error code value. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let mut rng = RNG::new().expect("Error with RNG::new()"); + /// let mut dh = DH::new_named(DH::FFDHE_2048).expect("Error with new_named()"); + /// let mut private = [0u8; 256]; + /// let mut private_size = 0u32; + /// let mut public = [0u8; 256]; + /// let mut public_size = 0u32; + /// dh.generate_key_pair(&mut rng, &mut private, &mut private_size, &mut public, &mut public_size).expect("Error with generate_key_pair()"); + /// let public = &public[0..(public_size as usize)]; + /// dh.check_pub_key(public).expect("Error with check_pub_key()"); + /// ``` + pub fn check_pub_key(&mut self, public: &[u8]) -> Result<(), i32> { + let public_size = public.len() as u32; + let rc = unsafe { + ws::wc_DhCheckPubKey(&mut self.wc_dhkey, public.as_ptr(), public_size) + }; + if rc != 0 { + return Err(rc); + } + Ok(()) + } + + /// Check public key for invalid numbers (full check). + /// + /// This performs a full public-key validation routine. + /// + /// # Parameters + /// + /// * `public`: Buffer containing public key. + /// * `prime`: Buffer containing prime value. + /// + /// # Returns + /// + /// Returns either Ok(()) on success or Err(e) containing the wolfSSL + /// library error code value. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let p = [ + /// 0xc5u8, 0x7c, 0xa2, 0x4f, 0x4b, 0xd6, 0x8c, 0x3c, + /// 0xda, 0xc7, 0xba, 0xaa, 0xea, 0x2e, 0x5c, 0x1e, + /// 0x18, 0xb2, 0x7b, 0x8c, 0x55, 0x65, 0x9f, 0xea, + /// 0xe0, 0xa1, 0x36, 0x53, 0x2b, 0x36, 0xe0, 0x4e, + /// 0x3e, 0x64, 0xa9, 0xe4, 0xfc, 0x8f, 0x32, 0x62, + /// 0x97, 0xe4, 0xbe, 0xf7, 0xc1, 0xde, 0x07, 0x5a, + /// 0x89, 0x28, 0xf3, 0xfe, 0x4f, 0xfe, 0x68, 0xbc, + /// 0xfb, 0x0a, 0x7c, 0xa4, 0xb3, 0x14, 0x48, 0x89, + /// 0x9f, 0xaf, 0xb8, 0x43, 0xe2, 0xa0, 0x62, 0x5c, + /// 0xb4, 0x88, 0x3f, 0x06, 0x50, 0x11, 0xfe, 0x65, + /// 0x8d, 0x49, 0xd2, 0xf5, 0x4b, 0x74, 0x79, 0xdb, + /// 0x06, 0x62, 0x92, 0x89, 0xed, 0xda, 0xcb, 0x87, + /// 0x37, 0x16, 0xd2, 0xa1, 0x7a, 0xe8, 0xde, 0x92, + /// 0xee, 0x3e, 0x41, 0x4a, 0x91, 0x5e, 0xed, 0xf3, + /// 0x6c, 0x6b, 0x7e, 0xfd, 0x15, 0x92, 0x18, 0xfc, + /// 0xa7, 0xac, 0x42, 0x85, 0x57, 0xe9, 0xdc, 0xda, + /// 0x55, 0xc9, 0x8b, 0x28, 0x9e, 0xc1, 0xc4, 0x46, + /// 0x4d, 0x88, 0xed, 0x62, 0x8e, 0xdb, 0x3f, 0xb9, + /// 0xd7, 0xc8, 0xe3, 0xcf, 0xb8, 0x34, 0x2c, 0xd2, + /// 0x6f, 0x28, 0x06, 0x41, 0xe3, 0x66, 0x8c, 0xfc, + /// 0x72, 0xff, 0x26, 0x3b, 0x6b, 0x6c, 0x6f, 0x73, + /// 0xde, 0xf2, 0x90, 0x29, 0xe0, 0x61, 0x32, 0xc4, + /// 0x12, 0x74, 0x09, 0x52, 0xec, 0xf3, 0x1b, 0xa6, + /// 0x45, 0x98, 0xac, 0xf9, 0x1c, 0x65, 0x8e, 0x3a, + /// 0x91, 0x84, 0x4b, 0x23, 0x8a, 0xb2, 0x3c, 0xc9, + /// 0xfa, 0xea, 0xf1, 0x38, 0xce, 0xd8, 0x05, 0xe0, + /// 0xfa, 0x44, 0x68, 0x1f, 0xeb, 0xd9, 0x57, 0xb8, + /// 0x4a, 0x97, 0x5b, 0x88, 0xc5, 0xf1, 0xbb, 0xb0, + /// 0x49, 0xc3, 0x91, 0x7c, 0xd3, 0x13, 0xb9, 0x47, + /// 0xbb, 0x91, 0x8f, 0xe5, 0x26, 0x07, 0xab, 0xa9, + /// 0xc5, 0xd0, 0x3d, 0x95, 0x41, 0x26, 0x92, 0x9d, + /// 0x13, 0x67, 0xf2, 0x7e, 0x11, 0x88, 0xdc, 0x2d + /// ]; + /// let g = [ + /// 0x4au8, 0x1a, 0xf3, 0xa4, 0x92, 0xe9, 0xee, 0x74, + /// 0x6e, 0x57, 0xd5, 0x8c, 0x2c, 0x5b, 0x41, 0x41, + /// 0x5e, 0xd4, 0x55, 0x19, 0xdc, 0xd9, 0x32, 0x91, + /// 0xf7, 0xfd, 0xc2, 0x57, 0xff, 0x03, 0x14, 0xdb, + /// 0xf1, 0xb7, 0x60, 0x0c, 0x43, 0x59, 0x3f, 0xff, + /// 0xac, 0xf1, 0x80, 0x9a, 0x15, 0x6f, 0xd8, 0x6e, + /// 0xb7, 0x85, 0x18, 0xc8, 0xec, 0x4e, 0x59, 0x4a, + /// 0xe2, 0x91, 0x43, 0x4c, 0xeb, 0x95, 0xb6, 0x2e, + /// 0x9a, 0xea, 0x53, 0x68, 0x80, 0x64, 0x69, 0x40, + /// 0xf9, 0xec, 0xbd, 0x85, 0x89, 0x26, 0x97, 0x67, + /// 0xaf, 0xb0, 0xad, 0x00, 0x1b, 0xd4, 0xfd, 0x94, + /// 0xd3, 0xe9, 0x92, 0xb1, 0xb4, 0xbc, 0x5a, 0xaa, + /// 0x92, 0x80, 0x89, 0x3b, 0x39, 0x05, 0x6c, 0x22, + /// 0x26, 0xfe, 0x5a, 0x28, 0x6c, 0x37, 0x50, 0x5a, + /// 0x38, 0x99, 0xcf, 0xf3, 0xc1, 0x96, 0x45, 0xdc, + /// 0x01, 0xcb, 0x20, 0x87, 0xa5, 0x00, 0x8c, 0xf5, + /// 0x4d, 0xc2, 0xef, 0xb8, 0x9b, 0xd1, 0x87, 0xbe, + /// 0xed, 0xd5, 0x0a, 0x29, 0x15, 0x34, 0x59, 0x4c, + /// 0x3a, 0x05, 0x22, 0x05, 0x44, 0x4f, 0x9f, 0xc8, + /// 0x47, 0x12, 0x24, 0x8e, 0xa8, 0x79, 0xe4, 0x67, + /// 0xba, 0x4d, 0x5b, 0x75, 0x56, 0x95, 0xeb, 0xe8, + /// 0x8a, 0xfa, 0x8e, 0x01, 0x8c, 0x1b, 0x74, 0x63, + /// 0xd9, 0x2f, 0xf7, 0xd3, 0x44, 0x8f, 0xa8, 0xf5, + /// 0xaf, 0x6c, 0x4f, 0xdb, 0xe7, 0xc9, 0x6c, 0x71, + /// 0x22, 0xa3, 0x1d, 0xf1, 0x40, 0xb2, 0xe0, 0x9a, + /// 0xb6, 0x72, 0xc9, 0xc0, 0x13, 0x16, 0xa2, 0x4a, + /// 0xe1, 0x92, 0xc7, 0x54, 0x23, 0xab, 0x9d, 0xa1, + /// 0xa1, 0xe5, 0x0b, 0xed, 0xba, 0xe8, 0x84, 0x37, + /// 0xb2, 0xe7, 0xfe, 0x32, 0x8d, 0xfa, 0x1c, 0x53, + /// 0x77, 0x97, 0xc7, 0xf3, 0x48, 0xc9, 0xdb, 0x2d, + /// 0x75, 0x52, 0x9d, 0x42, 0x51, 0x78, 0x62, 0x68, + /// 0x05, 0x45, 0x15, 0xf8, 0xa2, 0x4e, 0xf3, 0x0b + /// ]; + /// let q = [ + /// 0xe0u8, 0x35, 0x37, 0xaf, 0xb2, 0x50, 0x91, 0x8e, + /// 0xf2, 0x62, 0x2b, 0xd9, 0x9f, 0x6c, 0x11, 0x75, + /// 0xec, 0x24, 0x5d, 0x78, 0x59, 0xe7, 0x8d, 0xb5, + /// 0x40, 0x52, 0xed, 0x41 + /// ]; + /// let q0 = [ + /// 0x00u8, + /// 0xe0, 0x35, 0x37, 0xaf, 0xb2, 0x50, 0x91, 0x8e, + /// 0xf2, 0x62, 0x2b, 0xd9, 0x9f, 0x6c, 0x11, 0x75, + /// 0xec, 0x24, 0x5d, 0x78, 0x59, 0xe7, 0x8d, 0xb5, + /// 0x40, 0x52, 0xed, 0x41 + /// ]; + /// let mut rng = RNG::new().expect("Error with RNG::new()"); + /// let mut dh = DH::new_from_pgq_with_check(&p, &g, &q, 0, &mut rng).expect("Error with new_from_pgq()"); + /// let mut private = [0u8; 256]; + /// let mut private_size = 0u32; + /// let mut public = [0u8; 256]; + /// let mut public_size = 0u32; + /// dh.generate_key_pair(&mut rng, &mut private, &mut private_size, &mut public, &mut public_size).expect("Error with generate_key_pair()"); + /// let public = &public[0..(public_size as usize)]; + /// dh.check_pub_key_ex(public, &q0).expect("Error with check_pub_key_ex()"); + /// ``` + 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 rc = unsafe { + ws::wc_DhCheckPubKey_ex(&mut self.wc_dhkey, + public.as_ptr(), public_size, + prime.as_ptr(), prime_size) + }; + if rc != 0 { + return Err(rc); + } + Ok(()) + } + + /// Export Diffie-Hellman context parameters. + /// + /// # Parameters + /// + /// * `p`: Buffer in which to store the DH `p` parameter value. + /// * `p_size`: Output parameter holding number of bytes written to `p`. + /// * `q`: Buffer in which to store the DH `q` parameter value. + /// * `q_size`: Output parameter holding number of bytes written to `q`. + /// * `g`: Buffer in which to store the DH `g` parameter value. + /// * `g_size`: Output parameter holding number of bytes written to `g`. + /// + /// # Returns + /// + /// Returns either Ok(()) or Err(e) containing the wolfSSL library error + /// code value. + pub fn export_params_raw(&mut self, + 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; + let rc = unsafe { + ws::wc_DhExportParamsRaw(&mut self.wc_dhkey, + p.as_mut_ptr(), p_size, + q.as_mut_ptr(), q_size, + g.as_mut_ptr(), g_size) + }; + if rc != 0 { + return Err(rc); + } + Ok(()) + } + + /// Generate a public/private key pair for the given DH parameters. + /// + /// # Parameters + /// + /// * `rng`: `RNG` instance used for random number generation. + /// * `private`: Buffer in which to store the generated private key. + /// * `private_size`: Output parameter storing the private key size in bytes. + /// * `public`: Buffer in which to store the generated public key. + /// * `public_size`: Output parameter storing the public key size in bytes. + /// + /// # Returns + /// + /// Returns either Ok(()) or Err(e) containing the wolfSSL library error + /// code value. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let mut rng = RNG::new().expect("Failed to create RNG"); + /// let mut dh = DH::new_named(DH::FFDHE_2048).expect("Error with new_named()"); + /// let mut private = [0u8; 256]; + /// let mut private_size = 0u32; + /// let mut public = [0u8; 256]; + /// let mut public_size = 0u32; + /// dh.generate_key_pair(&mut rng, &mut private, &mut private_size, &mut public, &mut public_size).expect("Error with generate_key_pair()"); + /// ``` + 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; + let rc = unsafe { + ws::wc_DhGenerateKeyPair(&mut self.wc_dhkey, &mut rng.wc_rng, + private.as_mut_ptr(), private_size, + public.as_mut_ptr(), public_size) + }; + if rc != 0 { + return Err(rc); + } + Ok(()) + } + + /// Generate a shared secret agreed upon by both parties. + /// + /// This function generates an agreed upon secret key based on a local + /// private key and a received public key. If completed on both sides of an + /// exchange, this function generates an agreed upon secret key for + /// symmetric communication. On successfully generating a shared secret + /// key, the size of the secret key written to `dout` will be returned. + /// + /// # Returns + /// + /// Returns either Ok(size) containing the size of the key written to + /// `dout` or Err(e) containing the wolfSSL library error code value. + /// + /// # Example + /// + /// ```rust + /// use wolfssl::wolfcrypt::random::RNG; + /// use wolfssl::wolfcrypt::dh::DH; + /// let mut rng = RNG::new().expect("Error with RNG::new()"); + /// let mut dh = DH::new_named(DH::FFDHE_2048).expect("Error with new_named()"); + /// let mut private0 = [0u8; 256]; + /// let mut private0_size = 0u32; + /// let mut public0 = [0u8; 256]; + /// let mut public0_size = 0u32; + /// dh.generate_key_pair(&mut rng, &mut private0, &mut private0_size, &mut public0, &mut public0_size).expect("Error with generate_key_pair()"); + /// let mut private1 = [0u8; 256]; + /// let mut private1_size = 0u32; + /// let mut public1 = [0u8; 256]; + /// let mut public1_size = 0u32; + /// dh.generate_key_pair(&mut rng, &mut private1, &mut private1_size, &mut public1, &mut public1_size).expect("Error with generate_key_pair()"); + /// let mut ss0 = [0u8; 256]; + /// let ss0_size = dh.shared_secret(&mut ss0, &private0, &public1).expect("Error with shared_secret()"); + /// let ss0 = &ss0[0..ss0_size]; + /// ``` + 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 rc = unsafe { + ws::wc_DhAgree(&mut self.wc_dhkey, + dout.as_mut_ptr(), &mut dout_size, + private.as_ptr(), private_size, + other_pub.as_ptr(), other_pub_size) + }; + if rc != 0 { + return Err(rc); + } + Ok(dout_size as usize) + } +} + +impl Drop for DH { + /// Safely free the underlying wolfSSL DhKey context. + /// + /// This calls the `wc_FreeDhKey()` wolfssl library function. + /// + /// The Rust Drop trait guarantees that this method is called when the + /// DH struct instance goes out of scope, automatically cleaning up + /// resources and preventing memory leaks. + fn drop(&mut self) { + unsafe { ws::wc_FreeDhKey(&mut self.wc_dhkey); } + } +} diff --git a/wrapper/rust/wolfssl/tests/test_dh.rs b/wrapper/rust/wolfssl/tests/test_dh.rs new file mode 100644 index 000000000..ba7673448 --- /dev/null +++ b/wrapper/rust/wolfssl/tests/test_dh.rs @@ -0,0 +1,196 @@ +//use std::fs; +use wolfssl::wolfcrypt::dh::DH; +use wolfssl::wolfcrypt::random::RNG; + +#[test] +fn test_dh_named_parameters() { + assert_eq!(DH::get_min_key_size_for_named_parameters(DH::FFDHE_2048), 29); + + let mut p_size = 0u32; + let mut g_size = 0u32; + let mut q_size = 0u32; + DH::get_named_parameter_sizes(DH::FFDHE_2048, &mut p_size, &mut g_size, &mut q_size); + + assert!(p_size > 0u32); + assert!(g_size > 0u32); + let mut dh = DH::new_named(DH::FFDHE_2048).expect("Error with new_named()"); + + let mut p = [0u8; 256]; + let mut q = [0u8; 256]; + let mut g = [0u8; 256]; + dh.export_params_raw(&mut p, &mut p_size, &mut q, &mut q_size, &mut g, &mut g_size).expect("Error with export_params_raw()"); + + assert_ne!(p, [0u8; 256]); + assert_ne!(g, [0u8; 256]); +} + +#[test] +fn test_generate_params() { + let mut rng = RNG::new().expect("Error with RNG::new()"); + let mut dh = DH::generate(&mut rng, 2048).expect("Error with generate()"); + + let mut private = [0u8; 256]; + let mut private_size = 0u32; + let mut public = [0u8; 256]; + let mut public_size = 0u32; + dh.generate_key_pair(&mut rng, &mut private, &mut private_size, &mut public, &mut public_size).expect("Error with generate_key_pair()"); +} + +#[test] +fn test_generate_key_pair() { + let mut rng = RNG::new().expect("Error with RNG::new()"); + let mut dh = DH::new_named(DH::FFDHE_2048).expect("Error with new_named()"); + + let mut p = [0u8; 256]; + let mut q = [0u8; 256]; + let mut g = [0u8; 256]; + let mut p_size = 0u32; + let mut q_size = 0u32; + let mut g_size = 0u32; + dh.export_params_raw(&mut p, &mut p_size, &mut q, &mut q_size, &mut g, &mut g_size).expect("Error with export_params_raw()"); + let p = &p[0..(p_size as usize)]; + let g = &g[0..(g_size as usize)]; + + assert!(DH::compare_named_key(DH::FFDHE_2048, p, g, None)); + + let mut private = [0u8; 256]; + let mut private_size = 0u32; + let mut public = [0u8; 256]; + let mut public_size = 0u32; + dh.generate_key_pair(&mut rng, &mut private, &mut private_size, &mut public, &mut public_size).expect("Error with generate_key_pair()"); + + let private = &private[0..(private_size as usize)]; + let public = &public[0..(public_size as usize)]; + dh.check_key_pair(public, private).expect("Error with check_key_pair()"); + dh.check_priv_key(private).expect("Error with check_priv_key()"); + dh.check_pub_key(public).expect("Error with check_pub_key()"); +} + +#[test] +fn test_dh_checks() { + let p = [ + 0xc5u8, 0x7c, 0xa2, 0x4f, 0x4b, 0xd6, 0x8c, 0x3c, + 0xda, 0xc7, 0xba, 0xaa, 0xea, 0x2e, 0x5c, 0x1e, + 0x18, 0xb2, 0x7b, 0x8c, 0x55, 0x65, 0x9f, 0xea, + 0xe0, 0xa1, 0x36, 0x53, 0x2b, 0x36, 0xe0, 0x4e, + 0x3e, 0x64, 0xa9, 0xe4, 0xfc, 0x8f, 0x32, 0x62, + 0x97, 0xe4, 0xbe, 0xf7, 0xc1, 0xde, 0x07, 0x5a, + 0x89, 0x28, 0xf3, 0xfe, 0x4f, 0xfe, 0x68, 0xbc, + 0xfb, 0x0a, 0x7c, 0xa4, 0xb3, 0x14, 0x48, 0x89, + 0x9f, 0xaf, 0xb8, 0x43, 0xe2, 0xa0, 0x62, 0x5c, + 0xb4, 0x88, 0x3f, 0x06, 0x50, 0x11, 0xfe, 0x65, + 0x8d, 0x49, 0xd2, 0xf5, 0x4b, 0x74, 0x79, 0xdb, + 0x06, 0x62, 0x92, 0x89, 0xed, 0xda, 0xcb, 0x87, + 0x37, 0x16, 0xd2, 0xa1, 0x7a, 0xe8, 0xde, 0x92, + 0xee, 0x3e, 0x41, 0x4a, 0x91, 0x5e, 0xed, 0xf3, + 0x6c, 0x6b, 0x7e, 0xfd, 0x15, 0x92, 0x18, 0xfc, + 0xa7, 0xac, 0x42, 0x85, 0x57, 0xe9, 0xdc, 0xda, + 0x55, 0xc9, 0x8b, 0x28, 0x9e, 0xc1, 0xc4, 0x46, + 0x4d, 0x88, 0xed, 0x62, 0x8e, 0xdb, 0x3f, 0xb9, + 0xd7, 0xc8, 0xe3, 0xcf, 0xb8, 0x34, 0x2c, 0xd2, + 0x6f, 0x28, 0x06, 0x41, 0xe3, 0x66, 0x8c, 0xfc, + 0x72, 0xff, 0x26, 0x3b, 0x6b, 0x6c, 0x6f, 0x73, + 0xde, 0xf2, 0x90, 0x29, 0xe0, 0x61, 0x32, 0xc4, + 0x12, 0x74, 0x09, 0x52, 0xec, 0xf3, 0x1b, 0xa6, + 0x45, 0x98, 0xac, 0xf9, 0x1c, 0x65, 0x8e, 0x3a, + 0x91, 0x84, 0x4b, 0x23, 0x8a, 0xb2, 0x3c, 0xc9, + 0xfa, 0xea, 0xf1, 0x38, 0xce, 0xd8, 0x05, 0xe0, + 0xfa, 0x44, 0x68, 0x1f, 0xeb, 0xd9, 0x57, 0xb8, + 0x4a, 0x97, 0x5b, 0x88, 0xc5, 0xf1, 0xbb, 0xb0, + 0x49, 0xc3, 0x91, 0x7c, 0xd3, 0x13, 0xb9, 0x47, + 0xbb, 0x91, 0x8f, 0xe5, 0x26, 0x07, 0xab, 0xa9, + 0xc5, 0xd0, 0x3d, 0x95, 0x41, 0x26, 0x92, 0x9d, + 0x13, 0x67, 0xf2, 0x7e, 0x11, 0x88, 0xdc, 0x2d + ]; + let g = [ + 0x4au8, 0x1a, 0xf3, 0xa4, 0x92, 0xe9, 0xee, 0x74, + 0x6e, 0x57, 0xd5, 0x8c, 0x2c, 0x5b, 0x41, 0x41, + 0x5e, 0xd4, 0x55, 0x19, 0xdc, 0xd9, 0x32, 0x91, + 0xf7, 0xfd, 0xc2, 0x57, 0xff, 0x03, 0x14, 0xdb, + 0xf1, 0xb7, 0x60, 0x0c, 0x43, 0x59, 0x3f, 0xff, + 0xac, 0xf1, 0x80, 0x9a, 0x15, 0x6f, 0xd8, 0x6e, + 0xb7, 0x85, 0x18, 0xc8, 0xec, 0x4e, 0x59, 0x4a, + 0xe2, 0x91, 0x43, 0x4c, 0xeb, 0x95, 0xb6, 0x2e, + 0x9a, 0xea, 0x53, 0x68, 0x80, 0x64, 0x69, 0x40, + 0xf9, 0xec, 0xbd, 0x85, 0x89, 0x26, 0x97, 0x67, + 0xaf, 0xb0, 0xad, 0x00, 0x1b, 0xd4, 0xfd, 0x94, + 0xd3, 0xe9, 0x92, 0xb1, 0xb4, 0xbc, 0x5a, 0xaa, + 0x92, 0x80, 0x89, 0x3b, 0x39, 0x05, 0x6c, 0x22, + 0x26, 0xfe, 0x5a, 0x28, 0x6c, 0x37, 0x50, 0x5a, + 0x38, 0x99, 0xcf, 0xf3, 0xc1, 0x96, 0x45, 0xdc, + 0x01, 0xcb, 0x20, 0x87, 0xa5, 0x00, 0x8c, 0xf5, + 0x4d, 0xc2, 0xef, 0xb8, 0x9b, 0xd1, 0x87, 0xbe, + 0xed, 0xd5, 0x0a, 0x29, 0x15, 0x34, 0x59, 0x4c, + 0x3a, 0x05, 0x22, 0x05, 0x44, 0x4f, 0x9f, 0xc8, + 0x47, 0x12, 0x24, 0x8e, 0xa8, 0x79, 0xe4, 0x67, + 0xba, 0x4d, 0x5b, 0x75, 0x56, 0x95, 0xeb, 0xe8, + 0x8a, 0xfa, 0x8e, 0x01, 0x8c, 0x1b, 0x74, 0x63, + 0xd9, 0x2f, 0xf7, 0xd3, 0x44, 0x8f, 0xa8, 0xf5, + 0xaf, 0x6c, 0x4f, 0xdb, 0xe7, 0xc9, 0x6c, 0x71, + 0x22, 0xa3, 0x1d, 0xf1, 0x40, 0xb2, 0xe0, 0x9a, + 0xb6, 0x72, 0xc9, 0xc0, 0x13, 0x16, 0xa2, 0x4a, + 0xe1, 0x92, 0xc7, 0x54, 0x23, 0xab, 0x9d, 0xa1, + 0xa1, 0xe5, 0x0b, 0xed, 0xba, 0xe8, 0x84, 0x37, + 0xb2, 0xe7, 0xfe, 0x32, 0x8d, 0xfa, 0x1c, 0x53, + 0x77, 0x97, 0xc7, 0xf3, 0x48, 0xc9, 0xdb, 0x2d, + 0x75, 0x52, 0x9d, 0x42, 0x51, 0x78, 0x62, 0x68, + 0x05, 0x45, 0x15, 0xf8, 0xa2, 0x4e, 0xf3, 0x0b + ]; + let q = [ + 0xe0u8, 0x35, 0x37, 0xaf, 0xb2, 0x50, 0x91, 0x8e, + 0xf2, 0x62, 0x2b, 0xd9, 0x9f, 0x6c, 0x11, 0x75, + 0xec, 0x24, 0x5d, 0x78, 0x59, 0xe7, 0x8d, 0xb5, + 0x40, 0x52, 0xed, 0x41 + ]; + let q0 = [ + 0x00u8, + 0xe0, 0x35, 0x37, 0xaf, 0xb2, 0x50, 0x91, 0x8e, + 0xf2, 0x62, 0x2b, 0xd9, 0x9f, 0x6c, 0x11, 0x75, + 0xec, 0x24, 0x5d, 0x78, 0x59, 0xe7, 0x8d, 0xb5, + 0x40, 0x52, 0xed, 0x41 + ]; + let mut rng = RNG::new().expect("Error with RNG::new()"); + let _dh = DH::new_from_pg(&p, &g).expect("Error with new_from_pg()"); + let _dh = DH::new_from_pgq(&p, &g, &q).expect("Error with new_from_pgq()"); + let mut dh = DH::new_from_pgq_with_check(&p, &g, &q, 0, &mut rng).expect("Error with new_from_pgq()"); + let mut private = [0u8; 256]; + let mut private_size = 0u32; + let mut public = [0u8; 256]; + let mut public_size = 0u32; + dh.generate_key_pair(&mut rng, &mut private, &mut private_size, &mut public, &mut public_size).expect("Error with generate_key_pair()"); + + let private = &private[0..(private_size as usize)]; + let public = &public[0..(public_size as usize)]; + dh.check_priv_key_ex(private, Some(&q)).expect("Error with check_priv_key_ex()"); + DH::check_pub_value(&p, public).expect("Error with check_pub_value()"); + dh.check_pub_key_ex(public, &q0).expect("Error with check_pub_key_ex()"); +} + +#[test] +fn test_dh_shared_secret() { + let mut rng = RNG::new().expect("Error with RNG::new()"); + let mut dh = DH::new_named(DH::FFDHE_2048).expect("Error with new_named()"); + + let mut private0 = [0u8; 256]; + let mut private0_size = 0u32; + let mut public0 = [0u8; 256]; + let mut public0_size = 0u32; + dh.generate_key_pair(&mut rng, &mut private0, &mut private0_size, &mut public0, &mut public0_size).expect("Error with generate_key_pair()"); + + let mut private1 = [0u8; 256]; + let mut private1_size = 0u32; + let mut public1 = [0u8; 256]; + let mut public1_size = 0u32; + dh.generate_key_pair(&mut rng, &mut private1, &mut private1_size, &mut public1, &mut public1_size).expect("Error with generate_key_pair()"); + + let mut ss0 = [0u8; 256]; + let ss0_size = dh.shared_secret(&mut ss0, &private0, &public1).expect("Error with shared_secret()"); + let ss0 = &ss0[0..ss0_size]; + + let mut ss1 = [0u8; 256]; + let ss1_size = dh.shared_secret(&mut ss1, &private1, &public0).expect("Error with shared_secret()"); + let ss1 = &ss1[0..ss1_size]; + + assert_eq!(ss0_size, ss1_size); + assert_eq!(*ss0, *ss1); +}