[−][src]Struct rand::rngs::JitterRng
A true random number generator based on jitter in the CPU execution time, and jitter in memory access time.
Methods
impl JitterRng
[src]
pub fn new() -> Result<JitterRng, TimerError>
[src]
Create a new JitterRng
. Makes use of std::time
for a timer, or a
platform-specific function with higher accuracy if necessary and
available.
During initialization CPU execution timing jitter is measured a few hundred times. If this does not pass basic quality tests, an error is returned. The test result is cached to make subsequent calls faster.
pub fn new_with_timer(timer: fn() -> u64) -> JitterRng
[src]
Create a new JitterRng
.
A custom timer can be supplied, making it possible to use JitterRng
in
no_std
environments.
The timer must have nanosecond precision.
This method is more low-level than new()
. It is the responsibility of
the caller to run test_timer
before using any numbers generated with
JitterRng
, and optionally call set_rounds
. Also it is important to
consume at least one u64
before using the first result to initialize
the entropy collection pool.
Example
use rand_jitter::JitterRng; fn get_nstime() -> u64 { use std::time::{SystemTime, UNIX_EPOCH}; let dur = SystemTime::now().duration_since(UNIX_EPOCH).unwrap(); // The correct way to calculate the current time is // `dur.as_secs() * 1_000_000_000 + dur.subsec_nanos() as u64` // But this is faster, and the difference in terms of entropy is // negligible (log2(10^9) == 29.9). dur.as_secs() << 30 | dur.subsec_nanos() as u64 } let mut rng = JitterRng::new_with_timer(get_nstime); let rounds = rng.test_timer()?; rng.set_rounds(rounds); // optional let _ = rng.next_u64(); // Ready for use let v: u64 = rng.next_u64();
pub fn set_rounds(&mut self, rounds: u8)
[src]
Configures how many rounds are used to generate each 64-bit value. This must be greater than zero, and has a big impact on performance and output quality.
new_with_timer
conservatively uses 64 rounds, but often less rounds
can be used. The test_timer()
function returns the minimum number of
rounds required for full strength (platform dependent), so one may use
rng.set_rounds(rng.test_timer()?);
or cache the value.
pub fn test_timer(&mut self) -> Result<u8, TimerError>
[src]
Basic quality tests on the timer, by measuring CPU timing jitter a few hundred times.
If successful, this will return the estimated number of rounds necessary
to collect 64 bits of entropy. Otherwise a [TimerError
] with the cause
of the failure will be returned.
pub fn timer_stats(&mut self, var_rounds: bool) -> i64
[src]
Statistical test: return the timer delta of one normal run of the
JitterRng
entropy collector.
Setting var_rounds
to true
will execute the memory access and the
CPU jitter noice sources a variable amount of times (just like a real
JitterRng
round).
Setting var_rounds
to false
will execute the noice sources the
minimal number of times. This can be used to measure the minimum amount
of entropy one round of the entropy collector can collect in the worst
case.
See this crate's README on how to use timer_stats
to test the quality
of JitterRng
.
Trait Implementations
impl Debug for JitterRng
[src]
impl CryptoRng for JitterRng
[src]
impl RngCore for JitterRng
[src]
fn next_u32(&mut self) -> u32
[src]
fn next_u64(&mut self) -> u64
[src]
fn fill_bytes(&mut self, dest: &mut [u8])
[src]
fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>
[src]
impl Clone for JitterRng
[src]
Auto Trait Implementations
impl Send for JitterRng
impl Unpin for JitterRng
impl Sync for JitterRng
impl UnwindSafe for JitterRng
impl RefUnwindSafe for JitterRng
Blanket Implementations
impl<R> Rng for R where
R: RngCore + ?Sized,
[src]
R: RngCore + ?Sized,
fn gen<T>(&mut self) -> T where
Standard: Distribution<T>,
[src]
Standard: Distribution<T>,
fn gen_range<T: SampleUniform, B1, B2>(&mut self, low: B1, high: B2) -> T where
B1: SampleBorrow<T> + Sized,
B2: SampleBorrow<T> + Sized,
[src]
B1: SampleBorrow<T> + Sized,
B2: SampleBorrow<T> + Sized,
fn sample<T, D: Distribution<T>>(&mut self, distr: D) -> T
[src]
ⓘImportant traits for DistIter<'a, D, R, T>fn sample_iter<'a, T, D: Distribution<T>>(
&'a mut self,
distr: &'a D
) -> DistIter<'a, D, Self, T> where
Self: Sized,
[src]
&'a mut self,
distr: &'a D
) -> DistIter<'a, D, Self, T> where
Self: Sized,
fn fill<T: AsByteSliceMut + ?Sized>(&mut self, dest: &mut T)
[src]
fn try_fill<T: AsByteSliceMut + ?Sized>(
&mut self,
dest: &mut T
) -> Result<(), Error>
[src]
&mut self,
dest: &mut T
) -> Result<(), Error>
fn gen_bool(&mut self, p: f64) -> bool
[src]
fn gen_ratio(&mut self, numerator: u32, denominator: u32) -> bool
[src]
fn choose<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T>
[src]
fn choose_mut<'a, T>(&mut self, values: &'a mut [T]) -> Option<&'a mut T>
[src]
fn shuffle<T>(&mut self, values: &mut [T])
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From<T> for T
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,