Struct SigningKeyPair 

pub struct SigningKeyPair<PublicKey: ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES> + Zeroize, SecretKey: ByteArray<CRYPTO_SIGN_SECRETKEYBYTES> + Zeroize> {
    pub public_key: PublicKey,
    pub secret_key: SecretKey,
}

An Ed25519 keypair for public-key signatures

Fields

public_key: PublicKey

Public key

secret_key: SecretKey

Secret key

Implementations

impl SigningKeyPair<Locked<HeapByteArray<CRYPTO_SIGN_PUBLICKEYBYTES>>, Locked<HeapByteArray<CRYPTO_SIGN_SECRETKEYBYTES>>>

pub fn new_locked_keypair() -> Result<Self, Error>

Available on crate feature protected only.

Returns a new locked signing keypair.

Errors

Returns Error::Io if either allocation cannot be locked.

Panics

Panics if either page-aligned allocation cannot be created or its size cannot be represented with guard pages.

pub fn generate_locked_keypair() -> Result<Self, Error>

Available on crate feature protected only.

Returns a new randomly generated locked signing keypair.

Errors

Returns Error::Io if either allocation cannot be locked.

Panics

Panics if either page-aligned allocation cannot be created, its size cannot be represented with guard pages, or the operating system’s random number generator fails.

pub fn gen_locked_keypair() -> Result<Self, Error>

👎Deprecated:

use generate_locked_keypair() instead

Available on crate feature protected only.

Returns a new randomly generated locked signing keypair.

Prefer generate_locked_keypair. This method is retained for compatibility.

Errors

Returns the same errors as generate_locked_keypair.

Panics

Panics under the same conditions as generate_locked_keypair.

impl SigningKeyPair<LockedRO<HeapByteArray<CRYPTO_SIGN_PUBLICKEYBYTES>>, LockedRO<HeapByteArray<CRYPTO_SIGN_SECRETKEYBYTES>>>

pub fn generate_readonly_locked_keypair() -> Result<Self, Error>

Available on crate feature protected only.

Returns a new randomly generated locked, read-only signing keypair.

Errors

Returns Error::Io if either allocation cannot be locked or its page permissions cannot be changed to read-only.

Panics

Panics if either page-aligned allocation cannot be created, its size cannot be represented with guard pages, or the operating system’s random number generator fails.

pub fn gen_readonly_locked_keypair() -> Result<Self, Error>

👎Deprecated:

use generate_readonly_locked_keypair() instead

Available on crate feature protected only.

Returns a new randomly generated locked, read-only signing keypair.

Prefer generate_readonly_locked_keypair. This method is retained for compatibility.

Errors

Returns the same errors as generate_readonly_locked_keypair.

Panics

Panics under the same conditions as generate_readonly_locked_keypair.

impl<PublicKey: NewByteArray<CRYPTO_SIGN_PUBLICKEYBYTES> + Zeroize, SecretKey: NewByteArray<CRYPTO_SIGN_SECRETKEYBYTES> + Zeroize> SigningKeyPair<PublicKey, SecretKey>

pub fn new() -> Self

Creates a new, empty signing keypair.

pub fn generate() -> Self

Generates a random signing keypair.

pub fn gen() -> Self

👎Deprecated:

use generate() instead

Generates a random signing keypair.

Prefer generate. gen is retained for compatibility with older Rust editions.

pub fn from_secret_key(secret_key: SecretKey) -> Self

Derives a signing keypair from secret_key, and consumes it, returning a new keypair.

pub fn from_seed<Seed: ByteArray<CRYPTO_SIGN_SEEDBYTES>>(seed: &Seed) -> Self

Derives a signing keypair from seed, returning a new keypair.

impl<PublicKey: ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES> + Zeroize, SecretKey: ByteArray<CRYPTO_SIGN_SECRETKEYBYTES> + Zeroize> SigningKeyPair<PublicKey, SecretKey>

pub fn to_seed<SeedOut: NewByteArray<CRYPTO_SIGN_SEEDBYTES>>(&self) -> SeedOut

Extracts the Ed25519 seed from this keypair’s secret key.

pub fn to_public_key<PublicKeyOut: NewByteArray<CRYPTO_SIGN_PUBLICKEYBYTES>>( &self, ) -> PublicKeyOut

Extracts the Ed25519 public key embedded in this keypair’s secret key.

