Struct SecretKey

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

Symmetric encryption/decryption secret key.

Note: this implementation tries to prevent certain types of attacks by making sure the underlying sensitive key material is always stored at most in one place. This is achieved by putting it on the heap which means it is not moved when the key itself is moved which could otherwise leave a copy of the data in memory. Additionally, the data is behind a Arc which means the key can be cheaply cloned without actually cloning the data. Finally, the data is scrambled (overwritten with zeros) when the key is dropped to make sure it does not stay in the memory past its lifetime.

Implementations

impl SecretKey

pub const SIZE: usize = 32usize

Size of the key in bytes.

pub fn parse_hex(hex_str: &str) -> Result<Self, FromHexError>

Parse secret key from hexadecimal string of size 2*SIZE.

pub fn generate<R: Rng + CryptoRng + ?Sized>(rng: &mut R) -> Self

Generate a random secret key using the given cryptographically secure random number generator.

Note: this is purposefully not implemented as impl Distribution<SecretKey> for Standard to enforce the additional CryptoRng bound.

pub fn random() -> Self

Generate a random secret key using the default RNG.

pub fn derive_from_key(master_key: &[u8; 32], nonce: &[u8]) -> Self

Derive a secret key from another secret key and a nonce.

pub fn random_salt() -> PasswordSalt

pub fn derive_from_password(user_password: &str, salt: &PasswordSalt) -> Self

Derive a secret key from user’s password and salt.

pub fn as_array(&self) -> &[u8; 32]

Note this method is somewhat dangerous because if used carelessly the underlying sensitive data can be copied or revealed.

Trait Implementations

impl AsRef<[u8]> for SecretKey

Note this trait is somewhat dangerous because if used carelessly the underlying sensitive data can be copied or revealed.

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 copy 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<'de> Deserialize<'de> for SecretKey

fn deserialize<D>(d: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for SecretKey

Note this impl uses constant-time operations (using subtle) and so provides protection against software side-channel attacks.

fn eq(&self, other: &Self) -> 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 Serialize for SecretKey

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&[u8]> for SecretKey

type Error = SecretKeyLengthError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Eq for SecretKey