Struct DehydratedDeviceKey

pub struct DehydratedDeviceKey { /* private fields */ }

The pickle key used to safely store the dehydrated device pickle.

This input key material will be expanded using HKDF into an AES key, MAC key, and an initialization vector (IV).

Implementations

impl DehydratedDeviceKey

pub const KEY_SIZE: usize = 32usize

The number of bytes the encryption key will hold.

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

Generates a new random pickle key.

pub fn from_slice(slice: &[u8]) -> Result<Self, DehydrationError>

Creates a new dehydration pickle key from the given slice.

Fail if the slice length is not 32.

pub fn from_bytes(raw_key: &[u8; 32]) -> Self

Creates a dehydration pickle key from the given bytes.

pub fn to_base64(&self) -> String

Export the DehydratedDeviceKey as a base64 encoded string.

Trait Implementations

impl Clone for DehydratedDeviceKey

fn clone(&self) -> DehydratedDeviceKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DehydratedDeviceKey

Available on non-tarpaulin_include only.

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DehydratedDeviceKey

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Drop for DehydratedDeviceKey

fn drop(&mut self)

Executes the destructor for this type.

impl From<&[u8; 32]> for DehydratedDeviceKey

fn from(value: &[u8; 32]) -> Self

Converts to this type from the input type.

impl From<DehydratedDeviceKey> for Vec<u8>

fn from(key: DehydratedDeviceKey) -> Self

Converts to this type from the input type.

impl Serialize for DehydratedDeviceKey

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Zeroize for DehydratedDeviceKey

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.