MemSecurity

https://docs.rs/memsecurity/3.5.2/memsecurity/
Admin
MemSecurity is a Rust crate that securely holds secrets in memory and protects them against...
Tokens:37,629
Snippets:329
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Getting Metadata with Path and and_then

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Demonstrates using `and_then` with `Path::metadata` to chain operations that might fail due to file system errors. Note that path resolution can differ across operating systems.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

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

### Initialize ZeroizeByte as Zeroed

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeByte.html

Initializes a new ZeroizeByte with its value already zeroed. Use this when you need a zeroed byte from the start.

```rust
pub fn new_zeroed() -> Self
```

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

### Example Usage of MinMaxNum Trait

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/trait.MinMaxNum.html

Demonstrates how to use a generic function `foo` that is constrained by the `MustBeInRange` trait (which likely relies on `MinMaxNum`). Shows calls with valid `u64` values within the expected range.

```rust
// The function with the enforced constraint
fn foo<T: MustBeInRange>(bar: T) {
    // Use T as needed
    println!("Input: {:?}", bar);
}

foo(42u64);
foo(0u64);
foo(std::u64::MAX);
```

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

### Into Ok Value (Never Panics)

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `into_ok` to get the contained `Ok` value. This method is guaranteed not to panic for Result types it's implemented for.

```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

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

### Unwrap Ok Value

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `unwrap` to get the contained `Ok` value. Panics if the value is an `Err`.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

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

### Unwrap with Panic on Error

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `unwrap` to get the contained `Ok` value. Panics with a message provided by the `Err`'s value if the result is an `Err`.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // panics with `emergency failure`
```

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

### Get a reference to the contained value

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `as_ref()` to convert a `&Result<T, E>` into a `Result<&T, &E>`. This allows inspecting the contents of a `Result` without consuming it.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

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

### X25519PublicKey Methods

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.X25519PublicKey.html

Methods for initializing, filling, and accessing the X25519PublicKey structure.

```APIDOC
## X25519PublicKey Methods

### Description
Methods to manage the 32-byte X25519 public key array, including secure initialization and memory management.

### Methods
- **new(value: [u8; 32])** - Initialize a ZeroizeArray with the provided 32 bytes.
- **new_zeroed()** - Initialize a new array with zeroed bytes.
- **fill_from_array(value: [u8; 32])** - Fill the array with new values.
- **new_from_slice(value: &[u8])** - Create an array from a slice, returning a MemSecurityResult.
- **expose_borrowed()** - Expose the internal data as a borrowed array.
- **zeroize()** - Securely zero out the object from memory.
```

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

### Get TypeId

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeArrayVecBytes.html

Gets the TypeId of the current type, part of the Any trait implementation.

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

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

### Unwrap Error Value

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `unwrap_err` to get the contained `Err` value. Panics if the value is an `Ok`.

```rust
let x: Result<u32, &str> = Ok(2);
x.unwrap_err(); // panics with `2`
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(x.unwrap_err(), "emergency failure");
```

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

### ZeroizeBytes Methods

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeBytes.html

Methods for initializing and manipulating the ZeroizeBytes structure.

```APIDOC
## ZeroizeBytes Methods

### Description
Methods to create, update, and expose the internal byte buffer of a ZeroizeBytes instance.

### Methods
- **new()** -> Self: Create a new array with no allocation and no specified capacity.
- **new_with_data(value: &[u8])** -> Self: Initialize the array with the provided byte slice.
- **new_with_capacity(capacity: usize)** -> Self: Initialize the array with a specified capacity.
- **set_bytes_mut(&mut self, value: BytesMut)** -> &mut Self: Set the internal value using BytesMut.
- **set(&mut self, value: &[u8])** -> &mut Self: Set the internal value to the new byte slice.
- **set_byte(&mut self, value: u8)** -> &mut Self: Add a single byte to the internal value.
- **expose_borrowed(&self) -> &BytesMut**: Expose the internal value as a reference.
- **zeroize(&mut self)**: Zero out this object from memory using Rust intrinsics.
```

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

### ZeroizeArray<N> Implementations

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.TaiTimestamp.html

Provides methods for initializing, filling, and exposing the ZeroizeArray, ensuring secure memory operations.

