Secrecy

https://docs.rs/secrecy
Admin
Secrecy provides a SecretBox wrapper type for carefully handling sensitive values like passwords,...
Tokens:13,217
Snippets:214
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Get TypeId of SecretBox

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Retrieves the `TypeId` of the SecretBox. This is part of the `Any` trait implementation, useful for dynamic type checking.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### ExposeSecret Trait Definition

Source: https://docs.rs/secrecy/latest/src/secrecy/lib.rs.html

Defines the `ExposeSecret` trait, which provides a method to get a read-only reference to the inner secret. This is the primary mechanism for accessing secret data.

```rust
pub trait ExposeSecret<S: ?Sized> {
    /// Expose secret: this is the only method providing access to a secret.
    fn expose_secret(&self) -> &S;
}
```

--------------------------------

### SecretBox::try_init_with

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Safely creates a SecretBox using a fallible constructor function. This is similar to `init_with` but handles potential errors during construction.

```APIDOC
## SecretBox::try_init_with

### Description
Same as `Self::init_with`, but the constructor can be fallible.

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

### Signature
`pub fn try_init_with<E>(ctr: impl FnOnce() -> Result<S, E>) -> Result<Self, E>`

### Parameters
* `ctr` (impl FnOnce() -> Result<S, E>) - A closure that returns a `Result` containing the secret value or an error.

### Returns
* `Result<Self, E>` - A `Result` containing the initialized `SecretBox` or an error if construction failed.
```

--------------------------------

### SecretBox::new

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Creates a new SecretBox with a pre-boxed secret value. This is a direct and preferred method for initialization.

```APIDOC
## SecretBox::new

### Description
Create a secret value using a pre-boxed value.

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

### Parameters
* `boxed_secret` (Box<S>) - The secret value to be wrapped in a SecretBox.
```

--------------------------------

### SecretBox::init_with

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Creates a SecretBox using a constructor function. This method attempts to zeroize the locally constructed value before copying it to the heap.

```APIDOC
## SecretBox::init_with

### Description
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::init_with_mut` is preferable when possible, since this method’s safety relies on empiric evidence and may be violated on some targets.

### Signature
`pub fn init_with(ctr: impl FnOnce() -> S) -> Self`

### Parameters
* `ctr` (impl FnOnce() -> S) - A closure that returns the secret value to be constructed.
```

--------------------------------

### Initialize SecretBox with Constructor

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Creates a SecretBox using a constructor function. The implementation attempts to zeroize the locally constructed value before copying. Prefer `new` or `init_with_mut` when possible.

```rust
pub fn init_with(ctr: impl FnOnce() -> S) -> Self>
```

--------------------------------

### Try Initialize SecretBox with Fallible Constructor

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Similar to init_with, but allows the constructor function to return a Result, handling potential errors during secret creation.

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

--------------------------------

### Initialize SecretBox with Constructor

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Creates a secret value using a provided constructor function. The implementation attempts to zeroize the value before it's moved to the heap.

```rust
pub fn init_with(ctr: impl FnOnce() -> S) -> Self
```

--------------------------------

### Create SecretBox with Constructor Function

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Initializes a SecretBox using a closure that returns the secret value. The implementation attempts to zeroize the value before copying to minimize exposure.

```rust
pub fn init_with(ctr: impl FnOnce() -> S) -> Self

