Enum PrivateKey 

#[non_exhaustive]
pub enum PrivateKey {
    Ed25519(SigningKey),
}

Algorithm-agnostic signing key for creating signatures.

Wraps algorithm-specific signing key types in a single enum. Secret material is volatile-zeroed on drop via the inner key types’ [ZeroizeOnDrop] implementations.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Ed25519(SigningKey)

Ed25519 signing key (32 bytes)

Implementations

impl PrivateKey

pub fn sign(&self, data: &[u8]) -> Vec<u8>

Sign the given data and return the raw signature bytes.

pub fn public_key(&self) -> PublicKey

Derive the corresponding public key.

pub fn generate() -> Self

Generate a new key using the default algorithm (Ed25519).

pub fn to_bytes(&self) -> Zeroizing<Vec<u8>>

Export the raw key bytes (for encryption/storage).

The returned buffer is wrapped in [Zeroizing] so the key material is automatically cleared from memory when dropped.

pub fn from_bytes(algorithm: &str, bytes: &[u8]) -> Result<Self, AuthError>

Reconstruct a private key from raw bytes and an algorithm identifier.

pub fn to_prefixed_string(&self) -> Zeroizing<String>

Format the private key as a prefixed string (e.g. "ed25519:base64...").

The returned string is wrapped in [Zeroizing] so the key material is automatically cleared from memory when dropped.

pub fn from_prefixed_string(s: &str) -> Result<Self, AuthError>

Parse a private key from a prefixed string (e.g. "ed25519:base64...").

pub fn algorithm(&self) -> &'static str

Get the algorithm name for this key.

Trait Implementations

impl Clone for PrivateKey

fn clone(&self) -> PrivateKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PrivateKey

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PrivateKey

Deserializes from the prefixed string format (e.g. "ed25519:base64...").

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl From<PrivateKey> for DatabaseKey

fn from(signing_key: PrivateKey) -> Self

Convert a PrivateKey into a DatabaseKey with pubkey-derived identity.

This is equivalent to DatabaseKey::new and covers the most common case where the key’s identity in auth settings is its own public key.

impl Serialize for PrivateKey

Serializes as the prefixed string format (e.g. "ed25519:base64...").

fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>

Serialize this value into the given Serde serializer.

impl ZeroizeOnDrop for PrivateKey

Zeroization is handled by the inner key types’ Drop impls. For Ed25519, the zeroize feature on ed25519-dalek ensures SigningKey::Drop uses volatile writes to clear the secret bytes.

Invariant: all inner key types must implement [ZeroizeOnDrop].