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 via Deref/DerefMut, but redacts itself in debug output and requires explicit access to the inner value.

Use this for fixed-size secrets like encryption keys or nonces.

Examples

use secure_gate::Fixed;

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

Tuple Fields

0: T

Implementations

impl<T> Fixed<T>

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

Creates a new Fixed wrapper around the given value.

This is zero-cost and usually not called directly—prefer fixed_alias! + .into().

Examples

use secure_gate::Fixed;

let secret = Fixed::new([42u8; 32]);
assert_eq!(secret.len(), 32);

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

Converts a byte slice into a fixed-size secret array.

Panics

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

Examples

use secure_gate::Fixed;

let bytes = [42u8; 32];
let secret = Fixed::from_slice(&bytes);
assert_eq!(secret.expose_secret(), &[42u8; 32]);

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

impl<T> Fixed<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::Fixed;

let secret: Fixed<i32> = Fixed::new(42);
assert_eq!(*secret.expose_secret(), 42);

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

Accesses the secret value mutably.

Use for in-place modifications.

Examples

use secure_gate::Fixed;

let mut secret: Fixed<i32> = Fixed::new(42);
*secret.expose_secret_mut() += 1;
assert_eq!(*secret.expose_secret(), 43);

pub fn into_inner(self) -> T

Consumes the wrapper and returns the inner value.

Useful for passing ownership to functions expecting T.

Examples

use secure_gate::Fixed;

let secret: Fixed<i32> = Fixed::new(42);
let value: i32 = secret.into_inner();
assert_eq!(value, 42);

Trait Implementations

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

Mutably borrows the fixed byte array as a slice.

Useful for in-place modifications like key scheduling.

Examples

use secure_gate::Fixed;

let mut secret: Fixed<[u8; 4]> = [1, 2, 3, 4].into();
let slice: &mut [u8] = secret.as_mut();
slice[0] = 42;
assert_eq!(secret.expose_secret(), &[42, 2, 3, 4]);

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]>

Borrows the fixed byte array as a slice.

Useful for passing to crypto APIs expecting &[u8].

Examples

use secure_gate::Fixed;

let secret: Fixed<[u8; 4]> = [1, 2, 3, 4].into();
let slice: &[u8] = secret.as_ref();
assert_eq!(slice, &[1, 2, 3, 4]);

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>

Implements Clone 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>

fn deref(&self) -> &T

Dereferences the wrapper to access the inner value immutably.

type Target = T

The resulting type after dereferencing.

impl<T> DerefMut for Fixed<T>

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

Dereferences the wrapper mutably to access the inner value.

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

Converts a raw array into a fixed-size secret.

Enables idiomatic construction like Aes256Key::from(rng.gen()).

Examples

use secure_gate::Fixed;

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

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.

Convenience conversions from non-zeroizing wrappers.

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.

Zeroize impls for the non-zeroizing wrappers when the zeroize feature is active.

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,

Implements Copy for small fixed-size byte arrays.

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

Available on crate feature zeroize only.