```

--------------------------------

### SecretBox::try_init_with constructor

Source: https://docs.rs/secrecy/0.10.3/src/secrecy/lib.rs.html

A fallible version of `init_with` that handles potential errors during secret construction.

```rust
pub fn try_init_with<E>(ctr: impl FnOnce() -> Result<S, E>) -> Result<Self, E> {
    let mut data = ctr()?;
    let secret = Self {
        inner_secret: Box::new(data.clone()),
    };

```

--------------------------------

### Create Fallible SecretBox with Constructor Function

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Similar to init_with, but allows the constructor closure to return a Result, enabling fallible secret creation.

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

```

--------------------------------

### clone_to_uninit

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`.

### Method
unsafe fn

### Parameters
#### Path Parameters
- **dest** (*mut u8) - Required - The destination pointer to copy to.

### Note
This is a nightly-only experimental API.
```

--------------------------------

### SecretBox::init_with constructor

Source: https://docs.rs/secrecy/0.10.3/src/secrecy/lib.rs.html

Constructs a SecretBox using a closure that returns the secret value. It attempts to securely zeroize the temporary value.

```rust
pub fn init_with(ctr: impl FnOnce() -> S) -> Self {
    let mut data = ctr();
    let secret = Self {
        inner_secret: Box::new(data.clone()),
    };
    data.zeroize();
    secret
}
```

--------------------------------

### Create SecretBox from Pre-boxed Value

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Constructs a SecretBox directly from an existing Box<S>, useful when the secret value is already boxed.

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

```

--------------------------------

### Create SecretBox with In-place Initialization

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Initializes a SecretBox using a closure that can modify the secret value in-place. This is often preferred for efficiency.

```rust
pub fn init_with_mut(ctr: impl FnOnce(&mut S)) -> Self

```

--------------------------------

### Initialize SecretBox In-Place

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Creates a SecretBox by initializing a mutable secret value in-place using a provided closure. This is preferred for safety.

```rust
pub fn init_with_mut(ctr: impl FnOnce(&mut S)) -> Self>
```

--------------------------------

### into

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Calls `U::from(self)`. This conversion is determined by the implementation of `From<T> for U`.

```APIDOC
## fn into(self) -> U

### Description
Calls `U::from(self)`. This conversion is whatever the implementation of `From<T> for U` chooses to do.

### Method
fn

### Returns
- U - The result of the conversion.
```

--------------------------------

### SecretBox::init_with_mut

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Initializes a SecretBox using a mutable closure to set the secret value in-place. This is a preferred initialization method.

```APIDOC
## SecretBox::init_with_mut

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

### Signature
`pub fn init_with_mut(ctr: impl FnOnce(&mut S)) -> Self`

### Parameters
* `ctr` (impl FnOnce(&mut S)): A closure that takes a mutable reference to the secret and initializes it.
```

--------------------------------

### Serialize Implementation for SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Enables serialization of SecretBox to various formats using the Serde library. Requires the 'serde' feature flag.

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

```

--------------------------------

### Initialize SecretBox In-Place

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Creates a secret value by initializing it in-place using a mutable reference within a closure. This is often preferred for safety.

```rust
pub fn init_with_mut(ctr: impl FnOnce(&mut S)) -> Self
```

--------------------------------

### SecretBox::new constructor

Source: https://docs.rs/secrecy/0.10.3/src/secrecy/lib.rs.html

Creates a new SecretBox instance from a pre-boxed secret value.

```rust
pub fn new(boxed_secret: Box<S>) -> Self {
    Self {
        inner_secret: boxed_secret,
    }
}
```

--------------------------------

### Create SecretString from &str

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Shows how to create a SecretString from a string slice using the From<&str> trait implementation.

```rust
fn from(s: &str) -> Self
```

--------------------------------

### Create SecretString from String

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Demonstrates the preferred method for constructing a SecretString from a standard String using the From<String> trait implementation.

```rust
fn from(s: String) -> Self
```

--------------------------------

### try_from

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Performs the conversion from U to T. Returns a Result indicating success or failure.

```APIDOC
## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion from `value`.

### Method
fn

### Parameters
#### Path Parameters
- **value** (U) - Required - The value to convert.

### Returns
- Result<T, <T as TryFrom<U>>::Error> - A Result containing the converted value or an error.
```

--------------------------------

### SecretBox Default Implementation

Source: https://docs.rs/secrecy/latest/src/secrecy/lib.rs.html

Provides a default implementation for SecretBox, initializing the inner secret with its default value. This is useful when a default, zeroed state is required.

```rust
impl<S: Zeroize + Default> Default for SecretBox<S> {
    fn default() -> Self {
        Self {
            inner_secret: Box::<S>::default(),
        }
    }
}
```

--------------------------------

### From<Box<S>> Implementation for SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Enables conversion of a Box<S> into a SecretBox<S>, providing another way to construct secret boxes.

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

```

--------------------------------

### clone_into

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Uses borrowed data to replace owned data, usually by cloning.

```APIDOC
## fn clone_into(&self, target: &mut T)

### Description
Uses borrowed data to replace owned data, usually by cloning.

### Method
fn

### Parameters
#### Path Parameters
- **target** (&mut T) - Required - The mutable reference to the owned data to be replaced.
```

--------------------------------

### Serialize SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Implementation for serializing a SecretBox using Serde. Requires the 'serde' feature flag and that the inner type T implements Serialize.

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

--------------------------------

### ZeroizeOnDrop Implementation for SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Indicates that SecretBox instances will have their memory zeroized automatically upon dropping, enhancing security.

```rust
impl<S: Zeroize + ?Sized> ZeroizeOnDrop for SecretBox<S>

```

--------------------------------

### try_into

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Performs the conversion from T to U. Returns a Result indicating success or failure.

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion.

### Method
fn

### Returns
- Result<U, <U as TryFrom<T>>::Error> - A Result containing the converted value or an error.
```

--------------------------------

### ExposeSecretMut Implementation for SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Provides a method to expose the secret value mutably, allowing for in-place modification of the secret data.

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

```

--------------------------------

### from

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Returns the argument unchanged. This is a conversion from type T to type T.

```APIDOC
## fn from(t: T) -> T

### Description
Returns the argument unchanged.

### Method
fn

### Parameters
#### Path Parameters
- **t** (T) - Required - The value to return.

### Returns
- T - The argument `t`.
```

--------------------------------

### SecretBox::init_with_mut

Source: https://docs.rs/secrecy/latest/src/secrecy/lib.rs.html

Initializes a SecretBox with a mutable reference to the secret value, allowing in-place modification during initialization. Requires the secret type `S` to implement `Default`.

```APIDOC
## SecretBox::init_with_mut

### Description
Initializes a `SecretBox` with a mutable reference to the secret value, allowing in-place modification during initialization. Requires the secret type `S` to implement `Default`.

### Method

```rust
pub fn init_with_mut(ctr: impl FnOnce(&mut S)) -> Self
```

### Parameters

*   **ctr** (`impl FnOnce(&mut S)`) - A closure that takes a mutable reference to the secret value and performs initialization.

### Returns

A new `SecretBox<S>` instance initialized by the provided closure.
```

--------------------------------

### Deserialize Implementation for SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Enables deserialization of SecretBox from various formats using the Serde library. Requires the 'serde' feature flag.

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

```

--------------------------------

### Clone SecretString

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Illustrates how to create a duplicate of a SecretString value using the Clone trait.

```rust
fn clone(&self) -> Self
```

--------------------------------

### SecretBox Implementations for SecretString

Source: https://docs.rs/secrecy/latest/secrecy/type.SecretString.html

Provides methods for creating and managing secret values within SecretBox, which SecretString utilizes.

```APIDOC
## Implementations for SecretBox<S>

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

#### `pub fn init_with(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::init_with_mut` is preferable when possible, since this method’s safety relies on empiric evidence and may be violated on some targets.

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

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

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

### `impl<S: Zeroize + ?Sized> 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 init_with_mut(ctr: impl FnOnce(&mut S)) -> Self`

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

--------------------------------

### Convert Box<S> to SecretBox

Source: https://docs.rs/secrecy/latest/secrecy/type.SecretString.html

Creates a SecretBox from a pre-existing Box<S>. This is a direct conversion from a boxed value to a secret-wrapped boxed value.

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

--------------------------------

### SecretBox::init_with_mut constructor

Source: https://docs.rs/secrecy/0.10.3/src/secrecy/lib.rs.html

Initializes a SecretBox with a mutable reference to its inner value, allowing in-place modification.

```rust
pub fn init_with_mut(ctr: impl FnOnce(&mut S)) -> Self {
    let mut secret = Self::default();
    ctr(secret.expose_secret_mut());
    secret
}
```

--------------------------------

### From<T>

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Provides a conversion from a type T to itself.

```APIDOC
## fn from(t: T) -> T

### Description
Returns the argument unchanged.

### Method
fn

### Parameters
#### Path Parameters
- **t** (T) - Required - The value to convert.

### Returns
- T - The argument unchanged.
```

--------------------------------

### ExposeSecret Implementation for SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Provides a method to expose the secret value immutably, which is the primary way to access the secret data.

```rust
fn expose_secret(&self) -> &S

```

--------------------------------

### Trait Implementations for SecretString

Source: https://docs.rs/secrecy/latest/secrecy/type.SecretString.html

Details the trait implementations available for SecretString, including Clone, Default, From, and Serde integration.

```APIDOC
## Trait Implementations for SecretString

### `impl Clone for SecretString`

#### `fn clone(&self) -> Self`

Returns a duplicate of the value.

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

Performs copy-assignment from `source`.

### `impl Default for SecretString`

#### `fn default() -> Self`

Returns the “default value” for a type.

### `impl<'de> Deserialize<'de> for SecretString`

Available on **crate feature`serde`** only.

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

Deserialize this value from the given Serde deserializer.

### `impl From<&str> for SecretString`

#### `fn from(s: &str) -> Self`

Converts to this type from the input type.

### `impl From<String> for SecretString`

#### `fn from(s: String) -> Self`

Converts to this type from the input type.
```

--------------------------------

### TryInto<U>

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Provides a fallible conversion from type T into type U, where U implements TryFrom<T>.

```APIDOC
## type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.
```

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion.

### Method
fn

### Parameters
#### Path Parameters
- **self** (T) - Required - The value to attempt to convert.

### Returns
- Result<U, <U as TryFrom<T>>::Error> - The result of the conversion.
```

--------------------------------

### TryFrom<U>

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Provides a fallible conversion from type U into type T.

```APIDOC
## type Error = Infallible

### Description
The type returned in the event of a conversion error.
```

```APIDOC
## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion.

### Method
fn

### Parameters
#### Path Parameters
- **value** (U) - Required - The value to attempt to convert.

### Returns
- Result<T, <T as TryFrom<U>>::Error> - The result of the conversion.
```

--------------------------------

### Serialize SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Serializes a SecretBox into a Serde serializer. Available only when the `serde` feature is enabled. Requires the inner type `T` to implement `Zeroize`, `SerializableSecret`, and `Serialize`.

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

--------------------------------

### to_owned

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Creates owned data from borrowed data, usually by cloning.

```APIDOC
## fn to_owned(&self) -> T

### Description
Creates owned data from borrowed data, usually by cloning.

### Method
fn

### Returns
- T - The owned data.
```

--------------------------------

### From<Vec<S>> Implementation for SecretSlice

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Enables conversion of a Vec<S> into a SecretSlice<S>, which is noted as the preferred construction method.

```rust
fn from(vec: Vec<S>) -> Self

```

--------------------------------

### Into<U>

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Provides a conversion from type T into type U, where U implements From<T>.

```APIDOC
## fn into(self) -> U

### Description
Calls `U::from(self)`. This conversion is determined by the implementation of `From<T> for U`.

### Method
fn

### Parameters
#### Path Parameters
- **self** (T) - Required - The value to convert.

### Returns
- U - The result of the conversion.
```

--------------------------------

### Zeroize Implementation for SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Implements the Zeroize trait for SecretBox, ensuring that the secret data is securely erased from memory.

```rust
fn zeroize(&mut self)

```

--------------------------------

### Drop Implementation for SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Implements the Drop trait for SecretBox, ensuring that secrets are securely zeroized when the SecretBox goes out of scope.

```rust
fn drop(&mut self)

```

--------------------------------

### Deserialize SecretString

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Shows the implementation for deserializing a SecretString from a Serde deserializer. This requires the 'serde' feature flag.

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

--------------------------------

### Clone Implementation for SecretSlice

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Provides cloning functionality for SecretSlice, allowing for duplicate secret slices to be created.

```rust
fn clone(&self) -> Self

```

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

```

--------------------------------

### Any Trait Implementation for SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Implements the `Any` trait for SecretBox, allowing it to be downcast to a specific type at runtime.

```rust
fn type_id(&self) -> TypeId>
```

--------------------------------

### Format SecretBox for Debugging

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Implements the `Debug` trait for SecretBox, allowing it to be formatted for debugging purposes. Requires the inner type `S` to implement `Zeroize`.

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

--------------------------------

### Serialize SecretBox

Source: https://docs.rs/secrecy/0.10.3/src/secrecy/lib.rs.html

Implements the `Serialize` trait for `SecretBox<T>` to enable serialization of the secret data it contains. The secret is exposed before serialization.

```rust
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: ser::Serializer,
    {
        self.expose_secret().serialize(serializer)
    }
}
```

--------------------------------

### Clone From SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Performs copy-assignment from a source SecretBox to self. Requires the inner type `S` to implement `CloneableSecret`.

```rust
fn clone_from(&mut self, source: &Self)>
```

--------------------------------

### SecretBox::expose_secret_mut

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Provides mutable access to the inner secret value. Use with caution to avoid accidental exposure or modification.

```APIDOC
## SecretBox::expose_secret_mut

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

### Signature
`fn expose_secret_mut(&mut self) -> &mut S`

### Returns
* `&mut S` - A mutable reference to the inner secret value.
```

--------------------------------

### Default SecretBox Value

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Provides a default value for SecretBox. Requires the inner type `S` to implement `Zeroize` and `Default`.

```rust
fn default() -> Self>
```

--------------------------------

### Zeroize SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Ensures that the secret data is securely zeroed out from memory when it's no longer needed, preventing memory leaks.

```rust
fn zeroize(&mut self)
```

--------------------------------

### Debug Implementation for SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Implements the Debug trait for SecretBox, allowing secret boxes to be formatted for debugging purposes.

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

```

--------------------------------

### SecretBox Clone Implementation

Source: https://docs.rs/secrecy/latest/src/secrecy/lib.rs.html

Allows cloning a SecretBox if the inner type `S` implements `CloneableSecret`. This enables creating copies of secrets when necessary, adhering to the `CloneableSecret` trait's constraints.

```rust
impl<S> Clone for SecretBox<S>
where
    S: CloneableSecret,
{
    fn clone(&self) -> Self {
        SecretBox {
            inner_secret: self.inner_secret.clone(),
        }
    }
}
```

--------------------------------

### Integer Primitives as CloneableSecret

Source: https://docs.rs/secrecy/latest/src/secrecy/lib.rs.html

Marks various integer primitive types as implementing `CloneableSecret`. This allows these common numeric types to be cloned when used within `SecretBox` or related types.

```rust
impl CloneableSecret for i8 {}
impl CloneableSecret for i16 {}
impl CloneableSecret for i32 {}
impl CloneableSecret for i64 {}
impl CloneableSecret for i128 {}
impl CloneableSecret for isize {}

impl CloneableSecret for u8 {}
impl CloneableSecret for u16 {}
impl CloneableSecret for u32 {}
impl CloneableSecret for u64 {}
impl CloneableSecret for u128 {}
impl CloneableSecret for usize {}
```

--------------------------------

### Expose Mutable SecretBox Content

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Provides mutable access to the secret inner value of a SecretBox. Use with caution. Requires the inner type `S` to implement `Zeroize`.

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

--------------------------------

### SecretBox Struct Definition

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Shows the structure of SecretBox, which is the underlying type for SecretSlice. Note that fields are private.

```rust
pub struct SecretSlice<S> { /* private fields */ }

```

--------------------------------

### Default SecretString

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Provides the default value for SecretString, which is an empty or zeroed secret string.

```rust
fn default() -> Self
```

--------------------------------

### Clone From SecretString

Source: https://docs.rs/secrecy/latest/secrecy/type.SecretString.html

Performs copy-assignment from a source SecretString to the current one. This updates the current secret with the content of the source.

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

--------------------------------

### SecretBox struct definition

Source: https://docs.rs/secrecy/0.10.3/src/secrecy/lib.rs.html

Defines the SecretBox wrapper for secrets, ensuring they implement the Zeroize trait.

```rust
pub struct SecretBox<S: Zeroize + ?Sized> {
    inner_secret: Box<S>,
}
```

--------------------------------

### ToOwned

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Provides methods for creating owned data from borrowed data.

```APIDOC
## type Owned = T

### Description
The resulting type after obtaining ownership.
```

```APIDOC
## fn to_owned(&self) -> T

### Description
Creates owned data from borrowed data, usually by cloning.

### Method
fn

### Returns
- T - The owned data.
```

```APIDOC
## fn clone_into(&self, target: &mut T)

### Description
Uses borrowed data to replace owned data, usually by cloning.

### Method
fn

### Parameters
#### Path Parameters
- **target** (&mut T) - Required - The mutable reference to the owned data to be replaced.
```

--------------------------------

### Clone SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Returns a duplicate of the SecretBox. Requires the inner type `S` to implement `CloneableSecret`.

```rust
fn clone(&self) -> Self>
```

--------------------------------

### Drop SecretBox

Source: https://docs.rs/secrecy/latest/secrecy/type.SecretString.html

Executes the destructor for SecretBox, ensuring that the secret data is securely zeroed out from memory when the value goes out of scope.

```rust
fn drop(&mut self)
```

--------------------------------

### Drop SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Executes the destructor for SecretBox, ensuring the secret is zeroized from memory when the box goes out of scope. Requires the inner type `S` to implement `Zeroize`.

```rust
fn drop(&mut self)>
```

--------------------------------

### Expose Mutable Secret Data

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Provides mutable access to the underlying secret data. Use with caution as it allows modification of the secret.

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

--------------------------------

### Expose SecretBox Content

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Provides immutable access to the secret inner value of a SecretBox. This is the primary method for reading the secret. Requires the inner type `S` to implement `Zeroize`.

```rust
fn expose_secret(&self) -> &S>
```

--------------------------------

### Zeroize SecretBox Content

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Zeroes out the SecretBox's content from memory using compiler-intrinsics-ensured operations. This is crucial for secure secret handling.

```rust
fn zeroize(&mut self)>
```

--------------------------------

### SecretBox::expose_secret

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Provides immutable access to the inner secret value. This is the primary method for reading the secret.

```APIDOC
## SecretBox::expose_secret

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

### Signature
`fn expose_secret(&self) -> &S`

### Returns
* `&S` - An immutable reference to the inner secret value.
```

--------------------------------

### Borrow SecretBox Immutably

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Provides an immutable borrow to the SecretBox. This is a blanket implementation of the `Borrow` trait.

```rust
fn borrow(&self) -> &T
```

--------------------------------

### Borrow Trait Implementation for SecretBox

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Implements the `Borrow` trait for SecretBox, allowing immutable borrowing of the inner secret.

```rust
fn borrow(&self) -> &T>
```

--------------------------------

### Default Implementation for SecretSlice

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Implements the Default trait for SecretSlice, allowing for the creation of a default (likely empty or zeroed) secret slice.

```rust
fn default() -> Self

```

--------------------------------

### SecretString Struct Definition

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Shows the underlying struct definition for SecretString, which is private.

```rust
pub struct SecretString { /* private fields */ }
```

--------------------------------

### Debug Format SecretBox

Source: https://docs.rs/secrecy/latest/secrecy/type.SecretString.html

Formats the SecretBox value for debugging purposes. This implementation ensures that sensitive data is not leaked during debugging.

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

--------------------------------

### SecretBox Freeze Auto Trait

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Implements the `Freeze` auto trait for SecretBox, indicating that it does not contain any interior mutability that would violate freezing guarantees.

```rust
impl<S> Freeze for SecretBox<S>
where S: ?Sized,
```

--------------------------------

### SecretBox Sync Auto Trait

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Implements the `Sync` auto trait for SecretBox, indicating that it is safe to share across threads.

```rust
impl<S> Sync for SecretBox<S>
where S: Sync + ?Sized,
```

--------------------------------

### Expose Secret Data

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Provides read-only access to the underlying secret data. This is the primary method for accessing the secret's value.

```rust
fn expose_secret(&self) -> &S
```

--------------------------------

### Borrow SecretBox Mutably

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Provides a mutable borrow to the SecretBox. This is a blanket implementation of the `BorrowMut` trait.

```rust
fn borrow_mut(&mut self) -> &mut T
```

--------------------------------

### SecretBox::zeroize

Source: https://docs.rs/secrecy/latest/secrecy/struct.SecretBox.html

Explicitly zeroizes the secret value in memory. This is part of the `Zeroize` trait implementation.

```APIDOC
## SecretBox::zeroize

### Description
Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

### Signature
`fn zeroize(&mut self)`
```

--------------------------------

### SecretBox Send Auto Trait

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Implements the `Send` auto trait for SecretBox, indicating that it is safe to send across threads.

```rust
impl<S> Send for SecretBox<S>
where S: Send + ?Sized,
```

--------------------------------

### ExposeSecret Trait Definition

Source: https://docs.rs/secrecy/0.10.3/secrecy/trait.ExposeSecret.html

Defines the ExposeSecret trait with its required method.

```rust
pub trait ExposeSecret<S: ?Sized> {
    // Required method
    fn expose_secret(&self) -> &S;
}
```

--------------------------------

### SecretBox Unpin Auto Trait

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Implements the `Unpin` auto trait for SecretBox, indicating that its memory location is stable.

```rust
impl<S> Unpin for SecretBox<S>
where S: ?Sized,
```

--------------------------------

### SecretSlice Type Alias Definition

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretSlice.html

Defines SecretSlice as a type alias for SecretBox<[S]>, providing a more convenient way to refer to secret slices.

```rust
pub type SecretSlice<S> = SecretBox<[S]>;

```

--------------------------------

### SecretBox UnwindSafe Auto Trait

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Implements the `UnwindSafe` auto trait for SecretBox, indicating that it is safe to unwind through it.

```rust
impl<S> UnwindSafe for SecretBox<S>
where S: UnwindSafe + ?Sized,
```

--------------------------------

### Define SecretString as a Type Alias

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

Defines SecretString as a type alias for SecretBox<str>. This is the primary way SecretString is declared.

```rust
pub type SecretString = SecretBox<str>;
```

--------------------------------

### SerializableSecret Trait Definition

Source: https://docs.rs/secrecy/0.10.3/secrecy/trait.SerializableSecret.html

Defines the SerializableSecret trait, which is a marker trait for types that can be serialized by `serde`. This trait is gated by the `serde` feature flag.

```rust
pub trait SerializableSecret: Serialize { }
```

--------------------------------

### SerializableSecret Trait Definition (Serde)

Source: https://docs.rs/secrecy/latest/src/secrecy/lib.rs.html

Defines the `SerializableSecret` trait for types that can be serialized by `serde`. This trait is conditional on the `serde` feature being enabled and is used to manage secret serialization.

```rust
#[cfg(feature = "serde")]
pub trait SerializableSecret: Serialize {}
```

--------------------------------

### SecretString Type Alias

Source: https://docs.rs/secrecy/0.10.3/secrecy/type.SecretString.html

SecretString is a type alias for SecretBox<str>, designed for secure storage and handling of string data. It offers convenient construction from String and &str.

```APIDOC
## Type Alias: SecretString

### Description

`SecretString` is a type alias for `SecretBox<str>`. It provides a secure way to store and manage sensitive string data, leveraging the capabilities of `SecretBox`.

### Type Definition

```rust
pub type SecretString = SecretBox<str>;
```

### Construction

`SecretString` can be constructed using the `From` trait:

- **From `String`**: `SecretString::from(my_string)`
- **From `&str`**: `SecretString::from(my_str)`

### Aliased Type

While `SecretString` is an alias, its underlying structure is `SecretBox<str>`:

```rust
pub struct SecretBox<S: Zeroize + ?Sized> { /* private fields */ }
```

### Implementations

`SecretString` (as `SecretBox<str>`) implements several traits for usability and security:

- **`Clone`**: Allows creating duplicate copies of the secret string.
- **`Default`**: Provides a default value for `SecretString`.
- **`Deserialize` (with `serde` feature)**: Enables deserialization from formats like JSON.
- **`From<&str>`**: Converts a string slice into a `SecretString`.
- **`From<String>`**: Converts a `String` into a `SecretString`.
- **`Debug`**: For debugging purposes.
- **`Drop`**: Ensures memory is zeroized when the secret goes out of scope.
- **`ExposeSecret`**: Provides safe access to the underlying secret data.
- **`ExposeSecretMut`**: Provides mutable access to the underlying secret data.
- **`Serialize` (with `serde` feature)**: Enables serialization to formats like JSON.
- **`Zeroize`**: Ensures the secret data is securely zeroized from memory.
- **`ZeroizeOnDrop`**: Guarantees zeroization upon dropping the `SecretString` instance.
```

--------------------------------

### SecretString Type Alias

Source: https://docs.rs/secrecy/latest/secrecy/type.SecretString.html

SecretString is a type alias for SecretBox<str>, designed for secure string handling. It implements From<String> for easy construction.

```APIDOC
## Type Alias SecretString

```rust
pub type SecretString = SecretBox<str>;
```

### Description

Secret string type. This is a type alias for `SecretBox<str>` which supports some helpful trait impls. Notably it has a `From<String>` impl which is the preferred method for construction.

### Aliased Type

```rust
pub struct SecretString { /* private fields */ }
```
```

--------------------------------

### SecretBox RefUnwindSafe Auto Trait

Source: https://docs.rs/secrecy/0.10.3/secrecy/struct.SecretBox.html

Implements the `RefUnwindSafe` auto trait for SecretBox, indicating that it is safe to unwind through references to it.

```rust
impl<S> RefUnwindSafe for SecretBox<S>
where S: RefUnwindSafe + ?Sized,
```

--------------------------------

### ExposeSecretMut Trait Definition

Source: https://docs.rs/secrecy/0.10.3/secrecy/trait.ExposeSecretMut.html

Defines the ExposeSecretMut trait, which requires implementing types to provide mutable access to an inner secret of type S.

```rust
pub trait ExposeSecretMut<S: ?Sized> {
    // Required method
    fn expose_secret_mut(&mut self) -> &mut S;
}
```

--------------------------------

### CloneableSecret Trait Definition

Source: https://docs.rs/secrecy/0.10.3/secrecy/trait.CloneableSecret.html

Defines the CloneableSecret trait, a marker for secrets that can be cloned. Requires the secret to also implement Clone and Zeroize.

```rust
pub trait CloneableSecret: Clone + Zeroize { }
```
Tokens:
Raw