impl SigningKeyPair<StackByteArray<CRYPTO_SIGN_PUBLICKEYBYTES>, StackByteArray<CRYPTO_SIGN_SECRETKEYBYTES>>

pub fn generate_with_defaults() -> Self

Randomly generates a new signing keypair, using default types (stack-allocated byte arrays). Provided for convenience.

pub fn gen_with_defaults() -> Self

👎Deprecated:

use generate_with_defaults() instead

Randomly generates a new signing keypair, using default types (stack-allocated byte arrays). Provided for convenience.

Prefer generate_with_defaults. This method is retained for compatibility.

impl<'a, PublicKey: ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES> + TryFrom<&'a [u8]> + Zeroize, SecretKey: ByteArray<CRYPTO_SIGN_SECRETKEYBYTES> + TryFrom<&'a [u8]> + Zeroize> SigningKeyPair<PublicKey, SecretKey>

pub fn from_slices( public_key: &'a [u8], secret_key: &'a [u8], ) -> Result<Self, Error>

Constructs a new signing keypair from key slices, consuming them. Does not check validity or authenticity of keypair.

Errors

Returns an error if either slice has the wrong length for its key type, or if the target key type rejects the key bytes.

impl<PublicKey: ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES> + Zeroize, SecretKey: ByteArray<CRYPTO_SIGN_SECRETKEYBYTES> + Zeroize> SigningKeyPair<PublicKey, SecretKey>

pub fn sign<Signature: NewByteArray<CRYPTO_SIGN_BYTES> + Zeroize, Message: Bytes + Zeroize>( &self, message: Message, ) -> Result<SignedMessage<Signature, Message>, Error>

Signs message using this keypair, consuming the message, and returning a new SignedMessage. The type of message should match that of the target signed message.

Errors

The fixed-size signature and secret-key types satisfy the current implementation’s requirements, so this function does not return an error for valid type implementations. The Result is retained for compatibility with the underlying signing API.

pub fn sign_with_defaults<Message: Bytes>( &self, message: Message, ) -> Result<SignedMessage<StackByteArray<CRYPTO_SIGN_BYTES>, Vec<u8>>, Error>

Signs message, putting the result into a Vec. Convenience wrapper for SigningKeyPair::sign.

Errors

The default fixed-size types satisfy the current implementation’s requirements, so this function does not return an error in normal use. The Result is retained for API compatibility.

Trait Implementations

impl<PublicKey: Clone + ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES> + Zeroize, SecretKey: Clone + ByteArray<CRYPTO_SIGN_SECRETKEYBYTES> + Zeroize> Clone for SigningKeyPair<PublicKey, SecretKey>

fn clone(&self) -> SigningKeyPair<PublicKey, SecretKey>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<PublicKey: ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES> + Zeroize, SecretKey: ByteArray<CRYPTO_SIGN_SECRETKEYBYTES> + Zeroize> Debug for SigningKeyPair<PublicKey, SecretKey>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SigningKeyPair<PublicKey, SecretKey>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, PublicKey, SecretKey> Deserialize<'de> for SigningKeyPair<PublicKey, SecretKey>

where PublicKey: Deserialize<'de> + ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES> + Zeroize, SecretKey: Deserialize<'de> + ByteArray<CRYPTO_SIGN_SECRETKEYBYTES> + Zeroize,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<PublicKey: ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES> + Zeroize, SecretKey: ByteArray<CRYPTO_SIGN_SECRETKEYBYTES> + Zeroize> Drop for SigningKeyPair<PublicKey, SecretKey>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl<PublicKey: ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES> + Zeroize, SecretKey: ByteArray<CRYPTO_SIGN_SECRETKEYBYTES> + Zeroize> PartialEq for SigningKeyPair<PublicKey, SecretKey>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<PublicKey, SecretKey> Serialize for SigningKeyPair<PublicKey, SecretKey>

where PublicKey: Serialize + ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES> + Zeroize, SecretKey: Serialize + ByteArray<CRYPTO_SIGN_SECRETKEYBYTES> + Zeroize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<PublicKey, SecretKey> Zeroize for SigningKeyPair<PublicKey, SecretKey>

where PublicKey: Zeroize + ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES>, SecretKey: Zeroize + ByteArray<CRYPTO_SIGN_SECRETKEYBYTES>,

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.