Struct dryoc::sign::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 nightly only.

Returns a new locked signing keypair.

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

Available on crate feature nightly only.

Returns a new randomly generated locked signing keypair.

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

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

Available on crate feature nightly only.

Returns a new randomly generated locked, read-only signing 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 gen() -> Self

Generates a random signing keypair.

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 SigningKeyPair<StackByteArray<CRYPTO_SIGN_PUBLICKEYBYTES>, StackByteArray<CRYPTO_SIGN_SECRETKEYBYTES>>

pub fn gen_with_defaults() -> Self

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

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.

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.

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.

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 copy of the value.

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

Performs copy-assignment from source.

impl<PublicKey: Debug + ByteArray<CRYPTO_SIGN_PUBLICKEYBYTES> + Zeroize, SecretKey: Debug + 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.

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

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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.