Struct Sensitive 

pub struct Sensitive<T>(pub(crate) T);

A wrapper type that marks the inner value as secret. This is used to prevent accidental logging of secrets by overriding the Debug and Display implementations to redact the value. This redaction can be bypassed by enabling the dangerous-crypto-debug feature.

Tuple Fields

0: T

Trait Implementations

impl<T> Clone for Sensitive<T>

where T: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Sensitive<T>

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

Formats the value using the given formatter.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for Sensitive<T>

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

Deserialize this value from the given Serde deserializer.

impl<T: Display> Display for Sensitive<T>

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

Formats the value using the given formatter.

impl<T> ExposeSensitive for Sensitive<T>

fn expose(&self) -> &T

Explicitly borrow the wrapped value. This exposes the secret to logging. This should be used exactly only when interacting with APIs we do not control. Each usage of expose MUST have a comment justifying why it is necessary and acknowledging that the appropriate checks have been performed.

use bitwarden_sensitive_value::{ExposeSensitive, Sensitive};
fn hash_password(password: &Sensitive<String>) -> [u8; 32] {
   // EXPOSE: We need to pass the password to pbkdf2, because `pbkdf2` does not support the
   // sensitive type and is an external crate. It is safe to do so because the library does
   // not log data.
   let exposed = password.expose();
   pbkdf2(exposed.as_bytes(), b"salt", 100_000)
}

fn expose_owned(self) -> T

Consume the wrapper and return the inner value. This exposes the secret to logging.

type Exposed = T

The type of the inner value that is being wrapped. This is used to define the return type of the expose and expose_owned methods.

impl From<&str> for Sensitive<String>

fn from(value: &str) -> Self

Converts to this type from the input type.

impl<T> From<T> for Sensitive<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T> PartialEq for Sensitive<T>

where T: PartialEq,

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> Serialize for Sensitive<T>

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

Serialize this value into the given Serde serializer.