```APIDOC
## Implementations for ZeroizeArray<N>

### `impl<const N: usize> ZeroizeArray<N>`

#### `pub fn new(value: [u8; N]) -> Self`
Initialize a ZeroizeArray with the value specified by the array of bytes.

#### `pub fn new_zeroed() -> Self`
Initialize a new array with zeroed bytes of length `N`.

#### `pub fn fill_from_array(self, value: [u8; N]) -> Self`
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

#### `pub fn fill_from_array_borrowed(&mut self, value: [u8; N]) -> &mut Self`
Fill the current array with new values specified by the method parameter `value: [u8; N]`, returning a `&mut Self`.

#### `pub fn new_from_slice(value: &[u8]) -> MemSecurityResult<Self>`
Create an array with new values specified by the method parameter `value: &[u8]`.

#### `pub fn fill_from_slice(self, value: &[u8]) -> MemSecurityResult<Self>`
Fill the current array with new values specified by the method parameter `value: &[u8]`.

#### `pub fn fill_from_slice_borrowed(&mut self, value: &[u8]) -> MemSecurityResult<&mut Self>`
Fill the current array with new values specified by the method parameter `value: &[u8]`.

#### `pub fn expose_borrowed(&self) -> &[u8; N]`
Expose the internal array as a borrowed slice.

#### `pub fn own(self) -> Self`
Return ownership of this array.

#### `pub fn insert(&mut self, index: usize, value: u8) -> &mut Self`
Insert a value at the specified index in the array.
```

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

### ZeroizeArray<N> Implementations

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.Ed25519SecretKey.html

Provides methods for initializing, filling, exposing, and managing ZeroizeArray instances.

```APIDOC
## Implementations for ZeroizeArray<N>

### pub fn new(value: [u8; N]) -> Self
Initialize a ZeroizeArray with the value specified by the array of bytes.

### pub fn new_zeroed() -> Self
Initialize a new array which is zeroed bytes of len `N` as specified by the generic `const N: usize`.

### pub fn fill_from_array(self, value: [u8; N]) -> Self
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

### pub fn fill_from_array_borrowed(&mut self, value: [u8; N]) -> &mut Self
Fill the current array with new values specified by the method parameter `value: [u8; N]` but returning a `&mut Self`.

### pub fn new_from_slice(value: &[u8]) -> MemSecurityResult<Self>
Create array with new values specified by the method parameter `value: [u8; N]`.

### pub fn fill_from_slice(self, value: &[u8]) -> MemSecurityResult<Self>
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

### pub fn fill_from_slice_borrowed(&mut self, value: &[u8]) -> MemSecurityResult<&mut Self>
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

### pub fn expose_borrowed(&self) -> &[u8; N]
Expose the internal as a borrowed array.

### pub fn own(self) -> Self
Own this array.

### pub fn insert(&mut self, index: usize, value: u8) -> &mut Self
Insert a value at the specified index in the array.
```

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

### Providing a Default Value with unwrap_or

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `unwrap_or` to get the Ok value or a default value if the Result is Err. The default value is eagerly evaluated.

```rust
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);
```

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

### Into Err Value (Never Panics)

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `into_err` to get the contained `Err` value. This method is guaranteed not to panic for Result types it's implemented for.

```rust
fn only_bad_news() -> Result<!, String> {
    Err("Oops, it failed".into())
}

let error: String = only_bad_news().into_err();
println!("{error}");
```

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

### ZeroizeArray<N> Implementations

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.X25519EphemeralSecretKey.html

Provides methods for initializing, filling, exposing, owning, and inserting values into a ZeroizeArray.

```APIDOC
## Implementations for ZeroizeArray<N>

### `impl<const N: usize> ZeroizeArray<N>`

#### `pub fn new(value: [u8; N]) -> Self`
Initialize a ZeroizeArray with the value specified by the array of bytes.

#### `pub fn new_zeroed() -> Self`
Initialize a new array which is zeroed bytes of length `N` as specified by the generic `const N: usize`.

#### `pub fn fill_from_array(self, value: [u8; N]) -> Self`
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

#### `pub fn fill_from_array_borrowed(&mut self, value: [u8; N]) -> &mut Self`
Fill the current array with new values specified by the method parameter `value: [u8; N]` but returning a `&mut Self`.

#### `pub fn new_from_slice(value: &[u8]) -> MemSecurityResult<Self>`
Create array with new values specified by the method parameter `value: [u8; N]`.

#### `pub fn fill_from_slice(self, value: &[u8]) -> MemSecurityResult<Self>`
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

#### `pub fn fill_from_slice_borrowed(&mut self, value: &[u8]) -> MemSecurityResult<&mut Self>`
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

#### `pub fn expose_borrowed(&self) -> &[u8; N]`
Expose the internal as a borrowed array.

#### `pub fn own(self) -> Self`
Own this array.

#### `pub fn insert(&mut self, index: usize, value: u8) -> &mut Self`
Insert a value at the specified index in the array.
```

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

