/*
 * Copyright (C) 2006-2026 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 EdDSA Curve
448 (Ed448) functionality.
*/

#![cfg(ed448)]

use crate::sys;
use crate::random::RNG;
use core::mem::MaybeUninit;

/// The `Ed448` struct manages the lifecycle of a wolfSSL `ed448_key`
/// object.
///
/// It ensures proper initialization and deallocation.
///
/// An instance can be created with `generate()` or `new()`.
pub struct Ed448 {
    ws_key: sys::ed448_key,
}

impl Ed448 {
    /** Size of private key only. */
    pub const KEY_SIZE: usize = sys::ED448_KEY_SIZE as usize;
    /** Size of signature. */
    pub const SIG_SIZE: usize = sys::ED448_SIG_SIZE as usize;
    /** Compressed public key size. */
    pub const PUB_KEY_SIZE: usize = sys::ED448_PUB_KEY_SIZE as usize;
    /** Size of both private and public key. */
    pub const PRV_KEY_SIZE: usize = sys::ED448_PRV_KEY_SIZE as usize;

    pub const ED448: u8 = sys::Ed448 as u8;
    pub const ED448PH: u8 = sys::Ed448ph as u8;

    /// Generate a new Ed448 key.
    ///
    /// # Parameters
    ///
    /// * `rng`: `RNG` instance to use for random number generation.
    ///
    /// # Returns
    ///
    /// Returns either Ok(ed448) containing the Ed448 struct instance or
    /// Err(e) containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// ```
    pub fn generate(rng: &RNG) -> Result<Self, i32> {
        Self::generate_ex(rng, None, None)
    }

    /// Generate a new Ed448 key with optional heap and device ID.
    ///
    /// # Parameters
    ///
    /// * `rng`: `RNG` instance to use for random number generation.
    /// * `heap`: Optional heap hint.
    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
    ///
    /// # Returns
    ///
    /// Returns either Ok(ed448) containing the Ed448 struct instance or
    /// Err(e) containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let ed = Ed448::generate_ex(&mut rng, None, None).expect("Error with generate_ex()");
    /// ```
    pub fn generate_ex(rng: &RNG, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
        let mut ws_key: MaybeUninit<sys::ed448_key> = MaybeUninit::uninit();
        let heap = match heap {
            Some(heap) => heap,
            None => core::ptr::null_mut(),
        };
        let dev_id = match dev_id {
            Some(dev_id) => dev_id,
            None => sys::INVALID_DEVID,
        };
        let rc = unsafe { sys::wc_ed448_init_ex(ws_key.as_mut_ptr(), heap, dev_id) };
        if rc != 0 {
            return Err(rc);
        }
        let ws_key = unsafe { ws_key.assume_init() };
        let mut ed448 = Ed448 { ws_key };
        let rc = unsafe {
            sys::wc_ed448_make_key(rng.wc_rng,
                sys::ED448_KEY_SIZE as i32, &mut ed448.ws_key)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(ed448)
    }

    /// Create and initialize a new Ed448 instance.
    ///
    /// A key will not be present but can be imported with one of the import
    /// functions.
    ///
    /// # Returns
    ///
    /// Returns either Ok(ed448) containing the Ed448 struct instance or
    /// Err(e) containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let ed = Ed448::new().expect("Error with new()");
    /// ```
    pub fn new() -> Result<Self, i32> {
        Self::new_ex(None, None)
    }

    /// Create and initialize a new Ed448 instance with optional heap and
    /// device ID.
    ///
    /// A key will not be present but can be imported with one of the import
    /// functions.
    ///
    /// # Parameters
    ///
    /// * `heap`: Optional heap hint.
    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
    ///
    /// # Returns
    ///
    /// Returns either Ok(ed448) containing the Ed448 struct instance or
    /// Err(e) containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let ed = Ed448::new_ex(None, None).expect("Error with new()");
    /// ```
    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
        let mut ws_key: MaybeUninit<sys::ed448_key> = MaybeUninit::uninit();
        let heap = match heap {
            Some(heap) => heap,
            None => core::ptr::null_mut(),
        };
        let dev_id = match dev_id {
            Some(dev_id) => dev_id,
            None => sys::INVALID_DEVID,
        };
        let rc = unsafe { sys::wc_ed448_init_ex(ws_key.as_mut_ptr(), heap, dev_id) };
        if rc != 0 {
            return Err(rc);
        }
        let ws_key = unsafe { ws_key.assume_init() };
        let ed448 = Ed448 { ws_key };
        Ok(ed448)
    }

