Struct Fixed 

pub struct Fixed<T>(pub T);

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

Fixed<T> stores its value directly in the struct (no heap allocation). It behaves exactly like T thanks to Deref/DerefMut, but:

• Prints as [REDACTED] in debug output
• Provides .expose_secret() as the explicit, loud way to access the secret
• Works perfectly with fixed_alias! for beautiful type aliases

Examples

use secure_gate::{Fixed, fixed_alias};

// Define a beautiful type alias (this is the recommended pattern)
fixed_alias!(Aes256Key, 32);

// Generate a random key and convert it directly
let raw_key = [42u8; 32];  // In real code: use rand::Rng::gen()
let key: Aes256Key = raw_key.into();

// Access the bytes
let bytes: &[u8] = key.expose_secret();
assert_eq!(bytes.len(), 32);

Tuple Fields

0: T

Implementations

impl<T> Fixed<T>

pub const fn new(value: T) -> Self

Create a new Fixed wrapper around a value.

This is usually not called directly — prefer fixed_alias! + .into().

impl<const N: usize> Fixed<[u8; N]>

Convert a byte slice into a fixed-size secret.

Panics if the slice length doesn’t match exactly.

Panics

Panics with “slice length mismatch” if bytes.len() != N.

pub fn from_slice(bytes: &[u8]) -> Self

impl<T> Fixed<T>

pub fn expose_secret(&self) -> &T

Access the secret value immutably.

This is the canonical way to read the secret — loud and clear.

Examples

use secure_gate::{Fixed, fixed_alias};

fixed_alias!(Aes256Key, 32);

let key: Aes256Key = [1u8; 32].into();
let bytes: &[u8] = key.expose_secret();
assert_eq!(bytes[0], 1);

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

Access the secret value mutably.

Use this for in-place operations like key derivation.

pub fn into_inner(self) -> T

Consume the wrapper and return the inner value.

This is useful when you need to pass the secret to a function that takes ownership.

Trait Implementations

impl<const N: usize> AsMut<[u8]> for Fixed<[u8; N]>

Mutably borrow as a byte slice — e.g. for key scheduling.

fn as_mut(&mut self) -> &mut [u8]

Converts this type into a mutable reference of the (usually inferred) input type.

impl<const N: usize> AsRef<[u8]> for Fixed<[u8; N]>

Borrow as a byte slice — useful for crypto APIs.

fn as_ref(&self) -> &[u8]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone> Clone for Fixed<T>

Clone is implemented when the inner type is Clone.

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Fixed<T>

All Fixed<T> values print as [REDACTED] to prevent accidental leakage.

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

Formats the value using the given formatter.

impl<T> Deref for Fixed<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for Fixed<T>

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

Mutably dereferences the value.

impl<const N: usize> From<[u8; N]> for Fixed<[u8; N]>

Convert a raw array into a fixed-size secret.

This enables the beautiful let key: Aes256Key = rng.gen().into(); pattern.

fn from(arr: [u8; N]) -> Self

Converts to this type from the input type.

impl<T: Zeroize> From<Fixed<T>> for FixedZeroizing<T>

Available on crate feature zeroize only.

fn from(fixed: Fixed<T>) -> Self

Converts to this type from the input type.

impl<T: Zeroize> Zeroize for Fixed<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<const N: usize> Copy for Fixed<[u8; N]>

where [u8; N]: Copy,

Copy is implemented for small fixed-size byte arrays.

impl<T: Zeroize> ZeroizeOnDrop for Fixed<T>

Available on crate feature zeroize only.