### Initialize EncryptedMem

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.EncryptedMem.html

Create a new instance of EncryptedMem.

```rust
let data = EncryptedMem::new();
```

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

### ZeroizeByte Methods

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeByte.html

Provides methods for initializing, modifying, and accessing the ZeroizeByte.

```APIDOC
## Implementations for ZeroizeByte

### `new(value: u8) -> Self`
Initialize a ZeroizeByte with the value of specified by byte.

### `new_zeroed() -> Self`
Initialize a new byte which is zeroed byte.

### `set(&mut self, value: u8) -> &mut Self`
Fill the current array with new values specified by the method parameter `value: u8`.

### `expose_borrowed(&self) -> &u8`
Expose the internal as an borrowed byte.

### `own(self) -> Self`
Own this array.

### `csprng() -> Self`
Generate some random byte and initialize an new `ZeroizeByte` in the process.
```

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

### Handling File Metadata with `and_then`

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Illustrates using `and_then` to chain operations that might fail, such as retrieving file metadata.

```APIDOC
## File Metadata Example with `and_then`

### Description
Note: on Windows "/" maps to "C:\".

### Request Example
```rust
use std::{io::ErrorKind, path::Path};

let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```
```

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

### X25519StaticSecretKey Methods

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.X25519StaticSecretKey.html

Methods for initializing, filling, and manipulating the X25519StaticSecretKey structure.

```APIDOC
## X25519StaticSecretKey Methods

### Description
Methods to manage the 32-byte X25519 static secret key, including initialization from values or slices, and memory-safe operations.

### Methods
- **new(value: [u8; 32])** - Initializes a new ZeroizeArray with the provided 32 bytes.
- **new_zeroed()** - Initializes a new array with all bytes set to zero.
- **fill_from_array(value: [u8; 32])** - Replaces current contents with new values.
- **new_from_slice(value: &[u8])** - Creates an array from a slice, returning a MemSecurityResult.
- **expose_borrowed()** - Returns a reference to the internal 32-byte array.
- **zeroize()** - Securely clears the memory occupied by the key.
```

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

### Unwrap or Default Value

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `unwrap_or_default` to get the contained `Ok` value or the default value for the type if it's an `Err`. Requires the type to implement `Default`.

```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```

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

### EncryptedMem::new

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.EncryptedMem.html

Initializes a new instance of EncryptedMem.

```APIDOC
## POST /EncryptedMem/new

### Description
Initializes a new EncryptedMem.

### Method
POST

### Endpoint
/EncryptedMem/new

### Request Body
None

### Response
#### Success Response (200)
- **Self** (EncryptedMem) - A new instance of EncryptedMem.

### Request Example
```json
{}
```

### Response Example
```json
{
  "ciphertext": "...",
  "nonce": "..."
}
```
```

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

### Unsafe Unwrapping with unwrap_unchecked

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `unwrap_unchecked` to get the Ok value without checking if it's an Err. This is unsafe and can lead to undefined behavior if called on an Err value.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(unsafe { x.unwrap_unchecked() }, 2);
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
unsafe { x.unwrap_unchecked() }; // Undefined behavior!
```

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

### ZeroizeArray<N> Implementations

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.X25519ReusableSecretKey.html

Provides methods for initializing, filling, and exposing data within a ZeroizeArray, along with trait implementations for common operations.

```APIDOC
## Implementations for ZeroizeArray<N>

### pub fn new(value: [u8; N]) -> Self
Initialize a ZeroizeArray with the value specified by the array of bytes.

### pub fn new_zeroed() -> Self
Initialize a new array which is zeroed bytes of len `N` as specified by the generic `const N: usize`.

### pub fn fill_from_array(self, value: [u8; N]) -> Self
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

