Struct seckey::SecKey

pub struct SecKey<T: ?Sized> { /* fields omitted */ }

Secure Key

The use memsec/malloc protection secret bytes.

Note that this does not protect data outside of the secure heap.

More docs see Secure memory · libsodium.

Methods

impl<T> SecKey<T>

pub fn new(t: T) -> Result<SecKey<T>, T>

use seckey::{ free, SecKey };

let k = SecKey::new([1, 2, 3])
    .unwrap_or_else(|mut val| {
        // NOTE should zero it
        free(val);
        panic!()
    });
assert_eq!([1, 2, 3], *k.read());

pub unsafe fn from_ptr(t: *const T) -> Option<SecKey<T>>

use seckey::SecKey;

let mut v = [1, 2, 3];
let k = unsafe { SecKey::from_ptr(&v).unwrap() };
assert_eq!([1, 2, 3], v);
assert_eq!([1, 2, 3], *k.read());

pub unsafe fn with<F>(f: F) -> Option<SecKey<T>> where
    F: FnOnce(*mut T), 

use seckey::SecKey;

let k: SecKey<u32> = unsafe { SecKey::with(|ptr| *ptr = 1).unwrap() };
assert_eq!(1, *k.read());

impl<T: Copy> SecKey<T>

pub fn from_ref(t: &T) -> Option<SecKey<T>>

impl<T: Default> SecKey<T>

pub fn with_default<F>(f: F) -> Option<SecKey<T>> where
    F: FnOnce(&mut T), 

use seckey::SecKey;

let k: SecKey<u32> = SecKey::with_default(|ptr| *ptr += 1).unwrap();
assert_eq!(1, *k.read());

impl SecKey<[u8]>

pub fn from_bytes(src: &mut [u8]) -> Option<SecKey<[u8]>>

On success src is zeroed and a new protected SecKey<[u8]> is returned. On failure src remains untouched and None is returned.

use seckey::SecKey;

let mut unprotected = [1u8; 2];
let k = SecKey::from_bytes(&mut unprotected[..]).unwrap();

assert_eq!(unprotected, [0u8; 2]);
assert_eq!(*k.read(), [1u8; 2]);

impl SecKey<str>

pub fn from_str(src: &mut str) -> Option<SecKey<str>>

On success src is zeroed and a new protected SecKey<str> is returned. On failure src remains untouched and None is returned.

use seckey::SecKey;

let mut unprotected = "abc".to_string();
let k = SecKey::from_str(&mut unprotected).unwrap();

assert_eq!(&unprotected, "\0\0\0");
assert_eq!(&*k.read(), "abc");

impl<T: ?Sized> SecKey<T>

pub fn read(&self) -> SecReadGuard<T>

Borrow Read

use seckey::SecKey;

let secpass = SecKey::new([8u8; 8]).unwrap();
assert_eq!([8u8; 8], *secpass.read());

pub fn write(&mut self) -> SecWriteGuard<T>

Borrow Write

let mut wpass = secpass.write();
wpass[0] = 0;
assert_eq!([0, 8, 8, 8, 8, 8, 8, 8], *wpass);

Trait Implementations

impl<T: ?Sized> Debug for SecKey<T>

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

Formats the value using the given formatter.

impl<T: ?Sized> Drop for SecKey<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T: ?Sized> Pointer for SecKey<T>

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

Formats the value using the given formatter.