Struct SecretKey 

pub struct SecretKey(/* private fields */);

A secret key for Ed25519 digital signatures

Used to create signatures that can be verified with the corresponding PublicKey. The secret key must be kept private to maintain security.

Properties

• Size: 64 bytes (512 bits)
• Contains both the secret scalar (32 bytes) and the public key (32 bytes)
• Must be kept confidential
• Used to sign messages

Security Considerations

The secret key is the most sensitive component in the digital signature system. If compromised, an attacker can create valid signatures for any message, impersonating the legitimate owner of the key.

Best practices for secret key management:

• Store secret keys in secure, encrypted storage
• Consider using hardware security modules (HSMs) for high-security applications
• Implement proper access controls to limit who can use the signing key
• Rotate keys periodically according to your security policy
• Have a revocation plan in case a key is compromised

Usage

use libsodium_rs as sodium;
use sodium::crypto_sign;
use sodium::ensure_init;

// Initialize libsodium
ensure_init().expect("Failed to initialize libsodium");

// Generate a key pair
let keypair = crypto_sign::KeyPair::generate().unwrap();
let secret_key = keypair.secret_key;

// Sign a message
let message = b"Important document";
let signature = crypto_sign::sign_detached(message, &secret_key).unwrap();

// In a real application, you would securely store the secret key
// and implement proper key management procedures

Implementations

impl SecretKey

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

Generate a new secret key from bytes

Arguments

• bytes - The bytes to create the secret key from

Returns

• Result<Self> - The secret key or an error if the input is invalid

Errors

Returns an error if the input is not exactly SECRETKEYBYTES bytes long

pub fn as_bytes(&self) -> &[u8; 64]

Get the bytes of the secret key

Returns

• &[u8; SECRETKEYBYTES] - A reference to the secret key bytes

pub const fn from_bytes_exact(bytes: [u8; 64]) -> Self

Create a secret key from a fixed-size byte array

Arguments

• bytes - Byte array of exactly SECRETKEYBYTES length

Returns

• Self - A new secret key

Trait Implementations

impl AsRef<[u8]> for SecretKey

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for SecretKey

fn clone(&self) -> SecretKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SecretKey

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

Formats the value using the given formatter.

impl Display for SecretKey

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

Formats the value using the given formatter.

impl Drop for 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 Eq for SecretKey

impl From<SecretKey> for [u8; 64]

fn from(key: SecretKey) -> [u8; 64]

Converts to this type from the input type.

impl From<[u8; 64]> for SecretKey

fn from(bytes: [u8; 64]) -> Self

Converts to this type from the input type.

impl PartialEq for SecretKey

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for SecretKey

impl TryFrom<&[u8]> for SecretKey

type Error = SodiumError

The type returned in the event of a conversion error.

fn try_from(bytes: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

impl Zeroize for SecretKey

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.