### pub fn fill_from_array_borrowed(&mut self, value: [u8; N]) -> &mut Self
Fill the current array with new values specified by the method parameter `value: [u8; N]` but returning a `&mut Self`.

### pub fn new_from_slice(value: &[u8]) -> MemSecurityResult<Self>
Create array with new values specified by the method parameter `value: [u8; N]`.

### pub fn fill_from_slice(self, value: &[u8]) -> MemSecurityResult<Self>
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

### pub fn fill_from_slice_borrowed(&mut self, value: &[u8]) -> MemSecurityResult<&mut Self>
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

### pub fn expose_borrowed(&self) -> &[u8; N]
Expose the internal as a borrowed array.

### pub fn own(self) -> Self
Own this array.

### pub fn insert(&mut self, index: usize, value: u8) -> &mut Self
Insert a value at the specified index in the array.

### Trait Implementations

#### AsRef<[u8]>
- `fn as_ref(&self) -> &[u8]`

#### BorshDeserialize
- `fn deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>`
- `fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>`
- `fn try_from_slice(v: &[u8]) -> Result<Self, Error>`
- `fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>` where R: Read

#### BorshSerialize
- `fn serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>`

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

#### Drop
- `fn drop(&mut self)`

#### PartialEq
- `fn eq(&self, other: &Self) -> bool`
- `fn ne(&self, other: &Rhs) -> bool`

#### ToBlake3Hash for ZeroizeArray<32>
- `fn hash(&self) -> Hash`

#### Zeroize
- `fn zeroize(&mut self)`

#### Eq
(No methods defined)

#### ZeroizeOnDrop
(No methods defined)
```

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

### Unsafe Unwrapping of Error with unwrap_err_unchecked

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `unwrap_err_unchecked` to get the Err value without checking if it's an Ok. This is unsafe and can lead to undefined behavior if called on an Ok value.

```rust
let x: Result<u32, &str> = Ok(2);
unsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");
```

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

### ZeroizeArray<N> Implementations

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.Blake3Hash.html

Provides methods for initializing, filling, and accessing data within a ZeroizeArray.

```APIDOC
## Implementations for ZeroizeArray<N>

### `impl<const N: usize> ZeroizeArray<N>`

#### `pub fn new(value: [u8; N]) -> Self`
Initialize a ZeroizeArray with the value specified by the array of bytes.

#### `pub fn new_zeroed() -> Self`
Initialize a new array which is zeroed bytes of length `N` as specified by the generic `const N: usize`.

#### `pub fn fill_from_array(self, value: [u8; N]) -> Self`
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

#### `pub fn fill_from_array_borrowed(&mut self, value: [u8; N]) -> &mut Self`
Fill the current array with new values specified by the method parameter `value: [u8; N]` but returning a `&mut Self`.

#### `pub fn new_from_slice(value: &[u8]) -> MemSecurityResult<Self>`
Create array with new values specified by the method parameter `value: [u8; N]`.

#### `pub fn fill_from_slice(self, value: &[u8]) -> MemSecurityResult<Self>`
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

#### `pub fn fill_from_slice_borrowed(&mut self, value: &[u8]) -> MemSecurityResult<&mut Self>`
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

#### `pub fn expose_borrowed(&self) -> &[u8; N]`
Expose the internal as a borrowed array.

#### `pub fn own(self) -> Self`
Own this array.

#### `pub fn insert(&mut self, index: usize, value: u8) -> &mut Self`
Insert a value at the index specified in the array.
```

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

### Expect Error with Custom Panic Message

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `expect_err` to get the contained `Err` value. Panics if the value is an `Ok`, including the provided message and the `Ok`'s content.

```rust
let x: Result<u32, &str> = Ok(10);
x.expect_err("Testing expect_err"); // panics with `Testing expect_err: 10`
```

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

### Use zero-on-drop data types

Source: https://docs.rs/memsecurity

Requires the 'symm_asymm' feature. Use 'clonable_mem' if cloning is required.

```rust
use memsecurity::{ZeroizeArray, ZeroizeBytes};

// Create an array of 4 bytes that will be zeroed out when dropped.
let array_like = ZeroizeArray::<4>::new([4u8, 3,2,1]);

// Use the value
array_like.expose_borrowed();

// Create a Vec like array using `BytesMut` from `bytes` crate that re-allocates when it's capacity is exceeded.
let mut vector_like = ZeroizeBytes::new();

