Struct Fixed 

pub struct Fixed<T>(/* private fields */);

Re-export of the Fixed type. Stack-allocated secure secret wrapper.

This is a zero-cost wrapper for fixed-size secrets like byte arrays or primitives. The inner field is private, forcing all access through explicit methods.

Security invariants:

• No Deref or AsRef — prevents silent access or borrowing.
• No implicit Copy — even for [u8; N], duplication must be explicit via .clone().
• Debug is always redacted.

Examples

Basic usage:

use secure_gate::{Fixed, ExposeSecret};
let secret = Fixed::new(42u32);
assert_eq!(*secret.expose_secret(), 42);

For byte arrays (most common):

use secure_gate::{fixed_alias, Fixed, ExposeSecret};
fixed_alias!(Aes256Key, 32);
let key_bytes = [0x42u8; 32];
let key: Aes256Key = Fixed::from(key_bytes);
assert_eq!(key.len(), 32);
assert_eq!(key.expose_secret()[0], 0x42);

With zeroize feature (automatic wipe on drop):

use secure_gate::Fixed;
let mut secret = Fixed::new([1u8, 2, 3]);
drop(secret); // memory wiped automatically

Implementations

impl<T> Fixed<T>

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

Wrap a value in a Fixed secret.

This is zero-cost and const-friendly.

Example

use secure_gate::Fixed;
const SECRET: Fixed<u32> = Fixed::new(42);

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

This impl block contains no items.

Byte-array specific helpers

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

Constant-time equality — only available with ct-eq feature.

pub fn ct_eq(&self, other: &Self) -> bool

Constant-time equality comparison.

This is the only safe way to compare two fixed-size secrets. Available only when the ct-eq feature is enabled.

Example

use secure_gate::Fixed;
let a = Fixed::new([1u8; 32]);
let b = Fixed::new([1u8; 32]);
assert!(a.ct_eq(&b));

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

Random generation — only available with rand feature.

pub fn generate_random() -> Self

Generate fresh random bytes using the OS RNG.

This is a convenience method that generates random bytes directly without going through FixedRandom. Equivalent to: FixedRandom::<N>::generate().into_inner()

Example

use secure_gate::Fixed;
let key: Fixed<[u8; 32]> = Fixed::generate_random();

pub fn try_generate_random() -> Result<Self, OsError>

Try to generate random bytes for Fixed.

Returns an error if the RNG fails.

Example

use secure_gate::Fixed;
let key: Result<Fixed<[u8; 32]>, rand::rand_core::OsError> = Fixed::try_generate_random();
assert!(key.is_ok());

impl<const N: usize> Fixed<CloneableArrayInner<N>>

pub fn init_with<F>(constructor: F) -> Self

where F: FnOnce() -> [u8; N],

Construct a cloneable array secret by building it in a closure.

Same stack-minimization benefits as CloneableString::init_with.

Example

use secure_gate::CloneableArray;

let key = CloneableArray::<32>::init_with(|| {
    let mut arr = [0u8; 32];
    // Fill from some source...
    arr
});

pub fn try_init_with<F, E>(constructor: F) -> Result<Self, E>

where F: FnOnce() -> Result<[u8; N], E>,

Fallible version of init_with.

Same stack-minimization benefits as init_with, but allows for construction that may fail with an error. Useful when reading secrets from fallible sources like files or network connections.

Trait Implementations

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

Available on crate feature zeroize only.

Opt-in Clone — only for types marked CloneSafe (default no-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>

Debug implementation (always redacted).

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

Formats the value using the given formatter.

impl<const N: usize, T> ExposeSecret for Fixed<[T; N]>

Implementation for [Fixed<[T; N]>] - provides full read/write access for arrays.

Fixed is a core wrapper that allows both reading and mutation of secrets. This implementation directly accesses the inner field.

type Inner = [T; N]

The inner secret type being exposed.

fn expose_secret(&self) -> &[T; N]

Expose the secret for read-only access.

fn len(&self) -> usize

Returns the length of the secret.

fn is_empty(&self) -> bool

Returns true if the secret is empty.

impl<const N: usize> ExposeSecret for Fixed<CloneableArrayInner<N>>

Available on crate feature zeroize only.

Implementation for Fixed<CloneableArrayInner<N>> - exposes the inner wrapper.

type Inner = CloneableArrayInner<N>

The inner secret type being exposed.

fn expose_secret(&self) -> &CloneableArrayInner<N>

Expose the secret for read-only access.

fn len(&self) -> usize

Returns the length of the secret.

fn is_empty(&self) -> bool

Returns true if the secret is empty.

impl ExposeSecret for Fixed<u32>

Implementation for Fixed<u32> - provides access for test compatibility.

type Inner = u32

The inner secret type being exposed.

fn expose_secret(&self) -> &u32

Expose the secret for read-only access.

fn len(&self) -> usize

Returns the length of the secret.

fn is_empty(&self) -> bool

Returns true if the secret is empty.

impl<const N: usize, T> ExposeSecretMut for Fixed<[T; N]>

Implementation for [Fixed<[T; N]>] - provides mutable access for arrays.

Extends the read-only implementation with mutation capabilities.

fn expose_secret_mut(&mut self) -> &mut [T; N]

Expose the secret for mutable access.

impl<const N: usize> ExposeSecretMut for Fixed<CloneableArrayInner<N>>

Available on crate feature zeroize only.

Implementation for Fixed<CloneableArrayInner<N>> - provides mutable access.

fn expose_secret_mut(&mut self) -> &mut CloneableArrayInner<N>

Expose the secret for mutable access.

impl ExposeSecretMut for Fixed<u32>

Implementation for Fixed<u32> - provides mutable access.

fn expose_secret_mut(&mut self) -> &mut u32

Expose the secret for mutable access.

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

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

Wrap a raw byte array in a Fixed secret.

Zero-cost conversion.

Example

use secure_gate::Fixed;
let key: Fixed<[u8; 4]> = [1, 2, 3, 4].into();

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

fn from(rng: FixedRandom<N>) -> Self

Convert a FixedRandom to Fixed, transferring ownership.

This preserves all security guarantees. The FixedRandom type ensures the value came from secure RNG, and this conversion transfers that value to Fixed without exposing bytes.

Example

use secure_gate::{Fixed, random::FixedRandom};
let key: Fixed<[u8; 32]> = FixedRandom::<32>::generate().into();

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

Implements TryFrom<&[u8]> for creating a Fixed from a byte slice of exact length.

type Error = FromSliceError

The type returned in the event of a conversion error.

fn try_from(slice: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.

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

Available on crate feature zeroize only.

Zeroize integration.

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: Zeroize> ZeroizeOnDrop for Fixed<T>

Available on crate feature zeroize only.

Zeroize on drop integration.