# Struct rand::chacha::ChaChaRng [−] [src]

    pub struct ChaChaRng {
        // some 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`

#### `fn new_unseeded() -> ChaChaRng`

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

#### `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`.

## Trait Implementations

### `impl Rng for ChaChaRng`

#### `fn next_u32(&mut self) -> u32`

#### `fn next_u64(&mut self) -> u64`

#### `fn next_f32(&mut self) -> f32`

#### `fn next_f64(&mut self) -> f64`

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

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

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

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

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

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

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

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

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

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

#### `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 Rand for ChaChaRng`

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

### Derived Implementations

### `impl Clone for ChaChaRng`

#### `fn clone(&self) -> ChaChaRng`

#### `fn clone_from(&mut self, source: &Self)`1.0.0

### `impl Copy for ChaChaRng`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)