Struct memsecurity::ZeroizeArray

pub struct ZeroizeArray<const N: usize>(/* private fields */);

This is a array whose size is specified as a const generic N and can be zeroed out when dropped from memory. This array is useful when specifying fixed size bytes like passwords which need to be zeroed out from memory before being dropped.

Structure

pub struct ZeroizeArray<const N: usize>([u8; N]);

Implementations

impl<const N: usize> ZeroizeArray<N>

pub fn new(value: [u8; N]) -> Self

Initialize a ZeroizeArray with the value of specified by the array of bytes

pub fn new_zeroed() -> Self

Initialize a new array which is zeroed bytes of len N as specified by the generic const N: usize

pub fn fill_from_array(self, value: [u8; N]) -> Self

File the current array with new values specified by the method parameter value: [u8; N]

pub fn fill_from_array_borrowed(&mut self, value: [u8; N]) -> &mut Self

Fill the current array with new values specified by the method parameter value: [u8; N] but returing a &mut Self

pub fn new_from_slice(value: &[u8]) -> MemSecurityResult<Self>

Create array with new values specified by the method parameter value: [u8; N]

pub fn fill_from_slice(self, value: &[u8]) -> MemSecurityResult<Self>

Fill the current array with new values specified by the method parameter value: [u8; N]

pub fn fill_from_slice_borrowed( &mut self, value: &[u8] ) -> MemSecurityResult<&mut Self>

File the current array with new values specified by the method parameter value: [u8; N]

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

Expose the internal as an borrowed array

pub fn own(self) -> Self

Own this array

pub fn insert(&mut self, index: usize, value: u8) -> &mut Self

Insert a value at index specified in the array

Trait Implementations

impl<const N: usize> AsRef<[u8]> for ZeroizeArray<N>

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

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

impl<const N: usize> BorshDeserialize for ZeroizeArray<N>

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl<const N: usize> BorshSerialize for ZeroizeArray<N>

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

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

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.

impl<const N: usize> PartialEq for ZeroizeArray<N>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl ToBlake3Hash for ZeroizeArray<12>

fn hash(&self) -> Hash

The outcome of hashing Self with blake3::hash

impl ToBlake3Hash for ZeroizeArray<128>

fn hash(&self) -> Hash

The outcome of hashing Self with blake3::hash

impl ToBlake3Hash for ZeroizeArray<16>

fn hash(&self) -> Hash

The outcome of hashing Self with blake3::hash

impl ToBlake3Hash for ZeroizeArray<24>

fn hash(&self) -> Hash

The outcome of hashing Self with blake3::hash

impl ToBlake3Hash for ZeroizeArray<32>

fn hash(&self) -> Hash

The outcome of hashing Self with blake3::hash

impl ToBlake3Hash for ZeroizeArray<64>

fn hash(&self) -> Hash

The outcome of hashing Self with blake3::hash

impl ToBlake3Hash for ZeroizeArray<8>

fn hash(&self) -> Hash

The outcome of hashing Self with blake3::hash

impl ToBlake3Hash for ZeroizeArray<96>

fn hash(&self) -> Hash

The outcome of hashing Self with blake3::hash

impl<const N: usize> Zeroize for ZeroizeArray<N>

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.

impl<const N: usize> Eq for ZeroizeArray<N>

impl<const N: usize> ZeroizeOnDrop for ZeroizeArray<N>