Struct CryptoSensitive 

pub struct CryptoSensitive<const N: usize> { /* private fields */ }

A cryptographic material represented in a cross-platform way, as a fixed-length array in a well-defined format.

Thus, it can be imported into any Crypto provider and exported from it without worrying about endianness or other platform-specific representation issues.

The reason for wrapping the array with a newtype is so that the following protection measures are taken:

• The material is not accidentally printed in logs or debug output.
• The material has a single access / access_mut method and deliberately does not implement Deref or AsRef traits to avoid accidental leakage.
• The material is zeroed out when dropped; note however that this has a limited use case, in Rust, because of the Rust move semantics.

Regarding sensitivity, rs-matter takes a radical approach and assumes that all cryptographic material is sensitive. Including, but not limited to:

• Secret keys (obviously)
• Signatures (because they can leak information about the secret key)
• Hashes (because they can be pre-images of sensitive data)
• Public keys (just in case)

Implementations

impl<const N: usize> CryptoSensitive<N>

pub const fn new() -> CryptoSensitive<N>

Create a new zeroed CryptoSensitive instance.

pub const fn new_from_ref( other: CryptoSensitiveRef<'_, N>, ) -> CryptoSensitive<N>

Create a new CryptoSensitive instance by loading data from the provided reference.

pub fn init() -> impl Init<CryptoSensitive<N>>

Return an in-place initializer for a zeroed CryptoSensitive instance.

pub fn zeroize(&mut self)

Zeroizes the cryptographic material held by this instance.

pub const fn reference(&self) -> CryptoSensitiveRef<'_, N>

Get a reference to this cryptographic material.

pub const fn load(&mut self, other: CryptoSensitiveRef<'_, N>)

Load data from another cryptographic material reference.

pub const fn load_from_array(&mut self, data: &[u8; N])

Load data from a byte array.

pub fn try_load_from_slice(&mut self, data: &[u8]) -> Result<(), Error>

Try to load data from a byte slice.

Returns an error if the slice length does not match the expected length.

pub const fn access(&self) -> &[u8; N]

Access the underlying data as a byte array reference.

NOTE: care should be taken when using this method, as it exposes the sensitive data.

pub const fn access_mut(&mut self) -> &mut [u8; N]

Access the underlying data as a mutable byte array reference.

NOTE: care should be taken when using this method, as it exposes the sensitive data.

Trait Implementations

impl<const N: usize> Clone for CryptoSensitive<N>

fn clone(&self) -> CryptoSensitive<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: usize> Debug for CryptoSensitive<N>

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

Formats the value using the given formatter.

impl<const N: usize> Default for CryptoSensitive<N>

fn default() -> CryptoSensitive<N>

Returns the “default value” for a type.

impl<const N: usize> Drop for CryptoSensitive<N>

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<'a, const N: usize> From<&'a CryptoSensitive<N>> for CryptoSensitiveRef<'a, N>

fn from(cs: &'a CryptoSensitive<N>) -> CryptoSensitiveRef<'a, N>

Converts to this type from the input type.

impl<const N: usize> From<&[u8; N]> for CryptoSensitive<N>

fn from(data: &[u8; N]) -> CryptoSensitive<N>

Converts to this type from the input type.

impl<const N: usize> From<CryptoSensitiveRef<'_, N>> for CryptoSensitive<N>

fn from(other: CryptoSensitiveRef<'_, N>) -> CryptoSensitive<N>

Converts to this type from the input type.

impl<const N: usize> From<[u8; N]> for CryptoSensitive<N>

fn from(data: [u8; N]) -> CryptoSensitive<N>

Converts to this type from the input type.

impl<'a, const N: usize> FromTLV<'a> for CryptoSensitive<N>

fn from_tlv(element: &TLVElement<'a>) -> Result<CryptoSensitive<N>, Error>

Deserialize the type from a TLV-encoded element.

fn init_from_tlv( element: TLVElement<'a>, ) -> impl Init<CryptoSensitive<N>, Error>

Generate an in-place initializer for the type that initializes the type from a TLV-encoded element.

fn nullable_from_tlv(element: &TLVElement<'a>) -> Result<Self, Error>

Deserialize the type from a TLV-encoded element.

fn init_nullable_from_tlv(element: TLVElement<'a>) -> impl Init<Self, Error>

Generate an in-place initializer for the type that initializes the type from a TLV-encoded element.

impl<const N: usize> ToTLV for CryptoSensitive<N>

fn to_tlv<W>(&self, tag: &TLVTag, tw: W) -> Result<(), Error>

where W: TLVWrite,

Serialize the type to a TLV-encoded stream.

fn tlv_iter(&self, tag: TLVTag) -> impl Iterator<Item = Result<TLV<'_>, Error>>

Serialize the type as an iterator of TLV instances by potentially borrowing data from the type.

fn nullable_to_tlv<W>(&self, tag: &TLVTag, tw: W) -> Result<(), Error>

where W: TLVWrite,

Serialize the type to a TLV-encoded stream.

fn nullable_tlv_iter( &self, tag: TLVTag, ) -> impl Iterator<Item = Result<TLV<'_>, Error>>

Serialize the type as an iterator of TLV instances by potentially borrowing data from the type.

impl<const N: usize> TryFrom<&[u8]> for CryptoSensitive<N>

type Error = Error

The type returned in the event of a conversion error.

fn try_from( data: &[u8], ) -> Result<CryptoSensitive<N>, <CryptoSensitive<N> as TryFrom<&[u8]>>::Error>

Performs the conversion.