    /// Check the public key is valid.
    ///
    /// When a private key is present, check that the calculated public key
    /// matches it. When a private key is not present, check that Y is in range
    /// and an X is able to be calculated.
    ///
    /// # 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::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// ed.check_key().expect("Error with check_key()");
    /// ```
    pub fn check_key(&mut self) -> Result<(), i32> {
        let rc = unsafe { sys::wc_ed448_check_key(&mut self.ws_key) };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Export private and public key to separate buffers.
    ///
    /// # Parameters
    ///
    /// * `private`: Output buffer in which to store the public/private key
    ///   pair. The length should be PRV_KEY_SIZE.
    /// * `public`: Output buffer in which to store the public key. The length
    ///   should be PUB_KEY_SIZE.
    ///
    /// # Returns
    ///
    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
    /// library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_export)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let mut private = [0u8; Ed448::PRV_KEY_SIZE];
    /// let mut public = [0u8; Ed448::PUB_KEY_SIZE];
    /// ed.export_key(&mut private, &mut public).expect("Error with export_key()");
    /// }
    /// ```
    #[cfg(ed448_export)]
    pub fn export_key(&self, private: &mut [u8], public: &mut [u8]) -> Result<(), i32> {
        let mut private_size = crate::buffer_len_to_u32(private.len())?;
        let mut public_size = crate::buffer_len_to_u32(public.len())?;
        let rc = unsafe {
            sys::wc_ed448_export_key(&self.ws_key,
                private.as_mut_ptr(), &mut private_size,
                public.as_mut_ptr(), &mut public_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Export public key to buffer.
    ///
    /// # Parameters
    ///
    /// * `public`: Output buffer in which to store the public key. The length
    ///   should be PUB_KEY_SIZE.
    ///
    /// # Returns
    ///
    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
    /// library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_export)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let mut public = [0u8; Ed448::PUB_KEY_SIZE];
    /// ed.export_public(&mut public).expect("Error with export_public()");
    /// }
    /// ```
    #[cfg(ed448_export)]
    pub fn export_public(&self, public: &mut [u8]) -> Result<(), i32> {
        let mut public_size = crate::buffer_len_to_u32(public.len())?;
        let rc = unsafe {
            sys::wc_ed448_export_public(&self.ws_key, public.as_mut_ptr(),
                &mut public_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Export public/private key pair to buffer.
    ///
    /// # Parameters
    ///
    /// * `keyout`: Output buffer in which to store the key pair. The length
    ///   should be PRV_KEY_SIZE.
    ///
    /// # Returns
    ///
    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
    /// library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_export)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let mut private = [0u8; Ed448::PRV_KEY_SIZE];
    /// ed.export_private(&mut private).expect("Error with export_private()");
    /// }
    /// ```
    #[cfg(ed448_export)]
    pub fn export_private(&self, keyout: &mut [u8]) -> Result<(), i32> {
        let mut keyout_size = crate::buffer_len_to_u32(keyout.len())?;
        let rc = unsafe {
            sys::wc_ed448_export_private(&self.ws_key, keyout.as_mut_ptr(),
                &mut keyout_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Export private key only to buffer.
    ///
    /// # Parameters
    ///
    /// * `private`: Output buffer in which to store the private key. The
    ///   length should be KEY_SIZE.
    ///
    /// # Returns
    ///
    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
    /// library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_export)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let mut private_only = [0u8; Ed448::KEY_SIZE];
    /// ed.export_private_only(&mut private_only).expect("Error with export_private_only()");
    /// }
    /// ```
    #[cfg(ed448_export)]
    pub fn export_private_only(&self, private: &mut [u8]) -> Result<(), i32> {
        let mut private_size = crate::buffer_len_to_u32(private.len())?;
        let rc = unsafe {
            sys::wc_ed448_export_private_only(&self.ws_key,
                private.as_mut_ptr(), &mut private_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Import a public Ed448 key from buffer.
    ///
    /// This function handles either compressed or uncompressed keys.
    /// The public key is checked that it matches the private key if one is
    /// already present.
    ///
    /// # Parameters
    ///
    /// * `public`: Input buffer containing public key.
    ///
    /// # Returns
    ///
    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
    /// library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_import)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let mut private = [0u8; Ed448::PRV_KEY_SIZE];
    /// let mut public = [0u8; Ed448::PUB_KEY_SIZE];
    /// ed.export_key(&mut private, &mut public).expect("Error with export_key()");
    /// let mut ed = Ed448::new().expect("Error with new()");
    /// ed.import_public(&public).expect("Error with import_public()");
    /// }
    /// ```
    #[cfg(ed448_import)]
    pub fn import_public(&mut self, public: &[u8]) -> Result<(), i32> {
        let public_size = crate::buffer_len_to_u32(public.len())?;
        let rc = unsafe {
            sys::wc_ed448_import_public(public.as_ptr(), public_size, &mut self.ws_key)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Import a public Ed448 key from buffer with trusted flag.
    ///
    /// This function handles either compressed or uncompressed keys.
    /// The public key is checked that it matches the private key if one is
    /// already present and trusted is false.
    ///
    /// # Parameters
    ///
    /// * `public`: Input buffer containing public key.
    /// * `trusted`: Whether the public key buffer is trusted.
    ///
    /// # Returns
    ///
    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
    /// library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_import)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let mut private = [0u8; Ed448::PRV_KEY_SIZE];
    /// let mut public = [0u8; Ed448::PUB_KEY_SIZE];
    /// ed.export_key(&mut private, &mut public).expect("Error with export_key()");
    /// let mut ed = Ed448::new().expect("Error with new()");
    /// ed.import_public_ex(&public, false).expect("Error with import_public_ex()");
    /// }
    /// ```
    #[cfg(ed448_import)]
    pub fn import_public_ex(&mut self, public: &[u8], trusted: bool) -> Result<(), i32> {
        let public_size = crate::buffer_len_to_u32(public.len())?;
        let rc = unsafe {
            sys::wc_ed448_import_public_ex(public.as_ptr(), public_size,
                &mut self.ws_key, if trusted {1} else {0})
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Import private Ed448 key only from buffer.
    ///
    /// # Parameters
    ///
    /// * `private`: Input buffer containing private key.
    ///
    /// # Returns
    ///
    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
    /// library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_import)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let mut private_only = [0u8; Ed448::KEY_SIZE];
    /// ed.export_private_only(&mut private_only).expect("Error with export_private_only()");
    /// let mut ed = Ed448::new().expect("Error with new()");
    /// ed.import_private_only(&private_only).expect("Error with import_private_only()");
    /// }
    /// ```
    #[cfg(ed448_import)]
    pub fn import_private_only(&mut self, private: &[u8]) -> Result<(), i32> {
        let private_size = crate::buffer_len_to_u32(private.len())?;
        let rc = unsafe {
            sys::wc_ed448_import_private_only(private.as_ptr(), private_size,
                &mut self.ws_key)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Import public/private Ed448 key pair from buffers.
    ///
    /// This functions handles either compressed or uncompressed keys.
    /// The public key is assumed to be untrusted and is checked against the
    /// private key.
    ///
    /// # Parameters
    ///
    /// * `private`: Input buffer containing private key.
    /// * `public`: Optional input buffer containing public key.
    ///
    /// # Returns
    ///
    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
    /// library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_import)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let mut private = [0u8; Ed448::PRV_KEY_SIZE];
    /// let mut public = [0u8; Ed448::PUB_KEY_SIZE];
    /// ed.export_key(&mut private, &mut public).expect("Error with export_key()");
    /// let mut ed = Ed448::new().expect("Error with new()");
    /// ed.import_private_key(&private, Some(&public)).expect("Error with import_private_key()");
    /// }
    /// ```
    #[cfg(ed448_import)]
    pub fn import_private_key(&mut self, private: &[u8], public: Option<&[u8]>) -> Result<(), i32> {
        let private_size = crate::buffer_len_to_u32(private.len())?;
        let mut public_ptr: *const u8 = core::ptr::null();
        let mut public_size = 0u32;
        if let Some(public) = public {
            public_ptr = public.as_ptr();
            public_size = crate::buffer_len_to_u32(public.len())?;
        }
        let rc = unsafe {
            sys::wc_ed448_import_private_key(private.as_ptr(), private_size,
                public_ptr, public_size, &mut self.ws_key)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Import public/private Ed448 key pair from buffers with trusted flag.
    ///
    /// This functions handles either compressed or uncompressed keys.
    /// The public is checked against private key if not trusted.
    ///
    /// # Parameters
    ///
    /// * `private`: Input buffer containing private key.
    /// * `public`: Optional input buffer containing private key.
    /// * `trusted`: Whether the public key buffer is trusted.
    ///
    /// # Returns
    ///
    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
    /// library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_import)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let mut private = [0u8; Ed448::PRV_KEY_SIZE];
    /// let mut public = [0u8; Ed448::PUB_KEY_SIZE];
    /// ed.export_key(&mut private, &mut public).expect("Error with export_key()");
    /// let mut ed = Ed448::new().expect("Error with new()");
    /// ed.import_private_key_ex(&private, Some(&public), false).expect("Error with import_private_key_ex()");
    /// }
    /// ```
    #[cfg(ed448_import)]
    pub fn import_private_key_ex(&mut self, private: &[u8], public: Option<&[u8]>, trusted: bool) -> Result<(), i32> {
        let private_size = crate::buffer_len_to_u32(private.len())?;
        let mut public_ptr: *const u8 = core::ptr::null();
        let mut public_size = 0u32;
        if let Some(public) = public {
            public_ptr = public.as_ptr();
            public_size = crate::buffer_len_to_u32(public.len())?;
        }
        let rc = unsafe {
            sys::wc_ed448_import_private_key_ex(private.as_ptr(), private_size,
                public_ptr, public_size, &mut self.ws_key, if trusted {1} else {0})
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Generate the Ed448 public key from the private key stored in the
    /// Ed448 object.
    ///
    /// The public key is written to the pubkey output buffer.
    ///
    /// # Parameters
    ///
    /// * `pubkey`: Output buffer in which to store the 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::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let mut private = [0u8; Ed448::KEY_SIZE];
    /// ed.export_private_only(&mut private).expect("Error with export_private_only()");
    /// let mut ed = Ed448::new().expect("Error with new()");
    /// ed.import_private_only(&private).expect("Error with import_private_only()");
    /// let mut public = [0u8; Ed448::KEY_SIZE];
    /// ed.make_public(&mut public).expect("Error with make_public()");
    /// ```
    pub fn make_public(&mut self, pubkey: &mut [u8]) -> Result<(), i32> {
        let pubkey_size = crate::buffer_len_to_u32(pubkey.len())?;
        let rc = unsafe {
            sys::wc_ed448_make_public(&mut self.ws_key,
                pubkey.as_mut_ptr(), pubkey_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Sign a message with optional context using Ed448 key.
    ///
    /// The context is part of the data signed.
    ///
    /// # Parameters
    ///
    /// * `message`: Message to sign.
    /// * `context`: Optional buffer containing context for which message is being signed.
    /// * `signature`: Output buffer to hold signature.
    ///
    /// # Returns
    ///
    /// Returns either Ok(size) containing the number of bytes written to
    /// signature on success or Err(e) containing the wolfSSL library error
    /// code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_sign)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let message = [0x42u8, 33, 55, 66];
    /// let context = b"context";
    /// let mut signature = [0u8; Ed448::SIG_SIZE];
    /// ed.sign_msg(&message, Some(context), &mut signature).expect("Error with sign_msg()");
    /// }
    /// ```
    #[cfg(ed448_sign)]
    pub fn sign_msg(&mut self, message: &[u8], context: Option<&[u8]>, signature: &mut [u8]) -> Result<usize, i32> {
        let message_size = crate::buffer_len_to_u32(message.len())?;
        let mut context_ptr: *const u8 = core::ptr::null();
        let mut context_size = 0u8;
        if let Some(context) = context {
            context_ptr = context.as_ptr();
            if context.len() > 255 {
                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
            }
            context_size = context.len() as u8;
        }
        let mut signature_size = crate::buffer_len_to_u32(signature.len())?;
        let rc = unsafe {
            sys::wc_ed448_sign_msg(message.as_ptr(), message_size,
                signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key,
                context_ptr, context_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(signature_size as usize)
    }

    /// Sign a message digest with optional context using Ed448 key.
    ///
    /// The context is part of the data signed.
    /// The message is pre-hashed before signature calculation.
    ///
    /// # Parameters
    ///
    /// * `hash`: Message digest to sign.
    /// * `context`: Optional buffer containing context for which hash is being signed.
    /// * `signature`: Output buffer to hold signature.
    ///
    /// # Returns
    ///
    /// Returns either Ok(size) containing the number of bytes written to
    /// signature on success or Err(e) containing the wolfSSL library error
    /// code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_sign)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let hash = [
    ///     0xddu8,0xaf,0x35,0xa1,0x93,0x61,0x7a,0xba,
    ///     0xcc,0x41,0x73,0x49,0xae,0x20,0x41,0x31,
    ///     0x12,0xe6,0xfa,0x4e,0x89,0xa9,0x7e,0xa2,
    ///     0x0a,0x9e,0xee,0xe6,0x4b,0x55,0xd3,0x9a,
    ///     0x21,0x92,0x99,0x2a,0x27,0x4f,0xc1,0xa8,
    ///     0x36,0xba,0x3c,0x23,0xa3,0xfe,0xeb,0xbd,
    ///     0x45,0x4d,0x44,0x23,0x64,0x3c,0xe8,0x0e,
    ///     0x2a,0x9a,0xc9,0x4f,0xa5,0x4c,0xa4,0x9f
    /// ];
    /// let context = b"context";
    /// let mut signature = [0u8; Ed448::SIG_SIZE];
    /// ed.sign_hash_ph(&hash, Some(context), &mut signature).expect("Error with sign_hash_ph()");
    /// }
    /// ```
    #[cfg(ed448_sign)]
    pub fn sign_hash_ph(&mut self, hash: &[u8], context: Option<&[u8]>, signature: &mut [u8]) -> Result<usize, i32> {
        let hash_size = crate::buffer_len_to_u32(hash.len())?;
        let mut context_ptr: *const u8 = core::ptr::null();
        let mut context_size = 0u8;
        if let Some(context) = context {
            context_ptr = context.as_ptr();
            if context.len() > 255 {
                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
            }
            context_size = context.len() as u8;
        }
        let mut signature_size = crate::buffer_len_to_u32(signature.len())?;
        let rc = unsafe {
            sys::wc_ed448ph_sign_hash(hash.as_ptr(), hash_size,
                signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key,
                context_ptr, context_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(signature_size as usize)
    }

    /// Sign a message with optional context using Ed448 key.
    ///
    /// The context is part of the data signed.
    /// The message is pre-hashed before signature calculation.
    ///
    /// # Parameters
    ///
    /// * `message`: Message digest to sign.
    /// * `context`: Optional buffer containing context for which message is being signed.
    /// * `signature`: Output buffer to hold signature.
    ///
    /// # Returns
    ///
    /// Returns either Ok(size) containing the number of bytes written to
    /// signature on success or Err(e) containing the wolfSSL library error
    /// code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_sign)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let message = [0x42u8, 33, 55, 66];
    /// let context = b"context";
    /// let mut signature = [0u8; Ed448::SIG_SIZE];
    /// ed.sign_msg_ph(&message, Some(context), &mut signature).expect("Error with sign_msg_ph()");
    /// }
    /// ```
    #[cfg(ed448_sign)]
    pub fn sign_msg_ph(&mut self, message: &[u8], context: Option<&[u8]>, signature: &mut [u8]) -> Result<usize, i32> {
        let message_size = crate::buffer_len_to_u32(message.len())?;
        let mut context_ptr: *const u8 = core::ptr::null();
        let mut context_size = 0u8;
        if let Some(context) = context {
            context_ptr = context.as_ptr();
            if context.len() > 255 {
                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
            }
            context_size = context.len() as u8;
        }
        let mut signature_size = crate::buffer_len_to_u32(signature.len())?;
        let rc = unsafe {
            sys::wc_ed448ph_sign_msg(message.as_ptr(), message_size,
                signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key,
                context_ptr, context_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(signature_size as usize)
    }

    /// Sign input data with optional context using Ed448 key.
    ///
    /// If provided, the context is part of the data signed.
    ///
    /// # Parameters
    ///
    /// * `din`: Data to sign.
    /// * `context`: Optional buffer containing context for which `din` is being signed.
    /// * `typ`: One of `Ed448::ED448` or `Ed448::ED448PH`.
    /// * `signature`: Output buffer to hold signature.
    ///
    /// # Returns
    ///
    /// Returns either Ok(size) containing the number of bytes written to
    /// signature on success or Err(e) containing the wolfSSL library error
    /// code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_sign)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let message = [0x42u8, 33, 55, 66];
    /// let context = b"context";
    /// let mut signature = [0u8; Ed448::SIG_SIZE];
    /// ed.sign_msg_ex(&message, Some(context), Ed448::ED448, &mut signature).expect("Error with sign_msg_ex()");
    /// }
    /// ```
    #[cfg(ed448_sign)]
    pub fn sign_msg_ex(&mut self, din: &[u8], context: Option<&[u8]>, typ: u8, signature: &mut [u8]) -> Result<usize, i32> {
        let din_size = crate::buffer_len_to_u32(din.len())?;
        let mut context_ptr: *const u8 = core::ptr::null();
        let mut context_size = 0u8;
        if let Some(context) = context {
            context_ptr = context.as_ptr();
            if context.len() > 255 {
                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
            }
            context_size = context.len() as u8;
        }
        let mut signature_size = crate::buffer_len_to_u32(signature.len())?;
        let rc = unsafe {
            sys::wc_ed448_sign_msg_ex(din.as_ptr(), din_size,
                signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key,
                typ, context_ptr, context_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(signature_size as usize)
    }

    /// Verify the Ed448 signature of a message and optional context to ensure authenticity.
    ///
    /// The context is included as part of the data verified.
    ///
    /// # Parameters
    ///
    /// * `signature`: Signature to verify.
    /// * `message`: Message to verify the signature of.
    /// * `context`: Optional buffer containing context for which the message was signed.
    ///
    /// # Returns
    ///
    /// Returns either Ok(valid) containing whether the signature is valid or
    /// Err(e) containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_verify)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let message = b"Hello!";
    /// let context = b"context";
    /// let mut signature = [0u8; Ed448::SIG_SIZE];
    /// ed.sign_msg(message, Some(context), &mut signature).expect("Error with sign_msg()");
    /// let signature_valid = ed.verify_msg(&signature, message, Some(context)).expect("Error with verify_msg()");
    /// assert!(signature_valid);
    /// }
    /// ```
    #[cfg(ed448_verify)]
    pub fn verify_msg(&mut self, signature: &[u8], message: &[u8], context: Option<&[u8]>) -> Result<bool, i32> {
        let signature_size = crate::buffer_len_to_u32(signature.len())?;
        let message_size = crate::buffer_len_to_u32(message.len())?;
        let mut context_ptr: *const u8 = core::ptr::null();
        let mut context_size = 0u8;
        if let Some(context) = context {
            context_ptr = context.as_ptr();
            if context.len() > 255 {
                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
            }
            context_size = context.len() as u8;
        }
        let mut res = 0i32;
        let rc = unsafe {
            sys::wc_ed448_verify_msg(signature.as_ptr(), signature_size,
                message.as_ptr(), message_size, &mut res, &mut self.ws_key,
                context_ptr, context_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(res == 1)
    }

    /// Verify the Ed448 signature of a message digest and optional context to ensure authenticity.
    ///
    /// The context is included as part of the data verified.
    /// The hash algorithm used to create message digest must be SHA-512.
    /// The message is pre-hashed before verification.
    ///
    /// # Parameters
    ///
    /// * `signature`: Signature to verify.
    /// * `hash`: Message to verify the signature of.
    /// * `context`: Optional buffer containing context for which the hash was signed.
    ///
    /// # Returns
    ///
    /// Returns either Ok(valid) containing whether the signature is valid or
    /// Err(e) containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_verify)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let hash = [
    ///     0xddu8,0xaf,0x35,0xa1,0x93,0x61,0x7a,0xba,
    ///     0xcc,0x41,0x73,0x49,0xae,0x20,0x41,0x31,
    ///     0x12,0xe6,0xfa,0x4e,0x89,0xa9,0x7e,0xa2,
    ///     0x0a,0x9e,0xee,0xe6,0x4b,0x55,0xd3,0x9a,
    ///     0x21,0x92,0x99,0x2a,0x27,0x4f,0xc1,0xa8,
    ///     0x36,0xba,0x3c,0x23,0xa3,0xfe,0xeb,0xbd,
    ///     0x45,0x4d,0x44,0x23,0x64,0x3c,0xe8,0x0e,
    ///     0x2a,0x9a,0xc9,0x4f,0xa5,0x4c,0xa4,0x9f
    /// ];
    /// let context = b"context";
    /// let mut signature = [0u8; Ed448::SIG_SIZE];
    /// ed.sign_hash_ph(&hash, Some(context), &mut signature).expect("Error with sign_hash_ph()");
    /// let signature_valid = ed.verify_hash_ph(&signature, &hash, Some(context)).expect("Error with verify_hash_ph()");
    /// assert!(signature_valid);
    /// }
    /// ```
    #[cfg(ed448_verify)]
    pub fn verify_hash_ph(&mut self, signature: &[u8], hash: &[u8], context: Option<&[u8]>) -> Result<bool, i32> {
        let signature_size = crate::buffer_len_to_u32(signature.len())?;
        let hash_size = crate::buffer_len_to_u32(hash.len())?;
        let mut context_ptr: *const u8 = core::ptr::null();
        let mut context_size = 0u8;
        if let Some(context) = context {
            context_ptr = context.as_ptr();
            if context.len() > 255 {
                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
            }
            context_size = context.len() as u8;
        }
        let mut res = 0i32;
        let rc = unsafe {
            sys::wc_ed448ph_verify_hash(signature.as_ptr(), signature_size,
                hash.as_ptr(), hash_size, &mut res, &mut self.ws_key,
                context_ptr, context_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(res == 1)
    }

    /// Verify the Ed448 signature of a message and optional context to ensure authenticity.
    ///
    /// The context is included as part of the data verified.
    /// The message is pre-hashed before verification.
    ///
    /// # Parameters
    ///
    /// * `signature`: Signature to verify.
    /// * `message`: Message to verify the signature of.
    /// * `context`: Optional buffer containing context for which the message was signed.
    ///
    /// # Returns
    ///
    /// Returns either Ok(valid) containing whether the signature is valid or
    /// Err(e) containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_verify)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let message = [0x42u8, 33, 55, 66];
    /// let context = b"context";
    /// let mut signature = [0u8; Ed448::SIG_SIZE];
    /// ed.sign_msg_ph(&message, Some(context), &mut signature).expect("Error with sign_msg_ph()");
    /// let signature_valid = ed.verify_msg_ph(&signature, &message, Some(context)).expect("Error with verify_msg_ph()");
    /// assert!(signature_valid);
    /// }
    /// ```
    #[cfg(ed448_verify)]
    pub fn verify_msg_ph(&mut self, signature: &[u8], message: &[u8], context: Option<&[u8]>) -> Result<bool, i32> {
        let signature_size = crate::buffer_len_to_u32(signature.len())?;
        let message_size = crate::buffer_len_to_u32(message.len())?;
        let mut context_ptr: *const u8 = core::ptr::null();
        let mut context_size = 0u8;
        if let Some(context) = context {
            context_ptr = context.as_ptr();
            if context.len() > 255 {
                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
            }
            context_size = context.len() as u8;
        }
        let mut res = 0i32;
        let rc = unsafe {
            sys::wc_ed448ph_verify_msg(signature.as_ptr(), signature_size,
                message.as_ptr(), message_size, &mut res, &mut self.ws_key,
                context_ptr, context_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(res == 1)
    }

    /// Verify the Ed448 signature of a message and optional context to ensure authenticity.
    ///
    /// The context is included as part of the data verified.
    ///
    /// # Parameters
    ///
    /// * `signature`: Signature to verify.
    /// * `din`: Message to verify the signature of.
    /// * `context`: Optional buffer containing context for which the input data was signed.
    /// * `typ`: One of `Ed448::ED448` or `Ed448::ED448PH`.
    ///
    /// # Returns
    ///
    /// Returns either Ok(valid) containing whether the signature is valid or
    /// Err(e) containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_verify)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let message = [0x42u8, 33, 55, 66];
    /// let context = b"context";
    /// let mut signature = [0u8; Ed448::SIG_SIZE];
    /// ed.sign_msg_ex(&message, Some(context), Ed448::ED448, &mut signature).expect("Error with sign_msg_ex()");
    /// let signature_valid = ed.verify_msg_ex(&signature, &message, Some(context), Ed448::ED448).expect("Error with verify_msg_ex()");
    /// assert!(signature_valid);
    /// }
    /// ```
    #[cfg(ed448_verify)]
    pub fn verify_msg_ex(&mut self, signature: &[u8], din: &[u8], context: Option<&[u8]>, typ: u8) -> Result<bool, i32> {
        let signature_size = crate::buffer_len_to_u32(signature.len())?;
        let din_size = crate::buffer_len_to_u32(din.len())?;
        let mut context_ptr: *const u8 = core::ptr::null();
        let mut context_size = 0u8;
        if let Some(context) = context {
            context_ptr = context.as_ptr();
            if context.len() > 255 {
                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
            }
            context_size = context.len() as u8;
        }
        let mut res = 0i32;
        let rc = unsafe {
            sys::wc_ed448_verify_msg_ex(signature.as_ptr(), signature_size,
                din.as_ptr(), din_size, &mut res, &mut self.ws_key, typ,
                context_ptr, context_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(res == 1)
    }

    /// Initialize Ed448 key to perform streaming verification.
    ///
    /// # Parameters
    ///
    /// * `signature`: Signature to verify.
    /// * `context`: Optional buffer containing context for which the input data was signed.
    /// * `typ`: One of `Ed448::ED448` or `Ed448::ED448PH`.
    ///
    /// # Returns
    ///
    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
    /// library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_streaming_verify)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let message = [0x42u8, 33, 55, 66];
    /// let context = [0x42u8, 1, 2, 3];
    /// let mut signature = [0u8; Ed448::SIG_SIZE];
    /// ed.sign_msg(&message, Some(&context), &mut signature).expect("Error with sign_msg()");
    /// ed.verify_msg_init(&signature, Some(&context), Ed448::ED448).expect("Error with verify_msg_init()");
    /// ed.verify_msg_update(&message[0..2]).expect("Error with verify_msg_update()");
    /// ed.verify_msg_update(&message[2..4]).expect("Error with verify_msg_update()");
    /// let signature_valid = ed.verify_msg_final(&signature).expect("Error with verify_msg_final()");
    /// assert!(signature_valid);
    /// }
    /// ```
    #[cfg(ed448_streaming_verify)]
    pub fn verify_msg_init(&mut self, signature: &[u8], context: Option<&[u8]>, typ: u8) -> Result<(), i32> {
        let signature_size = crate::buffer_len_to_u32(signature.len())?;
        let mut context_ptr: *const u8 = core::ptr::null();
        let mut context_size = 0u8;
        if let Some(context) = context {
            context_ptr = context.as_ptr();
            if context.len() > 255 {
                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
            }
            context_size = context.len() as u8;
        }
        let rc = unsafe {
            sys::wc_ed448_verify_msg_init(signature.as_ptr(), signature_size,
                &mut self.ws_key, typ, context_ptr, context_size)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Add input data to Ed448 streaming verification.
    ///
    /// # Parameters
    ///
    /// * `din`: Segment of message to verify the signature of.
    ///
    /// # Returns
    ///
    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
    /// library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_streaming_verify)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let message = [0x42u8, 33, 55, 66];
    /// let context = [0x42u8, 1, 2, 3];
    /// let mut signature = [0u8; Ed448::SIG_SIZE];
    /// ed.sign_msg(&message, Some(&context), &mut signature).expect("Error with sign_msg()");
    /// ed.verify_msg_init(&signature, Some(&context), Ed448::ED448).expect("Error with verify_msg_init()");
    /// ed.verify_msg_update(&message[0..2]).expect("Error with verify_msg_update()");
    /// ed.verify_msg_update(&message[2..4]).expect("Error with verify_msg_update()");
    /// let signature_valid = ed.verify_msg_final(&signature).expect("Error with verify_msg_final()");
    /// assert!(signature_valid);
    /// }
    /// ```
    #[cfg(ed448_streaming_verify)]
    pub fn verify_msg_update(&mut self, din: &[u8]) -> Result<(), i32> {
        let din_size = crate::buffer_len_to_u32(din.len())?;
        let rc = unsafe {
            sys::wc_ed448_verify_msg_update(din.as_ptr(), din_size,
                &mut self.ws_key)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(())
    }

    /// Finalize Ed448 streaming verification.
    ///
    /// # Parameters
    ///
    /// * `signature`: Signature to verify.
    ///
    /// # Returns
    ///
    /// Returns either Ok(valid) containing whether the signature is valid or
    /// Err(e) containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// #[cfg(ed448_streaming_verify)]
    /// {
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let mut ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let message = [0x42u8, 33, 55, 66];
    /// let context = [0x42u8, 1, 2, 3];
    /// let mut signature = [0u8; Ed448::SIG_SIZE];
    /// ed.sign_msg(&message, Some(&context), &mut signature).expect("Error with sign_msg()");
    /// ed.verify_msg_init(&signature, Some(&context), Ed448::ED448).expect("Error with verify_msg_init()");
    /// ed.verify_msg_update(&message[0..2]).expect("Error with verify_msg_update()");
    /// ed.verify_msg_update(&message[2..4]).expect("Error with verify_msg_update()");
    /// let signature_valid = ed.verify_msg_final(&signature).expect("Error with verify_msg_final()");
    /// assert!(signature_valid);
    /// }
    /// ```
    #[cfg(ed448_streaming_verify)]
    pub fn verify_msg_final(&mut self, signature: &[u8]) -> Result<bool, i32> {
        let signature_size = crate::buffer_len_to_u32(signature.len())?;
        let mut res = 0i32;
        let rc = unsafe {
            sys::wc_ed448_verify_msg_final(signature.as_ptr(), signature_size,
                &mut res, &mut self.ws_key)
        };
        if rc != 0 {
            return Err(rc);
        }
        Ok(res == 1)
    }

    /// Get the size of an Ed448 key (57 bytes).
    ///
    /// # Returns
    ///
    /// Returns either Ok(size) containing the key size or Err(e)
    /// containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let key_size = ed.size().expect("Error with size()");
    /// assert_eq!(key_size, Ed448::KEY_SIZE);
    /// ```
    pub fn size(&self) -> Result<usize, i32> {
        let rc = unsafe { sys::wc_ed448_size(&self.ws_key) };
        if rc < 0 {
            return Err(rc);
        }
        Ok(rc as usize)
    }

    /// Get the size of a private (including public) Ed448 key (114 bytes).
    ///
    /// # Returns
    ///
    /// Returns either Ok(size) containing the key size or Err(e)
    /// containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let priv_size = ed.priv_size().expect("Error with priv_size()");
    /// assert_eq!(priv_size, Ed448::PRV_KEY_SIZE);
    /// ```
    pub fn priv_size(&self) -> Result<usize, i32> {
        let rc = unsafe { sys::wc_ed448_priv_size(&self.ws_key) };
        if rc < 0 {
            return Err(rc);
        }
        Ok(rc as usize)
    }

    /// Get the size of a public Ed448 key (57 bytes).
    ///
    /// # Returns
    ///
    /// Returns either Ok(size) containing the key size or Err(e)
    /// containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let pub_size = ed.pub_size().expect("Error with pub_size()");
    /// assert_eq!(pub_size, Ed448::PUB_KEY_SIZE);
    /// ```
    pub fn pub_size(&self) -> Result<usize, i32> {
        let rc = unsafe { sys::wc_ed448_pub_size(&self.ws_key) };
        if rc < 0 {
            return Err(rc);
        }
        Ok(rc as usize)
    }

    /// Get the size of a Ed448 signature (114 bytes).
    ///
    /// # Returns
    ///
    /// Returns either Ok(size) containing the key size or Err(e)
    /// containing the wolfSSL library error code value.
    ///
    /// # Example
    ///
    /// ```rust
    /// use wolfssl_wolfcrypt::random::RNG;
    /// use wolfssl_wolfcrypt::ed448::Ed448;
    /// let mut rng = RNG::new().expect("Error creating RNG");
    /// let ed = Ed448::generate(&mut rng).expect("Error with generate()");
    /// let sig_size = ed.sig_size().expect("Error with sig_size()");
    /// assert_eq!(sig_size, Ed448::SIG_SIZE);
    /// ```
    pub fn sig_size(&self) -> Result<usize, i32> {
        let rc = unsafe { sys::wc_ed448_sig_size(&self.ws_key) };
        if rc < 0 {
            return Err(rc);
        }
        Ok(rc as usize)
    }
}

impl Ed448 {
    fn zeroize(&mut self) {
        unsafe { crate::zeroize_raw(&mut self.ws_key); }
    }
}

impl Drop for Ed448 {
    /// Safely free the wolfSSL resources.
    fn drop(&mut self) {
        unsafe { sys::wc_ed448_free(&mut self.ws_key); }
        self.zeroize();
    }
}

/// RustCrypto `signature` crate trait implementations.
///
/// Provides a fixed-size [`Signature`] and a [`VerifyingKey`] type so that
/// [`Ed448`] can be used wherever the `signature` crate's
/// [`signature::SignerMut`], [`signature::Keypair`], and
/// [`signature::Verifier`] traits are accepted.
///
/// These impls use the plain Ed448 (pure) signature variant with no context;
/// the context-, hashed-, and streaming-signature variants remain accessible
/// via the inherent methods on [`Ed448`].
#[cfg(feature = "signature")]
mod signature_impl {
    use super::Ed448;
    use signature::Error;

    /// Ed448 signature in its standard 114-byte encoded form.
    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
    pub struct Signature([u8; Ed448::SIG_SIZE]);

    impl Signature {
        /// Construct a signature from its raw bytes.
        pub const fn from_bytes(bytes: [u8; Ed448::SIG_SIZE]) -> Self {
            Self(bytes)
        }

        /// Return the raw signature bytes.
        pub const fn to_bytes(&self) -> [u8; Ed448::SIG_SIZE] {
            self.0
        }
    }

    impl AsRef<[u8]> for Signature {
        fn as_ref(&self) -> &[u8] {
            &self.0
        }
    }

    impl TryFrom<&[u8]> for Signature {
        type Error = Error;
        fn try_from(bytes: &[u8]) -> Result<Self, Error> {
            let arr: [u8; Ed448::SIG_SIZE] = bytes.try_into().map_err(|_| Error::new())?;
            Ok(Self(arr))
        }
    }

    impl From<Signature> for [u8; Ed448::SIG_SIZE] {
        fn from(sig: Signature) -> Self {
            sig.0
        }
    }

    impl signature::SignatureEncoding for Signature {
        type Repr = [u8; Ed448::SIG_SIZE];
    }

    /// Ed448 verifying (public) key.
    ///
    /// Owns a copy of the 57-byte compressed public key and instantiates a
    /// short-lived wolfCrypt `ed448_key` on each verification.
    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
    pub struct VerifyingKey([u8; Ed448::PUB_KEY_SIZE]);

    impl VerifyingKey {
        /// Construct a verifying key from its raw public key bytes.
        pub const fn from_bytes(bytes: [u8; Ed448::PUB_KEY_SIZE]) -> Self {
            Self(bytes)
        }

        /// Return the raw public key bytes.
        pub const fn to_bytes(&self) -> [u8; Ed448::PUB_KEY_SIZE] {
            self.0
        }
    }

    impl AsRef<[u8]> for VerifyingKey {
        fn as_ref(&self) -> &[u8] {
            &self.0
        }
    }

    impl TryFrom<&[u8]> for VerifyingKey {
        type Error = Error;
        fn try_from(bytes: &[u8]) -> Result<Self, Error> {
            let arr: [u8; Ed448::PUB_KEY_SIZE] =
                bytes.try_into().map_err(|_| Error::new())?;
            Ok(Self(arr))
        }
    }

    #[cfg(all(ed448_sign, ed448_export))]
    impl signature::Keypair for Ed448 {
        type VerifyingKey = VerifyingKey;
        fn verifying_key(&self) -> Self::VerifyingKey {
            let mut pub_key = [0u8; Ed448::PUB_KEY_SIZE];
            self.export_public(&mut pub_key).expect("ed448 export_public failed");
            VerifyingKey(pub_key)
        }
    }

    #[cfg(ed448_sign)]
    impl signature::SignerMut<Signature> for Ed448 {
        fn try_sign(&mut self, msg: &[u8]) -> Result<Signature, Error> {
            let mut sig = [0u8; Ed448::SIG_SIZE];
            self.sign_msg(msg, None, &mut sig).map_err(|_| Error::new())?;
            Ok(Signature(sig))
        }
    }

    #[cfg(all(ed448_import, ed448_verify))]
    impl signature::Verifier<Signature> for VerifyingKey {
        fn verify(&self, msg: &[u8], signature: &Signature) -> Result<(), Error> {
            let mut key = Ed448::new().map_err(|_| Error::new())?;
            key.import_public(&self.0).map_err(|_| Error::new())?;
            let valid = key
                .verify_msg(&signature.0, msg, None)
                .map_err(|_| Error::new())?;
            if valid { Ok(()) } else { Err(Error::new()) }
        }
    }
}

#[cfg(feature = "signature")]
pub use signature_impl::{Signature, VerifyingKey};
