Struct HKDFRng 

pub struct HKDFRng { /* private fields */ }

A deterministic random number generator based on HKDF-HMAC-SHA256.

HKDFRng uses the HMAC-based Key Derivation Function (HKDF) to generate deterministic random numbers from a combination of key material and salt. It serves as a key-stretching mechanism that can produce an arbitrary amount of random-looking bytes from a single seed.

Since it produces deterministic output based on the same inputs, it’s useful for situations where repeatable randomness is required, such as in testing or when deterministically deriving keys from a master seed.

Security considerations:

• The security of the generator depends on the entropy and secrecy of the key material
• The same key material and salt will always produce the same sequence
• Use a secure random seed for cryptographic applications
• Never reuse the same HKDFRng instance for different purposes

The implementation automatically handles buffer management, fetching new data using HKDF as needed with an incrementing counter to ensure unique output for each request.

Implementations

impl HKDFRng

pub fn new_with_page_length( key_material: impl AsRef<[u8]>, salt: &str, page_length: usize, ) -> Self

Creates a new HKDFRng with a custom page length.

Parameters

• key_material - The seed material to derive random numbers from
• salt - A salt value to mix with the key material
• page_length - The number of bytes to generate in each HKDF call

Returns

A new HKDFRng instance configured with the specified parameters.

Example

use bc_components::HKDFRng;
use rand_core::RngCore;

// Create an HKDF-based RNG with a 64-byte page length
let mut rng = HKDFRng::new_with_page_length(
    b"my secure seed",
    "application-context",
    64,
);

// Generate some random bytes
let random_u32 = rng.next_u32();

pub fn new(key_material: impl AsRef<[u8]>, salt: &str) -> Self

Creates a new HKDFRng with the default page length of 32 bytes.

Parameters

• key_material - The seed material to derive random numbers from
• salt - A salt value to mix with the key material

Returns

A new HKDFRng instance configured with the specified key material and salt.

Example

use bc_components::HKDFRng;
use rand_core::RngCore;

// Create an HKDF-based RNG
let mut rng = HKDFRng::new(b"my secure seed", "wallet-derivation");

// Generate two u32 values
let random1 = rng.next_u32();
let random2 = rng.next_u32();

// The same seed and salt will always produce the same sequence
let mut rng2 = HKDFRng::new(b"my secure seed", "wallet-derivation");
assert_eq!(random1, rng2.next_u32());
assert_eq!(random2, rng2.next_u32());

Trait Implementations

impl Drop for HKDFRng

fn drop(&mut self)

Executes the destructor for this type.

impl RngCore for HKDFRng

Implementation of the RngCore trait for HKDFRng.

This allows HKDFRng to be used with any code that accepts a random number generator implementing the standard Rust traits.

fn next_u32(&mut self) -> u32

Generates a random u32 value.

Returns

A deterministic random 32-bit unsigned integer.

fn next_u64(&mut self) -> u64

Generates a random u64 value.

Returns

A deterministic random 64-bit unsigned integer.

fn fill_bytes(&mut self, dest: &mut [u8])

Fills the provided buffer with random bytes.

Parameters

• dest - The buffer to fill with random bytes

fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>

Attempts to fill the provided buffer with random bytes.

This implementation never fails, so it simply calls fill_bytes.

Parameters

• dest - The buffer to fill with random bytes

Returns

Always returns Ok(()) as this implementation cannot fail.

impl CryptoRng for HKDFRng

Implementation of the CryptoRng marker trait for HKDFRng.

This marker indicates that HKDFRng is suitable for cryptographic use when seeded with appropriately secure key material.