Struct nanorand::rand::chacha::ChaCha

#[repr(C)]
pub struct ChaCha<const ROUNDS: u8> { /* fields omitted */ }

An instance of the ChaCha random number generator. Seeded from the system entropy generator when available. This generator is theoretically cryptographically secure.

Implementations

impl<const ROUNDS: u8> ChaCha<ROUNDS>

pub fn new() -> Self

Create a new ChaCha instance, seeding from the system’s default source of entropy.

pub const fn new_key(key: [u8; 32], nonce: [u8; 8]) -> Self

Create a new ChaCha instance, using the provided key and nonce.

Trait Implementations

impl<const ROUNDS: u8> Clone for ChaCha<ROUNDS>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<const ROUNDS: u8> Default for ChaCha<ROUNDS>

fn default() -> Self

Returns the “default value” for a type.

impl<const ROUNDS: u8> Display for ChaCha<ROUNDS>

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

Formats the value using the given formatter.

impl<const ROUNDS: u8> Drop for ChaCha<ROUNDS>

fn drop(&mut self)

Executes the destructor for this type.

impl<const ROUNDS: u8> Rng for ChaCha<ROUNDS>

type Output = [u8; 64]

The byte output that this RNG emits.

fn rand(&mut self) -> Self::Output

Generates a random sequence of bytes, seeding from the internal state.

fn rand_with_seed(_seed: &[u8]) -> Self::Output

Generates a random sequence of bytes, with a custom seed.

fn reseed(&mut self, new_seed: &[u8])

Reseeds the RNG using a custom seed.

fn generate<R>(&mut self) -> R where
    R: RandomGen<Self>, 

Generates a random of the specified type, seeding from the internal state.

fn fill<R, A>(&mut self, target: A) where
    R: RandomGen<Self>,
    A: AsMut<[R]>, 

Fill an array with the specified type.

fn generate_range<R, B>(&mut self, range: B) -> R where
    R: RandomRange<Self>,
    B: RangeBounds<R>, 

Generates a random of the specified type, seeding from the internal state.

fn shuffle<I, S>(&mut self, target: S) where
    S: AsMut<[I]>, 

Shuffle a slice, using the RNG.

impl<const ROUNDS: u8> Zeroize for ChaCha<ROUNDS>

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.