luna - wolfssl/wrapper/rust/wolfssl-wolfcrypt/src/ed25519.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 EdDSA Curve
  2325519 (Ed25519) functionality.
  24*/
  25
  26#![cfg(ed25519)]
  27
  28use crate::sys;
  29use crate::random::RNG;
  30use core::mem::MaybeUninit;
  31
  32/// The `Ed25519` struct manages the lifecycle of a wolfSSL `ed25519_key`
  33/// object.
  34///
  35/// It ensures proper initialization and deallocation.
  36///
  37/// An instance can be created with `generate()` or `new()`.
  38pub struct Ed25519 {
  39    ws_key: sys::ed25519_key,
  40}
  41
  42impl Ed25519 {
  43    /** Size of private key only. */
  44    pub const KEY_SIZE: usize = sys::ED25519_KEY_SIZE as usize;
  45    /** Size of signature. */
  46    pub const SIG_SIZE: usize = sys::ED25519_SIG_SIZE as usize;
  47    /** Compressed public key size. */
  48    pub const PUB_KEY_SIZE: usize = sys::ED25519_PUB_KEY_SIZE as usize;
  49    /** Size of both private and public key. */
  50    pub const PRV_KEY_SIZE: usize = sys::ED25519_PRV_KEY_SIZE as usize;
  51
  52    pub const ED25519: u8 = sys::Ed25519 as u8;
  53    pub const ED25519CTX: u8 = sys::Ed25519ctx as u8;
  54    pub const ED25519PH: u8 = sys::Ed25519ph as u8;
  55
  56    /// Generate a new Ed25519 key.
  57    ///
  58    /// # Parameters
  59    ///
  60    /// * `rng`: `RNG` instance to use for random number generation.
  61    ///
  62    /// # Returns
  63    ///
  64    /// Returns either Ok(ed25519) containing the Ed25519 struct instance or
  65    /// Err(e) containing the wolfSSL library error code value.
  66    ///
  67    /// # Example
  68    ///
  69    /// ```rust
  70    /// use wolfssl_wolfcrypt::random::RNG;
  71    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
  72    /// let mut rng = RNG::new().expect("Error creating RNG");
  73    /// let ed = Ed25519::generate(&mut rng).expect("Error with generate()");
  74    /// ```
  75    pub fn generate(rng: &mut RNG) -> Result<Self, i32> {
  76        Self::generate_ex(rng, None, None)
  77    }
  78
  79    /// Generate a new Ed25519 key with optional heap and device ID.
  80    ///
  81    /// # Parameters
  82    ///
  83    /// * `rng`: `RNG` instance to use for random number generation.
  84    /// * `heap`: Optional heap hint.
  85    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
  86    ///
  87    /// # Returns
  88    ///
  89    /// Returns either Ok(ed25519) containing the Ed25519 struct instance or
  90    /// Err(e) containing the wolfSSL library error code value.
  91    ///
  92    /// # Example
  93    ///
  94    /// ```rust
  95    /// use wolfssl_wolfcrypt::random::RNG;
  96    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
  97    /// let mut rng = RNG::new().expect("Error creating RNG");
  98    /// let ed = Ed25519::generate_ex(&mut rng, None, None).expect("Error with generate_ex()");
  99    /// ```
 100    pub fn generate_ex(rng: &mut RNG, heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
 101        let mut ws_key: MaybeUninit<sys::ed25519_key> = MaybeUninit::uninit();
 102        let heap = match heap {
 103            Some(heap) => heap,
 104            None => core::ptr::null_mut(),
 105        };
 106        let dev_id = match dev_id {
 107            Some(dev_id) => dev_id,
 108            None => sys::INVALID_DEVID,
 109        };
 110        let rc = unsafe { sys::wc_ed25519_init_ex(ws_key.as_mut_ptr(), heap, dev_id) };
 111        if rc != 0 {
 112            return Err(rc);
 113        }
 114        let ws_key = unsafe { ws_key.assume_init() };
 115        let mut ed25519 = Ed25519 { ws_key };
 116        let rc = unsafe {
 117            sys::wc_ed25519_make_key(&mut rng.wc_rng,
 118                sys::ED25519_KEY_SIZE as i32, &mut ed25519.ws_key)
 119        };
 120        if rc != 0 {
 121            return Err(rc);
 122        }
 123        Ok(ed25519)
 124    }
 125
 126    /// Create and initialize a new Ed25519 instance.
 127    ///
 128    /// A key will not be present but can be imported with one of the import
 129    /// functions.
 130    ///
 131    /// # Returns
 132    ///
 133    /// Returns either Ok(ed25519) containing the Ed25519 struct instance or
 134    /// Err(e) containing the wolfSSL library error code value.
 135    ///
 136    /// # Example
 137    ///
 138    /// ```rust
 139    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 140    /// let ed = Ed25519::new().expect("Error with new()");
 141    /// ```
 142    pub fn new() -> Result<Self, i32> {
 143        Self::new_ex(None, None)
 144    }
 145
 146    /// Create and initialize a new Ed25519 instance with optional heap and
 147    /// device ID.
 148    ///
 149    /// A key will not be present but can be imported with one of the import
 150    /// functions.
 151    ///
 152    /// # Parameters
 153    ///
 154    /// * `heap`: Optional heap hint.
 155    /// * `dev_id` Optional device ID to use with crypto callbacks or async hardware.
 156    ///
 157    /// # Returns
 158    ///
 159    /// Returns either Ok(ed25519) containing the Ed25519 struct instance or
 160    /// Err(e) containing the wolfSSL library error code value.
 161    ///
 162    /// # Example
 163    ///
 164    /// ```rust
 165    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 166    /// let ed = Ed25519::new_ex(None, None).expect("Error with new()");
 167    /// ```
 168    pub fn new_ex(heap: Option<*mut core::ffi::c_void>, dev_id: Option<i32>) -> Result<Self, i32> {
 169        let mut ws_key: MaybeUninit<sys::ed25519_key> = MaybeUninit::uninit();
 170        let heap = match heap {
 171            Some(heap) => heap,
 172            None => core::ptr::null_mut(),
 173        };
 174        let dev_id = match dev_id {
 175            Some(dev_id) => dev_id,
 176            None => sys::INVALID_DEVID,
 177        };
 178        let rc = unsafe { sys::wc_ed25519_init_ex(ws_key.as_mut_ptr(), heap, dev_id) };
 179        if rc != 0 {
 180            return Err(rc);
 181        }
 182        let ws_key = unsafe { ws_key.assume_init() };
 183        let ed25519 = Ed25519 { ws_key };
 184        Ok(ed25519)
 185    }
 186
 187    /// Check the public key is valid.
 188    ///
 189    /// When a private key is present, check that the calculated public key
 190    /// matches it. When a private key is not present, check that Y is in range
 191    /// and an X is able to be calculated.
 192    ///
 193    /// # Returns
 194    ///
 195    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 196    /// library error code value.
 197    ///
 198    /// # Example
 199    ///
 200    /// ```rust
 201    /// use wolfssl_wolfcrypt::random::RNG;
 202    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 203    /// let mut rng = RNG::new().expect("Error creating RNG");
 204    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 205    /// ed.check_key().expect("Error with check_key()");
 206    /// ```
 207    pub fn check_key(&mut self) -> Result<(), i32> {
 208        let rc = unsafe { sys::wc_ed25519_check_key(&mut self.ws_key) };
 209        if rc != 0 {
 210            return Err(rc);
 211        }
 212        Ok(())
 213    }
 214
 215    /// Export private and public key to separate buffers.
 216    ///
 217    /// # Parameters
 218    ///
 219    /// * `private`: Output buffer in which to store the public/private key
 220    ///   pair. The length should be PRV_KEY_SIZE.
 221    /// * `public`: Output buffer in which to store the public key. The length
 222    ///   should be PUB_KEY_SIZE.
 223    ///
 224    /// # Returns
 225    ///
 226    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 227    /// library error code value.
 228    ///
 229    /// # Example
 230    ///
 231    /// ```rust
 232    /// #[cfg(ed25519_export)]
 233    /// {
 234    /// use wolfssl_wolfcrypt::random::RNG;
 235    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 236    /// let mut rng = RNG::new().expect("Error creating RNG");
 237    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 238    /// let mut private = [0u8; Ed25519::PRV_KEY_SIZE];
 239    /// let mut public = [0u8; Ed25519::PUB_KEY_SIZE];
 240    /// ed.export_key(&mut private, &mut public).expect("Error with export_key()");
 241    /// }
 242    /// ```
 243    #[cfg(ed25519_export)]
 244    pub fn export_key(&self, private: &mut [u8], public: &mut [u8]) -> Result<(), i32> {
 245        let mut private_size = crate::buffer_len_to_u32(private.len())?;
 246        let mut public_size = crate::buffer_len_to_u32(public.len())?;
 247        let rc = unsafe {
 248            sys::wc_ed25519_export_key(&self.ws_key,
 249                private.as_mut_ptr(), &mut private_size,
 250                public.as_mut_ptr(), &mut public_size)
 251        };
 252        if rc != 0 {
 253            return Err(rc);
 254        }
 255        Ok(())
 256    }
 257
 258    /// Export public key to buffer.
 259    ///
 260    /// # Parameters
 261    ///
 262    /// * `public`: Output buffer in which to store the public key. The length
 263    ///   should be PUB_KEY_SIZE.
 264    ///
 265    /// # Returns
 266    ///
 267    /// Returns either Ok(size) containing the number of bytes written to
 268    /// `public` on success or Err(e) containing the wolfSSL library error
 269    /// code value.
 270    ///
 271    /// # Example
 272    ///
 273    /// ```rust
 274    /// #[cfg(ed25519_export)]
 275    /// {
 276    /// use wolfssl_wolfcrypt::random::RNG;
 277    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 278    /// let mut rng = RNG::new().expect("Error creating RNG");
 279    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 280    /// let mut public = [0u8; Ed25519::PUB_KEY_SIZE];
 281    /// ed.export_public(&mut public).expect("Error with export_public()");
 282    /// }
 283    /// ```
 284    #[cfg(ed25519_export)]
 285    pub fn export_public(&self, public: &mut [u8]) -> Result<(), i32> {
 286        let mut public_size = crate::buffer_len_to_u32(public.len())?;
 287        let rc = unsafe {
 288            sys::wc_ed25519_export_public(&self.ws_key, public.as_mut_ptr(),
 289                &mut public_size)
 290        };
 291        if rc != 0 {
 292            return Err(rc);
 293        }
 294        Ok(())
 295    }
 296
 297    /// Export public/private key pair to buffer.
 298    ///
 299    /// # Parameters
 300    ///
 301    /// * `keyout`: Output buffer in which to store the key pair. The length
 302    ///   should be PRV_KEY_SIZE.
 303    ///
 304    /// # Returns
 305    ///
 306    /// Returns either Ok(size) containing the number of bytes written to
 307    /// `keyout` on success or Err(e) containing the wolfSSL library error
 308    /// code value.
 309    ///
 310    /// # Example
 311    ///
 312    /// ```rust
 313    /// #[cfg(ed25519_export)]
 314    /// {
 315    /// use wolfssl_wolfcrypt::random::RNG;
 316    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 317    /// let mut rng = RNG::new().expect("Error creating RNG");
 318    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 319    /// let mut private = [0u8; Ed25519::PRV_KEY_SIZE];
 320    /// ed.export_private(&mut private).expect("Error with export_private()");
 321    /// }
 322    /// ```
 323    #[cfg(ed25519_export)]
 324    pub fn export_private(&self, keyout: &mut [u8]) -> Result<(), i32> {
 325        let mut keyout_size = crate::buffer_len_to_u32(keyout.len())?;
 326        let rc = unsafe {
 327            sys::wc_ed25519_export_private(&self.ws_key, keyout.as_mut_ptr(),
 328                &mut keyout_size)
 329        };
 330        if rc != 0 {
 331            return Err(rc);
 332        }
 333        Ok(())
 334    }
 335
 336    /// Export private key only to buffer.
 337    ///
 338    /// # Parameters
 339    ///
 340    /// * `private`: Output buffer in which to store the private key. The
 341    ///   length should be KEY_SIZE.
 342    ///
 343    /// # Returns
 344    ///
 345    /// Returns either Ok(size) containing the number of bytes written to
 346    /// `private` on success or Err(e) containing the wolfSSL library error
 347    /// code value.
 348    ///
 349    /// # Example
 350    ///
 351    /// ```rust
 352    /// #[cfg(ed25519_export)]
 353    /// {
 354    /// use wolfssl_wolfcrypt::random::RNG;
 355    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 356    /// let mut rng = RNG::new().expect("Error creating RNG");
 357    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 358    /// let mut private_only = [0u8; Ed25519::KEY_SIZE];
 359    /// ed.export_private_only(&mut private_only).expect("Error with export_private_only()");
 360    /// }
 361    /// ```
 362    #[cfg(ed25519_export)]
 363    pub fn export_private_only(&self, private: &mut [u8]) -> Result<(), i32> {
 364        let mut private_size = crate::buffer_len_to_u32(private.len())?;
 365        let rc = unsafe {
 366            sys::wc_ed25519_export_private_only(&self.ws_key,
 367                private.as_mut_ptr(), &mut private_size)
 368        };
 369        if rc != 0 {
 370            return Err(rc);
 371        }
 372        Ok(())
 373    }
 374
 375    /// Import a public Ed25519 key from buffer.
 376    ///
 377    /// This function handles either compressed or uncompressed keys.
 378    /// The public key is checked that it matches the private key if one is
 379    /// already present.
 380    ///
 381    /// # Parameters
 382    ///
 383    /// * `public`: Input buffer containing public key.
 384    ///
 385    /// # Returns
 386    ///
 387    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 388    /// library error code value.
 389    ///
 390    /// # Example
 391    ///
 392    /// ```rust
 393    /// #[cfg(ed25519_import)]
 394    /// {
 395    /// use wolfssl_wolfcrypt::random::RNG;
 396    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 397    /// let mut rng = RNG::new().expect("Error creating RNG");
 398    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 399    /// let mut private = [0u8; Ed25519::PRV_KEY_SIZE];
 400    /// let mut public = [0u8; Ed25519::PUB_KEY_SIZE];
 401    /// ed.export_key(&mut private, &mut public).expect("Error with export_key()");
 402    /// let mut ed = Ed25519::new().expect("Error with new()");
 403    /// ed.import_public(&public).expect("Error with import_public()");
 404    /// }
 405    /// ```
 406    #[cfg(ed25519_import)]
 407    pub fn import_public(&mut self, public: &[u8]) -> Result<(), i32> {
 408        let public_size = crate::buffer_len_to_u32(public.len())?;
 409        let rc = unsafe {
 410            sys::wc_ed25519_import_public(public.as_ptr(), public_size, &mut self.ws_key)
 411        };
 412        if rc != 0 {
 413            return Err(rc);
 414        }
 415        Ok(())
 416    }
 417
 418    /// Import a public Ed25519 key from buffer with trusted flag.
 419    ///
 420    /// This function handles either compressed or uncompressed keys.
 421    /// The public key is checked that it matches the private key if one is
 422    /// already present and trusted is false.
 423    ///
 424    /// # Parameters
 425    ///
 426    /// * `public`: Input buffer containing public key.
 427    /// * `trusted`: Whether the public key buffer is trusted.
 428    ///
 429    /// # Returns
 430    ///
 431    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 432    /// library error code value.
 433    ///
 434    /// # Example
 435    ///
 436    /// ```rust
 437    /// #[cfg(ed25519_import)]
 438    /// {
 439    /// use wolfssl_wolfcrypt::random::RNG;
 440    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 441    /// let mut rng = RNG::new().expect("Error creating RNG");
 442    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 443    /// let mut private = [0u8; Ed25519::PRV_KEY_SIZE];
 444    /// let mut public = [0u8; Ed25519::PUB_KEY_SIZE];
 445    /// ed.export_key(&mut private, &mut public).expect("Error with export_key()");
 446    /// let mut ed = Ed25519::new().expect("Error with new()");
 447    /// ed.import_public_ex(&public, false).expect("Error with import_public_ex()");
 448    /// }
 449    /// ```
 450    #[cfg(ed25519_import)]
 451    pub fn import_public_ex(&mut self, public: &[u8], trusted: bool) -> Result<(), i32> {
 452        let public_size = crate::buffer_len_to_u32(public.len())?;
 453        let rc = unsafe {
 454            sys::wc_ed25519_import_public_ex(public.as_ptr(), public_size,
 455                &mut self.ws_key, if trusted {1} else {0})
 456        };
 457        if rc != 0 {
 458            return Err(rc);
 459        }
 460        Ok(())
 461    }
 462
 463    /// Import private Ed25519 key only from buffer.
 464    ///
 465    /// # Parameters
 466    ///
 467    /// * `private`: Input buffer containing private key.
 468    ///
 469    /// # Returns
 470    ///
 471    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 472    /// library error code value.
 473    ///
 474    /// # Example
 475    ///
 476    /// ```rust
 477    /// #[cfg(ed25519_import)]
 478    /// {
 479    /// use wolfssl_wolfcrypt::random::RNG;
 480    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 481    /// let mut rng = RNG::new().expect("Error creating RNG");
 482    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 483    /// let mut private_only = [0u8; Ed25519::KEY_SIZE];
 484    /// ed.export_private_only(&mut private_only).expect("Error with export_private_only()");
 485    /// let mut ed = Ed25519::new().expect("Error with new()");
 486    /// ed.import_private_only(&private_only).expect("Error with import_private_only()");
 487    /// }
 488    /// ```
 489    #[cfg(ed25519_import)]
 490    pub fn import_private_only(&mut self, private: &[u8]) -> Result<(), i32> {
 491        let private_size = crate::buffer_len_to_u32(private.len())?;
 492        let rc = unsafe {
 493            sys::wc_ed25519_import_private_only(private.as_ptr(), private_size,
 494                &mut self.ws_key)
 495        };
 496        if rc != 0 {
 497            return Err(rc);
 498        }
 499        Ok(())
 500    }
 501
 502    /// Import public/private Ed25519 key pair from buffers.
 503    ///
 504    /// This functions handles either compressed or uncompressed keys.
 505    /// The public key is assumed to be untrusted and is checked against the
 506    /// private key.
 507    ///
 508    /// # Parameters
 509    ///
 510    /// * `private`: Input buffer containing private key.
 511    /// * `public`: Optional input buffer containing public key.
 512    ///
 513    /// # Returns
 514    ///
 515    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 516    /// library error code value.
 517    ///
 518    /// # Example
 519    ///
 520    /// ```rust
 521    /// #[cfg(ed25519_import)]
 522    /// {
 523    /// use wolfssl_wolfcrypt::random::RNG;
 524    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 525    /// let mut rng = RNG::new().expect("Error creating RNG");
 526    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 527    /// let mut private = [0u8; Ed25519::PRV_KEY_SIZE];
 528    /// let mut public = [0u8; Ed25519::PUB_KEY_SIZE];
 529    /// ed.export_key(&mut private, &mut public).expect("Error with export_key()");
 530    /// let mut ed = Ed25519::new().expect("Error with new()");
 531    /// ed.import_private_key(&private, Some(&public)).expect("Error with import_private_key()");
 532    /// }
 533    /// ```
 534    #[cfg(ed25519_import)]
 535    pub fn import_private_key(&mut self, private: &[u8], public: Option<&[u8]>) -> Result<(), i32> {
 536        let private_size = crate::buffer_len_to_u32(private.len())?;
 537        let mut public_ptr: *const u8 = core::ptr::null();
 538        let mut public_size = 0u32;
 539        if let Some(public) = public {
 540            public_ptr = public.as_ptr();
 541            public_size = crate::buffer_len_to_u32(public.len())?;
 542        }
 543        let rc = unsafe {
 544            sys::wc_ed25519_import_private_key(private.as_ptr(), private_size,
 545                public_ptr, public_size, &mut self.ws_key)
 546        };
 547        if rc != 0 {
 548            return Err(rc);
 549        }
 550        Ok(())
 551    }
 552
 553    /// Import public/private Ed25519 key pair from buffers with trusted flag.
 554    ///
 555    /// This functions handles either compressed or uncompressed keys.
 556    /// The public is checked against private key if not trusted.
 557    ///
 558    /// # Parameters
 559    ///
 560    /// * `private`: Input buffer containing private key.
 561    /// * `public`: Optional input buffer containing private key.
 562    /// * `trusted`: Whether the public key buffer is trusted.
 563    ///
 564    /// # Returns
 565    ///
 566    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 567    /// library error code value.
 568    ///
 569    /// # Example
 570    ///
 571    /// ```rust
 572    /// #[cfg(ed25519_import)]
 573    /// {
 574    /// use wolfssl_wolfcrypt::random::RNG;
 575    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 576    /// let mut rng = RNG::new().expect("Error creating RNG");
 577    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 578    /// let mut private = [0u8; Ed25519::PRV_KEY_SIZE];
 579    /// let mut public = [0u8; Ed25519::PUB_KEY_SIZE];
 580    /// ed.export_key(&mut private, &mut public).expect("Error with export_key()");
 581    /// let mut ed = Ed25519::new().expect("Error with new()");
 582    /// ed.import_private_key_ex(&private, Some(&public), false).expect("Error with import_private_key_ex()");
 583    /// }
 584    /// ```
 585    #[cfg(ed25519_import)]
 586    pub fn import_private_key_ex(&mut self, private: &[u8], public: Option<&[u8]>, trusted: bool) -> Result<(), i32> {
 587        let private_size = crate::buffer_len_to_u32(private.len())?;
 588        let mut public_ptr: *const u8 = core::ptr::null();
 589        let mut public_size = 0u32;
 590        if let Some(public) = public {
 591            public_ptr = public.as_ptr();
 592            public_size = crate::buffer_len_to_u32(public.len())?;
 593        }
 594        let rc = unsafe {
 595            sys::wc_ed25519_import_private_key_ex(private.as_ptr(), private_size,
 596                public_ptr, public_size, &mut self.ws_key, if trusted {1} else {0})
 597        };
 598        if rc != 0 {
 599            return Err(rc);
 600        }
 601        Ok(())
 602    }
 603
 604    /// Generate the Ed25519 public key from the private key stored in the
 605    /// Ed25519 object.
 606    ///
 607    /// The public key is written to the pubkey output buffer.
 608    ///
 609    /// # Parameters
 610    ///
 611    /// * `pubkey`: Output buffer in which to store the public key.
 612    ///
 613    /// # Returns
 614    ///
 615    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
 616    /// library error code value.
 617    ///
 618    /// # Example
 619    ///
 620    /// ```rust
 621    /// use wolfssl_wolfcrypt::random::RNG;
 622    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 623    /// let mut rng = RNG::new().expect("Error creating RNG");
 624    /// let ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 625    /// let mut private = [0u8; Ed25519::KEY_SIZE];
 626    /// ed.export_private_only(&mut private).expect("Error with export_private_only()");
 627    /// let mut ed = Ed25519::new().expect("Error with new()");
 628    /// ed.import_private_only(&private).expect("Error with import_private_only()");
 629    /// let mut public = [0u8; Ed25519::KEY_SIZE];
 630    /// ed.make_public(&mut public).expect("Error with make_public()");
 631    /// ```
 632    pub fn make_public(&mut self, pubkey: &mut [u8]) -> Result<(), i32> {
 633        let pubkey_size = crate::buffer_len_to_u32(pubkey.len())?;
 634        let rc = unsafe {
 635            sys::wc_ed25519_make_public(&mut self.ws_key,
 636                pubkey.as_mut_ptr(), pubkey_size)
 637        };
 638        if rc != 0 {
 639            return Err(rc);
 640        }
 641        Ok(())
 642    }
 643
 644    /// Sign a message using Ed25519 key.
 645    ///
 646    /// # Parameters
 647    ///
 648    /// * `message`: Message to sign.
 649    /// * `signature`: Output buffer to hold signature.
 650    ///
 651    /// # Returns
 652    ///
 653    /// Returns either Ok(size) containing the number of bytes written to
 654    /// signature on success or Err(e) containing the wolfSSL library error
 655    /// code value.
 656    ///
 657    /// # Example
 658    ///
 659    /// ```rust
 660    /// #[cfg(ed25519_sign)]
 661    /// {
 662    /// use wolfssl_wolfcrypt::random::RNG;
 663    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 664    /// let mut rng = RNG::new().expect("Error creating RNG");
 665    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 666    /// let message = [0x42u8, 33, 55, 66];
 667    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
 668    /// ed.sign_msg(&message, &mut signature).expect("Error with sign_msg()");
 669    /// }
 670    /// ```
 671    #[cfg(ed25519_sign)]
 672    pub fn sign_msg(&mut self, message: &[u8], signature: &mut [u8]) -> Result<usize, i32> {
 673        let message_size = crate::buffer_len_to_u32(message.len())?;
 674        let mut signature_size = crate::buffer_len_to_u32(signature.len())?;
 675        let rc = unsafe {
 676            sys::wc_ed25519_sign_msg(message.as_ptr(), message_size,
 677                signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key)
 678        };
 679        if rc != 0 {
 680            return Err(rc);
 681        }
 682        Ok(signature_size as usize)
 683    }
 684
 685    /// Sign a message with context using Ed25519 key.
 686    ///
 687    /// The context is part of the data signed.
 688    ///
 689    /// # Parameters
 690    ///
 691    /// * `message`: Message to sign.
 692    /// * `context`: Buffer containing context for which message is being signed.
 693    /// * `signature`: Output buffer to hold signature.
 694    ///
 695    /// # Returns
 696    ///
 697    /// Returns either Ok(size) containing the number of bytes written to
 698    /// signature on success or Err(e) containing the wolfSSL library error
 699    /// code value.
 700    ///
 701    /// # Example
 702    ///
 703    /// ```rust
 704    /// #[cfg(ed25519_sign)]
 705    /// {
 706    /// use wolfssl_wolfcrypt::random::RNG;
 707    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 708    /// let mut rng = RNG::new().expect("Error creating RNG");
 709    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 710    /// let message = [0x42u8, 33, 55, 66];
 711    /// let context = b"context";
 712    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
 713    /// ed.sign_msg_ctx(&message, context, &mut signature).expect("Error with sign_msg_ctx()");
 714    /// }
 715    /// ```
 716    #[cfg(ed25519_sign)]
 717    pub fn sign_msg_ctx(&mut self, message: &[u8], context: &[u8], signature: &mut [u8]) -> Result<usize, i32> {
 718        let message_size = crate::buffer_len_to_u32(message.len())?;
 719        if context.len() > 255 {
 720            return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
 721        }
 722        let context_size = context.len() as u8;
 723        let mut signature_size = crate::buffer_len_to_u32(signature.len())?;
 724        let rc = unsafe {
 725            sys::wc_ed25519ctx_sign_msg(message.as_ptr(), message_size,
 726                signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key,
 727                context.as_ptr(), context_size)
 728        };
 729        if rc != 0 {
 730            return Err(rc);
 731        }
 732        Ok(signature_size as usize)
 733    }
 734
 735    /// Sign a message digest with context using Ed25519 key.
 736    ///
 737    /// The context is part of the data signed.
 738    /// The message is pre-hashed before signature calculation.
 739    ///
 740    /// # Parameters
 741    ///
 742    /// * `hash`: Message digest to sign.
 743    /// * `context`: Optional buffer containing context for which hash is being signed.
 744    /// * `signature`: Output buffer to hold signature.
 745    ///
 746    /// # Returns
 747    ///
 748    /// Returns either Ok(size) containing the number of bytes written to
 749    /// signature on success or Err(e) containing the wolfSSL library error
 750    /// code value.
 751    ///
 752    /// # Example
 753    ///
 754    /// ```rust
 755    /// #[cfg(ed25519_sign)]
 756    /// {
 757    /// use wolfssl_wolfcrypt::random::RNG;
 758    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 759    /// let mut rng = RNG::new().expect("Error creating RNG");
 760    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 761    /// let hash = [
 762    ///     0xddu8,0xaf,0x35,0xa1,0x93,0x61,0x7a,0xba,
 763    ///     0xcc,0x41,0x73,0x49,0xae,0x20,0x41,0x31,
 764    ///     0x12,0xe6,0xfa,0x4e,0x89,0xa9,0x7e,0xa2,
 765    ///     0x0a,0x9e,0xee,0xe6,0x4b,0x55,0xd3,0x9a,
 766    ///     0x21,0x92,0x99,0x2a,0x27,0x4f,0xc1,0xa8,
 767    ///     0x36,0xba,0x3c,0x23,0xa3,0xfe,0xeb,0xbd,
 768    ///     0x45,0x4d,0x44,0x23,0x64,0x3c,0xe8,0x0e,
 769    ///     0x2a,0x9a,0xc9,0x4f,0xa5,0x4c,0xa4,0x9f
 770    /// ];
 771    /// let context = b"context";
 772    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
 773    /// ed.sign_hash_ph(&hash, Some(context), &mut signature).expect("Error with sign_hash_ph()");
 774    /// }
 775    /// ```
 776    #[cfg(ed25519_sign)]
 777    pub fn sign_hash_ph(&mut self, hash: &[u8], context: Option<&[u8]>, signature: &mut [u8]) -> Result<usize, i32> {
 778        let hash_size = crate::buffer_len_to_u32(hash.len())?;
 779        let mut context_ptr: *const u8 = core::ptr::null();
 780        let mut context_size = 0u8;
 781        if let Some(context) = context {
 782            context_ptr = context.as_ptr();
 783            if context.len() > 255 {
 784                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
 785            }
 786            context_size = context.len() as u8;
 787        }
 788        let mut signature_size = crate::buffer_len_to_u32(signature.len())?;
 789        let rc = unsafe {
 790            sys::wc_ed25519ph_sign_hash(hash.as_ptr(), hash_size,
 791                signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key,
 792                context_ptr, context_size)
 793        };
 794        if rc != 0 {
 795            return Err(rc);
 796        }
 797        Ok(signature_size as usize)
 798    }
 799
 800    /// Sign a message with context using Ed25519 key.
 801    ///
 802    /// The context is part of the data signed.
 803    /// The message is pre-hashed before signature calculation.
 804    ///
 805    /// # Parameters
 806    ///
 807    /// * `message`: Message digest to sign.
 808    /// * `context`: Optional buffer containing context for which message is being signed.
 809    /// * `signature`: Output buffer to hold signature.
 810    ///
 811    /// # Returns
 812    ///
 813    /// Returns either Ok(size) containing the number of bytes written to
 814    /// signature on success or Err(e) containing the wolfSSL library error
 815    /// code value.
 816    ///
 817    /// # Example
 818    ///
 819    /// ```rust
 820    /// #[cfg(ed25519_sign)]
 821    /// {
 822    /// use wolfssl_wolfcrypt::random::RNG;
 823    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 824    /// let mut rng = RNG::new().expect("Error creating RNG");
 825    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 826    /// let message = [0x42u8, 33, 55, 66];
 827    /// let context = b"context";
 828    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
 829    /// ed.sign_msg_ph(&message, Some(context), &mut signature).expect("Error with sign_msg_ph()");
 830    /// }
 831    /// ```
 832    #[cfg(ed25519_sign)]
 833    pub fn sign_msg_ph(&mut self, message: &[u8], context: Option<&[u8]>, signature: &mut [u8]) -> Result<usize, i32> {
 834        let message_size = crate::buffer_len_to_u32(message.len())?;
 835        let mut context_ptr: *const u8 = core::ptr::null();
 836        let mut context_size = 0u8;
 837        if let Some(context) = context {
 838            context_ptr = context.as_ptr();
 839            if context.len() > 255 {
 840                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
 841            }
 842            context_size = context.len() as u8;
 843        }
 844        let mut signature_size = crate::buffer_len_to_u32(signature.len())?;
 845        let rc = unsafe {
 846            sys::wc_ed25519ph_sign_msg(message.as_ptr(), message_size,
 847                signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key,
 848                context_ptr, context_size)
 849        };
 850        if rc != 0 {
 851            return Err(rc);
 852        }
 853        Ok(signature_size as usize)
 854    }
 855
 856    /// Sign input data with optional context using Ed25519 key.
 857    ///
 858    /// If provided, the context is part of the data signed.
 859    ///
 860    /// # Parameters
 861    ///
 862    /// * `din`: Data to sign.
 863    /// * `context`: Optional buffer containing context for which `din` is being signed.
 864    /// * `typ`: One of `Ed25519::ED25519`, `Ed25519::ED25519CTX`, or `Ed25519::ED25519PH`.
 865    /// * `signature`: Output buffer to hold signature.
 866    ///
 867    /// # Returns
 868    ///
 869    /// Returns either Ok(size) containing the number of bytes written to
 870    /// signature on success or Err(e) containing the wolfSSL library error
 871    /// code value.
 872    ///
 873    /// # Example
 874    ///
 875    /// ```rust
 876    /// #[cfg(ed25519_sign)]
 877    /// {
 878    /// use wolfssl_wolfcrypt::random::RNG;
 879    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 880    /// let mut rng = RNG::new().expect("Error creating RNG");
 881    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 882    /// let message = [0x42u8, 33, 55, 66];
 883    /// let context = b"context";
 884    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
 885    /// ed.sign_msg_ex(&message, Some(context), Ed25519::ED25519, &mut signature).expect("Error with sign_msg_ex()");
 886    /// }
 887    /// ```
 888    #[cfg(ed25519_sign)]
 889    pub fn sign_msg_ex(&mut self, din: &[u8], context: Option<&[u8]>, typ: u8, signature: &mut [u8]) -> Result<usize, i32> {
 890        let din_size = crate::buffer_len_to_u32(din.len())?;
 891        let mut context_ptr: *const u8 = core::ptr::null();
 892        let mut context_size = 0u8;
 893        if let Some(context) = context {
 894            context_ptr = context.as_ptr();
 895            if context.len() > 255 {
 896                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
 897            }
 898            context_size = context.len() as u8;
 899        }
 900        let mut signature_size = crate::buffer_len_to_u32(signature.len())?;
 901        let rc = unsafe {
 902            sys::wc_ed25519_sign_msg_ex(din.as_ptr(), din_size,
 903                signature.as_mut_ptr(), &mut signature_size, &mut self.ws_key,
 904                typ, context_ptr, context_size)
 905        };
 906        if rc != 0 {
 907            return Err(rc);
 908        }
 909        Ok(signature_size as usize)
 910    }
 911
 912    /// Verify the Ed25519 signature of a message to ensure authenticity.
 913    ///
 914    /// # Parameters
 915    ///
 916    /// * `signature`: Signature to verify.
 917    /// * `message`: Message to verify the signature of.
 918    ///
 919    /// # Returns
 920    ///
 921    /// Returns either Ok(valid) containing whether the signature is valid or
 922    /// Err(e) containing the wolfSSL library error code value.
 923    ///
 924    /// # Example
 925    ///
 926    /// ```rust
 927    /// #[cfg(ed25519_verify)]
 928    /// {
 929    /// use wolfssl_wolfcrypt::random::RNG;
 930    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 931    /// let mut rng = RNG::new().expect("Error creating RNG");
 932    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 933    /// let message = [0x42u8, 33, 55, 66];
 934    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
 935    /// ed.sign_msg(&message, &mut signature).expect("Error with sign_msg()");
 936    /// let signature_valid = ed.verify_msg(&signature, &message).expect("Error with verify_msg()");
 937    /// assert!(signature_valid);
 938    /// }
 939    /// ```
 940    #[cfg(ed25519_verify)]
 941    pub fn verify_msg(&mut self, signature: &[u8], message: &[u8]) -> Result<bool, i32> {
 942        let signature_size = crate::buffer_len_to_u32(signature.len())?;
 943        let message_size = crate::buffer_len_to_u32(message.len())?;
 944        let mut res = 0i32;
 945        let rc = unsafe {
 946            sys::wc_ed25519_verify_msg(signature.as_ptr(), signature_size,
 947                message.as_ptr(), message_size, &mut res, &mut self.ws_key)
 948        };
 949        if rc != 0 {
 950            return Err(rc);
 951        }
 952        Ok(res == 1)
 953    }
 954
 955    /// Verify the Ed25519 signature of a message and context to ensure authenticity.
 956    ///
 957    /// The context is included as part of the data verified.
 958    ///
 959    /// # Parameters
 960    ///
 961    /// * `signature`: Signature to verify.
 962    /// * `message`: Message to verify the signature of.
 963    /// * `context`: Buffer containing context for which the message was signed.
 964    ///
 965    /// # Returns
 966    ///
 967    /// Returns either Ok(valid) containing whether the signature is valid or
 968    /// Err(e) containing the wolfSSL library error code value.
 969    ///
 970    /// # Example
 971    ///
 972    /// ```rust
 973    /// #[cfg(ed25519_verify)]
 974    /// {
 975    /// use wolfssl_wolfcrypt::random::RNG;
 976    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
 977    /// let mut rng = RNG::new().expect("Error creating RNG");
 978    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
 979    /// let message = b"Hello!";
 980    /// let context = b"context";
 981    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
 982    /// ed.sign_msg_ctx(message, context, &mut signature).expect("Error with sign_msg()");
 983    /// let signature_valid = ed.verify_msg_ctx(&signature, message, context).expect("Error with verify_msg_ctx()");
 984    /// assert!(signature_valid);
 985    /// }
 986    /// ```
 987    #[cfg(ed25519_verify)]
 988    pub fn verify_msg_ctx(&mut self, signature: &[u8], message: &[u8], context: &[u8]) -> Result<bool, i32> {
 989        let signature_size = crate::buffer_len_to_u32(signature.len())?;
 990        let message_size = crate::buffer_len_to_u32(message.len())?;
 991        if context.len() > 255 {
 992            return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
 993        }
 994        let context_size = context.len() as u8;
 995        let mut res = 0i32;
 996        let rc = unsafe {
 997            sys::wc_ed25519ctx_verify_msg(signature.as_ptr(), signature_size,
 998                message.as_ptr(), message_size, &mut res, &mut self.ws_key,
 999                context.as_ptr(), context_size)
1000        };
1001        if rc != 0 {
1002            return Err(rc);
1003        }
1004        Ok(res == 1)
1005    }
1006
1007    /// Verify the Ed25519 signature of a message digest and context to ensure authenticity.
1008    ///
1009    /// The context is included as part of the data verified.
1010    /// The hash algorithm used to create message digest must be SHA-512.
1011    /// The message is pre-hashed before verification.
1012    ///
1013    /// # Parameters
1014    ///
1015    /// * `signature`: Signature to verify.
1016    /// * `hash`: Message to verify the signature of.
1017    /// * `context`: Optional buffer containing context for which the hash was signed.
1018    ///
1019    /// # Returns
1020    ///
1021    /// Returns either Ok(valid) containing whether the signature is valid or
1022    /// Err(e) containing the wolfSSL library error code value.
1023    ///
1024    /// # Example
1025    ///
1026    /// ```rust
1027    /// #[cfg(ed25519_verify)]
1028    /// {
1029    /// use wolfssl_wolfcrypt::random::RNG;
1030    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
1031    /// let mut rng = RNG::new().expect("Error creating RNG");
1032    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
1033    /// let hash = [
1034    ///     0xddu8,0xaf,0x35,0xa1,0x93,0x61,0x7a,0xba,
1035    ///     0xcc,0x41,0x73,0x49,0xae,0x20,0x41,0x31,
1036    ///     0x12,0xe6,0xfa,0x4e,0x89,0xa9,0x7e,0xa2,
1037    ///     0x0a,0x9e,0xee,0xe6,0x4b,0x55,0xd3,0x9a,
1038    ///     0x21,0x92,0x99,0x2a,0x27,0x4f,0xc1,0xa8,
1039    ///     0x36,0xba,0x3c,0x23,0xa3,0xfe,0xeb,0xbd,
1040    ///     0x45,0x4d,0x44,0x23,0x64,0x3c,0xe8,0x0e,
1041    ///     0x2a,0x9a,0xc9,0x4f,0xa5,0x4c,0xa4,0x9f
1042    /// ];
1043    /// let context = b"context";
1044    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
1045    /// ed.sign_hash_ph(&hash, Some(context), &mut signature).expect("Error with sign_hash_ph()");
1046    /// let signature_valid = ed.verify_hash_ph(&signature, &hash, Some(context)).expect("Error with verify_hash_ph()");
1047    /// assert!(signature_valid);
1048    /// }
1049    /// ```
1050    #[cfg(ed25519_verify)]
1051    pub fn verify_hash_ph(&mut self, signature: &[u8], hash: &[u8], context: Option<&[u8]>) -> Result<bool, i32> {
1052        let signature_size = crate::buffer_len_to_u32(signature.len())?;
1053        let hash_size = crate::buffer_len_to_u32(hash.len())?;
1054        let mut context_ptr: *const u8 = core::ptr::null();
1055        let mut context_size = 0u8;
1056        if let Some(context) = context {
1057            context_ptr = context.as_ptr();
1058            if context.len() > 255 {
1059                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
1060            }
1061            context_size = context.len() as u8;
1062        }
1063        let mut res = 0i32;
1064        let rc = unsafe {
1065            sys::wc_ed25519ph_verify_hash(signature.as_ptr(), signature_size,
1066                hash.as_ptr(), hash_size, &mut res, &mut self.ws_key,
1067                context_ptr, context_size)
1068        };
1069        if rc != 0 {
1070            return Err(rc);
1071        }
1072        Ok(res == 1)
1073    }
1074
1075    /// Verify the Ed25519 signature of a message and context to ensure authenticity.
1076    ///
1077    /// The context is included as part of the data verified.
1078    /// The message is pre-hashed before verification.
1079    ///
1080    /// # Parameters
1081    ///
1082    /// * `signature`: Signature to verify.
1083    /// * `message`: Message to verify the signature of.
1084    /// * `context`: Option buffer containing context for which the message was signed.
1085    ///
1086    /// # Returns
1087    ///
1088    /// Returns either Ok(valid) containing whether the signature is valid or
1089    /// Err(e) containing the wolfSSL library error code value.
1090    ///
1091    /// # Example
1092    ///
1093    /// ```rust
1094    /// #[cfg(ed25519_verify)]
1095    /// {
1096    /// use wolfssl_wolfcrypt::random::RNG;
1097    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
1098    /// let mut rng = RNG::new().expect("Error creating RNG");
1099    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
1100    /// let message = [0x42u8, 33, 55, 66];
1101    /// let context = b"context";
1102    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
1103    /// ed.sign_msg_ph(&message, Some(context), &mut signature).expect("Error with sign_msg_ph()");
1104    /// let signature_valid = ed.verify_msg_ph(&signature, &message, Some(context)).expect("Error with verify_msg_ph()");
1105    /// assert!(signature_valid);
1106    /// }
1107    /// ```
1108    #[cfg(ed25519_verify)]
1109    pub fn verify_msg_ph(&mut self, signature: &[u8], message: &[u8], context: Option<&[u8]>) -> Result<bool, i32> {
1110        let signature_size = crate::buffer_len_to_u32(signature.len())?;
1111        let message_size = crate::buffer_len_to_u32(message.len())?;
1112        let mut context_ptr: *const u8 = core::ptr::null();
1113        let mut context_size = 0u8;
1114        if let Some(context) = context {
1115            context_ptr = context.as_ptr();
1116            if context.len() > 255 {
1117                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
1118            }
1119            context_size = context.len() as u8;
1120        }
1121        let mut res = 0i32;
1122        let rc = unsafe {
1123            sys::wc_ed25519ph_verify_msg(signature.as_ptr(), signature_size,
1124                message.as_ptr(), message_size, &mut res, &mut self.ws_key,
1125                context_ptr, context_size)
1126        };
1127        if rc != 0 {
1128            return Err(rc);
1129        }
1130        Ok(res == 1)
1131    }
1132
1133    /// Verify the Ed25519 signature of a message and context to ensure authenticity.
1134    ///
1135    /// The context is included as part of the data verified.
1136    ///
1137    /// # Parameters
1138    ///
1139    /// * `signature`: Signature to verify.
1140    /// * `din`: Message to verify the signature of.
1141    /// * `context`: Optional buffer containing context for which the input data was signed.
1142    /// * `typ`: One of `Ed25519::ED25519`, `Ed25519::ED25519CTX`, or `Ed25519::ED25519PH`.
1143    ///
1144    /// # Returns
1145    ///
1146    /// Returns either Ok(valid) containing whether the signature is valid or
1147    /// Err(e) containing the wolfSSL library error code value.
1148    ///
1149    /// # Example
1150    ///
1151    /// ```rust
1152    /// #[cfg(ed25519_verify)]
1153    /// {
1154    /// use wolfssl_wolfcrypt::random::RNG;
1155    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
1156    /// let mut rng = RNG::new().expect("Error creating RNG");
1157    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
1158    /// let message = [0x42u8, 33, 55, 66];
1159    /// let context = b"context";
1160    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
1161    /// ed.sign_msg_ex(&message, Some(context), Ed25519::ED25519, &mut signature).expect("Error with sign_msg_ex()");
1162    /// let signature_valid = ed.verify_msg_ex(&signature, &message, Some(context), Ed25519::ED25519).expect("Error with verify_msg_ex()");
1163    /// assert!(signature_valid);
1164    /// }
1165    /// ```
1166    #[cfg(ed25519_verify)]
1167    pub fn verify_msg_ex(&mut self, signature: &[u8], din: &[u8], context: Option<&[u8]>, typ: u8) -> Result<bool, i32> {
1168        let signature_size = crate::buffer_len_to_u32(signature.len())?;
1169        let din_size = crate::buffer_len_to_u32(din.len())?;
1170        let mut context_ptr: *const u8 = core::ptr::null();
1171        let mut context_size = 0u8;
1172        if let Some(context) = context {
1173            context_ptr = context.as_ptr();
1174            if context.len() > 255 {
1175                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
1176            }
1177            context_size = context.len() as u8;
1178        }
1179        let mut res = 0i32;
1180        let rc = unsafe {
1181            sys::wc_ed25519_verify_msg_ex(signature.as_ptr(), signature_size,
1182                din.as_ptr(), din_size, &mut res, &mut self.ws_key, typ,
1183                context_ptr, context_size)
1184        };
1185        if rc != 0 {
1186            return Err(rc);
1187        }
1188        Ok(res == 1)
1189    }
1190
1191    /// Initialize Ed25519 key to perform streaming verification.
1192    ///
1193    /// # Parameters
1194    ///
1195    /// * `signature`: Signature to verify.
1196    /// * `context`: Optional buffer containing context for which the input data was signed.
1197    /// * `typ`: One of `Ed25519::ED25519`, `Ed25519::ED25519CTX`, or `Ed25519::ED25519PH`.
1198    ///
1199    /// # Returns
1200    ///
1201    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1202    /// library error code value.
1203    ///
1204    /// # Example
1205    ///
1206    /// ```rust
1207    /// #[cfg(ed25519_streaming_verify)]
1208    /// {
1209    /// use wolfssl_wolfcrypt::random::RNG;
1210    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
1211    /// let mut rng = RNG::new().expect("Error creating RNG");
1212    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
1213    /// let message = [0x42u8, 33, 55, 66];
1214    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
1215    /// ed.sign_msg(&message, &mut signature).expect("Error with sign_msg()");
1216    /// ed.verify_msg_init(&signature, None, Ed25519::ED25519).expect("Error with verify_msg_init()");
1217    /// ed.verify_msg_update(&message[0..2]).expect("Error with verify_msg_update()");
1218    /// ed.verify_msg_update(&message[2..4]).expect("Error with verify_msg_update()");
1219    /// let signature_valid = ed.verify_msg_final(&signature).expect("Error with verify_msg_final()");
1220    /// assert!(signature_valid);
1221    /// }
1222    /// ```
1223    #[cfg(ed25519_streaming_verify)]
1224    pub fn verify_msg_init(&mut self, signature: &[u8], context: Option<&[u8]>, typ: u8) -> Result<(), i32> {
1225        let signature_size = crate::buffer_len_to_u32(signature.len())?;
1226        let mut context_ptr: *const u8 = core::ptr::null();
1227        let mut context_size = 0u8;
1228        if let Some(context) = context {
1229            context_ptr = context.as_ptr();
1230            if context.len() > 255 {
1231                return Err(sys::wolfCrypt_ErrorCodes_BAD_FUNC_ARG);
1232            }
1233            context_size = context.len() as u8;
1234        }
1235        let rc = unsafe {
1236            sys::wc_ed25519_verify_msg_init(signature.as_ptr(), signature_size,
1237                &mut self.ws_key, typ, context_ptr, context_size)
1238        };
1239        if rc != 0 {
1240            return Err(rc);
1241        }
1242        Ok(())
1243    }
1244
1245    /// Add input data to Ed25519 streaming verification.
1246    ///
1247    /// # Parameters
1248    ///
1249    /// * `din`: Segment of message to verify the signature of.
1250    ///
1251    /// # Returns
1252    ///
1253    /// Returns either Ok(()) on success or Err(e) containing the wolfSSL
1254    /// library error code value.
1255    ///
1256    /// # Example
1257    ///
1258    /// ```rust
1259    /// #[cfg(ed25519_streaming_verify)]
1260    /// {
1261    /// use wolfssl_wolfcrypt::random::RNG;
1262    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
1263    /// let mut rng = RNG::new().expect("Error creating RNG");
1264    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
1265    /// let message = [0x42u8, 33, 55, 66];
1266    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
1267    /// ed.sign_msg(&message, &mut signature).expect("Error with sign_msg()");
1268    /// ed.verify_msg_init(&signature, None, Ed25519::ED25519).expect("Error with verify_msg_init()");
1269    /// ed.verify_msg_update(&message[0..2]).expect("Error with verify_msg_update()");
1270    /// ed.verify_msg_update(&message[2..4]).expect("Error with verify_msg_update()");
1271    /// let signature_valid = ed.verify_msg_final(&signature).expect("Error with verify_msg_final()");
1272    /// assert!(signature_valid);
1273    /// }
1274    /// ```
1275    #[cfg(ed25519_streaming_verify)]
1276    pub fn verify_msg_update(&mut self, din: &[u8]) -> Result<(), i32> {
1277        let din_size = crate::buffer_len_to_u32(din.len())?;
1278        let rc = unsafe {
1279            sys::wc_ed25519_verify_msg_update(din.as_ptr(), din_size,
1280                &mut self.ws_key)
1281        };
1282        if rc != 0 {
1283            return Err(rc);
1284        }
1285        Ok(())
1286    }
1287
1288    /// Finalize Ed25519 streaming verification.
1289    ///
1290    /// # Parameters
1291    ///
1292    /// * `signature`: Signature to verify.
1293    ///
1294    /// # Returns
1295    ///
1296    /// Returns either Ok(valid) containing whether the signature is valid or
1297    /// Err(e) containing the wolfSSL library error code value.
1298    ///
1299    /// # Example
1300    ///
1301    /// ```rust
1302    /// #[cfg(ed25519_streaming_verify)]
1303    /// {
1304    /// use wolfssl_wolfcrypt::random::RNG;
1305    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
1306    /// let mut rng = RNG::new().expect("Error creating RNG");
1307    /// let mut ed = Ed25519::generate(&mut rng).expect("Error with generate()");
1308    /// let message = [0x42u8, 33, 55, 66];
1309    /// let mut signature = [0u8; Ed25519::SIG_SIZE];
1310    /// ed.sign_msg(&message, &mut signature).expect("Error with sign_msg()");
1311    /// ed.verify_msg_init(&signature, None, Ed25519::ED25519).expect("Error with verify_msg_init()");
1312    /// ed.verify_msg_update(&message[0..2]).expect("Error with verify_msg_update()");
1313    /// ed.verify_msg_update(&message[2..4]).expect("Error with verify_msg_update()");
1314    /// let signature_valid = ed.verify_msg_final(&signature).expect("Error with verify_msg_final()");
1315    /// assert!(signature_valid);
1316    /// }
1317    /// ```
1318    #[cfg(ed25519_streaming_verify)]
1319    pub fn verify_msg_final(&mut self, signature: &[u8]) -> Result<bool, i32> {
1320        let signature_size = crate::buffer_len_to_u32(signature.len())?;
1321        let mut res = 0i32;
1322        let rc = unsafe {
1323            sys::wc_ed25519_verify_msg_final(signature.as_ptr(), signature_size,
1324                &mut res, &mut self.ws_key)
1325        };
1326        if rc != 0 {
1327            return Err(rc);
1328        }
1329        Ok(res == 1)
1330    }
1331
1332    /// Get the size of an Ed25519 key (32 bytes).
1333    ///
1334    /// # Returns
1335    ///
1336    /// Returns either Ok(size) containing the key size or Err(e)
1337    /// containing the wolfSSL library error code value.
1338    ///
1339    /// # Example
1340    ///
1341    /// ```rust
1342    /// use wolfssl_wolfcrypt::random::RNG;
1343    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
1344    /// let mut rng = RNG::new().expect("Error creating RNG");
1345    /// let ed = Ed25519::generate(&mut rng).expect("Error with generate()");
1346    /// let key_size = ed.size().expect("Error with size()");
1347    /// assert_eq!(key_size, Ed25519::KEY_SIZE);
1348    /// ```
1349    pub fn size(&self) -> Result<usize, i32> {
1350        let rc = unsafe { sys::wc_ed25519_size(&self.ws_key) };
1351        if rc < 0 {
1352            return Err(rc);
1353        }
1354        Ok(rc as usize)
1355    }
1356
1357    /// Get the size of a private (including public) Ed25519 key (64 bytes).
1358    ///
1359    /// # Returns
1360    ///
1361    /// Returns either Ok(size) containing the key size or Err(e)
1362    /// containing the wolfSSL library error code value.
1363    ///
1364    /// # Example
1365    ///
1366    /// ```rust
1367    /// use wolfssl_wolfcrypt::random::RNG;
1368    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
1369    /// let mut rng = RNG::new().expect("Error creating RNG");
1370    /// let ed = Ed25519::generate(&mut rng).expect("Error with generate()");
1371    /// let priv_size = ed.priv_size().expect("Error with priv_size()");
1372    /// assert_eq!(priv_size, Ed25519::PRV_KEY_SIZE);
1373    /// ```
1374    pub fn priv_size(&self) -> Result<usize, i32> {
1375        let rc = unsafe { sys::wc_ed25519_priv_size(&self.ws_key) };
1376        if rc < 0 {
1377            return Err(rc);
1378        }
1379        Ok(rc as usize)
1380    }
1381
1382    /// Get the size of a public Ed25519 key (32 bytes).
1383    ///
1384    /// # Returns
1385    ///
1386    /// Returns either Ok(size) containing the key size or Err(e)
1387    /// containing the wolfSSL library error code value.
1388    ///
1389    /// # Example
1390    ///
1391    /// ```rust
1392    /// use wolfssl_wolfcrypt::random::RNG;
1393    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
1394    /// let mut rng = RNG::new().expect("Error creating RNG");
1395    /// let ed = Ed25519::generate(&mut rng).expect("Error with generate()");
1396    /// let pub_size = ed.pub_size().expect("Error with pub_size()");
1397    /// assert_eq!(pub_size, Ed25519::PUB_KEY_SIZE);
1398    /// ```
1399    pub fn pub_size(&self) -> Result<usize, i32> {
1400        let rc = unsafe { sys::wc_ed25519_pub_size(&self.ws_key) };
1401        if rc < 0 {
1402            return Err(rc);
1403        }
1404        Ok(rc as usize)
1405    }
1406
1407    /// Get the size of a Ed25519 signature (64 bytes).
1408    ///
1409    /// # Returns
1410    ///
1411    /// Returns either Ok(size) containing the key size or Err(e)
1412    /// containing the wolfSSL library error code value.
1413    ///
1414    /// # Example
1415    ///
1416    /// ```rust
1417    /// use wolfssl_wolfcrypt::random::RNG;
1418    /// use wolfssl_wolfcrypt::ed25519::Ed25519;
1419    /// let mut rng = RNG::new().expect("Error creating RNG");
1420    /// let ed = Ed25519::generate(&mut rng).expect("Error with generate()");
1421    /// let sig_size = ed.sig_size().expect("Error with sig_size()");
1422    /// assert_eq!(sig_size, Ed25519::SIG_SIZE);
1423    /// ```
1424    pub fn sig_size(&self) -> Result<usize, i32> {
1425        let rc = unsafe { sys::wc_ed25519_sig_size(&self.ws_key) };
1426        if rc < 0 {
1427            return Err(rc);
1428        }
1429        Ok(rc as usize)
1430    }
1431}
1432
1433impl Ed25519 {
1434    fn zeroize(&mut self) {
1435        unsafe { crate::zeroize_raw(&mut self.ws_key); }
1436    }
1437}
1438
1439impl Drop for Ed25519 {
1440    /// Safely free the wolfSSL resources.
1441    fn drop(&mut self) {
1442        unsafe { sys::wc_ed25519_free(&mut self.ws_key); }
1443        self.zeroize();
1444    }
1445}
1446
1447/// RustCrypto `signature` crate trait implementations.
1448///
1449/// Provides a fixed-size [`Signature`] and a [`VerifyingKey`] type so that
1450/// [`Ed25519`] can be used wherever the `signature` crate's
1451/// [`signature::SignerMut`], [`signature::Keypair`], and
1452/// [`signature::Verifier`] traits are accepted.
1453#[cfg(feature = "signature")]
1454mod signature_impl {
1455    use super::Ed25519;
1456    use signature::Error;
1457
1458    /// Ed25519 signature in its standard 64-byte encoded form.
1459    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
1460    pub struct Signature([u8; Ed25519::SIG_SIZE]);
1461
1462    impl Signature {
1463        /// Construct a signature from its raw bytes.
1464        pub const fn from_bytes(bytes: [u8; Ed25519::SIG_SIZE]) -> Self {
1465            Self(bytes)
1466        }
1467
1468        /// Return the raw signature bytes.
1469        pub const fn to_bytes(&self) -> [u8; Ed25519::SIG_SIZE] {
1470            self.0
1471        }
1472    }
1473
1474    impl AsRef<[u8]> for Signature {
1475        fn as_ref(&self) -> &[u8] {
1476            &self.0
1477        }
1478    }
1479
1480    impl TryFrom<&[u8]> for Signature {
1481        type Error = Error;
1482        fn try_from(bytes: &[u8]) -> Result<Self, Error> {
1483            let arr: [u8; Ed25519::SIG_SIZE] = bytes.try_into().map_err(|_| Error::new())?;
1484            Ok(Self(arr))
1485        }
1486    }
1487
1488    impl From<Signature> for [u8; Ed25519::SIG_SIZE] {
1489        fn from(sig: Signature) -> Self {
1490            sig.0
1491        }
1492    }
1493
1494    impl signature::SignatureEncoding for Signature {
1495        type Repr = [u8; Ed25519::SIG_SIZE];
1496    }
1497
1498    /// Ed25519 verifying (public) key.
1499    ///
1500    /// Owns a copy of the 32-byte compressed public key and instantiates a
1501    /// short-lived wolfCrypt `ed25519_key` on each verification.
1502    #[derive(Clone, Copy, Debug, Eq, PartialEq)]
1503    pub struct VerifyingKey([u8; Ed25519::PUB_KEY_SIZE]);
1504
1505    impl VerifyingKey {
1506        /// Construct a verifying key from its raw public key bytes.
1507        pub const fn from_bytes(bytes: [u8; Ed25519::PUB_KEY_SIZE]) -> Self {
1508            Self(bytes)
1509        }
1510
1511        /// Return the raw public key bytes.
1512        pub const fn to_bytes(&self) -> [u8; Ed25519::PUB_KEY_SIZE] {
1513            self.0
1514        }
1515    }
1516
1517    impl AsRef<[u8]> for VerifyingKey {
1518        fn as_ref(&self) -> &[u8] {
1519            &self.0
1520        }
1521    }
1522
1523    impl TryFrom<&[u8]> for VerifyingKey {
1524        type Error = Error;
1525        fn try_from(bytes: &[u8]) -> Result<Self, Error> {
1526            let arr: [u8; Ed25519::PUB_KEY_SIZE] =
1527                bytes.try_into().map_err(|_| Error::new())?;
1528            Ok(Self(arr))
1529        }
1530    }
1531
1532    #[cfg(all(ed25519_sign, ed25519_export))]
1533    impl signature::Keypair for Ed25519 {
1534        type VerifyingKey = VerifyingKey;
1535        fn verifying_key(&self) -> Self::VerifyingKey {
1536            let mut pub_key = [0u8; Ed25519::PUB_KEY_SIZE];
1537            self.export_public(&mut pub_key).expect("ed25519 export_public failed");
1538            VerifyingKey(pub_key)
1539        }
1540    }
1541
1542    #[cfg(ed25519_sign)]
1543    impl signature::SignerMut<Signature> for Ed25519 {
1544        fn try_sign(&mut self, msg: &[u8]) -> Result<Signature, Error> {
1545            let mut sig = [0u8; Ed25519::SIG_SIZE];
1546            self.sign_msg(msg, &mut sig).map_err(|_| Error::new())?;
1547            Ok(Signature(sig))
1548        }
1549    }
1550
1551    #[cfg(all(ed25519_import, ed25519_verify))]
1552    impl signature::Verifier<Signature> for VerifyingKey {
1553        fn verify(&self, msg: &[u8], signature: &Signature) -> Result<(), Error> {
1554            let mut key = Ed25519::new().map_err(|_| Error::new())?;
1555            key.import_public(&self.0).map_err(|_| Error::new())?;
1556            let valid = key
1557                .verify_msg(&signature.0, msg)
1558                .map_err(|_| Error::new())?;
1559            if valid { Ok(()) } else { Err(Error::new()) }
1560        }
1561    }
1562}
1563
1564#[cfg(feature = "signature")]
1565pub use signature_impl::{Signature, VerifyingKey};