// Insert a slice of bytes
vector_like.set(&[4u8, 5,6,7]); // Must be a byte (u8) type

// Use the value
vector_like.expose_borrowed();
```

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

### Get a mutable reference to the contained value

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `as_mut()` to convert a `&mut Result<T, E>` into a `Result<&mut T, &mut E>`. This enables modifying the contents of a `Result` in place.

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

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

### ZeroizeArray Methods

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeArray.html

Methods for initializing, filling, and accessing the ZeroizeArray structure.

```APIDOC
## ZeroizeArray Methods

### Description
Methods to manage the lifecycle and content of a ZeroizeArray, ensuring secure memory handling.

### Methods
- **new(value: [u8; N])** - Initialize a ZeroizeArray with the specified array of bytes.
- **new_zeroed()** - Initialize a new array of length N with zeroed bytes.
- **fill_from_array(value: [u8; N])** - Fill the current array with new values.
- **fill_from_array_borrowed(&mut self, value: [u8; N])** - Fill the current array and return a mutable reference.
- **new_from_slice(value: &[u8])** - Create an array from a slice.
- **fill_from_slice(value: &[u8])** - Fill the current array from a slice.
- **fill_from_slice_borrowed(&mut self, value: &[u8])** - Fill the current array from a slice and return a mutable reference.
- **expose_borrowed()** - Expose the internal array as a borrowed reference.
- **own()** - Return ownership of the array.
- **insert(index: usize, value: u8)** - Insert a byte at a specific index.
```

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

### Lazy Default Value Computation with unwrap_or_else

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `unwrap_or_else` to get the Ok value or compute a default value using a closure if the Result is Err. This is useful when the default value computation is expensive.

```rust
fn count(x: &str) -> usize { x.len() }

assert_eq!(Ok(2).unwrap_or_else(count), 2);
assert_eq!(Err("foo").unwrap_or_else(count), 3);
```

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

### ZeroizeArrayVecBytes Implementations

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeArrayVecBytes.html

Provides methods for initializing, manipulating, and accessing the ZeroizeArrayVecBytes.

```APIDOC
## impl<const N: usize> ZeroizeArrayVecBytes<N>

### Methods

#### `new()`
Initialize a ZeroizeArray with the value of specified by the array of bytes.

#### `new_with(value: [u8; N])`
Initialize a ZeroizeArray with the value of specified by the array of bytes.

#### `fill_from_slice(&mut self, value: [u8; N]) -> &mut Self`
Fill the current array with new values specified by the method parameter `value: [u8; N]`.

#### `expose_borrowed(&self) -> &ArrayVec<u8, N>`
Expose the internal as a borrowed array.

#### `own(self) -> Self`
Own this array.

#### `push(&mut self, value: u8) -> &mut Self`
Insert a value in the array after the last index.

#### `insert(&mut self, index: usize, value: u8) -> &mut Self`
Insert a value at the index specified in the array.
```

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

### Initialize ZeroizeByte with Value

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeByte.html

Initializes a ZeroizeByte with a specified byte value. Use this when you need a ZeroizeByte with a known initial value.

```rust
pub fn new(value: u8) -> Self
```

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

### Ed25519KeyPair Methods

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.Ed25519KeyPair.html

Methods for initializing and manipulating the Ed25519KeyPair structure.

```APIDOC
## Ed25519KeyPair Methods

### Description
Methods to create, fill, and access the 64-byte Ed25519 keypair array.

### Methods
- **new(value: [u8; 64])** - Initializes a new ZeroizeArray with the provided 64 bytes.
- **new_zeroed()** - Initializes a new array filled with zeroed bytes.
- **fill_from_array(value: [u8; 64])** - Replaces current array contents with new values.
- **new_from_slice(value: &[u8])** - Creates an array from a slice, returning a MemSecurityResult.
- **expose_borrowed()** - Returns a reference to the internal 64-byte array.
- **insert(index: usize, value: u8)** - Inserts a single byte at the specified index.
- **zeroize()** - Securely clears the memory occupied by the keypair.
```

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

### Initialize ZeroizeArrayVecBytes

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeArrayVecBytes.html

Initializes a new ZeroizeArrayVecBytes with default values.

```rust
pub fn new() -> Self
```

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

### ZeroizeArray<N> Implementations

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.Key32Byte.html

Provides details on the methods available for ZeroizeArray, which Key32Byte inherits.

```APIDOC
## Implementations for ZeroizeArray<N>

