Struct ZeroizingMutGuard 

pub struct ZeroizingMutGuard<'a, T>
where
    T: FastZeroizable + ZeroizationProbe + ?Sized,
{ /* private fields */ }

RAII guard for mutable references that automatically zeroizes on drop.

ZeroizingMutGuard wraps a mutable reference &mut T and ensures that the referenced value is zeroized when the guard is dropped. This is useful for protecting sensitive data during temporary operations (e.g., encryption, decryption, signing).

Design

• Wraps &'a mut T (borrows the value mutably)
• Implements Deref and DerefMut for convenient access
• Zeroizes *inner on drop via #[fast_zeroize(drop)]
• Contains ZeroizeOnDropSentinel to verify zeroization happened

Usage

use redoubt_zero_core::{ZeroizingMutGuard, ZeroizationProbe};

let mut sensitive: u64 = 12345;

{
    // Guard borrows `sensitive` and zeroizes it on drop
    let mut guard = ZeroizingMutGuard::from(&mut sensitive);
    *guard = 67890;
    println!("Value: {}", *guard);
} // guard drops here → sensitive is zeroized

assert!(sensitive.is_zeroized());

Composition with Temporary Data

ZeroizingMutGuard is useful for wrapping sensitive temporary data:

use redoubt_zero_core::ZeroizingMutGuard;

struct Context<'a> {
    key: ZeroizingMutGuard<'a, [u8; 32]>,
    nonce: ZeroizingMutGuard<'a, [u8; 16]>,
}

impl Drop for Context<'_> {
    fn drop(&mut self) {
        // key and nonce auto-zeroize when guards drop
    }
}

Panics

The guard panics on drop if the wrapped value’s ZeroizeOnDropSentinel was not marked as zeroized. This ensures zeroization invariants are enforced.

Implementations

impl<'a, T> ZeroizingMutGuard<'a, T>

where T: FastZeroizable + ZeroizationProbe + ?Sized,

pub fn from(inner: &'a mut T) -> Self

Creates a new guard wrapping a mutable reference.

The guard takes ownership of the mutable reference and will zeroize the referenced value when dropped.

Example

use redoubt_zero_core::ZeroizingMutGuard;

let mut value: u32 = 42;

let guard = ZeroizingMutGuard::from(&mut value);
assert_eq!(*guard, 42);

Trait Implementations

impl<'a, T> AssertZeroizeOnDrop for ZeroizingMutGuard<'a, T>

where T: FastZeroizable + ZeroizationProbe + ?Sized,

fn clone_sentinel(&self) -> ZeroizeOnDropSentinel

Clones the internal ZeroizeOnDropSentinel for verification.

fn assert_zeroize_on_drop(self)

Asserts that zeroization happens when this value is dropped.

impl<'a, T> Debug for ZeroizingMutGuard<'a, T>

where T: FastZeroizable + ZeroizationProbe + ?Sized,

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

Formats the value using the given formatter.

impl<'a, T> Deref for ZeroizingMutGuard<'a, T>

where T: FastZeroizable + ZeroizationProbe + ?Sized,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'a, T> DerefMut for ZeroizingMutGuard<'a, T>

where T: FastZeroizable + ZeroizationProbe + ?Sized,

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T> Drop for ZeroizingMutGuard<'a, T>

where T: FastZeroizable + ZeroizationProbe + ?Sized,

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T> FastZeroizable for ZeroizingMutGuard<'a, T>

where T: FastZeroizable + ZeroizationProbe + ?Sized,

fn fast_zeroize(&mut self)

Zeroizes the value in place.

impl<'a, T> ZeroizationProbe for ZeroizingMutGuard<'a, T>

where T: FastZeroizable + ZeroizationProbe + ?Sized,

fn is_zeroized(&self) -> bool

Returns true if the value is zeroized (all bytes are 0).