luna - wolfssl/wrapper/rust/wolfssl-wolfcrypt/src/sha.rs

   1/*
   2 * Copyright (C) 2006-2026 wolfSSL Inc.
   3 *
   4 * This file is part of wolfSSL.
   5 *
   6 * wolfSSL is free software; you can redistribute it and/or modify
   7 * it under the terms of the GNU General Public License as published by
   8 * the Free Software Foundation; either version 3 of the License, or
   9 * (at your option) any later version.
  10 *
  11 * wolfSSL is distributed in the hope that it will be useful,
  12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 * GNU General Public License for more details.
  15 *
  16 * You should have received a copy of the GNU General Public License
  17 * along with this program; if not, write to the Free Software
  18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335, USA
  19 */
  20
  21/*!
  22This module provides a Rust wrapper for the wolfCrypt library's Secure Hash
  23Algorithm (SHA) functionality.
  24*/
  25
  26use crate::sys;
  27use core::mem::MaybeUninit;
  28
  29/// Context for SHA-1 computation.
  30#[cfg(sha)]
  31pub struct SHA {
  32    wc_sha: sys::wc_Sha,
  33}
  34
  35#[cfg(sha)]
  36impl SHA {
  37    /// SHA-1 digest size in bytes.
  38    pub const DIGEST_SIZE: usize = sys::WC_SHA_DIGEST_SIZE as usize;
  39
  40    /// Build a new SHA instance.
  41    ///
  42    /// # Returns
  43    ///
  44    /// Returns either Ok(sha) containing the SHA struct instance or Err(e)
  45    /// containing the wolfSSL library error code value.
  46    ///
  47    /// # Example
  48    ///
  49    /// ```rust
  50    /// use wolfssl_wolfcrypt::sha::SHA;
  51    /// let sha = SHA::new().expect("Error with new()");
  52    /// ```
  53    pub fn new() -> Result<Self, i32> {
  54        Self::new_ex(None, None)
  55    }
  56
  57    /// Build a new SHA instance with optional heap and device ID.
  58    ///
  59    /// # Parameters
  60    ///
  61    /// * `heap`: Optional heap hint.
  62    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
  63    ///
  64    /// # Returns
  65    ///
  66    /// Returns either Ok(sha) containing the SHA struct instance or Err(e)
  67    /// containing the wolfSSL library error code value.
  68    ///
  69    /// # Example
  70    ///
  71    /// ```rust
  72    /// use wolfssl_wolfcrypt::sha::SHA;
  73    /// let sha = SHA::new_ex(None, None).expect("Error with new_ex()");
  74    /// ```
  75    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
  76        let mut wc_sha: MaybeUninit<sys::wc_Sha> = MaybeUninit::uninit();
  77        let heap = match heap {
  78            Some(heap) => heap,
  79            None => core::ptr::null_mut(),
  80        };
  81        let dev_id = match dev_id {
  82            Some(dev_id) => dev_id,
  83            None => sys::INVALID_DEVID,
  84        };
  85        let rc = unsafe { sys::wc_InitSha_ex(wc_sha.as_mut_ptr(), heap, dev_id) };
  86        if rc != 0 {
  87            return Err(rc);
  88        }
  89        let wc_sha = unsafe { wc_sha.assume_init() };
  90        let sha = SHA { wc_sha };
  91        Ok(sha)
  92    }
  93
  94    /// Reinitialize a SHA instance for a new hash calculation.
  95    ///
  96    /// This does not need to be called after `new()`, but should be called
  97    /// after a hash calculation to prepare for a new calculation.
  98    ///
  99    /// # Returns
 100    ///
 101    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 102    /// library error code value.
 103    ///
 104    /// # Example
 105    ///
 106    /// ```rust
 107    /// use wolfssl_wolfcrypt::sha::SHA;
 108    /// let mut sha = SHA::new().expect("Error with new()");
 109    /// sha.init().expect("Error with init()");
 110    /// ```
 111    pub fn init(&mut self) -> Result<(), i32> {
 112        self.init_ex(None, None)
 113    }
 114
 115    /// Reinitialize a SHA instance for a new hash calculation with optional
 116    /// heap and device ID.
 117    ///
 118    /// This does not need to be called after `new()`, but should be called
 119    /// after a hash calculation to prepare for a new calculation.
 120    ///
 121    /// # Parameters
 122    ///
 123    /// * `heap`: Optional heap hint.
 124    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
 125    ///
 126    /// # Returns
 127    ///
 128    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 129    /// library error code value.
 130    ///
 131    /// # Example
 132    ///
 133    /// ```rust
 134    /// use wolfssl_wolfcrypt::sha::SHA;
 135    /// let mut sha = SHA::new().expect("Error with new()");
 136    /// sha.init_ex(None, None).expect("Error with init_ex()");
 137    /// ```
 138    pub fn init_ex(&mut self, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<(), i32> {
 139        let heap = match heap {
 140            Some(heap) => heap,
 141            None => core::ptr::null_mut(),
 142        };
 143        let dev_id = match dev_id {
 144            Some(dev_id) => dev_id,
 145            None => sys::INVALID_DEVID,
 146        };
 147        let rc = unsafe { sys::wc_InitSha_ex(&mut self.wc_sha, heap, dev_id) };
 148        if rc != 0 {
 149            return Err(rc);
 150        }
 151        Ok(())
 152    }
 153
 154    /// Update the SHA calculation by feeding in more input data.
 155    ///
 156    /// # Parameters
 157    ///
 158    /// * `data`: Input data.
 159    ///
 160    /// # Returns
 161    ///
 162    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 163    /// library error code value.
 164    ///
 165    /// # Example
 166    ///
 167    /// ```rust
 168    /// use wolfssl_wolfcrypt::sha::SHA;
 169    /// let mut sha = SHA::new().expect("Error with new()");
 170    /// sha.update(b"input").expect("Error with update()");
 171    /// ```
 172    pub fn update(&mut self, data: &[u8]) -> Result<(), i32> {
 173        let data_size = crate::buffer_len_to_u32(data.len())?;
 174        let rc = unsafe {
 175            sys::wc_ShaUpdate(&mut self.wc_sha, data.as_ptr(), data_size)
 176        };
 177        if rc != 0 {
 178            return Err(rc);
 179        }
 180        Ok(())
 181    }
 182
 183    /// Finalize the SHA calculation and retrieve the calculated hash.
 184    ///
 185    /// # Parameters
 186    ///
 187    /// * `hash`: Buffer in which to store the calculated hash. The length
 188    ///   should be SHA::DIGEST_SIZE.
 189    ///
 190    /// # Returns
 191    ///
 192    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 193    /// library error code value.
 194    ///
 195    /// # Example
 196    ///
 197    /// ```rust
 198    /// use wolfssl_wolfcrypt::sha::SHA;
 199    /// let mut sha = SHA::new().expect("Error with new()");
 200    /// sha.update(b"input").expect("Error with update()");
 201    /// let mut hash = [0u8; SHA::DIGEST_SIZE];
 202    /// sha.finalize(&mut hash).expect("Error with finalize()");
 203    /// ```
 204    pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> {
 205        if hash.len() != Self::DIGEST_SIZE {
 206            return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E);
 207        }
 208        let rc = unsafe {
 209            sys::wc_ShaFinal(&mut self.wc_sha, hash.as_mut_ptr())
 210        };
 211        if rc != 0 {
 212            return Err(rc);
 213        }
 214        Ok(())
 215    }
 216}
 217
 218#[cfg(sha)]
 219impl SHA {
 220    fn zeroize(&mut self) {
 221        unsafe { crate::zeroize_raw(&mut self.wc_sha); }
 222    }
 223}
 224
 225#[cfg(sha)]
 226impl Drop for SHA {
 227    /// Safely free the underlying wolfSSL SHA context.
 228    ///
 229    /// This calls the `wc_ShaFree` wolfssl library function.
 230    ///
 231    /// The Rust Drop trait guarantees that this method is called when the SHA
 232    /// struct goes out of scope, automatically cleaning up resources and
 233    /// preventing memory leaks.
 234    fn drop(&mut self) {
 235        unsafe { sys::wc_ShaFree(&mut self.wc_sha); }
 236        self.zeroize();
 237    }
 238}
 239
 240/// Context for SHA-224 (SHA-2) computation.
 241#[cfg(sha224)]
 242pub struct SHA224 {
 243    wc_sha224: sys::wc_Sha224,
 244}
 245
 246#[cfg(sha224)]
 247impl SHA224 {
 248    /// SHA-224 digest size in bytes.
 249    pub const DIGEST_SIZE: usize = sys::WC_SHA224_DIGEST_SIZE as usize;
 250
 251    /// Build a new SHA224 instance.
 252    ///
 253    /// # Returns
 254    ///
 255    /// Returns either Ok(sha) containing the SHA224 struct instance or Err(e)
 256    /// containing the wolfSSL library error code value.
 257    ///
 258    /// # Example
 259    ///
 260    /// ```rust
 261    /// use wolfssl_wolfcrypt::sha::SHA224;
 262    /// let sha = SHA224::new().expect("Error with new()");
 263    /// ```
 264    pub fn new() -> Result<Self, i32> {
 265        Self::new_ex(None, None)
 266    }
 267
 268    /// Build a new SHA224 instance with optional heap and device ID.
 269    ///
 270    /// # Parameters
 271    ///
 272    /// * `heap`: Optional heap hint.
 273    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
 274    ///
 275    /// # Returns
 276    ///
 277    /// Returns either Ok(sha) containing the SHA224 struct instance or Err(e)
 278    /// containing the wolfSSL library error code value.
 279    ///
 280    /// # Example
 281    ///
 282    /// ```rust
 283    /// use wolfssl_wolfcrypt::sha::SHA224;
 284    /// let sha = SHA224::new_ex(None, None).expect("Error with new_ex()");
 285    /// ```
 286    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
 287        let mut wc_sha224: MaybeUninit<sys::wc_Sha224> = MaybeUninit::uninit();
 288        let heap = match heap {
 289            Some(heap) => heap,
 290            None => core::ptr::null_mut(),
 291        };
 292        let dev_id = match dev_id {
 293            Some(dev_id) => dev_id,
 294            None => sys::INVALID_DEVID,
 295        };
 296        let rc = unsafe { sys::wc_InitSha224_ex(wc_sha224.as_mut_ptr(), heap, dev_id) };
 297        if rc != 0 {
 298            return Err(rc);
 299        }
 300        let wc_sha224 = unsafe { wc_sha224.assume_init() };
 301        let sha224 = SHA224 { wc_sha224 };
 302        Ok(sha224)
 303    }
 304
 305    /// Reinitialize a SHA224 instance for a new hash calculation.
 306    ///
 307    /// This does not need to be called after `new()`, but should be called
 308    /// after a hash calculation to prepare for a new calculation.
 309    ///
 310    /// # Returns
 311    ///
 312    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 313    /// library error code value.
 314    ///
 315    /// # Example
 316    ///
 317    /// ```rust
 318    /// use wolfssl_wolfcrypt::sha::SHA224;
 319    /// let mut sha = SHA224::new().expect("Error with new()");
 320    /// sha.init().expect("Error with init()");
 321    /// ```
 322    pub fn init(&mut self) -> Result<(), i32> {
 323        self.init_ex(None, None)
 324    }
 325
 326    /// Reinitialize a SHA224 instance for a new hash calculation with optional
 327    /// heap and device ID.
 328    ///
 329    /// This does not need to be called after `new()`, but should be called
 330    /// after a hash calculation to prepare for a new calculation.
 331    ///
 332    /// # Parameters
 333    ///
 334    /// * `heap`: Optional heap hint.
 335    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
 336    ///
 337    /// # Returns
 338    ///
 339    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 340    /// library error code value.
 341    ///
 342    /// # Example
 343    ///
 344    /// ```rust
 345    /// use wolfssl_wolfcrypt::sha::SHA224;
 346    /// let mut sha = SHA224::new().expect("Error with new()");
 347    /// sha.init_ex(None, None).expect("Error with init_ex()");
 348    /// ```
 349    pub fn init_ex(&mut self, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<(), i32> {
 350        let heap = match heap {
 351            Some(heap) => heap,
 352            None => core::ptr::null_mut(),
 353        };
 354        let dev_id = match dev_id {
 355            Some(dev_id) => dev_id,
 356            None => sys::INVALID_DEVID,
 357        };
 358        let rc = unsafe { sys::wc_InitSha224_ex(&mut self.wc_sha224, heap, dev_id) };
 359        if rc != 0 {
 360            return Err(rc);
 361        }
 362        Ok(())
 363    }
 364
 365    /// Update the SHA-224 calculation by feeding in more input data.
 366    ///
 367    /// # Parameters
 368    ///
 369    /// * `data`: Input data.
 370    ///
 371    /// # Returns
 372    ///
 373    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 374    /// library error code value.
 375    ///
 376    /// # Example
 377    ///
 378    /// ```rust
 379    /// use wolfssl_wolfcrypt::sha::SHA224;
 380    /// let mut sha = SHA224::new().expect("Error with new()");
 381    /// sha.update(b"input").expect("Error with update()");
 382    /// ```
 383    pub fn update(&mut self, data: &[u8]) -> Result<(), i32> {
 384        let data_size = crate::buffer_len_to_u32(data.len())?;
 385        let rc = unsafe {
 386            sys::wc_Sha224Update(&mut self.wc_sha224, data.as_ptr(), data_size)
 387        };
 388        if rc != 0 {
 389            return Err(rc);
 390        }
 391        Ok(())
 392    }
 393
 394    /// Finalize the SHA-224 calculation and retrieve the calculated hash.
 395    ///
 396    /// # Parameters
 397    ///
 398    /// * `hash`: Buffer in which to store the calculated hash. The length
 399    ///   should be SHA224::DIGEST_SIZE.
 400    ///
 401    /// # Returns
 402    ///
 403    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 404    /// library error code value.
 405    ///
 406    /// # Example
 407    ///
 408    /// ```rust
 409    /// use wolfssl_wolfcrypt::sha::SHA224;
 410    /// let mut sha = SHA224::new().expect("Error with new()");
 411    /// sha.update(b"input").expect("Error with update()");
 412    /// let mut hash = [0u8; SHA224::DIGEST_SIZE];
 413    /// sha.finalize(&mut hash).expect("Error with finalize()");
 414    /// ```
 415    pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> {
 416        if hash.len() != Self::DIGEST_SIZE {
 417            return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E);
 418        }
 419        let rc = unsafe {
 420            sys::wc_Sha224Final(&mut self.wc_sha224, hash.as_mut_ptr())
 421        };
 422        if rc != 0 {
 423            return Err(rc);
 424        }
 425        Ok(())
 426    }
 427}
 428
 429#[cfg(sha224)]
 430impl SHA224 {
 431    fn zeroize(&mut self) {
 432        unsafe { crate::zeroize_raw(&mut self.wc_sha224); }
 433    }
 434}
 435
 436#[cfg(sha224)]
 437impl Drop for SHA224 {
 438    /// Safely free the underlying wolfSSL SHA224 context.
 439    ///
 440    /// This calls the `wc_Sha224Free` wolfssl library function.
 441    ///
 442    /// The Rust Drop trait guarantees that this method is called when the
 443    /// SHA224 struct goes out of scope, automatically cleaning up resources
 444    /// and preventing memory leaks.
 445    fn drop(&mut self) {
 446        unsafe { sys::wc_Sha224Free(&mut self.wc_sha224); }
 447        self.zeroize();
 448    }
 449}
 450
 451/// Context for SHA-256 (SHA-2) computation.
 452#[cfg(sha256)]
 453pub struct SHA256 {
 454    wc_sha256: sys::wc_Sha256,
 455}
 456
 457#[cfg(sha256)]
 458impl SHA256 {
 459    /// SHA-256 digest size in bytes.
 460    pub const DIGEST_SIZE: usize = sys::WC_SHA256_DIGEST_SIZE as usize;
 461
 462    /// Build a new SHA256 instance.
 463    ///
 464    /// # Returns
 465    ///
 466    /// Returns either Ok(sha) containing the SHA256 struct instance or Err(e)
 467    /// containing the wolfSSL library error code value.
 468    ///
 469    /// # Example
 470    ///
 471    /// ```rust
 472    /// use wolfssl_wolfcrypt::sha::SHA256;
 473    /// let sha = SHA256::new().expect("Error with new()");
 474    /// ```
 475    pub fn new() -> Result<Self, i32> {
 476        Self::new_ex(None, None)
 477    }
 478
 479    /// Build a new SHA256 instance with optional heap and device ID.
 480    ///
 481    /// # Parameters
 482    ///
 483    /// * `heap`: Optional heap hint.
 484    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
 485    ///
 486    /// # Returns
 487    ///
 488    /// Returns either Ok(sha) containing the SHA256 struct instance or Err(e)
 489    /// containing the wolfSSL library error code value.
 490    ///
 491    /// # Example
 492    ///
 493    /// ```rust
 494    /// use wolfssl_wolfcrypt::sha::SHA256;
 495    /// let sha = SHA256::new_ex(None, None).expect("Error with new_ex()");
 496    /// ```
 497    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
 498        let mut wc_sha256: MaybeUninit<sys::wc_Sha256> = MaybeUninit::uninit();
 499        let heap = match heap {
 500            Some(heap) => heap,
 501            None => core::ptr::null_mut(),
 502        };
 503        let dev_id = match dev_id {
 504            Some(dev_id) => dev_id,
 505            None => sys::INVALID_DEVID,
 506        };
 507        let rc = unsafe { sys::wc_InitSha256_ex(wc_sha256.as_mut_ptr(), heap, dev_id) };
 508        if rc != 0 {
 509            return Err(rc);
 510        }
 511        let wc_sha256 = unsafe { wc_sha256.assume_init() };
 512        let sha256 = SHA256 { wc_sha256 };
 513        Ok(sha256)
 514    }
 515
 516    /// Reinitialize a SHA256 instance for a new hash calculation.
 517    ///
 518    /// This does not need to be called after `new()`, but should be called
 519    /// after a hash calculation to prepare for a new calculation.
 520    ///
 521    /// # Returns
 522    ///
 523    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 524    /// library error code value.
 525    ///
 526    /// # Example
 527    ///
 528    /// ```rust
 529    /// use wolfssl_wolfcrypt::sha::SHA256;
 530    /// let mut sha = SHA256::new().expect("Error with new()");
 531    /// sha.init().expect("Error with init()");
 532    /// ```
 533    pub fn init(&mut self) -> Result<(), i32> {
 534        self.init_ex(None, None)
 535    }
 536
 537    /// Reinitialize a SHA256 instance for a new hash calculation with optional
 538    /// heap and device ID.
 539    ///
 540    /// This does not need to be called after `new()`, but should be called
 541    /// after a hash calculation to prepare for a new calculation.
 542    ///
 543    /// # Parameters
 544    ///
 545    /// * `heap`: Optional heap hint.
 546    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
 547    ///
 548    /// # Returns
 549    ///
 550    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 551    /// library error code value.
 552    ///
 553    /// # Example
 554    ///
 555    /// ```rust
 556    /// use wolfssl_wolfcrypt::sha::SHA256;
 557    /// let mut sha = SHA256::new().expect("Error with new()");
 558    /// sha.init_ex(None, None).expect("Error with init_ex()");
 559    /// ```
 560    pub fn init_ex(&mut self, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<(), i32> {
 561        let heap = match heap {
 562            Some(heap) => heap,
 563            None => core::ptr::null_mut(),
 564        };
 565        let dev_id = match dev_id {
 566            Some(dev_id) => dev_id,
 567            None => sys::INVALID_DEVID,
 568        };
 569        let rc = unsafe { sys::wc_InitSha256_ex(&mut self.wc_sha256, heap, dev_id) };
 570        if rc != 0 {
 571            return Err(rc);
 572        }
 573        Ok(())
 574    }
 575
 576    /// Update the SHA-256 calculation by feeding in more input data.
 577    ///
 578    /// # Parameters
 579    ///
 580    /// * `data`: Input data.
 581    ///
 582    /// # Returns
 583    ///
 584    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 585    /// library error code value.
 586    ///
 587    /// # Example
 588    ///
 589    /// ```rust
 590    /// use wolfssl_wolfcrypt::sha::SHA256;
 591    /// let mut sha = SHA256::new().expect("Error with new()");
 592    /// sha.update(b"input").expect("Error with update()");
 593    /// ```
 594    pub fn update(&mut self, data: &[u8]) -> Result<(), i32> {
 595        let data_size = crate::buffer_len_to_u32(data.len())?;
 596        let rc = unsafe {
 597            sys::wc_Sha256Update(&mut self.wc_sha256, data.as_ptr(), data_size)
 598        };
 599        if rc != 0 {
 600            return Err(rc);
 601        }
 602        Ok(())
 603    }
 604
 605    /// Finalize the SHA-256 calculation and retrieve the calculated hash.
 606    ///
 607    /// # Parameters
 608    ///
 609    /// * `hash`: Buffer in which to store the calculated hash. The length
 610    ///   should be SHA256::DIGEST_SIZE.
 611    ///
 612    /// # Returns
 613    ///
 614    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 615    /// library error code value.
 616    ///
 617    /// # Example
 618    ///
 619    /// ```rust
 620    /// use wolfssl_wolfcrypt::sha::SHA256;
 621    /// let mut sha = SHA256::new().expect("Error with new()");
 622    /// sha.update(b"input").expect("Error with update()");
 623    /// let mut hash = [0u8; SHA256::DIGEST_SIZE];
 624    /// sha.finalize(&mut hash).expect("Error with finalize()");
 625    /// ```
 626    pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> {
 627        if hash.len() != Self::DIGEST_SIZE {
 628            return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E);
 629        }
 630        let rc = unsafe {
 631            sys::wc_Sha256Final(&mut self.wc_sha256, hash.as_mut_ptr())
 632        };
 633        if rc != 0 {
 634            return Err(rc);
 635        }
 636        Ok(())
 637    }
 638}
 639
 640#[cfg(sha256)]
 641impl SHA256 {
 642    fn zeroize(&mut self) {
 643        unsafe { crate::zeroize_raw(&mut self.wc_sha256); }
 644    }
 645}
 646
 647#[cfg(sha256)]
 648impl Drop for SHA256 {
 649    /// Safely free the underlying wolfSSL SHA256 context.
 650    ///
 651    /// This calls the `wc_Sha256Free` wolfssl library function.
 652    ///
 653    /// The Rust Drop trait guarantees that this method is called when the
 654    /// SHA256 struct goes out of scope, automatically cleaning up resources
 655    /// and preventing memory leaks.
 656    fn drop(&mut self) {
 657        unsafe { sys::wc_Sha256Free(&mut self.wc_sha256); }
 658        self.zeroize();
 659    }
 660}
 661
 662/// Context for SHA-384 (SHA-2) computation.
 663#[cfg(sha384)]
 664pub struct SHA384 {
 665    wc_sha384: sys::wc_Sha384,
 666}
 667
 668#[cfg(sha384)]
 669impl SHA384 {
 670    /// SHA-384 digest size in bytes.
 671    pub const DIGEST_SIZE: usize = sys::WC_SHA384_DIGEST_SIZE as usize;
 672
 673    /// Build a new SHA384 instance.
 674    ///
 675    /// # Returns
 676    ///
 677    /// Returns either Ok(sha) containing the SHA384 struct instance or Err(e)
 678    /// containing the wolfSSL library error code value.
 679    ///
 680    /// # Example
 681    ///
 682    /// ```rust
 683    /// use wolfssl_wolfcrypt::sha::SHA384;
 684    /// let sha = SHA384::new().expect("Error with new()");
 685    /// ```
 686    pub fn new() -> Result<Self, i32> {
 687        Self::new_ex(None, None)
 688    }
 689
 690    /// Build a new SHA384 instance with optional heap and device ID.
 691    ///
 692    /// # Parameters
 693    ///
 694    /// * `heap`: Optional heap hint.
 695    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
 696    ///
 697    /// # Returns
 698    ///
 699    /// Returns either Ok(sha) containing the SHA384 struct instance or Err(e)
 700    /// containing the wolfSSL library error code value.
 701    ///
 702    /// # Example
 703    ///
 704    /// ```rust
 705    /// use wolfssl_wolfcrypt::sha::SHA384;
 706    /// let sha = SHA384::new_ex(None, None).expect("Error with new_ex()");
 707    /// ```
 708    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
 709        let mut wc_sha384: MaybeUninit<sys::wc_Sha384> = MaybeUninit::uninit();
 710        let heap = match heap {
 711            Some(heap) => heap,
 712            None => core::ptr::null_mut(),
 713        };
 714        let dev_id = match dev_id {
 715            Some(dev_id) => dev_id,
 716            None => sys::INVALID_DEVID,
 717        };
 718        let rc = unsafe { sys::wc_InitSha384_ex(wc_sha384.as_mut_ptr(), heap, dev_id) };
 719        if rc != 0 {
 720            return Err(rc);
 721        }
 722        let wc_sha384 = unsafe { wc_sha384.assume_init() };
 723        let sha384 = SHA384 { wc_sha384 };
 724        Ok(sha384)
 725    }
 726
 727    /// Reinitialize a SHA384 instance for a new hash calculation.
 728    ///
 729    /// This does not need to be called after `new()`, but should be called
 730    /// after a hash calculation to prepare for a new calculation.
 731    ///
 732    /// # Returns
 733    ///
 734    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 735    /// library error code value.
 736    ///
 737    /// # Example
 738    ///
 739    /// ```rust
 740    /// use wolfssl_wolfcrypt::sha::SHA384;
 741    /// let mut sha = SHA384::new().expect("Error with new()");
 742    /// sha.init().expect("Error with init()");
 743    /// ```
 744    pub fn init(&mut self) -> Result<(), i32> {
 745        self.init_ex(None, None)
 746    }
 747
 748    /// Reinitialize a SHA384 instance for a new hash calculation with optional
 749    /// heap and device ID.
 750    ///
 751    /// This does not need to be called after `new()`, but should be called
 752    /// after a hash calculation to prepare for a new calculation.
 753    ///
 754    /// # Parameters
 755    ///
 756    /// * `heap`: Optional heap hint.
 757    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
 758    ///
 759    /// # Returns
 760    ///
 761    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 762    /// library error code value.
 763    ///
 764    /// # Example
 765    ///
 766    /// ```rust
 767    /// use wolfssl_wolfcrypt::sha::SHA384;
 768    /// let mut sha = SHA384::new().expect("Error with new()");
 769    /// sha.init_ex(None, None).expect("Error with init_ex()");
 770    /// ```
 771    pub fn init_ex(&mut self, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<(), i32> {
 772        let heap = match heap {
 773            Some(heap) => heap,
 774            None => core::ptr::null_mut(),
 775        };
 776        let dev_id = match dev_id {
 777            Some(dev_id) => dev_id,
 778            None => sys::INVALID_DEVID,
 779        };
 780        let rc = unsafe { sys::wc_InitSha384_ex(&mut self.wc_sha384, heap, dev_id) };
 781        if rc != 0 {
 782            return Err(rc);
 783        }
 784        Ok(())
 785    }
 786
 787    /// Update the SHA-384 calculation by feeding in more input data.
 788    ///
 789    /// # Parameters
 790    ///
 791    /// * `data`: Input data.
 792    ///
 793    /// # Returns
 794    ///
 795    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 796    /// library error code value.
 797    ///
 798    /// # Example
 799    ///
 800    /// ```rust
 801    /// use wolfssl_wolfcrypt::sha::SHA384;
 802    /// let mut sha = SHA384::new().expect("Error with new()");
 803    /// sha.update(b"input").expect("Error with update()");
 804    /// ```
 805    pub fn update(&mut self, data: &[u8]) -> Result<(), i32> {
 806        let data_size = crate::buffer_len_to_u32(data.len())?;
 807        let rc = unsafe {
 808            sys::wc_Sha384Update(&mut self.wc_sha384, data.as_ptr(), data_size)
 809        };
 810        if rc != 0 {
 811            return Err(rc);
 812        }
 813        Ok(())
 814    }
 815
 816    /// Finalize the SHA-384 calculation and retrieve the calculated hash.
 817    ///
 818    /// # Parameters
 819    ///
 820    /// * `hash`: Buffer in which to store the calculated hash. The length
 821    ///   should be SHA384::DIGEST_SIZE.
 822    ///
 823    /// # Returns
 824    ///
 825    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 826    /// library error code value.
 827    ///
 828    /// # Example
 829    ///
 830    /// ```rust
 831    /// use wolfssl_wolfcrypt::sha::SHA384;
 832    /// let mut sha = SHA384::new().expect("Error with new()");
 833    /// sha.update(b"input").expect("Error with update()");
 834    /// let mut hash = [0u8; SHA384::DIGEST_SIZE];
 835    /// sha.finalize(&mut hash).expect("Error with finalize()");
 836    /// ```
 837    pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> {
 838        if hash.len() != Self::DIGEST_SIZE {
 839            return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E);
 840        }
 841        let rc = unsafe {
 842            sys::wc_Sha384Final(&mut self.wc_sha384, hash.as_mut_ptr())
 843        };
 844        if rc != 0 {
 845            return Err(rc);
 846        }
 847        Ok(())
 848    }
 849}
 850
 851#[cfg(sha384)]
 852impl SHA384 {
 853    fn zeroize(&mut self) {
 854        unsafe { crate::zeroize_raw(&mut self.wc_sha384); }
 855    }
 856}
 857
 858#[cfg(sha384)]
 859impl Drop for SHA384 {
 860    /// Safely free the underlying wolfSSL SHA384 context.
 861    ///
 862    /// This calls the `wc_Sha384Free` wolfssl library function.
 863    ///
 864    /// The Rust Drop trait guarantees that this method is called when the
 865    /// SHA384 struct goes out of scope, automatically cleaning up resources
 866    /// and preventing memory leaks.
 867    fn drop(&mut self) {
 868        unsafe { sys::wc_Sha384Free(&mut self.wc_sha384); }
 869        self.zeroize();
 870    }
 871}
 872
 873/// Context for SHA-512 (SHA-2) computation.
 874#[cfg(sha512)]
 875pub struct SHA512 {
 876    wc_sha512: sys::wc_Sha512,
 877}
 878
 879#[cfg(sha512)]
 880impl SHA512 {
 881    /// SHA-512 digest size in bytes.
 882    pub const DIGEST_SIZE: usize = sys::WC_SHA512_DIGEST_SIZE as usize;
 883
 884    /// Build a new SHA512 instance.
 885    ///
 886    /// # Returns
 887    ///
 888    /// Returns either Ok(sha) containing the SHA512 struct instance or Err(e)
 889    /// containing the wolfSSL library error code value.
 890    ///
 891    /// # Example
 892    ///
 893    /// ```rust
 894    /// use wolfssl_wolfcrypt::sha::SHA512;
 895    /// let sha = SHA512::new().expect("Error with new()");
 896    /// ```
 897    pub fn new() -> Result<Self, i32> {
 898        Self::new_ex(None, None)
 899    }
 900
 901    /// Build a new SHA512 instance with optional heap and device ID.
 902    ///
 903    /// # Parameters
 904    ///
 905    /// * `heap`: Optional heap hint.
 906    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
 907    ///
 908    /// # Returns
 909    ///
 910    /// Returns either Ok(sha) containing the SHA512 struct instance or Err(e)
 911    /// containing the wolfSSL library error code value.
 912    ///
 913    /// # Example
 914    ///
 915    /// ```rust
 916    /// use wolfssl_wolfcrypt::sha::SHA512;
 917    /// let sha = SHA512::new_ex(None, None).expect("Error with new_ex()");
 918    /// ```
 919    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
 920        let mut wc_sha512: MaybeUninit<sys::wc_Sha512> = MaybeUninit::uninit();
 921        let heap = match heap {
 922            Some(heap) => heap,
 923            None => core::ptr::null_mut(),
 924        };
 925        let dev_id = match dev_id {
 926            Some(dev_id) => dev_id,
 927            None => sys::INVALID_DEVID,
 928        };
 929        let rc = unsafe { sys::wc_InitSha512_ex(wc_sha512.as_mut_ptr(), heap, dev_id) };
 930        if rc != 0 {
 931            return Err(rc);
 932        }
 933        let wc_sha512 = unsafe { wc_sha512.assume_init() };
 934        let sha512 = SHA512 { wc_sha512 };
 935        Ok(sha512)
 936    }
 937
 938    /// Reinitialize a SHA512 instance for a new hash calculation.
 939    ///
 940    /// This does not need to be called after `new()`, but should be called
 941    /// after a hash calculation to prepare for a new calculation.
 942    ///
 943    /// # Returns
 944    ///
 945    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 946    /// library error code value.
 947    ///
 948    /// # Example
 949    ///
 950    /// ```rust
 951    /// use wolfssl_wolfcrypt::sha::SHA512;
 952    /// let mut sha = SHA512::new().expect("Error with new()");
 953    /// sha.init().expect("Error with init()");
 954    /// ```
 955    pub fn init(&mut self) -> Result<(), i32> {
 956        self.init_ex(None, None)
 957    }
 958
 959    /// Reinitialize a SHA512 instance for a new hash calculation with optional
 960    /// heap and device ID.
 961    ///
 962    /// This does not need to be called after `new()`, but should be called
 963    /// after a hash calculation to prepare for a new calculation.
 964    ///
 965    /// # Parameters
 966    ///
 967    /// * `heap`: Optional heap hint.
 968    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
 969    ///
 970    /// # Returns
 971    ///
 972    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 973    /// library error code value.
 974    ///
 975    /// # Example
 976    ///
 977    /// ```rust
 978    /// use wolfssl_wolfcrypt::sha::SHA512;
 979    /// let mut sha = SHA512::new().expect("Error with new()");
 980    /// sha.init_ex(None, None).expect("Error with init_ex()");
 981    /// ```
 982    pub fn init_ex(&mut self, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<(), i32> {
 983        let heap = match heap {
 984            Some(heap) => heap,
 985            None => core::ptr::null_mut(),
 986        };
 987        let dev_id = match dev_id {
 988            Some(dev_id) => dev_id,
 989            None => sys::INVALID_DEVID,
 990        };
 991        let rc = unsafe { sys::wc_InitSha512_ex(&mut self.wc_sha512, heap, dev_id) };
 992        if rc != 0 {
 993            return Err(rc);
 994        }
 995        Ok(())
 996    }
 997
 998    /// Update the SHA-512 calculation by feeding in more input data.
 999    ///
1000    /// # Parameters
1001    ///
1002    /// * `data`: Input data.
1003    ///
1004    /// # Returns
1005    ///
1006    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1007    /// library error code value.
1008    ///
1009    /// # Example
1010    ///
1011    /// ```rust
1012    /// use wolfssl_wolfcrypt::sha::SHA512;
1013    /// let mut sha = SHA512::new().expect("Error with new()");
1014    /// sha.update(b"input").expect("Error with update()");
1015    /// ```
1016    pub fn update(&mut self, data: &[u8]) -> Result<(), i32> {
1017        let data_size = crate::buffer_len_to_u32(data.len())?;
1018        let rc = unsafe {
1019            sys::wc_Sha512Update(&mut self.wc_sha512, data.as_ptr(), data_size)
1020        };
1021        if rc != 0 {
1022            return Err(rc);
1023        }
1024        Ok(())
1025    }
1026
1027    /// Finalize the SHA-512 calculation and retrieve the calculated hash.
1028    ///
1029    /// # Parameters
1030    ///
1031    /// * `hash`: Buffer in which to store the calculated hash. The length
1032    ///   should be SHA512::DIGEST_SIZE.
1033    ///
1034    /// # Returns
1035    ///
1036    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1037    /// library error code value.
1038    ///
1039    /// # Example
1040    ///
1041    /// ```rust
1042    /// use wolfssl_wolfcrypt::sha::SHA512;
1043    /// let mut sha = SHA512::new().expect("Error with new()");
1044    /// sha.update(b"input").expect("Error with update()");
1045    /// let mut hash = [0u8; SHA512::DIGEST_SIZE];
1046    /// sha.finalize(&mut hash).expect("Error with finalize()");
1047    /// ```
1048    pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> {
1049        if hash.len() != Self::DIGEST_SIZE {
1050            return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E);
1051        }
1052        let rc = unsafe {
1053            sys::wc_Sha512Final(&mut self.wc_sha512, hash.as_mut_ptr())
1054        };
1055        if rc != 0 {
1056            return Err(rc);
1057        }
1058        Ok(())
1059    }
1060}
1061
1062#[cfg(sha512)]
1063impl SHA512 {
1064    fn zeroize(&mut self) {
1065        unsafe { crate::zeroize_raw(&mut self.wc_sha512); }
1066    }
1067}
1068
1069#[cfg(sha512)]
1070impl Drop for SHA512 {
1071    /// Safely free the underlying wolfSSL SHA512 context.
1072    ///
1073    /// This calls the `wc_Sha512Free` wolfssl library function.
1074    ///
1075    /// The Rust Drop trait guarantees that this method is called when the
1076    /// SHA512 struct goes out of scope, automatically cleaning up resources
1077    /// and preventing memory leaks.
1078    fn drop(&mut self) {
1079        unsafe { sys::wc_Sha512Free(&mut self.wc_sha512); }
1080        self.zeroize();
1081    }
1082}
1083
1084/// Context for SHA3-224 computation.
1085#[cfg(sha3)]
1086pub struct SHA3_224 {
1087    wc_sha3: sys::wc_Sha3,
1088}
1089
1090#[cfg(sha3)]
1091impl SHA3_224 {
1092    /// SHA3-224 digest size in bytes.
1093    pub const DIGEST_SIZE: usize = sys::WC_SHA3_224_DIGEST_SIZE as usize;
1094
1095    /// Build a new SHA3_224 instance.
1096    ///
1097    /// # Returns
1098    ///
1099    /// Returns either Ok(sha) containing the SHA3_224 struct instance or Err(e)
1100    /// containing the wolfSSL library error code value.
1101    ///
1102    /// # Example
1103    ///
1104    /// ```rust
1105    /// use wolfssl_wolfcrypt::sha::SHA3_224;
1106    /// let sha = SHA3_224::new().expect("Error with new()");
1107    /// ```
1108    pub fn new() -> Result<Self, i32> {
1109        Self::new_ex(None, None)
1110    }
1111
1112    /// Build a new SHA3_224 instance with optional heap and device ID.
1113    ///
1114    /// # Parameters
1115    ///
1116    /// * `heap`: Optional heap hint.
1117    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
1118    ///
1119    /// # Returns
1120    ///
1121    /// Returns either Ok(sha) containing the SHA3_224 struct instance or Err(e)
1122    /// containing the wolfSSL library error code value.
1123    ///
1124    /// # Example
1125    ///
1126    /// ```rust
1127    /// use wolfssl_wolfcrypt::sha::SHA3_224;
1128    /// let sha = SHA3_224::new_ex(None, None).expect("Error with new_ex()");
1129    /// ```
1130    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
1131        let mut wc_sha3: MaybeUninit<sys::wc_Sha3> = MaybeUninit::uninit();
1132        let heap = match heap {
1133            Some(heap) => heap,
1134            None => core::ptr::null_mut(),
1135        };
1136        let dev_id = match dev_id {
1137            Some(dev_id) => dev_id,
1138            None => sys::INVALID_DEVID,
1139        };
1140        let rc = unsafe { sys::wc_InitSha3_224(wc_sha3.as_mut_ptr(), heap, dev_id) };
1141        if rc != 0 {
1142            return Err(rc);
1143        }
1144        let wc_sha3 = unsafe { wc_sha3.assume_init() };
1145        let sha3_224 = SHA3_224 { wc_sha3 };
1146        Ok(sha3_224)
1147    }
1148
1149    /// Reinitialize a SHA3_224 instance for a new hash calculation.
1150    ///
1151    /// This does not need to be called after `new()`, but should be called
1152    /// after a hash calculation to prepare for a new calculation.
1153    ///
1154    /// # Returns
1155    ///
1156    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1157    /// library error code value.
1158    ///
1159    /// # Example
1160    ///
1161    /// ```rust
1162    /// use wolfssl_wolfcrypt::sha::SHA3_224;
1163    /// let mut sha = SHA3_224::new().expect("Error with new()");
1164    /// sha.init().expect("Error with init()");
1165    /// ```
1166    pub fn init(&mut self) -> Result<(), i32> {
1167        self.init_ex(None, None)
1168    }
1169
1170    /// Reinitialize a SHA3_224 instance for a new hash calculation with
1171    /// optional heap and device ID.
1172    ///
1173    /// This does not need to be called after `new()`, but should be called
1174    /// after a hash calculation to prepare for a new calculation.
1175    ///
1176    /// # Parameters
1177    ///
1178    /// * `heap`: Optional heap hint.
1179    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
1180    ///
1181    /// # Returns
1182    ///
1183    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1184    /// library error code value.
1185    ///
1186    /// # Example
1187    ///
1188    /// ```rust
1189    /// use wolfssl_wolfcrypt::sha::SHA3_224;
1190    /// let mut sha = SHA3_224::new().expect("Error with new()");
1191    /// sha.init_ex(None, None).expect("Error with init_ex()");
1192    /// ```
1193    pub fn init_ex(&mut self, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<(), i32> {
1194        let heap = match heap {
1195            Some(heap) => heap,
1196            None => core::ptr::null_mut(),
1197        };
1198        let dev_id = match dev_id {
1199            Some(dev_id) => dev_id,
1200            None => sys::INVALID_DEVID,
1201        };
1202        let rc = unsafe { sys::wc_InitSha3_224(&mut self.wc_sha3, heap, dev_id) };
1203        if rc != 0 {
1204            return Err(rc);
1205        }
1206        Ok(())
1207    }
1208
1209    /// Update the SHA3-224 calculation by feeding in more input data.
1210    ///
1211    /// # Parameters
1212    ///
1213    /// * `data`: Input data.
1214    ///
1215    /// # Returns
1216    ///
1217    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1218    /// library error code value.
1219    ///
1220    /// # Example
1221    ///
1222    /// ```rust
1223    /// use wolfssl_wolfcrypt::sha::SHA3_224;
1224    /// let mut sha = SHA3_224::new().expect("Error with new()");
1225    /// sha.update(b"input").expect("Error with update()");
1226    /// ```
1227    pub fn update(&mut self, data: &[u8]) -> Result<(), i32> {
1228        let data_size = crate::buffer_len_to_u32(data.len())?;
1229        let rc = unsafe {
1230            sys::wc_Sha3_224_Update(&mut self.wc_sha3, data.as_ptr(), data_size)
1231        };
1232        if rc != 0 {
1233            return Err(rc);
1234        }
1235        Ok(())
1236    }
1237
1238    /// Finalize the SHA3-224 calculation and retrieve the calculated hash.
1239    ///
1240    /// # Parameters
1241    ///
1242    /// * `hash`: Buffer in which to store the calculated hash. The length
1243    ///   should be SHA3_224::DIGEST_SIZE.
1244    ///
1245    /// # Returns
1246    ///
1247    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1248    /// library error code value.
1249    ///
1250    /// # Example
1251    ///
1252    /// ```rust
1253    /// use wolfssl_wolfcrypt::sha::SHA3_224;
1254    /// let mut sha = SHA3_224::new().expect("Error with new()");
1255    /// sha.update(b"input").expect("Error with update()");
1256    /// let mut hash = [0u8; SHA3_224::DIGEST_SIZE];
1257    /// sha.finalize(&mut hash).expect("Error with finalize()");
1258    /// ```
1259    pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> {
1260        if hash.len() != Self::DIGEST_SIZE {
1261            return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E);
1262        }
1263        let rc = unsafe {
1264            sys::wc_Sha3_224_Final(&mut self.wc_sha3, hash.as_mut_ptr())
1265        };
1266        if rc != 0 {
1267            return Err(rc);
1268        }
1269        Ok(())
1270    }
1271}
1272
1273#[cfg(sha3)]
1274impl SHA3_224 {
1275    fn zeroize(&mut self) {
1276        unsafe { crate::zeroize_raw(&mut self.wc_sha3); }
1277    }
1278}
1279
1280#[cfg(sha3)]
1281impl Drop for SHA3_224 {
1282    /// Safely free the underlying wolfSSL SHA3_224 context.
1283    ///
1284    /// This calls the `wc_Sha3_224_Free` wolfssl library function.
1285    ///
1286    /// The Rust Drop trait guarantees that this method is called when the
1287    /// SHA3_224 struct goes out of scope, automatically cleaning up resources
1288    /// and preventing memory leaks.
1289    fn drop(&mut self) {
1290        unsafe { sys::wc_Sha3_224_Free(&mut self.wc_sha3); }
1291        self.zeroize();
1292    }
1293}
1294
1295/// Context for SHA3-256 computation.
1296#[cfg(sha3)]
1297pub struct SHA3_256 {
1298    wc_sha3: sys::wc_Sha3,
1299}
1300
1301#[cfg(sha3)]
1302impl SHA3_256 {
1303    /// SHA3-256 digest size in bytes.
1304    pub const DIGEST_SIZE: usize = sys::WC_SHA3_256_DIGEST_SIZE as usize;
1305
1306    /// Build a new SHA3_256 instance.
1307    ///
1308    /// # Returns
1309    ///
1310    /// Returns either Ok(sha) containing the SHA3_256 struct instance or Err(e)
1311    /// containing the wolfSSL library error code value.
1312    ///
1313    /// # Example
1314    ///
1315    /// ```rust
1316    /// use wolfssl_wolfcrypt::sha::SHA3_256;
1317    /// let sha = SHA3_256::new().expect("Error with new()");
1318    /// ```
1319    pub fn new() -> Result<Self, i32> {
1320        Self::new_ex(None, None)
1321    }
1322
1323    /// Build a new SHA3_256 instance with optional heap and device ID.
1324    ///
1325    /// # Parameters
1326    ///
1327    /// * `heap`: Optional heap hint.
1328    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
1329    ///
1330    /// # Returns
1331    ///
1332    /// Returns either Ok(sha) containing the SHA3_256 struct instance or Err(e)
1333    /// containing the wolfSSL library error code value.
1334    ///
1335    /// # Example
1336    ///
1337    /// ```rust
1338    /// use wolfssl_wolfcrypt::sha::SHA3_256;
1339    /// let sha = SHA3_256::new_ex(None, None).expect("Error with new_ex()");
1340    /// ```
1341    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
1342        let mut wc_sha3: MaybeUninit<sys::wc_Sha3> = MaybeUninit::uninit();
1343        let heap = match heap {
1344            Some(heap) => heap,
1345            None => core::ptr::null_mut(),
1346        };
1347        let dev_id = match dev_id {
1348            Some(dev_id) => dev_id,
1349            None => sys::INVALID_DEVID,
1350        };
1351        let rc = unsafe { sys::wc_InitSha3_256(wc_sha3.as_mut_ptr(), heap, dev_id) };
1352        if rc != 0 {
1353            return Err(rc);
1354        }
1355        let wc_sha3 = unsafe { wc_sha3.assume_init() };
1356        let sha3_256 = SHA3_256 { wc_sha3 };
1357        Ok(sha3_256)
1358    }
1359
1360    /// Reinitialize a SHA3_256 instance for a new hash calculation.
1361    ///
1362    /// This does not need to be called after `new()`, but should be called
1363    /// after a hash calculation to prepare for a new calculation.
1364    ///
1365    /// # Returns
1366    ///
1367    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1368    /// library error code value.
1369    ///
1370    /// # Example
1371    ///
1372    /// ```rust
1373    /// use wolfssl_wolfcrypt::sha::SHA3_256;
1374    /// let mut sha = SHA3_256::new().expect("Error with new()");
1375    /// sha.init().expect("Error with init()");
1376    /// ```
1377    pub fn init(&mut self) -> Result<(), i32> {
1378        self.init_ex(None, None)
1379    }
1380
1381    /// Reinitialize a SHA3_256 instance for a new hash calculation with
1382    /// optional heap and device ID.
1383    ///
1384    /// This does not need to be called after `new()`, but should be called
1385    /// after a hash calculation to prepare for a new calculation.
1386    ///
1387    /// # Parameters
1388    ///
1389    /// * `heap`: Optional heap hint.
1390    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
1391    ///
1392    /// # Returns
1393    ///
1394    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1395    /// library error code value.
1396    ///
1397    /// # Example
1398    ///
1399    /// ```rust
1400    /// use wolfssl_wolfcrypt::sha::SHA3_256;
1401    /// let mut sha = SHA3_256::new().expect("Error with new()");
1402    /// sha.init_ex(None, None).expect("Error with init_ex()");
1403    /// ```
1404    pub fn init_ex(&mut self, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<(), i32> {
1405        let heap = match heap {
1406            Some(heap) => heap,
1407            None => core::ptr::null_mut(),
1408        };
1409        let dev_id = match dev_id {
1410            Some(dev_id) => dev_id,
1411            None => sys::INVALID_DEVID,
1412        };
1413        let rc = unsafe { sys::wc_InitSha3_256(&mut self.wc_sha3, heap, dev_id) };
1414        if rc != 0 {
1415            return Err(rc);
1416        }
1417        Ok(())
1418    }
1419
1420    /// Update the SHA3-256 calculation by feeding in more input data.
1421    ///
1422    /// # Parameters
1423    ///
1424    /// * `data`: Input data.
1425    ///
1426    /// # Returns
1427    ///
1428    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1429    /// library error code value.
1430    ///
1431    /// # Example
1432    ///
1433    /// ```rust
1434    /// use wolfssl_wolfcrypt::sha::SHA3_256;
1435    /// let mut sha = SHA3_256::new().expect("Error with new()");
1436    /// sha.update(b"input").expect("Error with update()");
1437    /// ```
1438    pub fn update(&mut self, data: &[u8]) -> Result<(), i32> {
1439        let data_size = crate::buffer_len_to_u32(data.len())?;
1440        let rc = unsafe {
1441            sys::wc_Sha3_256_Update(&mut self.wc_sha3, data.as_ptr(), data_size)
1442        };
1443        if rc != 0 {
1444            return Err(rc);
1445        }
1446        Ok(())
1447    }
1448
1449    /// Finalize the SHA3-256 calculation and retrieve the calculated hash.
1450    ///
1451    /// # Parameters
1452    ///
1453    /// * `hash`: Buffer in which to store the calculated hash. The length
1454    ///   should be SHA3_256::DIGEST_SIZE.
1455    ///
1456    /// # Returns
1457    ///
1458    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1459    /// library error code value.
1460    ///
1461    /// # Example
1462    ///
1463    /// ```rust
1464    /// use wolfssl_wolfcrypt::sha::SHA3_256;
1465    /// let mut sha = SHA3_256::new().expect("Error with new()");
1466    /// sha.update(b"input").expect("Error with update()");
1467    /// let mut hash = [0u8; SHA3_256::DIGEST_SIZE];
1468    /// sha.finalize(&mut hash).expect("Error with finalize()");
1469    /// ```
1470    pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> {
1471        if hash.len() != Self::DIGEST_SIZE {
1472            return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E);
1473        }
1474        let rc = unsafe {
1475            sys::wc_Sha3_256_Final(&mut self.wc_sha3, hash.as_mut_ptr())
1476        };
1477        if rc != 0 {
1478            return Err(rc);
1479        }
1480        Ok(())
1481    }
1482}
1483
1484#[cfg(sha3)]
1485impl SHA3_256 {
1486    fn zeroize(&mut self) {
1487        unsafe { crate::zeroize_raw(&mut self.wc_sha3); }
1488    }
1489}
1490
1491#[cfg(sha3)]
1492impl Drop for SHA3_256 {
1493    /// Safely free the underlying wolfSSL SHA3_256 context.
1494    ///
1495    /// This calls the `wc_Sha3_256_Free` wolfssl library function.
1496    ///
1497    /// The Rust Drop trait guarantees that this method is called when the
1498    /// SHA3_256 struct goes out of scope, automatically cleaning up resources
1499    /// and preventing memory leaks.
1500    fn drop(&mut self) {
1501        unsafe { sys::wc_Sha3_256_Free(&mut self.wc_sha3); }
1502        self.zeroize();
1503    }
1504}
1505
1506/// Context for SHA3-384 computation.
1507#[cfg(sha3)]
1508pub struct SHA3_384 {
1509    wc_sha3: sys::wc_Sha3,
1510}
1511
1512#[cfg(sha3)]
1513impl SHA3_384 {
1514    /// SHA3-384 digest size in bytes.
1515    pub const DIGEST_SIZE: usize = sys::WC_SHA3_384_DIGEST_SIZE as usize;
1516
1517    /// Build a new SHA3_384 instance.
1518    ///
1519    /// # Returns
1520    ///
1521    /// Returns either Ok(sha) containing the SHA3_384 struct instance or Err(e)
1522    /// containing the wolfSSL library error code value.
1523    ///
1524    /// # Example
1525    ///
1526    /// ```rust
1527    /// use wolfssl_wolfcrypt::sha::SHA3_384;
1528    /// let sha = SHA3_384::new().expect("Error with new()");
1529    /// ```
1530    pub fn new() -> Result<Self, i32> {
1531        Self::new_ex(None, None)
1532    }
1533
1534    /// Build a new SHA3_384 instance with optional heap and device ID.
1535    ///
1536    /// # Parameters
1537    ///
1538    /// * `heap`: Optional heap hint.
1539    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
1540    ///
1541    /// # Returns
1542    ///
1543    /// Returns either Ok(sha) containing the SHA3_384 struct instance or Err(e)
1544    /// containing the wolfSSL library error code value.
1545    ///
1546    /// # Example
1547    ///
1548    /// ```rust
1549    /// use wolfssl_wolfcrypt::sha::SHA3_384;
1550    /// let sha = SHA3_384::new_ex(None, None).expect("Error with new_ex()");
1551    /// ```
1552    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
1553        let mut wc_sha3: MaybeUninit<sys::wc_Sha3> = MaybeUninit::uninit();
1554        let heap = match heap {
1555            Some(heap) => heap,
1556            None => core::ptr::null_mut(),
1557        };
1558        let dev_id = match dev_id {
1559            Some(dev_id) => dev_id,
1560            None => sys::INVALID_DEVID,
1561        };
1562        let rc = unsafe { sys::wc_InitSha3_384(wc_sha3.as_mut_ptr(), heap, dev_id) };
1563        if rc != 0 {
1564            return Err(rc);
1565        }
1566        let wc_sha3 = unsafe { wc_sha3.assume_init() };
1567        let sha3_384 = SHA3_384 { wc_sha3 };
1568        Ok(sha3_384)
1569    }
1570
1571    /// Reinitialize a SHA3_384 instance for a new hash calculation.
1572    ///
1573    /// This does not need to be called after `new()`, but should be called
1574    /// after a hash calculation to prepare for a new calculation.
1575    ///
1576    /// # Returns
1577    ///
1578    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1579    /// library error code value.
1580    ///
1581    /// # Example
1582    ///
1583    /// ```rust
1584    /// use wolfssl_wolfcrypt::sha::SHA3_384;
1585    /// let mut sha = SHA3_384::new().expect("Error with new()");
1586    /// sha.init().expect("Error with init()");
1587    /// ```
1588    pub fn init(&mut self) -> Result<(), i32> {
1589        self.init_ex(None, None)
1590    }
1591
1592    /// Reinitialize a SHA3_384 instance for a new hash calculation with
1593    /// optional heap and device ID.
1594    ///
1595    /// This does not need to be called after `new()`, but should be called
1596    /// after a hash calculation to prepare for a new calculation.
1597    ///
1598    /// # Parameters
1599    ///
1600    /// * `heap`: Optional heap hint.
1601    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
1602    ///
1603    /// # Returns
1604    ///
1605    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1606    /// library error code value.
1607    ///
1608    /// # Example
1609    ///
1610    /// ```rust
1611    /// use wolfssl_wolfcrypt::sha::SHA3_384;
1612    /// let mut sha = SHA3_384::new().expect("Error with new()");
1613    /// sha.init_ex(None, None).expect("Error with init_ex()");
1614    /// ```
1615    pub fn init_ex(&mut self, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<(), i32> {
1616        let heap = match heap {
1617            Some(heap) => heap,
1618            None => core::ptr::null_mut(),
1619        };
1620        let dev_id = match dev_id {
1621            Some(dev_id) => dev_id,
1622            None => sys::INVALID_DEVID,
1623        };
1624        let rc = unsafe { sys::wc_InitSha3_384(&mut self.wc_sha3, heap, dev_id) };
1625        if rc != 0 {
1626            return Err(rc);
1627        }
1628        Ok(())
1629    }
1630
1631    /// Update the SHA3-384 calculation by feeding in more input data.
1632    ///
1633    /// # Parameters
1634    ///
1635    /// * `data`: Input data.
1636    ///
1637    /// # Returns
1638    ///
1639    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1640    /// library error code value.
1641    ///
1642    /// # Example
1643    ///
1644    /// ```rust
1645    /// use wolfssl_wolfcrypt::sha::SHA3_384;
1646    /// let mut sha = SHA3_384::new().expect("Error with new()");
1647    /// sha.update(b"input").expect("Error with update()");
1648    /// ```
1649    pub fn update(&mut self, data: &[u8]) -> Result<(), i32> {
1650        let data_size = crate::buffer_len_to_u32(data.len())?;
1651        let rc = unsafe {
1652            sys::wc_Sha3_384_Update(&mut self.wc_sha3, data.as_ptr(), data_size)
1653        };
1654        if rc != 0 {
1655            return Err(rc);
1656        }
1657        Ok(())
1658    }
1659
1660    /// Finalize the SHA3-384 calculation and retrieve the calculated hash.
1661    ///
1662    /// # Parameters
1663    ///
1664    /// * `hash`: Buffer in which to store the calculated hash. The length
1665    ///   should be SHA3_384::DIGEST_SIZE.
1666    ///
1667    /// # Returns
1668    ///
1669    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1670    /// library error code value.
1671    ///
1672    /// # Example
1673    ///
1674    /// ```rust
1675    /// use wolfssl_wolfcrypt::sha::SHA3_384;
1676    /// let mut sha = SHA3_384::new().expect("Error with new()");
1677    /// sha.update(b"input").expect("Error with update()");
1678    /// let mut hash = [0u8; SHA3_384::DIGEST_SIZE];
1679    /// sha.finalize(&mut hash).expect("Error with finalize()");
1680    /// ```
1681    pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> {
1682        if hash.len() != Self::DIGEST_SIZE {
1683            return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E);
1684        }
1685        let rc = unsafe {
1686            sys::wc_Sha3_384_Final(&mut self.wc_sha3, hash.as_mut_ptr())
1687        };
1688        if rc != 0 {
1689            return Err(rc);
1690        }
1691        Ok(())
1692    }
1693}
1694
1695#[cfg(sha3)]
1696impl SHA3_384 {
1697    fn zeroize(&mut self) {
1698        unsafe { crate::zeroize_raw(&mut self.wc_sha3); }
1699    }
1700}
1701
1702#[cfg(sha3)]
1703impl Drop for SHA3_384 {
1704    /// Safely free the underlying wolfSSL SHA3_384 context.
1705    ///
1706    /// This calls the `wc_Sha3_384_Free` wolfssl library function.
1707    ///
1708    /// The Rust Drop trait guarantees that this method is called when the
1709    /// SHA3_384 struct goes out of scope, automatically cleaning up resources
1710    /// and preventing memory leaks.
1711    fn drop(&mut self) {
1712        unsafe { sys::wc_Sha3_384_Free(&mut self.wc_sha3); }
1713        self.zeroize();
1714    }
1715}
1716
1717/// Context for SHA3-512 computation.
1718#[cfg(sha3)]
1719pub struct SHA3_512 {
1720    wc_sha3: sys::wc_Sha3,
1721}
1722
1723#[cfg(sha3)]
1724impl SHA3_512 {
1725    /// SHA3-512 digest size in bytes.
1726    pub const DIGEST_SIZE: usize = sys::WC_SHA3_512_DIGEST_SIZE as usize;
1727
1728    /// Build a new SHA3_512 instance.
1729    ///
1730    /// # Returns
1731    ///
1732    /// Returns either Ok(sha) containing the SHA3_512 struct instance or Err(e)
1733    /// containing the wolfSSL library error code value.
1734    ///
1735    /// # Example
1736    ///
1737    /// ```rust
1738    /// use wolfssl_wolfcrypt::sha::SHA3_512;
1739    /// let sha = SHA3_512::new().expect("Error with new()");
1740    /// ```
1741    pub fn new() -> Result<Self, i32> {
1742        Self::new_ex(None, None)
1743    }
1744
1745    /// Build a new SHA3_512 instance with optional heap and device ID.
1746    ///
1747    /// # Parameters
1748    ///
1749    /// * `heap`: Optional heap hint.
1750    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
1751    ///
1752    /// # Returns
1753    ///
1754    /// Returns either Ok(sha) containing the SHA3_512 struct instance or Err(e)
1755    /// containing the wolfSSL library error code value.
1756    ///
1757    /// # Example
1758    ///
1759    /// ```rust
1760    /// use wolfssl_wolfcrypt::sha::SHA3_512;
1761    /// let sha = SHA3_512::new_ex(None, None).expect("Error with new_ex()");
1762    /// ```
1763    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
1764        let mut wc_sha3: MaybeUninit<sys::wc_Sha3> = MaybeUninit::uninit();
1765        let heap = match heap {
1766            Some(heap) => heap,
1767            None => core::ptr::null_mut(),
1768        };
1769        let dev_id = match dev_id {
1770            Some(dev_id) => dev_id,
1771            None => sys::INVALID_DEVID,
1772        };
1773        let rc = unsafe { sys::wc_InitSha3_512(wc_sha3.as_mut_ptr(), heap, dev_id) };
1774        if rc != 0 {
1775            return Err(rc);
1776        }
1777        let wc_sha3 = unsafe { wc_sha3.assume_init() };
1778        let sha3_512 = SHA3_512 { wc_sha3 };
1779        Ok(sha3_512)
1780    }
1781
1782    /// Reinitialize a SHA3_512 instance for a new hash calculation.
1783    ///
1784    /// This does not need to be called after `new()`, but should be called
1785    /// after a hash calculation to prepare for a new calculation.
1786    ///
1787    /// # Returns
1788    ///
1789    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1790    /// library error code value.
1791    ///
1792    /// # Example
1793    ///
1794    /// ```rust
1795    /// use wolfssl_wolfcrypt::sha::SHA3_512;
1796    /// let mut sha = SHA3_512::new().expect("Error with new()");
1797    /// sha.init().expect("Error with init()");
1798    /// ```
1799    pub fn init(&mut self) -> Result<(), i32> {
1800        self.init_ex(None, None)
1801    }
1802
1803    /// Reinitialize a SHA3_512 instance for a new hash calculation with
1804    /// optional heap and device ID.
1805    ///
1806    /// This does not need to be called after `new()`, but should be called
1807    /// after a hash calculation to prepare for a new calculation.
1808    ///
1809    /// # Parameters
1810    ///
1811    /// * `heap`: Optional heap hint.
1812    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
1813    ///
1814    /// # Returns
1815    ///
1816    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1817    /// library error code value.
1818    ///
1819    /// # Example
1820    ///
1821    /// ```rust
1822    /// use wolfssl_wolfcrypt::sha::SHA3_512;
1823    /// let mut sha = SHA3_512::new().expect("Error with new()");
1824    /// sha.init_ex(None, None).expect("Error with init_ex()");
1825    /// ```
1826    pub fn init_ex(&mut self, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<(), i32> {
1827        let heap = match heap {
1828            Some(heap) => heap,
1829            None => core::ptr::null_mut(),
1830        };
1831        let dev_id = match dev_id {
1832            Some(dev_id) => dev_id,
1833            None => sys::INVALID_DEVID,
1834        };
1835        let rc = unsafe { sys::wc_InitSha3_512(&mut self.wc_sha3, heap, dev_id) };
1836        if rc != 0 {
1837            return Err(rc);
1838        }
1839        Ok(())
1840    }
1841
1842    /// Update the SHA3-512 calculation by feeding in more input data.
1843    ///
1844    /// # Parameters
1845    ///
1846    /// * `data`: Input data.
1847    ///
1848    /// # Returns
1849    ///
1850    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1851    /// library error code value.
1852    ///
1853    /// # Example
1854    ///
1855    /// ```rust
1856    /// use wolfssl_wolfcrypt::sha::SHA3_512;
1857    /// let mut sha = SHA3_512::new().expect("Error with new()");
1858    /// sha.update(b"input").expect("Error with update()");
1859    /// ```
1860    pub fn update(&mut self, data: &[u8]) -> Result<(), i32> {
1861        let data_size = crate::buffer_len_to_u32(data.len())?;
1862        let rc = unsafe {
1863            sys::wc_Sha3_512_Update(&mut self.wc_sha3, data.as_ptr(), data_size)
1864        };
1865        if rc != 0 {
1866            return Err(rc);
1867        }
1868        Ok(())
1869    }
1870
1871    /// Finalize the SHA3-512 calculation and retrieve the calculated hash.
1872    ///
1873    /// # Parameters
1874    ///
1875    /// * `hash`: Buffer in which to store the calculated hash. The length
1876    ///   should be SHA3_512::DIGEST_SIZE.
1877    ///
1878    /// # Returns
1879    ///
1880    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1881    /// library error code value.
1882    ///
1883    /// # Example
1884    ///
1885    /// ```rust
1886    /// use wolfssl_wolfcrypt::sha::SHA3_512;
1887    /// let mut sha = SHA3_512::new().expect("Error with new()");
1888    /// sha.update(b"input").expect("Error with update()");
1889    /// let mut hash = [0u8; SHA3_512::DIGEST_SIZE];
1890    /// sha.finalize(&mut hash).expect("Error with finalize()");
1891    /// ```
1892    pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> {
1893        if hash.len() != Self::DIGEST_SIZE {
1894            return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E);
1895        }
1896        let rc = unsafe {
1897            sys::wc_Sha3_512_Final(&mut self.wc_sha3, hash.as_mut_ptr())
1898        };
1899        if rc != 0 {
1900            return Err(rc);
1901        }
1902        Ok(())
1903    }
1904}
1905
1906#[cfg(sha3)]
1907impl SHA3_512 {
1908    fn zeroize(&mut self) {
1909        unsafe { crate::zeroize_raw(&mut self.wc_sha3); }
1910    }
1911}
1912
1913#[cfg(sha3)]
1914impl Drop for SHA3_512 {
1915    /// Safely free the underlying wolfSSL SHA3_512 context.
1916    ///
1917    /// This calls the `wc_Sha3_512_Free` wolfssl library function.
1918    ///
1919    /// The Rust Drop trait guarantees that this method is called when the
1920    /// SHA3_512 struct goes out of scope, automatically cleaning up resources
1921    /// and preventing memory leaks.
1922    fn drop(&mut self) {
1923        unsafe { sys::wc_Sha3_512_Free(&mut self.wc_sha3); }
1924        self.zeroize();
1925    }
1926}
1927
1928/// Context for SHAKE128 (SHA-3) computation.
1929#[cfg(shake128)]
1930pub struct SHAKE128 {
1931    wc_shake: sys::wc_Shake,
1932}
1933
1934#[cfg(shake128)]
1935impl SHAKE128 {
1936    /// Squeeze block size.
1937    pub const SQUEEZE_BLOCK_SIZE: usize = sys::WC_SHA3_128_BLOCK_SIZE as usize;
1938
1939    /// Build a new SHAKE128 instance.
1940    ///
1941    /// # Returns
1942    ///
1943    /// Returns either Ok(sha) containing the SHAKE128 struct instance or Err(e)
1944    /// containing the wolfSSL library error code value.
1945    ///
1946    /// # Example
1947    ///
1948    /// ```rust
1949    /// use wolfssl_wolfcrypt::sha::SHAKE128;
1950    /// let sha = SHAKE128::new().expect("Error with new()");
1951    /// ```
1952    pub fn new() -> Result<Self, i32> {
1953        Self::new_ex(None, None)
1954    }
1955
1956    /// Build a new SHAKE128 instance with optional heap and device ID.
1957    ///
1958    /// # Parameters
1959    ///
1960    /// * `heap`: Optional heap hint.
1961    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
1962    ///
1963    /// # Returns
1964    ///
1965    /// Returns either Ok(sha) containing the SHAKE128 struct instance or Err(e)
1966    /// containing the wolfSSL library error code value.
1967    ///
1968    /// # Example
1969    ///
1970    /// ```rust
1971    /// use wolfssl_wolfcrypt::sha::SHAKE128;
1972    /// let sha = SHAKE128::new_ex(None, None).expect("Error with new_ex()");
1973    /// ```
1974    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
1975        let mut wc_shake: MaybeUninit<sys::wc_Shake> = MaybeUninit::uninit();
1976        let heap = match heap {
1977            Some(heap) => heap,
1978            None => core::ptr::null_mut(),
1979        };
1980        let dev_id = match dev_id {
1981            Some(dev_id) => dev_id,
1982            None => sys::INVALID_DEVID,
1983        };
1984        let rc = unsafe {
1985            sys::wc_InitShake128(wc_shake.as_mut_ptr(), heap, dev_id)
1986        };
1987        if rc != 0 {
1988            return Err(rc);
1989        }
1990        let wc_shake = unsafe { wc_shake.assume_init() };
1991        let shake128 = SHAKE128 { wc_shake };
1992        Ok(shake128)
1993    }
1994
1995    /// Reinitialize a SHAKE128 instance for a new hash calculation.
1996    ///
1997    /// This does not need to be called after `new()`, but should be called
1998    /// after a hash calculation to prepare for a new calculation.
1999    ///
2000    /// # Returns
2001    ///
2002    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
2003    /// library error code value.
2004    ///
2005    /// # Example
2006    ///
2007    /// ```rust
2008    /// use wolfssl_wolfcrypt::sha::SHAKE128;
2009    /// let mut sha = SHAKE128::new().expect("Error with new()");
2010    /// sha.init().expect("Error with init()");
2011    /// ```
2012    pub fn init(&mut self) -> Result<(), i32> {
2013        self.init_ex(None, None)
2014    }
2015
2016    /// Reinitialize a SHAKE128 instance for a new hash calculation with
2017    /// optional heap and device ID.
2018    ///
2019    /// This does not need to be called after `new()`, but should be called
2020    /// after a hash calculation to prepare for a new calculation.
2021    ///
2022    /// # Parameters
2023    ///
2024    /// * `heap`: Optional heap hint.
2025    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
2026    ///
2027    /// # Returns
2028    ///
2029    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
2030    /// library error code value.
2031    ///
2032    /// # Example
2033    ///
2034    /// ```rust
2035    /// use wolfssl_wolfcrypt::sha::SHAKE128;
2036    /// let mut sha = SHAKE128::new().expect("Error with new()");
2037    /// sha.init_ex(None, None).expect("Error with init_ex()");
2038    /// ```
2039    pub fn init_ex(&mut self, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<(), i32> {
2040        let heap = match heap {
2041            Some(heap) => heap,
2042            None => core::ptr::null_mut(),
2043        };
2044        let dev_id = match dev_id {
2045            Some(dev_id) => dev_id,
2046            None => sys::INVALID_DEVID,
2047        };
2048        let rc = unsafe {
2049            sys::wc_InitShake128(&mut self.wc_shake, heap, dev_id)
2050        };
2051        if rc != 0 {
2052            return Err(rc);
2053        }
2054        Ok(())
2055    }
2056
2057    /// Update the SHAKE128 calculation by feeding in more input data.
2058    ///
2059    /// # Parameters
2060    ///
2061    /// * `data`: Input data.
2062    ///
2063    /// # Returns
2064    ///
2065    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
2066    /// library error code value.
2067    ///
2068    /// # Example
2069    ///
2070    /// ```rust
2071    /// use wolfssl_wolfcrypt::sha::SHAKE128;
2072    /// let mut sha = SHAKE128::new().expect("Error with new()");
2073    /// sha.update(b"input").expect("Error with update()");
2074    /// ```
2075    pub fn update(&mut self, data: &[u8]) -> Result<(), i32> {
2076        let data_size = crate::buffer_len_to_u32(data.len())?;
2077        let rc = unsafe {
2078            sys::wc_Shake128_Update(&mut self.wc_shake, data.as_ptr(), data_size)
2079        };
2080        if rc != 0 {
2081            return Err(rc);
2082        }
2083        Ok(())
2084    }
2085
2086    /// Finalize the SHAKE128 calculation and retrieve the calculated hash.
2087    ///
2088    /// # Parameters
2089    ///
2090    /// * `hash`: Buffer in which to store the calculated hash.
2091    ///
2092    /// # Returns
2093    ///
2094    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
2095    /// library error code value.
2096    ///
2097    /// # Example
2098    ///
2099    /// ```rust
2100    /// use wolfssl_wolfcrypt::sha::SHAKE128;
2101    /// let mut sha = SHAKE128::new().expect("Error with new()");
2102    /// sha.update(b"input").expect("Error with update()");
2103    /// let mut hash = [0u8; 32];
2104    /// sha.finalize(&mut hash).expect("Error with finalize()");
2105    /// ```
2106    pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> {
2107        let hash_size = crate::buffer_len_to_u32(hash.len())?;
2108        let rc = unsafe {
2109            sys::wc_Shake128_Final(&mut self.wc_shake, hash.as_mut_ptr(), hash_size)
2110        };
2111        if rc != 0 {
2112            return Err(rc);
2113        }
2114        Ok(())
2115    }
2116
2117    /// Absorb the provided byte array. Cannot be called incrementally.
2118    ///
2119    /// # Parameters
2120    ///
2121    /// * `data`: Data buffer to absorb.
2122    ///
2123    /// # Returns
2124    ///
2125    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
2126    /// library error code value.
2127    ///
2128    /// # Example
2129    ///
2130    /// ```rust
2131    /// use wolfssl_wolfcrypt::sha::SHAKE128;
2132    /// let mut sha = SHAKE128::new().expect("Error with new()");
2133    /// sha.absorb(b"input").expect("Error with absorb()");
2134    /// ```
2135    pub fn absorb(&mut self, data: &[u8]) -> Result<(), i32> {
2136        let data_size = crate::buffer_len_to_u32(data.len())?;
2137        let rc = unsafe {
2138            sys::wc_Shake128_Absorb(&mut self.wc_shake, data.as_ptr(), data_size)
2139        };
2140        if rc != 0 {
2141            return Err(rc);
2142        }
2143        Ok(())
2144    }
2145
2146    /// Squeeze out more blocks of data.
2147    ///
2148    /// This function can be called inrementally.
2149    ///
2150    /// # Parameters
2151    ///
2152    /// * `dout`: Output buffer.
2153    ///
2154    /// # Returns
2155    ///
2156    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
2157    /// library error code value.
2158    ///
2159    /// # Example
2160    ///
2161    /// ```rust
2162    /// use wolfssl_wolfcrypt::sha::SHAKE128;
2163    /// let mut sha = SHAKE128::new().expect("Error with new()");
2164    /// sha.absorb(b"input").expect("Error with absorb()");
2165    /// let mut buffer = [0u8; 2 * SHAKE128::SQUEEZE_BLOCK_SIZE];
2166    /// sha.squeeze_blocks(&mut buffer).expect("Error with squeeze_blocks()");
2167    /// ```
2168    pub fn squeeze_blocks(&mut self, dout: &mut [u8]) -> Result<(), i32> {
2169        let dout_size = crate::buffer_len_to_u32(dout.len())?;
2170        if dout_size % (Self::SQUEEZE_BLOCK_SIZE as u32) != 0 {
2171            return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E);
2172        }
2173        let n_blocks = dout_size / (Self::SQUEEZE_BLOCK_SIZE as u32);
2174        let rc = unsafe {
2175            sys::wc_Shake128_SqueezeBlocks(&mut self.wc_shake, dout.as_mut_ptr(), n_blocks)
2176        };
2177        if rc != 0 {
2178            return Err(rc);
2179        }
2180        Ok(())
2181    }
2182}
2183
2184#[cfg(shake128)]
2185impl SHAKE128 {
2186    fn zeroize(&mut self) {
2187        unsafe { crate::zeroize_raw(&mut self.wc_shake); }
2188    }
2189}
2190
2191#[cfg(shake128)]
2192impl Drop for SHAKE128 {
2193    /// Safely free the underlying wolfSSL SHAKE128 context.
2194    ///
2195    /// This calls the `wc_Shake128_Free` wolfssl library function.
2196    ///
2197    /// The Rust Drop trait guarantees that this method is called when the
2198    /// SHAKE128 struct goes out of scope, automatically cleaning up resources
2199    /// and preventing memory leaks.
2200    fn drop(&mut self) {
2201        unsafe { sys::wc_Shake128_Free(&mut self.wc_shake); }
2202        self.zeroize();
2203    }
2204}
2205
2206/// Context for SHAKE256 (SHA-3) computation.
2207#[cfg(shake256)]
2208pub struct SHAKE256 {
2209    wc_shake: sys::wc_Shake,
2210}
2211
2212#[cfg(shake256)]
2213impl SHAKE256 {
2214    /// Squeeze block size.
2215    pub const SQUEEZE_BLOCK_SIZE: usize = sys::WC_SHA3_256_BLOCK_SIZE as usize;
2216
2217    /// Build a new SHAKE256 instance.
2218    ///
2219    /// # Returns
2220    ///
2221    /// Returns either Ok(sha) containing the SHAKE256 struct instance or Err(e)
2222    /// containing the wolfSSL library error code value.
2223    ///
2224    /// # Example
2225    ///
2226    /// ```rust
2227    /// use wolfssl_wolfcrypt::sha::SHAKE256;
2228    /// let sha = SHAKE256::new().expect("Error with new()");
2229    /// ```
2230    pub fn new() -> Result<Self, i32> {
2231        Self::new_ex(None, None)
2232    }
2233
2234    /// Build a new SHAKE256 instance with optional heap and device ID.
2235    ///
2236    /// # Parameters
2237    ///
2238    /// * `heap`: Optional heap hint.
2239    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
2240    ///
2241    /// # Returns
2242    ///
2243    /// Returns either Ok(sha) containing the SHAKE256 struct instance or Err(e)
2244    /// containing the wolfSSL library error code value.
2245    ///
2246    /// # Example
2247    ///
2248    /// ```rust
2249    /// use wolfssl_wolfcrypt::sha::SHAKE256;
2250    /// let sha = SHAKE256::new_ex(None, None).expect("Error with new_ex()");
2251    /// ```
2252    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
2253        let mut wc_shake: MaybeUninit<sys::wc_Shake> = MaybeUninit::uninit();
2254        let heap = match heap {
2255            Some(heap) => heap,
2256            None => core::ptr::null_mut(),
2257        };
2258        let dev_id = match dev_id {
2259            Some(dev_id) => dev_id,
2260            None => sys::INVALID_DEVID,
2261        };
2262        let rc = unsafe {
2263            sys::wc_InitShake256(wc_shake.as_mut_ptr(), heap, dev_id)
2264        };
2265        if rc != 0 {
2266            return Err(rc);
2267        }
2268        let wc_shake = unsafe { wc_shake.assume_init() };
2269        let shake256 = SHAKE256 { wc_shake };
2270        Ok(shake256)
2271    }
2272
2273    /// Reinitialize a SHAKE256 instance for a new hash calculation.
2274    ///
2275    /// This does not need to be called after `new()`, but should be called
2276    /// after a hash calculation to prepare for a new calculation.
2277    ///
2278    /// # Returns
2279    ///
2280    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
2281    /// library error code value.
2282    ///
2283    /// # Example
2284    ///
2285    /// ```rust
2286    /// use wolfssl_wolfcrypt::sha::SHAKE256;
2287    /// let mut sha = SHAKE256::new().expect("Error with new()");
2288    /// sha.init().expect("Error with init()");
2289    /// ```
2290    pub fn init(&mut self) -> Result<(), i32> {
2291        self.init_ex(None, None)
2292    }
2293
2294    /// Reinitialize a SHAKE256 instance for a new hash calculation with
2295    /// optional heap and device ID.
2296    ///
2297    /// This does not need to be called after `new()`, but should be called
2298    /// after a hash calculation to prepare for a new calculation.
2299    ///
2300    /// # Parameters
2301    ///
2302    /// * `heap`: Optional heap hint.
2303    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
2304    ///
2305    /// # Returns
2306    ///
2307    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
2308    /// library error code value.
2309    ///
2310    /// # Example
2311    ///
2312    /// ```rust
2313    /// use wolfssl_wolfcrypt::sha::SHAKE256;
2314    /// let mut sha = SHAKE256::new().expect("Error with new()");
2315    /// sha.init_ex(None, None).expect("Error with init_ex()");
2316    /// ```
2317    pub fn init_ex(&mut self, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<(), i32> {
2318        let heap = match heap {
2319            Some(heap) => heap,
2320            None => core::ptr::null_mut(),
2321        };
2322        let dev_id = match dev_id {
2323            Some(dev_id) => dev_id,
2324            None => sys::INVALID_DEVID,
2325        };
2326        let rc = unsafe {
2327            sys::wc_InitShake256(&mut self.wc_shake, heap, dev_id)
2328        };
2329        if rc != 0 {
2330            return Err(rc);
2331        }
2332        Ok(())
2333    }
2334
2335    /// Update the SHAKE256 calculation by feeding in more input data.
2336    ///
2337    /// # Parameters
2338    ///
2339    /// * `data`: Input data.
2340    ///
2341    /// # Returns
2342    ///
2343    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
2344    /// library error code value.
2345    ///
2346    /// # Example
2347    ///
2348    /// ```rust
2349    /// use wolfssl_wolfcrypt::sha::SHAKE256;
2350    /// let mut sha = SHAKE256::new().expect("Error with new()");
2351    /// sha.update(b"input").expect("Error with update()");
2352    /// ```
2353    pub fn update(&mut self, data: &[u8]) -> Result<(), i32> {
2354        let data_size = crate::buffer_len_to_u32(data.len())?;
2355        let rc = unsafe {
2356            sys::wc_Shake256_Update(&mut self.wc_shake, data.as_ptr(), data_size)
2357        };
2358        if rc != 0 {
2359            return Err(rc);
2360        }
2361        Ok(())
2362    }
2363
2364    /// Finalize the SHAKE256 calculation and retrieve the calculated hash.
2365    ///
2366    /// # Parameters
2367    ///
2368    /// * `hash`: Buffer in which to store the calculated hash.
2369    ///
2370    /// # Returns
2371    ///
2372    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
2373    /// library error code value.
2374    ///
2375    /// # Example
2376    ///
2377    /// ```rust
2378    /// use wolfssl_wolfcrypt::sha::SHAKE256;
2379    /// let mut sha = SHAKE256::new().expect("Error with new()");
2380    /// sha.update(b"input").expect("Error with update()");
2381    /// let mut hash = [0u8; 32];
2382    /// sha.finalize(&mut hash).expect("Error with finalize()");
2383    /// ```
2384    pub fn finalize(&mut self, hash: &mut [u8]) -> Result<(), i32> {
2385        let hash_size = crate::buffer_len_to_u32(hash.len())?;
2386        let rc = unsafe {
2387            sys::wc_Shake256_Final(&mut self.wc_shake, hash.as_mut_ptr(), hash_size)
2388        };
2389        if rc != 0 {
2390            return Err(rc);
2391        }
2392        Ok(())
2393    }
2394
2395    /// Absorb the provided byte array. Cannot be called incrementally.
2396    ///
2397    /// # Parameters
2398    ///
2399    /// * `data`: Data buffer to absorb.
2400    ///
2401    /// # Returns
2402    ///
2403    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
2404    /// library error code value.
2405    ///
2406    /// # Example
2407    ///
2408    /// ```rust
2409    /// use wolfssl_wolfcrypt::sha::SHAKE256;
2410    /// let mut sha = SHAKE256::new().expect("Error with new()");
2411    /// sha.absorb(b"input").expect("Error with absorb()");
2412    /// ```
2413    pub fn absorb(&mut self, data: &[u8]) -> Result<(), i32> {
2414        let data_size = crate::buffer_len_to_u32(data.len())?;
2415        let rc = unsafe {
2416            sys::wc_Shake256_Absorb(&mut self.wc_shake, data.as_ptr(), data_size)
2417        };
2418        if rc != 0 {
2419            return Err(rc);
2420        }
2421        Ok(())
2422    }
2423
2424    /// Squeeze out more blocks of data.
2425    ///
2426    /// This function can be called inrementally.
2427    ///
2428    /// # Parameters
2429    ///
2430    /// * `dout`: Output buffer.
2431    ///
2432    /// # Returns
2433    ///
2434    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
2435    /// library error code value.
2436    ///
2437    /// # Example
2438    ///
2439    /// ```rust
2440    /// use wolfssl_wolfcrypt::sha::SHAKE256;
2441    /// let mut sha = SHAKE256::new().expect("Error with new()");
2442    /// sha.absorb(b"input").expect("Error with absorb()");
2443    /// let mut buffer = [0u8; 2 * SHAKE256::SQUEEZE_BLOCK_SIZE];
2444    /// sha.squeeze_blocks(&mut buffer).expect("Error with squeeze_blocks()");
2445    /// ```
2446    pub fn squeeze_blocks(&mut self, dout: &mut [u8]) -> Result<(), i32> {
2447        let dout_size = crate::buffer_len_to_u32(dout.len())?;
2448        if dout_size % (Self::SQUEEZE_BLOCK_SIZE as u32) != 0 {
2449            return Err(sys::wolfCrypt_ErrorCodes_BUFFER_E);
2450        }
2451        let n_blocks = dout_size / (Self::SQUEEZE_BLOCK_SIZE as u32);
2452        let rc = unsafe {
2453            sys::wc_Shake256_SqueezeBlocks(&mut self.wc_shake, dout.as_mut_ptr(), n_blocks)
2454        };
2455        if rc != 0 {
2456            return Err(rc);
2457        }
2458        Ok(())
2459    }
2460}
2461
2462#[cfg(shake256)]
2463impl SHAKE256 {
2464    fn zeroize(&mut self) {
2465        unsafe { crate::zeroize_raw(&mut self.wc_shake); }
2466    }
2467}
2468
2469#[cfg(shake256)]
2470impl Drop for SHAKE256 {
2471    /// Safely free the underlying wolfSSL SHAKE256 context.
2472    ///
2473    /// This calls the `wc_Shake256_Free` wolfssl library function.
2474    ///
2475    /// The Rust Drop trait guarantees that this method is called when the
2476    /// SHAKE256 struct goes out of scope, automatically cleaning up resources
2477    /// and preventing memory leaks.
2478    fn drop(&mut self) {
2479        unsafe { sys::wc_Shake256_Free(&mut self.wc_shake); }
2480        self.zeroize();
2481    }
2482}