Struct Dynamic 

pub struct Dynamic<T: ?Sized>(pub Box<T>);

A zero-cost, heap-allocated wrapper for sensitive data.

Dynamic<T> stores its value on the heap via Box<T>. It behaves like T thanks to Deref/DerefMut, but redacts itself in debug output and requires explicit access to the inner value.

Use this for dynamic-sized secrets like passwords or variable-length keys.

Examples

use secure_gate::Dynamic;

let secret: Dynamic<Vec<u8>> = vec![1, 2, 3].into();
assert_eq!(secret.expose_secret(), &[1, 2, 3]);

Tuple Fields

0: Box<T>

Implementations

impl<T: ?Sized> Dynamic<T>

pub fn new_boxed(value: Box<T>) -> Self

Creates a new Dynamic from a boxed value.

Examples

use secure_gate::Dynamic;

let secret = Dynamic::new_boxed(Box::new("hello".to_string()));
assert_eq!(secret.expose_secret(), "hello");

pub fn new<U>(value: U) -> Self

where U: Into<Box<T>>,

Creates a new Dynamic from a value that can be converted into Box<T>.

Examples

use secure_gate::Dynamic;

let secret: Dynamic<String> = Dynamic::new("hunter2".to_string());
assert_eq!(secret.expose_secret(), "hunter2");

impl<T: ?Sized> Dynamic<T>

pub fn expose_secret(&self) -> &T

Accesses the secret value immutably.

This is the canonical, explicit way to read the secret.

Examples

use secure_gate::Dynamic;

let secret: Dynamic<String> = "secret".into();
assert_eq!(secret.expose_secret(), "secret");

pub fn expose_secret_mut(&mut self) -> &mut T

Accesses the secret value mutably.

Use for in-place modifications.

Examples

use secure_gate::Dynamic;

let mut secret: Dynamic<String> = "hello".into();
secret.expose_secret_mut().push('!');
assert_eq!(secret.expose_secret(), "hello!");

pub fn into_inner(self) -> Box<T>

Consumes the wrapper and returns the inner boxed value.

Examples

use secure_gate::Dynamic;

let secret: Dynamic<String> = "owned".into();
let owned: Box<String> = secret.into_inner();
assert_eq!(&*owned, "owned");

impl Dynamic<String>

pub fn finish_mut(&mut self) -> &mut String

Shrinks the string’s capacity to fit its length and returns a mutable reference.

Use this to eliminate slack memory after mutations.

Examples

use secure_gate::Dynamic;

let mut secret: Dynamic<String> = String::with_capacity(100).into();
secret.push_str("short");
let s: &mut String = secret.finish_mut();
assert_eq!(s.capacity(), 5);

impl Dynamic<Vec<u8>>

pub fn finish_mut(&mut self) -> &mut Vec<u8>

Shrinks the vector’s capacity to fit its length and returns a mutable reference.

Use this to eliminate slack memory after mutations.

Examples

use secure_gate::Dynamic;

let mut secret: Dynamic<Vec<u8>> = Vec::with_capacity(100).into();
secret.extend_from_slice(b"short");
let v: &mut Vec<u8> = secret.finish_mut();
assert_eq!(v.capacity(), 5);

Trait Implementations

impl<T: Clone + Zeroize> Clone for Dynamic<T>

Available on crate feature zeroize only.

fn clone(&self) -> Self

Clones the wrapper, cloning the inner value.

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

Performs copy-assignment from source.

impl<T: ?Sized> Debug for Dynamic<T>

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

Formats the value as “[REDACTED]” to prevent leakage in debug output.

impl<T: ?Sized> Deref for Dynamic<T>

fn deref(&self) -> &T

Dereferences the wrapper to access the inner value immutably.

type Target = T

The resulting type after dereferencing.

impl<T: ?Sized> DerefMut for Dynamic<T>

fn deref_mut(&mut self) -> &mut T

Dereferences the wrapper mutably to access the inner value.

impl From<&str> for Dynamic<String>

Convenience conversion from &str to Dynamic<String>.

Examples

use secure_gate::Dynamic;

let secret: Dynamic<String> = "password".into();
assert_eq!(secret.expose_secret(), "password");

fn from(s: &str) -> Self

Converts to this type from the input type.

impl<T: ?Sized> From<Box<T>> for Dynamic<T>

Converts a Box<T> into a Dynamic<T>.

fn from(boxed: Box<T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized + Zeroize> From<Dynamic<T>> for DynamicZeroizing<T>

Available on crate feature zeroize only.

fn from(dynamic: Dynamic<T>) -> Self

Converts to this type from the input type.

impl<T> From<T> for Dynamic<T>

where T: Sized,

Converts an owned value into a Dynamic.

Examples

use secure_gate::Dynamic;

let secret: Dynamic<Vec<u8>> = vec![1, 2, 3].into();
assert_eq!(secret.expose_secret(), &[1, 2, 3]);

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: PartialEq + ?Sized> PartialEq for Dynamic<T>

Implements PartialEq for Dynamic where T implements PartialEq.

This enables comparison on Dynamic types like Dynamic or Dynamic<Vec>.

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: Zeroize + DefaultIsZeroes> Zeroize for Dynamic<T>

Available on crate feature zeroize only.

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<T: Eq + ?Sized> Eq for Dynamic<T>

Implements Eq for Dynamic where T implements Eq.

impl<T: ?Sized + Zeroize> ZeroizeOnDrop for Dynamic<T>

Available on crate feature zeroize only.