Struct rand::rngs::adapter::ReseedingRng

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

A wrapper around any PRNG which reseeds the underlying PRNG after it has generated a certain number of random bytes.

When the RNG gets cloned, the clone is reseeded on first use.

Reseeding 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'.

Some small non-cryptographic PRNGs can have very small periods, for example less than 2⁶⁴. Would reseeding help to ensure that you do not wrap around at the end of the period? A period of 2⁶⁴ still takes several centuries of CPU-years on current hardware. Reseeding will actually make things worse, because the reseeded PRNG will just continue somewhere else in the same period, with a high chance of overlapping with previously used parts of it.

When should you use ReseedingRng?

• 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, occasionally reseeding should make exploiting it much more difficult or even impossible.
• It can be used as a poor man's cryptography (not recommended, just use a good CSPRNG). Previous implementations of thread_rng for example used ReseedingRng with the ISAAC RNG. That algorithm, although apparently strong and with no known attack, does not come with any proof of security and does not meet the current standards for a cryptographically secure PRNG. By reseeding it frequently (every 32 kiB) it seems safe to assume there is no attack that can operate on the tiny window between reseeds.

Error handling

Although extremely 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.

Implementations

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

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

Create a new ReseedingRng with the given parameters.

Arguments

• rng: the random number generator to use.
• threshold: the number of generated bytes after which to reseed the RNG.
• reseeder: the RNG to use for reseeding.

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

Reseed the internal PRNG.

Trait Implementations

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

fn clone(&self) -> ReseedingRng<R, Rsdr>

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

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

fn next_u32(&mut self) -> u32

Return the next random u32.

fn next_u64(&mut self) -> u64

Return the next random u64.

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

Fill dest with random data.

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

Fill dest entirely with random data.