### `new(value: [u8; N]) -> Self`
Initialize a ZeroizeArray with the value specified by the array of bytes.

### `new_zeroed() -> Self`
Initialize a new array with zeroed bytes of length `N`.

### `fill_from_array(self, value: [u8; N]) -> Self`
Fill the current array with new values specified by the `value` parameter.

### `fill_from_array_borrowed(&mut self, value: [u8; N]) -> &mut Self`
Fill the current array with new values specified by the `value` parameter, returning a mutable reference.

### `new_from_slice(value: &[u8]) -> MemSecurityResult<Self>`
Create an array with new values specified by the `value` slice. Returns a `MemSecurityResult`.

### `fill_from_slice(self, value: &[u8]) -> MemSecurityResult<Self>`
Fill the current array with new values specified by the `value` slice. Returns a `MemSecurityResult`.

### `fill_from_slice_borrowed(&mut self, value: &[u8]) -> MemSecurityResult<&mut Self>`
Fill the current array with new values specified by the `value` slice, returning a mutable reference. Returns a `MemSecurityResult`.

### `expose_borrowed(&self) -> &[u8; N]`
Expose the internal array as a borrowed slice.

### `own(self) -> Self`
Take ownership of the array.

### `insert(&mut self, index: usize, value: u8) -> &mut Self`
Insert a value at the specified index in the array, returning a mutable reference.
```

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

### ToBlake3Hash Implementations for ZeroizeArray

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeArray.html

Provides implementations for hashing ZeroizeArray instances of various sizes using the BLAKE3 algorithm.

```rust
fn hash(&self) -> Hash
```

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

### TryInto Trait Implementation

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.CsprngArray.html

Documentation for the TryInto trait implementation, which facilitates fallible conversions between types.

```APIDOC
## impl<T, U> TryInto<U> for T

### Description
Provides a fallible conversion from type T to type U, where U implements TryFrom<T>.

### Associated Types
- **Error** (<U as TryFrom<T>>::Error) - The type returned in the event of a conversion error.

### Methods
- **try_into(self) -> Result<U, <U as TryFrom<T>>::Error>** - Performs the conversion.
```

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

### VZip Trait Implementation

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.CsprngArray.html

Documentation for the VZip trait implementation, used for multi-lane operations.

```APIDOC
## impl<V, T> VZip<V> for T

### Description
Implementation of the VZip trait for types where V implements MultiLane<T>.

### Methods
- **vzip(self) -> V** - Performs the zip operation into the multi-lane type V.
```

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

### ZeroizeBytesArray Struct Methods

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeBytesArray.html

Methods for initializing and manipulating the ZeroizeBytesArray structure.

```APIDOC
## ZeroizeBytesArray Methods

### Description
Methods to initialize, set, and expose the internal byte data of the ZeroizeBytesArray.

### Methods
- **new()** -> Self: Initialize the array with an initial length of N.
- **new_with_data(value: [u8; N])** -> Self: Initialize the array with the provided data.
- **new_with_csprng()** -> Self: Initialize the array with cryptographically secure random data.
- **set(value: [u8; N])** -> Self: Set the internal value of the array.
- **set_byte(value: u8)** -> &mut Self: Add a byte to the internal value.
- **set_bytes_mut(value: BytesMut)** -> Self: Set the internal value using BytesMut.
- **with_additional_capacity(capacity: usize)** -> Self: Initialize with length N + capacity.
- **expose_borrowed()** -> &BytesMut: Expose the internal value of the array.
```

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

### Trait Implementations for ZeroizeByte

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeByte.html

Details the trait implementations for ZeroizeByte, including serialization, debugging, dropping, comparison, and zeroization.

```APIDOC
## Trait Implementations for ZeroizeByte

### `BorshDeserialize`
#### `deserialize_reader<__R: Read>(reader: &mut __R) -> Result<Self, Error>`
#### `deserialize(buf: &mut &[u8]) -> Result<Self, Error>`
Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.
#### `try_from_slice(v: &[u8]) -> Result<Self, Error>`
Deserialize this instance from a slice of bytes.
#### `try_from_reader<R>(reader: &mut R) -> Result<Self, Error>`
where R: Read,

