Trait SecretAccess 

pub trait SecretAccess<T: Zeroize + ?Sized> {
    // Required methods
    fn access<F, R>(&self, f: F) -> R
       where F: FnOnce(&T) -> R;
    fn access_mut<F, R>(&mut self, f: F) -> R
       where F: FnOnce(&mut T) -> R;
}

Available on Unix and crate feature sec_mem only.

Trait for types that can provide access to underlying data, whether protected or raw

Required Methods

fn access<F, R>(&self, f: F) -> R

where F: FnOnce(&T) -> R,

Access the underlying data for reading

fn access_mut<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut T) -> R,

Access the underlying data for mutation

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl SecretAccess<[u8]> for &[u8]

fn access<F, R>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

fn access_mut<F, R>(&mut self, _f: F) -> R

where F: FnOnce(&mut [u8]) -> R,

impl SecretAccess<[u8]> for &mut [u8]

fn access<F, R>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

fn access_mut<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut [u8]) -> R,

impl SecretAccess<[u8]> for Box<[u8]>

fn access<F, R>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

fn access_mut<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut [u8]) -> R,

impl<T: Zeroize, const N: usize> SecretAccess<[T; N]> for [T; N]

fn access<F, R>(&self, f: F) -> R

where F: FnOnce(&[T; N]) -> R,

fn access_mut<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut [T; N]) -> R,

impl<T: Zeroize> SecretAccess<T> for Box<T>

fn access<F, R>(&self, f: F) -> R

where F: FnOnce(&T) -> R,

fn access_mut<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut T) -> R,

impl<T: Zeroize> SecretAccess<[T]> for Vec<T>

where [T]: Zeroize,

fn access<F, R>(&self, f: F) -> R

where F: FnOnce(&[T]) -> R,

fn access_mut<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut [T]) -> R,

impl<T: Zeroize> SecretAccess<[T]> for [T]

where [T]: Zeroize,

fn access<F, R>(&self, f: F) -> R

where F: FnOnce(&[T]) -> R,

fn access_mut<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut [T]) -> R,

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

fn access<F, R>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

fn access_mut<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut [u8]) -> R,

Implementors

impl SecretAccess<[u8]> for SecMem<Vec<u8>>

impl<T: Zeroize> SecretAccess<T> for SecMem<T>

impl<const N: usize> SecretAccess<[u8]> for SecMem<[u8; N]>