pub trait RngCore {
// Required methods
fn next_u32(&mut self) -> u32;
fn next_u64(&mut self) -> u64;
fn fill_bytes(&mut self, dest: &mut [u8]);
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>;
}Expand description
The core of a random number generator.
This trait encapsulates the low-level functionality common to all
generators, and is the “back end”, to be implemented by generators.
End users should normally use the Rng trait from the rand crate,
which is automatically implemented for every type implementing RngCore.
Three different methods for generating random data are provided since the
optimal implementation of each is dependent on the type of generator. There
is no required relationship between the output of each; e.g. many
implementations of fill_bytes consume a whole number of u32 or u64
values and drop any remaining unused bytes. The same can happen with the
next_u32 and next_u64 methods, implementations may discard some
random bits for efficiency.
The try_fill_bytes method is a variant of fill_bytes allowing error
handling; it is not deemed sufficiently useful to add equivalents for
next_u32 or next_u64 since the latter methods are almost always used
with algorithmic generators (PRNGs), which are normally infallible.
Implementers should produce bits uniformly. Pathological RNGs (e.g. always
returning the same value, or never setting certain bits) can break rejection
sampling used by random distributions, and also break other RNGs when
seeding them via SeedableRng::from_rng.
Algorithmic generators implementing SeedableRng should normally have
portable, reproducible output, i.e. fix Endianness when converting values
to avoid platform differences, and avoid making any changes which affect
output (except by communicating that the release has breaking changes).
Typically an RNG will implement only one of the methods available
in this trait directly, then use the helper functions from the
impls module to implement the other methods.
It is recommended that implementations also implement:
Debugwith a custom implementation which does not print any internal state (at least,CryptoRngs should not risk leaking state throughDebug).SerializeandDeserialize(from Serde), preferably making Serde support optional at the crate level in PRNG libs.Clone, if possible.- never implement
Copy(accidental copies may cause repeated values). - do not implement
Defaultfor pseudorandom generators, but instead implementSeedableRng, to guide users towards proper seeding. External / hardware RNGs can choose to implementDefault. EqandPartialEqcould be implemented, but are probably not useful.
Example
A simple example, obviously not generating very random output:
#![allow(dead_code)]
use rand_core::{RngCore, Error, impls};
struct CountingRng(u64);
impl RngCore for CountingRng {
fn next_u32(&mut self) -> u32 {
self.next_u64() as u32
}
fn next_u64(&mut self) -> u64 {
self.0 += 1;
self.0
}
fn fill_bytes(&mut self, dest: &mut [u8]) {
impls::fill_bytes_via_next(self, dest)
}
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error> {
Ok(self.fill_bytes(dest))
}
}Required Methods§
sourcefn next_u32(&mut self) -> u32
fn next_u32(&mut self) -> u32
Return the next random u32.
RNGs must implement at least one method from this trait directly. In
the case this method is not implemented directly, it can be implemented
using self.next_u64() as u32 or via impls::next_u32_via_fill.
sourcefn next_u64(&mut self) -> u64
fn next_u64(&mut self) -> u64
Return the next random u64.
RNGs must implement at least one method from this trait directly. In
the case this method is not implemented directly, it can be implemented
via impls::next_u64_via_u32 or via impls::next_u64_via_fill.
sourcefn fill_bytes(&mut self, dest: &mut [u8])
fn fill_bytes(&mut self, dest: &mut [u8])
Fill dest with random data.
RNGs must implement at least one method from this trait directly. In
the case this method is not implemented directly, it can be implemented
via impls::fill_bytes_via_next or
via RngCore::try_fill_bytes; if this generator can
fail the implementation must choose how best to handle errors here
(e.g. panic with a descriptive message or log a warning and retry a few
times).
This method should guarantee that dest is entirely filled
with new data, and may panic if this is impossible
(e.g. reading past the end of a file that is being used as the
source of randomness).
sourcefn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>
Fill dest entirely with random data.
This is the only method which allows an RNG to report errors while
generating random data thus making this the primary method implemented
by external (true) RNGs (e.g. OsRng) which can fail. It may be used
directly to generate keys and to seed (infallible) PRNGs.
Other than error handling, this method is identical to RngCore::fill_bytes;
thus this may be implemented using Ok(self.fill_bytes(dest)) or
fill_bytes may be implemented with
self.try_fill_bytes(dest).unwrap() or more specific error handling.
Trait Implementations§
source§impl Read for dyn RngCore
impl Read for dyn RngCore
source§fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
fn read(&mut self, buf: &mut [u8]) -> Result<usize, Error>
1.36.0 · source§fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>
read, except that it reads into a slice of buffers. Read moresource§fn is_read_vectored(&self) -> bool
fn is_read_vectored(&self) -> bool
can_vector)1.0.0 · source§fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>
buf. Read more1.0.0 · source§fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>
buf. Read more1.6.0 · source§fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>
buf. Read moresource§fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>
read_buf)source§fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>
read_buf)cursor. Read more