[][src]Struct rand::rngs::adapter::ReseedingRng

pub struct ReseedingRng<R, Rsdr>(_)
where
    R: BlockRngCore + SeedableRng,
    Rsdr: RngCore
;

A wrapper around any PRNG that implements BlockRngCore, that adds the ability to reseed it.

ReseedingRng reseeds the underlying PRNG in the following cases:

When should reseeding after a fixed number of generated bytes be used?

Reseeding after a fixed number of generated bytes is never strictly necessary. Cryptographic PRNGs don't have a limited number of bytes they can output, or at least not a limit reachable in any practical way. There is no such thing as 'running out of entropy'.

Occasionally reseeding can be seen as some form of 'security in depth'. Even if in the future a cryptographic weakness is found in the CSPRNG being used, or a flaw in the implementation, occasionally reseeding should make exploiting it much more difficult or even impossible.

Use ReseedingRng::new with a threshold of 0 to disable reseeding after a fixed number of generated bytes.

Error handling

Although unlikely, reseeding the wrapped PRNG can fail. ReseedingRng will never panic but try to handle the error intelligently through some combination of retrying and delaying reseeding until later. If handling the source error fails ReseedingRng will continue generating data from the wrapped PRNG without reseeding.

Manually calling reseed() will not have this retry or delay logic, but reports the error.

Example

use rand::prelude::*;
use rand_chacha::ChaCha20Core; // Internal part of ChaChaRng that
                             // implements BlockRngCore
use rand::rngs::OsRng;
use rand::rngs::adapter::ReseedingRng;

let prng = ChaCha20Core::from_entropy();
let mut reseeding_rng = ReseedingRng::new(prng, 0, OsRng);

println!("{}", reseeding_rng.gen::<u64>());

let mut cloned_rng = reseeding_rng.clone();
assert!(reseeding_rng.gen::<u64>() != cloned_rng.gen::<u64>());

Methods

impl<R, Rsdr> ReseedingRng<R, Rsdr> where
    R: BlockRngCore + SeedableRng,
    Rsdr: RngCore
[src]

pub fn new(rng: R, threshold: u64, reseeder: Rsdr) -> Self[src]

Create a new ReseedingRng from an existing PRNG, combined with a RNG to use as reseeder.

threshold sets the number of generated bytes after which to reseed the PRNG. Set it to zero to never reseed based on the number of generated values.

pub fn reseed(&mut self) -> Result<(), Error>[src]

Reseed the internal PRNG.

Trait Implementations

impl<R, Rsdr> Clone for ReseedingRng<R, Rsdr> where
    R: BlockRngCore + SeedableRng + Clone,
    Rsdr: RngCore + Clone
[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl<R: Debug, Rsdr: Debug> Debug for ReseedingRng<R, Rsdr> where
    R: BlockRngCore + SeedableRng,
    Rsdr: RngCore
[src]

impl<R, Rsdr: RngCore> RngCore for ReseedingRng<R, Rsdr> where
    R: BlockRngCore<Item = u32> + SeedableRng,
    <R as BlockRngCore>::Results: AsRef<[u32]> + AsMut<[u32]>, 
[src]

impl<R, Rsdr> CryptoRng for ReseedingRng<R, Rsdr> where
    R: BlockRngCore + SeedableRng + CryptoRng,
    Rsdr: RngCore + CryptoRng
[src]

Auto Trait Implementations

impl<R, Rsdr> Unpin for ReseedingRng<R, Rsdr> where
    R: Unpin,
    Rsdr: Unpin,
    <R as BlockRngCore>::Results: Unpin

impl<R, Rsdr> Sync for ReseedingRng<R, Rsdr> where
    R: Sync,
    Rsdr: Sync,
    <R as BlockRngCore>::Results: Sync

impl<R, Rsdr> Send for ReseedingRng<R, Rsdr> where
    R: Send,
    Rsdr: Send,
    <R as BlockRngCore>::Results: Send

impl<R, Rsdr> UnwindSafe for ReseedingRng<R, Rsdr> where
    R: UnwindSafe,
    Rsdr: UnwindSafe,
    <R as BlockRngCore>::Results: UnwindSafe

impl<R, Rsdr> RefUnwindSafe for ReseedingRng<R, Rsdr> where
    R: RefUnwindSafe,
    Rsdr: RefUnwindSafe,
    <R as BlockRngCore>::Results: RefUnwindSafe

Blanket Implementations

impl<R> Rng for R where
    R: RngCore + ?Sized
[src]

fn gen<T>(&mut self) -> T where
    Standard: Distribution<T>, 
[src]

Return a random value supporting the [Standard] distribution. Read more

fn gen_range<T: SampleUniform, B1, B2>(&mut self, low: B1, high: B2) -> T where
    B1: SampleBorrow<T> + Sized,
    B2: SampleBorrow<T> + Sized
[src]

Generate a random value in the range [low, high), i.e. inclusive of low and exclusive of high. Read more

fn sample<T, D: Distribution<T>>(&mut self, distr: D) -> T[src]

Sample a new value, using the given distribution. Read more

Important traits for DistIter<D, R, T>
fn sample_iter<T, D>(self, distr: D) -> DistIter<D, Self, T> where
    D: Distribution<T>,
    Self: Sized
[src]

Create an iterator that generates values using the given distribution. Read more

fn fill<T: AsByteSliceMut + ?Sized>(&mut self, dest: &mut T)[src]

Fill dest entirely with random bytes (uniform value distribution), where dest is any type supporting [AsByteSliceMut], namely slices and arrays over primitive integer types (i8, i16, u32, etc.). Read more

fn try_fill<T: AsByteSliceMut + ?Sized>(
    &mut self,
    dest: &mut T
) -> Result<(), Error>
[src]

Fill dest entirely with random bytes (uniform value distribution), where dest is any type supporting [AsByteSliceMut], namely slices and arrays over primitive integer types (i8, i16, u32, etc.). Read more

fn gen_bool(&mut self, p: f64) -> bool[src]

Return a bool with a probability p of being true. Read more

fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool[src]

Return a bool with a probability of numerator/denominator of being true. I.e. gen_ratio(2, 3) has chance of 2 in 3, or about 67%, of returning true. If numerator == denominator, then the returned value is guaranteed to be true. If numerator == 0, then the returned value is guaranteed to be false. Read more

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 
[src]