Struct Fixed 

pub struct Fixed<T> { /* private fields */ }

Re-export of the Fixed type.

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

pub fn from_random() -> Self

Generate a secure random instance (panics on failure).

Fill with fresh random bytes using the System RNG. Panics on RNG failure for fail-fast crypto code. Guarantees secure entropy from system sources.

Example

use secure_gate::{Fixed, ExposeSecret};
let random: Fixed<[u8; 32]> = Fixed::from_random();
assert_eq!(random.len(), 32);

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

pub fn try_from_hex(s: &str) -> Result<Self, HexError>

Decode a hex string into a Fixed secret.

The decoded bytes must exactly match the array length N.

Example

use secure_gate::{Fixed, ExposeSecret};
let hex_string = "424344"; // 3 bytes
let secret: Fixed<[u8; 3]> = Fixed::try_from_hex(hex_string).unwrap();
assert_eq!(secret.expose_secret()[0], 0x42);

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

pub fn try_from_base64url(s: &str) -> Result<Self, Base64Error>

Decode a base64url string into a Fixed secret.

The decoded bytes must exactly match the array length N.

Example

use secure_gate::{Fixed, ExposeSecret};
let b64_string = "QkNE"; // 3 bytes
let secret: Fixed<[u8; 3]> = Fixed::try_from_base64url(b64_string).unwrap();
assert_eq!(secret.expose_secret()[0], 0x42);

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

pub fn try_from_bech32(s: &str) -> Result<Self, Bech32Error>

Decode a bech32 string into a Fixed secret, discarding the HRP.

The decoded bytes must exactly match the array length N.

Example

use secure_gate::{Fixed, ExposeSecret, ToBech32};
let original = Fixed::new([1, 2, 3, 4]);
let bech32_string = original.with_secret(|s| s.to_bech32("test"));
let decoded = Fixed::<[u8; 4]>::try_from_bech32(&bech32_string).unwrap();
// HRP "test" is discarded

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

pub fn try_from_bech32m(s: &str) -> Result<Self, Bech32Error>

Decode a bech32m string into a Fixed secret, discarding the HRP.

The decoded bytes must exactly match the array length N.

Example

use secure_gate::Fixed;
// Note: Bech32m strings must be valid Bech32m format
let bech32m_string = "abc1qpzry9x8gf2tvdw0s3jn54khce6mua7lmqqqxw"; // 32 bytes
let secret: Result<Fixed<[u8; 32]>, _> = Fixed::try_from_bech32m(bech32m_string);
// Returns Result<Fixed<[u8; 32]>, Bech32Error>

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

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));

Trait Implementations

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

Available on crate feature cloneable only.

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> ConstantTimeEq for Fixed<T>

where T: ConstantTimeEq,

Available on crate feature ct-eq only.

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

Compare two values in constant time.

impl<T> ConstantTimeEqExt for Fixed<T>

where T: AsRef<[u8]> + ConstantTimeEq,

Available on crate feature ct-eq-hash only.

fn len(&self) -> usize

Get the length of the secret data in bytes.

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

Force BLAKE3 digest comparison (constant-time on 32-byte output).

fn ct_eq_auto(&self, other: &Self, threshold_bytes: Option<usize>) -> bool

Recommended hybrid constant-time equality check.

impl<T> Debug for Fixed<T>

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

Formats the value using the given formatter.

impl<'de, const N: usize> Deserialize<'de> for Fixed<[u8; N]>

Available on crate feature serde-deserialize only.

Custom serde deserialization for byte arrays (direct to sequence).

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

type Inner = [T; N]

The inner secret type being exposed.

fn with_secret<F, R>(&self, f: F) -> R

where F: FnOnce(&[T; N]) -> R,

Provide scoped read-only access to the secret.

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, T> ExposeSecretMut for Fixed<[T; N]>

fn with_secret_mut<F, R>(&mut self, f: F) -> R

where F: FnOnce(&mut [T; N]) -> R,

Provide scoped mutable access to the secret.

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

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<T> Serialize for Fixed<T>

where T: SerializableSecret,

Available on crate feature serde-serialize only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

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

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

Attempt to create a Fixed from a byte slice. In debug builds, panics with detailed information on length mismatch to aid development. In release builds, returns an error on length mismatch to prevent information leaks.

Example

use secure_gate::Fixed;
let slice: &[u8] = &[1u8, 2, 3, 4];
let key: Result<Fixed<[u8; 4]>, _> = slice.try_into();
assert!(key.is_ok());

type Error = FromSliceError

The type returned in the event of a conversion error.

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

Available on crate feature zeroize only.

Zeroize on drop integration