Struct SecretBox 

pub struct SecretBox<S: Zeroize> {
    inner_secret: Box<S>,
}

Wrapper type for values that contains secrets.

It attempts to limit accidental exposure and ensure secrets are wiped from memory when dropped. (e.g. passwords, cryptographic keys, access tokens or other credentials)

Access to the secret inner value occurs through the ExposeSecret or ExposeSecretMut traits, which provide methods for accessing the inner secret value.

Fields

inner_secret: Box<S>

Implementations

impl<S: Zeroize> SecretBox<S>

pub fn new(boxed_secret: Box<S>) -> Self

Create a secret value using a pre-boxed value.

impl<S: Zeroize + Default> SecretBox<S>

pub fn new_with_mut(ctr: impl FnOnce(&mut S)) -> Self

Create a secret value using a function that can initialize the vale in-place.

impl<S: Zeroize + Clone> SecretBox<S>

pub fn new_with_ctr(ctr: impl FnOnce() -> S) -> Self

Create a secret value using the provided function as a constructor.

The implementation makes an effort to zeroize the locally constructed value before it is copied to the heap, and constructing it inside the closure minimizes the possibility of it being accidentally copied by other code.

Note: using Self::new or Self::new_with_mut is preferable when possible, since this method’s safety relies on empyric evidence and may be violated on some targets.

pub fn try_new_with_ctr<E>( ctr: impl FnOnce() -> Result<S, E>, ) -> Result<Self, E>

Same as Self::new_with_ctr, but the constructor can be fallible.

Note: using Self::new or Self::new_with_mut is preferable when possible, since this method’s safety relies on empyric evidence and may be violated on some targets.

Trait Implementations

impl<S> Clone for SecretBox<S>

where S: Clone + Zeroize,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Zeroize> Debug for SecretBox<S>

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

Formats the value using the given formatter.

impl<S: Zeroize + Default> Default for SecretBox<S>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for SecretBox<T>

where T: Zeroize + Clone + DeserializeOwned + Sized,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: Zeroize> Drop for SecretBox<S>

fn drop(&mut self)

Executes the destructor for this type.

impl<S: Zeroize> ExposeSecret<S> for SecretBox<S>

fn expose_secret(&self) -> &S

Expose secret: this is the only method providing access to a secret.

impl<S: Zeroize> ExposeSecretMut<S> for SecretBox<S>

fn expose_secret_mut(&mut self) -> &mut S

Expose secret: this is the only method providing access to a secret.

impl<S: Zeroize> From<Box<S>> for SecretBox<S>

fn from(source: Box<S>) -> Self

Converts to this type from the input type.

impl<S> PartialEq for SecretBox<S>

where S: PartialEq + Zeroize,

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T> Serialize for SecretBox<T>

where T: Zeroize + SerializableSecret + Serialize + Sized,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<S: Zeroize> Zeroize for SecretBox<S>

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<S: Zeroize> ZeroizeOnDrop for SecretBox<S>