### `BorshSerialize`
#### `serialize<__W: Write>(&self, writer: &mut __W) -> Result<(), Error>`

### `Debug`
#### `fmt(&self, f: &mut Formatter<'_>) -> Result`
Formats the value using the given formatter.

### `Drop`
#### `drop(&mut self)`
Executes the destructor for this type.

### `PartialEq`
#### `eq(&self, other: &Self) -> bool`
Tests for `self` and `other` values to be equal, and is used by `==`.
#### `ne(&self, other: &Rhs) -> bool`
Tests for `!=`.

### `Zeroize`
#### `zeroize(&mut self)`
Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

### `Eq`

### `ZeroizeOnDrop`
```

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

### Result<T, E> Core Methods

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Details core methods for Result<T, E> including is_ok, is_ok_and, is_err, and is_err_and.

```APIDOC
## Implementations for Result<T, E>

### `is_ok` Method

#### Description
Returns `true` if the result is `Ok`.

#### Example
```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

### `is_ok_and` Method

#### Description
Returns `true` if the result is `Ok` and the value inside of it matches a predicate.

#### Example
```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<String, &str> = Ok("ownership".to_string());
assert_eq!(x.as_ref().is_ok_and(|x| x.len() > 1), true);
println!("still alive {:?}", x);
```

### `is_err` Method

#### Description
Returns `true` if the result is `Err`.

#### Example
```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

### `is_err_and` Method

#### Description
Returns `true` if the result is `Err` and the value inside of it matches a predicate.

#### Example
```rust
// Example for is_err_and would go here if provided in source text.
```
```

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

### Combine Results with `and`

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Use `and` to return the second `Result` if the first is `Ok`, otherwise return the first `Err`. Arguments are eagerly evaluated.

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("late error"));
```

```rust
let x: Result<u32, &str> = Err("early error");
let y: Result<&str, &str> = Ok("foo");
assert_eq!(x.and(y), Err("early error"));
```

```rust
let x: Result<u32, &str> = Err("not a 2");
let y: Result<&str, &str> = Err("late error");
assert_eq!(x.and(y), Err("not a 2"));
```

```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<&str, &str> = Ok("different result type");
assert_eq!(x.and(y), Ok("different result type"));
```

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

### Result<&mut T, E> Implementations

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Provides implementations for Result<&mut T, E>, including methods to copy and clone the contained mutable reference.

```APIDOC
## Implementations for Result<&mut T, E>

### `copied` Method

#### Description
Maps a `Result<&mut T, E>` to a `Result<T, E>` by copying the contents of the `Ok` part. Requires `T` to implement `Copy`.

#### Example
```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x.copied(), Ok(12));
```

### `cloned` Method

#### Description
Maps a `Result<&mut T, E>` to a `Result<T, E>` by cloning the contents of the `Ok` part. Requires `T` to implement `Clone`.

#### Example
```rust
let mut val = 12;
let x: Result<&mut i32, i32> = Ok(&mut val);
assert_eq!(x.cloned(), Ok(12));
```
```

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

### Providing Alternative Results with `or`

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Shows how `or` returns the `Ok` value of self if it is `Ok`, otherwise returns the provided `Result`.

```APIDOC
## `or` Method

### Description
Returns `res` if the result is `Err`, otherwise returns the `Ok` value of `self`. Arguments passed to `or` are eagerly evaluated; if you are passing the result of a function call, it is recommended to use `or_else`, which is lazily evaluated.

### Request Example
```rust
let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Ok(2));

let x: Result<u32, &str> = Err("early error");
let y: Result<u32, &str> = Ok(2);
assert_eq!(x.or(y), Ok(2));

let x: Result<u32, &str> = Err("not a 2");
let y: Result<u32, &str> = Err("late error");
assert_eq!(x.or(y), Err("late error"));

let x: Result<u32, &str> = Ok(2);
let y: Result<u32, &str> = Ok(100);
assert_eq!(x.or(y), Ok(2));
```
```

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

### CsprngArraySimple Methods

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.CsprngArraySimple.html

Methods for generating cryptographically secure random byte arrays of specific sizes.

