Struct ChaCha12Rng 

pub struct ChaCha12Rng { /* private fields */ }

A cryptographically secure random number generator that uses the ChaCha stream cipher.

See the crate docs for more information about the underlying stream cipher.

This RNG implementation uses a 64-bit counter and 64-bit stream identifier (a.k.a nonce). A 64-bit counter over 64-byte (16 word) blocks allows 1 ZiB of output before cycling, and the stream identifier allows 2⁶⁴ unique streams of output per seed. Both counter and stream are initialized to zero but may be set via the set_word_pos and set_stream methods.

Example

use chacha20::ChaCha12Rng;
use rand_core::{SeedableRng, Rng};

let seed = [42u8; 32];
let mut rng = ChaCha12Rng::from_seed(seed);

let random_u32 = rng.next_u32();
let random_u64 = rng.next_u64();

let mut random_bytes = [0u8; 3];
rng.fill_bytes(&mut random_bytes);

See the rand crate for more advanced RNG functionality.

Implementations

impl ChaCha12Rng

pub fn get_word_pos(&self) -> u128

Get the offset from the start of the stream, in 32-bit words.

Since the generated blocks are 16 words (2⁴) long and the counter is 64-bits, the offset is a 68-bit number. Sub-word offsets are not supported, hence the result can simply be multiplied by 4 to get a byte-offset.

pub fn set_word_pos(&mut self, word_offset: u128)

Set the offset from the start of the stream, in 32-bit words.

This value will be erased when calling set_stream(), so call set_stream() before calling set_word_pos() if you intend on using both of them together.

As with get_word_pos, we use a 68-bit number. Since the generator simply cycles at the end of its period (1 ZiB), we ignore the upper 60 bits.

pub fn set_block_pos(&mut self, block_pos: u64)

Sets the block pos and resets the RNG’s index.

This value will be erased when calling set_stream(), so call set_stream() before calling set_block_pos() if you intend on using both of them together.

The word pos will be equal to block_pos * 16 words per block.

pub fn get_block_pos(&self) -> u64

Get the block pos.

pub fn set_stream(&mut self, stream: u64)

Set the stream ID and reset the word_pos to 0.

pub fn get_stream(&self) -> u64

Get the stream number (nonce).

pub fn get_seed(&self) -> [u8; 32]

Get the RNG seed.

pub fn serialize_state(&self) -> [u8; 49]

Serialize RNG state.

Warning

Leaking serialized RNG state to an attacker defeats security properties provided by the RNG.

pub fn deserialize_state(state: &[u8; 49]) -> ChaCha12Rng

Deserialize RNG state.

Trait Implementations

impl Debug for ChaCha12Rng

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

Formats the value using the given formatter.

impl Eq for ChaCha12Rng

impl PartialEq for ChaCha12Rng

fn eq(&self, rhs: &ChaCha12Rng) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SeedableRng for ChaCha12Rng

type Seed = [u8; 32]

Seed type, which is restricted to types mutably-dereferenceable as u8 arrays (we recommend [u8; N] for some N).

fn from_seed(seed: <ChaCha12Rng as SeedableRng>::Seed) -> ChaCha12Rng

Create a new PRNG using the given seed.

fn seed_from_u64(state: u64) -> Self

Create a new PRNG using a u64 seed.

fn from_rng<R>(rng: &mut R) -> Self

where R: Rng + ?Sized,

Create a new PRNG seeded from an infallible Rng.

fn try_from_rng<R>(rng: &mut R) -> Result<Self, <R as TryRng>::Error>

where R: TryRng + ?Sized,

Create a new PRNG seeded from a potentially fallible Rng.

fn fork(&mut self) -> Self

where Self: Rng,

Fork this PRNG

fn try_fork(&mut self) -> Result<Self, Self::Error>

where Self: TryRng,

Fork this PRNG

impl TryCryptoRng for ChaCha12Rng

impl TryRng for ChaCha12Rng

type Error = Infallible

The type returned in the event of a RNG error.

fn try_next_u32(&mut self) -> Result<u32, <ChaCha12Rng as TryRng>::Error>

Return the next random u32.

fn try_next_u64(&mut self) -> Result<u64, <ChaCha12Rng as TryRng>::Error>

Return the next random u64.

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

Fill dst entirely with random data.