# ReseedingRng in rand::rngs::adapter - Rust
A wrapper around any PRNG that implements `BlockRngCore`, that adds the ability to reseed it.
Keywords: rust, rustlang, rust-lang, ReseedingRng

# Struct rand::rngs::adapter::ReseedingRng

source · [−]

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

Expand description

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

`ReseedingRng` reseeds the underlying PRNG in the following cases:

- On a manual call to `reseed()`.
- After `clone()`, the clone will be reseeded on first use.
- When a process is forked on UNIX, the RNGs in both the parent and child processes will be reseeded just before the next call to `BlockRngCore::generate`, i.e. “soon”. For ChaCha and Hc128 this is a maximum of fifteen `u32` values before reseeding.
- After the PRNG has generated a configurable number of random bytes.

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

## Limitations

It is recommended that a `ReseedingRng` (including `ThreadRng`) not be used from a fork handler. Use `OsRng` or `getrandom`, or defer your use of the RNG until later.

## 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>());

## Implementations

source

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

source

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

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.

source

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

Reseed the internal PRNG.

## Trait Implementations

source

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

source

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

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from `source`. Read more

source

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

source

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

Formats the value using the given formatter. Read more

source

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

source

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

Return the next random `u32`. Read more

source

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

Return the next random `u64`. Read more

source

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

Fill `dest` with random data. Read more

source

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

Fill `dest` entirely with random data. Read more

source

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

## Auto Trait Implementations

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

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

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

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

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

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

#### fn clone_into(&self, target: &mut T)

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

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

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

source

### impl<V, T> VZip<V> for T where
V: MultiLane<T>,

source

#### fn vzip(self) -> V