```APIDOC
## CsprngArraySimple Methods

### Description
Methods to generate cryptographically secure random bytes of array size 8, 16, 24, 32, or 64.

### Methods
- **gen_u8_byte() -> u8**: Generate a random byte.
- **gen_u8_array() -> CsprngArray<8>**: Generate an array of 8 random bytes.
- **gen_u16_array() -> CsprngArray<16>**: Generate an array of 16 random bytes.
- **gen_u24_array() -> CsprngArray<24>**: Generate an array of 24 random bytes.
- **gen_u32_array() -> CsprngArray<32>**: Generate an array of 32 random bytes.
- **gen_u64_array() -> CsprngArray<64>**: Generate an array of 64 random bytes.

### Usage Example
```rust
let bytes = CsprngArray::gen_16();
assert_eq!(bytes.len(), 16);
```
```

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

### Blanket Implementations for Generic Types

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.SealingKey.html

Demonstrates blanket implementations that apply to generic types, including `SealingKey`, showcasing common Rust trait functionalities.

```APIDOC
## Blanket Implementations

### impl<T> Any for T

#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`. Read more

### impl<T> Borrow<T> for T

#### fn borrow(&self) -> &T
Immutably borrows from an owned value. Read more

### impl<T> BorrowMut<T> for T

#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more

### impl<T> From<T> for T

#### fn from(t: T) -> T
Returns the argument unchanged.

### impl<T, U> Into<U> for T

#### fn into(self) -> U
Calls `U::from(self)`.
That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### impl<T> Same for T

#### type Output = T
Should always be `Self`

### impl<T, U> TryFrom<U> for T

#### type Error = Infallible
The type returned in the event of a conversion error.

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.

### impl<T, U> TryInto<U> for T

#### type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.

### impl<V, T> VZip<V> for T

#### fn vzip(self) -> V
```

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

### Initialize ZeroizeArrayVecBytes with Value

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeArrayVecBytes.html

Initializes a ZeroizeArrayVecBytes with a specific byte array value.

```rust
pub fn new_with(value: [u8; N]) -> Self
```

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

### Result<Result<T, E>, E> Implementations

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.MemSecurityResult.html

Explains the flatten method for nested Results.

```APIDOC
## Implementations for Result<Result<T, E>, E>

### `flatten` Method

#### Description
Converts from `Result<Result<T, E>, E>` to `Result<T, E>`, removing one level of nesting.

#### Example
```rust
let x: Result<Result<&'static str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&'static str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());

// Flattening only removes one level of nesting at a time:
let x: Result<Result<Result<&'static str, u32>, u32>, u32> = Ok(Ok(Ok("hello")));
assert_eq!(Ok(Ok("hello")), x.flatten());
assert_eq!(Ok("hello"), x.flatten().flatten());
```
```

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

### ZeroizeArrayVec Methods

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/struct.ZeroizeArrayVec.html

Methods for initializing and manipulating the ZeroizeArrayVec structure.

```APIDOC
## ZeroizeArrayVec Methods

### Description
Methods to initialize, fill, and modify the ZeroizeArrayVec structure.

### Methods
- **new()** - Initializes a new ZeroizeArray.
- **new_with(value: [T; N])** - Initializes a new ZeroizeArray with a provided array of bytes.
- **fill_from_slice(value: [T; N])** - Fills the current array with new values.
- **expose_borrowed()** - Returns a reference to the internal ArrayVec.
- **own()** - Returns ownership of the array.
- **push(value: T)** - Inserts a value at the end of the array.
- **insert(index: usize, value: T)** - Inserts a value at a specific index.
```

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

### X25519StaticKeyPair Methods

Source: https://docs.rs/memsecurity/3.5.2/memsecurity/type.X25519StaticKeyPair.html

Methods available for interacting with the X25519StaticKeyPair type.

```APIDOC
## X25519StaticKeyPair Methods

### Description
Methods to initialize, fill, and expose data within the X25519StaticKeyPair (ZeroizeArray<64>).

### Methods
- **new(value: [u8; N])** - Initialize a ZeroizeArray with the provided byte array.
- **new_zeroed()** - Initialize a new array of length N with zeroed bytes.
- **fill_from_array(value: [u8; N])** - Fill the current array with new values.
- **new_from_slice(value: &[u8])** - Create an array from a slice, returning a MemSecurityResult.
- **expose_borrowed()** - Expose the internal data as a borrowed array.
- **zeroize()** - Securely zero out the object from memory to prevent data leakage.
```
Tokens:
Raw