Struct FuzzRng 

pub struct FuzzRng { /* private fields */ }

An RNG that expands a fuzzer byte slice into an infinite deterministic stream.

Design

FuzzRng maps a fuzzer-controlled byte slice to output blocks.

For each block counter ctr, it:

1. Reads a wrapping u64-wide window from the input bytes.
2. Xors in ctr and a domain constant.
3. Applies a SplitMix64-style finalizer.

input bytes (len = N):
  [b0 b1 b2 ... b(N-1)]

block ctr = i:
  word_i bytes = [b(i+0)%N, b(i+1)%N, ... b(i+7)%N]
  word_i       = big-endian u64 of those bytes
  out_i        = mix64(word_i ^ i ^ DOMAIN)

Why this mapping

Hashing the full input once and then seeding a PRNG makes tiny input changes look globally unrelated. This adapter avoids that by using a sliding window keyed by the block counter.

byte k affects anchors:
  i in [k-(BLOCK_BYTES-1), ..., k] (mod N)

Worked Example

With N = 4, input bytes repeat inside each block:

input: [a b c d]

ctr=0: word bytes [a b c d a b c d]
ctr=1: word bytes [b c d a b c d a]
ctr=2: word bytes [c d a b c d a b]
...

Even for low-entropy input like [0 0 0 0], output still changes because ctr is mixed into every block before finalization.

fill_bytes serves output from cached block bytes so callers get a stable byte stream regardless of whether they request randomness as next_u64, next_u32, or arbitrary byte slices.

Implementations

impl FuzzRng

pub const fn new(bytes: Vec<u8>) -> Self

Creates a new FuzzRng from a byte buffer.

Trait Implementations

impl RngCore for FuzzRng

fn next_u32(&mut self) -> u32

Return the next random u32.

fn next_u64(&mut self) -> u64

Return the next random u64.

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

Fill dest with random data.

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

Fill dest entirely with random data.

impl CryptoRng for FuzzRng