Struct rand::ChaChaRng

pub struct ChaChaRng { /* fields omitted */ }

A random number generator that uses the ChaCha20 algorithm [1].

The ChaCha algorithm is widely accepted as suitable for cryptographic purposes, but this implementation has not been verified as such. Prefer a generator like OsRng that defers to the operating system for cases that need high security.

[1]: D. J. Bernstein, ChaCha, a variant of Salsa20

Methods

impl ChaChaRng

pub fn new_unseeded() -> ChaChaRng

Create an ChaCha random number generator using the default fixed key of 8 zero words.

Examples

use rand::{Rng, ChaChaRng};

let mut ra = ChaChaRng::new_unseeded();
println!("{:?}", ra.next_u32());
println!("{:?}", ra.next_u32());

Since this equivalent to a RNG with a fixed seed, repeated executions of an unseeded RNG will produce the same result. This code sample will consistently produce:

• 2917185654
• 2419978656

pub fn set_counter(&mut self, counter_low: u64, counter_high: u64)

Sets the internal 128-bit ChaCha counter to a user-provided value. This permits jumping arbitrarily ahead (or backwards) in the pseudorandom stream.

Since the nonce words are used to extend the counter to 128 bits, users wishing to obtain the conventional ChaCha pseudorandom stream associated with a particular nonce can call this function with arguments 0, desired_nonce.

Examples

use rand::{Rng, ChaChaRng};

let mut ra = ChaChaRng::new_unseeded();
ra.set_counter(0u64, 1234567890u64);
println!("{:?}", ra.next_u32());
println!("{:?}", ra.next_u32());

Trait Implementations

impl Rand for ChaChaRng

fn rand<R: Rng>(other: &mut R) -> ChaChaRng

Generates a random instance of this type using the specified source of randomness.

impl Rng for ChaChaRng

fn next_u32(&mut self) -> u32

Return the next random u32.

fn next_u64(&mut self) -> u64

Return the next random u64.

fn next_f32(&mut self) -> f32

Return the next random f32 selected from the half-open interval [0, 1).

fn next_f64(&mut self) -> f64

Return the next random f64 selected from the half-open interval [0, 1).

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

Fill dest with random data.

fn gen<T: Rand>(&mut self) -> T where     Self: Sized,

Return a random value of a Rand type.

Important traits for Generator<'a, T, R>

impl<'a, T: Rand, R: Rng> Iterator for Generator<'a, T, R> type Item = T;

fn gen_iter<'a, T: Rand>(&'a mut self) -> Generator<'a, T, Self> where     Self: Sized,

Return an iterator that will yield an infinite number of randomly generated items.

fn gen_range<T: PartialOrd + SampleRange>(&mut self, low: T, high: T) -> T where     Self: Sized,

Generate a random value in the range [low, high).

fn gen_weighted_bool(&mut self, n: u32) -> bool where     Self: Sized,

Return a bool with a 1 in n chance of true

Important traits for AsciiGenerator<'a, R>

impl<'a, R: Rng> Iterator for AsciiGenerator<'a, R> type Item = char;

fn gen_ascii_chars<'a>(&'a mut self) -> AsciiGenerator<'a, Self> where     Self: Sized,

Return an iterator of random characters from the set A-Z,a-z,0-9.

fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> where     Self: Sized,

Return a random element from values.

fn choose_mut<'a, T>(&mut self, values: &'a mut [T]) -> Option<&'a mut T> where     Self: Sized,

Return a mutable pointer to a random element from values.

fn shuffle<T>(&mut self, values: &mut [T]) where     Self: Sized,

Shuffle a mutable slice in place.

impl<'a> SeedableRng<&'a [u32]> for ChaChaRng

fn reseed(&mut self, seed: &'a [u32])

Reseed an RNG with the given seed.

fn from_seed(seed: &'a [u32]) -> ChaChaRng

Create a ChaCha generator from a seed, obtained from a variable-length u32 array. Only up to 8 words are used; if less than 8 words are used, the remaining are set to zero.

impl Clone for ChaChaRng

fn clone(&self) -> ChaChaRng

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for ChaChaRng

impl Debug for ChaChaRng

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

Formats the value using the given formatter.