Struct FixedRandom 

pub struct FixedRandom<const N: usize>(/* private fields */);

Fixed-length cryptographically secure random value with encoding methods.

This is a newtype over Fixed<[u8; N]> that enforces construction only via secure RNG. Guarantees freshness — cannot be created from arbitrary bytes.

Requires the rand feature.

Supports direct encoding to Hex, Base64, Bech32, and Bech32m via convenience methods.

Examples

Basic usage:

use secure_gate::random::FixedRandom;
let random: FixedRandom<32> = FixedRandom::generate();
assert_eq!(random.len(), 32);

With alias:

use secure_gate::fixed_alias_random;
fixed_alias_random!(Nonce, 24);
let nonce = Nonce::generate();

Implementations

impl<const N: usize> FixedRandom<N>

pub fn generate() -> Self

Generate fresh random bytes using the OS RNG.

Uses rand::rngs::OsRng directly for maximum throughput. Panics if the RNG fails (rare, but correct for crypto code).

Example

use secure_gate::random::FixedRandom;
let random = FixedRandom::<16>::generate();
assert!(!random.is_empty());

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

Try to generate fresh random bytes using the OS RNG.

Returns an error if the RNG fails.

Example

use secure_gate::random::FixedRandom;
let random: Result<FixedRandom<32>, rand::rand_core::OsError> = FixedRandom::try_generate();
assert!(random.is_ok());

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

Expose the random bytes for read-only access.

Example

use secure_gate::random::FixedRandom;
let random = FixedRandom::<4>::generate();
let bytes = random.expose_secret();

pub const fn len(&self) -> usize

Returns the fixed length in bytes.

pub const fn is_empty(&self) -> bool

Returns true if the length is zero.

pub fn into_inner(self) -> Fixed<[u8; N]>

Consume the wrapper and return the inner Fixed<[u8; N]>.

This transfers ownership without exposing the secret bytes. The returned Fixed retains all security guarantees (zeroize, etc.).

Example

use secure_gate::{Fixed, random::FixedRandom};
let random = FixedRandom::<32>::generate();
let fixed: Fixed<[u8; 32]> = random.into_inner();
// Can now use fixed.expose_secret() as needed

impl<const N: usize> FixedRandom<N>

pub fn into_base64(self) -> Base64String

Consume self and return the random bytes as a validated base64 string.

The raw bytes are zeroized immediately after encoding.

impl<const N: usize> FixedRandom<N>

pub fn to_base64(&self) -> Base64String

Borrow and encode the random bytes as a validated base64 string (allocates).

The original secret remains intact and usable.

impl<const N: usize> FixedRandom<N>

pub fn try_into_bech32( self, hrp: &str, ) -> Result<Bech32String, Bech32EncodingError>

Consume self and return the random bytes as a validated Bech32 string with the specified HRP.

The raw bytes are zeroized immediately after encoding (via drop of self).

Errors

Returns an error if the HRP is invalid.

pub fn try_into_bech32m( self, hrp: &str, ) -> Result<Bech32String, Bech32EncodingError>

Consume self and return the random bytes as a validated Bech32m string with the specified HRP.

The raw bytes are zeroized immediately after encoding (via drop of self).

Errors

Returns an error if the HRP is invalid.

impl<const N: usize> FixedRandom<N>

pub fn try_to_bech32( &self, hrp: &str, ) -> Result<Bech32String, Bech32EncodingError>

Borrow and encode the random bytes as a validated Bech32 string with the specified HRP (allocates).

The original secret remains intact and usable.

Errors

Returns an error if the HRP is invalid.

pub fn try_to_bech32m( &self, hrp: &str, ) -> Result<Bech32String, Bech32EncodingError>

Borrow and encode the random bytes as a validated Bech32m string with the specified HRP (allocates).

The original secret remains intact and usable.

Errors

Returns an error if the HRP is invalid.

impl<const N: usize> FixedRandom<N>

pub fn into_hex(self) -> HexString

Consume self and return the random bytes as a validated hex string.

The raw bytes are zeroized immediately after encoding.

impl<const N: usize> FixedRandom<N>

pub fn to_hex(&self) -> HexString

Borrow and encode the random bytes as a validated lowercase hex string (allocates).

The original secret remains intact and usable.

Trait Implementations

impl<const N: usize> Debug for FixedRandom<N>

Debug implementation (always redacted).

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

Formats the value using the given formatter.

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