Browse Source
This only fixes things enough so that the project compiles again. More standard library changes from upstream Rust will be pulled in later.pull/10/head
Fenrir
7 years ago
committed by
FenrirWolf
11 changed files with 262 additions and 508 deletions
@ -1,286 +0,0 @@
@@ -1,286 +0,0 @@
|
||||
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
//! Utilities for random number generation
|
||||
//!
|
||||
//! The key functions are `random()` and `Rng::gen()`. These are polymorphic
|
||||
//! and so can be used to generate any type that implements `Rand`. Type inference
|
||||
//! means that often a simple call to `rand::random()` or `rng.gen()` will
|
||||
//! suffice, but sometimes an annotation is required, e.g. `rand::random::<f64>()`.
|
||||
//!
|
||||
//! See the `distributions` submodule for sampling random numbers from
|
||||
//! distributions like normal and exponential.
|
||||
//!
|
||||
//! # Thread-local RNG
|
||||
//!
|
||||
//! There is built-in support for a RNG associated with each thread stored
|
||||
//! in thread-local storage. This RNG can be accessed via `thread_rng`, or
|
||||
//! used implicitly via `random`. This RNG is normally randomly seeded
|
||||
//! from an operating-system source of randomness, e.g. `/dev/urandom` on
|
||||
//! Unix systems, and will automatically reseed itself from this source
|
||||
//! after generating 32 KiB of random data.
|
||||
//!
|
||||
//! # Cryptographic security
|
||||
//!
|
||||
//! An application that requires an entropy source for cryptographic purposes
|
||||
//! must use `OsRng`, which reads randomness from the source that the operating
|
||||
//! system provides (e.g. `/dev/urandom` on Unixes or `CryptGenRandom()` on Windows).
|
||||
//! The other random number generators provided by this module are not suitable
|
||||
//! for such purposes.
|
||||
//!
|
||||
//! *Note*: many Unix systems provide `/dev/random` as well as `/dev/urandom`.
|
||||
//! This module uses `/dev/urandom` for the following reasons:
|
||||
//!
|
||||
//! - On Linux, `/dev/random` may block if entropy pool is empty; `/dev/urandom` will not block.
|
||||
//! This does not mean that `/dev/random` provides better output than
|
||||
//! `/dev/urandom`; the kernel internally runs a cryptographically secure pseudorandom
|
||||
//! number generator (CSPRNG) based on entropy pool for random number generation,
|
||||
//! so the "quality" of `/dev/random` is not better than `/dev/urandom` in most cases.
|
||||
//! However, this means that `/dev/urandom` can yield somewhat predictable randomness
|
||||
//! if the entropy pool is very small, such as immediately after first booting.
|
||||
//! Linux 3.17 added the `getrandom(2)` system call which solves the issue: it blocks if entropy
|
||||
//! pool is not initialized yet, but it does not block once initialized.
|
||||
//! `getrandom(2)` was based on `getentropy(2)`, an existing system call in OpenBSD.
|
||||
//! `OsRng` tries to use `getrandom(2)` if available, and use `/dev/urandom` fallback if not.
|
||||
//! If an application does not have `getrandom` and likely to be run soon after first booting,
|
||||
//! or on a system with very few entropy sources, one should consider using `/dev/random` via
|
||||
//! `ReaderRng`.
|
||||
//! - On some systems (e.g. FreeBSD, OpenBSD and Mac OS X) there is no difference
|
||||
//! between the two sources. (Also note that, on some systems e.g. FreeBSD, both `/dev/random`
|
||||
//! and `/dev/urandom` may block once if the CSPRNG has not seeded yet.)
|
||||
|
||||
#![unstable(feature = "rand", issue = "0")] |
||||
|
||||
use cell::RefCell; |
||||
use fmt; |
||||
use io; |
||||
use mem; |
||||
use rc::Rc; |
||||
use sys; |
||||
|
||||
#[cfg(target_pointer_width = "32")] |
||||
use core_rand::IsaacRng as IsaacWordRng; |
||||
#[cfg(target_pointer_width = "64")] |
||||
use core_rand::Isaac64Rng as IsaacWordRng; |
||||
|
||||
pub use core_rand::{Rand, Rng, SeedableRng}; |
||||
pub use core_rand::{XorShiftRng, IsaacRng, Isaac64Rng}; |
||||
pub use core_rand::reseeding; |
||||
|
||||
pub mod reader; |
||||
|
||||
/// The standard RNG. This is designed to be efficient on the current
|
||||
/// platform.
|
||||
#[derive(Copy, Clone)] |
||||
pub struct StdRng { |
||||
rng: IsaacWordRng, |
||||
} |
||||
|
||||
impl StdRng { |
||||
/// Create a randomly seeded instance of `StdRng`.
|
||||
///
|
||||
/// This is a very expensive operation as it has to read
|
||||
/// randomness from the operating system and use this in an
|
||||
/// expensive seeding operation. If one is only generating a small
|
||||
/// number of random numbers, or doesn't need the utmost speed for
|
||||
/// generating each number, `thread_rng` and/or `random` may be more
|
||||
/// appropriate.
|
||||
///
|
||||
/// Reading the randomness from the OS may fail, and any error is
|
||||
/// propagated via the `io::Result` return value.
|
||||
pub fn new() -> io::Result<StdRng> { |
||||
OsRng::new().map(|mut r| StdRng { rng: r.gen() }) |
||||
} |
||||
} |
||||
|
||||
impl Rng for StdRng { |
||||
#[inline] |
||||
fn next_u32(&mut self) -> u32 { |
||||
self.rng.next_u32() |
||||
} |
||||
|
||||
#[inline] |
||||
fn next_u64(&mut self) -> u64 { |
||||
self.rng.next_u64() |
||||
} |
||||
} |
||||
|
||||
impl<'a> SeedableRng<&'a [usize]> for StdRng { |
||||
fn reseed(&mut self, seed: &'a [usize]) { |
||||
// the internal RNG can just be seeded from the above
|
||||
// randomness.
|
||||
self.rng.reseed(unsafe {mem::transmute(seed)}) |
||||
} |
||||
|
||||
fn from_seed(seed: &'a [usize]) -> StdRng { |
||||
StdRng { rng: SeedableRng::from_seed(unsafe {mem::transmute(seed)}) } |
||||
} |
||||
} |
||||
|
||||
/// Controls how the thread-local RNG is reseeded.
|
||||
struct ThreadRngReseeder; |
||||
|
||||
impl reseeding::Reseeder<StdRng> for ThreadRngReseeder { |
||||
fn reseed(&mut self, rng: &mut StdRng) { |
||||
*rng = match StdRng::new() { |
||||
Ok(r) => r, |
||||
Err(e) => panic!("could not reseed thread_rng: {}", e) |
||||
} |
||||
} |
||||
} |
||||
const THREAD_RNG_RESEED_THRESHOLD: usize = 32_768; |
||||
type ThreadRngInner = reseeding::ReseedingRng<StdRng, ThreadRngReseeder>; |
||||
|
||||
/// The thread-local RNG.
|
||||
#[derive(Clone)] |
||||
pub struct ThreadRng { |
||||
rng: Rc<RefCell<ThreadRngInner>>, |
||||
} |
||||
|
||||
impl fmt::Debug for ThreadRng { |
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
||||
f.pad("ThreadRng { .. }") |
||||
} |
||||
} |
||||
|
||||
/// Retrieve the lazily-initialized thread-local random number
|
||||
/// generator, seeded by the system. Intended to be used in method
|
||||
/// chaining style, e.g. `thread_rng().gen::<isize>()`.
|
||||
///
|
||||
/// The RNG provided will reseed itself from the operating system
|
||||
/// after generating a certain amount of randomness.
|
||||
///
|
||||
/// The internal RNG used is platform and architecture dependent, even
|
||||
/// if the operating system random number generator is rigged to give
|
||||
/// the same sequence always. If absolute consistency is required,
|
||||
/// explicitly select an RNG, e.g. `IsaacRng` or `Isaac64Rng`.
|
||||
pub fn thread_rng() -> ThreadRng { |
||||
// used to make space in TLS for a random number generator
|
||||
thread_local!(static THREAD_RNG_KEY: Rc<RefCell<ThreadRngInner>> = { |
||||
let r = match StdRng::new() { |
||||
Ok(r) => r, |
||||
Err(e) => panic!("could not initialize thread_rng: {}", e) |
||||
}; |
||||
let rng = reseeding::ReseedingRng::new(r, |
||||
THREAD_RNG_RESEED_THRESHOLD, |
||||
ThreadRngReseeder); |
||||
Rc::new(RefCell::new(rng)) |
||||
}); |
||||
|
||||
ThreadRng { rng: THREAD_RNG_KEY.with(|t| t.clone()) } |
||||
} |
||||
|
||||
impl Rng for ThreadRng { |
||||
fn next_u32(&mut self) -> u32 { |
||||
self.rng.borrow_mut().next_u32() |
||||
} |
||||
|
||||
fn next_u64(&mut self) -> u64 { |
||||
self.rng.borrow_mut().next_u64() |
||||
} |
||||
|
||||
#[inline] |
||||
fn fill_bytes(&mut self, bytes: &mut [u8]) { |
||||
self.rng.borrow_mut().fill_bytes(bytes) |
||||
} |
||||
} |
||||
|
||||
/// A random number generator that retrieves randomness straight from
|
||||
/// the operating system. Platform sources:
|
||||
///
|
||||
/// - Unix-like systems (Linux, Android, Mac OSX): read directly from
|
||||
/// `/dev/urandom`, or from `getrandom(2)` system call if available.
|
||||
/// - Windows: calls `CryptGenRandom`, using the default cryptographic
|
||||
/// service provider with the `PROV_RSA_FULL` type.
|
||||
/// - iOS: calls SecRandomCopyBytes as /dev/(u)random is sandboxed.
|
||||
/// - OpenBSD: uses the `getentropy(2)` system call.
|
||||
///
|
||||
/// This does not block.
|
||||
pub struct OsRng(sys::rand::OsRng); |
||||
|
||||
impl OsRng { |
||||
/// Create a new `OsRng`.
|
||||
pub fn new() -> io::Result<OsRng> { |
||||
sys::rand::OsRng::new().map(OsRng) |
||||
} |
||||
} |
||||
|
||||
impl Rng for OsRng { |
||||
#[inline] |
||||
fn next_u32(&mut self) -> u32 { |
||||
self.0.next_u32() |
||||
} |
||||
|
||||
#[inline] |
||||
fn next_u64(&mut self) -> u64 { |
||||
self.0.next_u64() |
||||
} |
||||
|
||||
#[inline] |
||||
fn fill_bytes(&mut self, bytes: &mut [u8]) { |
||||
self.0.fill_bytes(bytes) |
||||
} |
||||
} |
||||
|
||||
|
||||
#[cfg(test)] |
||||
mod tests { |
||||
use sync::mpsc::channel; |
||||
use rand::Rng; |
||||
use super::OsRng; |
||||
use thread; |
||||
|
||||
#[test] |
||||
fn test_os_rng() { |
||||
let mut r = OsRng::new().unwrap(); |
||||
|
||||
r.next_u32(); |
||||
r.next_u64(); |
||||
|
||||
let mut v = [0; 1000]; |
||||
r.fill_bytes(&mut v); |
||||
} |
||||
|
||||
#[test] |
||||
#[cfg_attr(target_os = "emscripten", ignore)] |
||||
fn test_os_rng_tasks() { |
||||
|
||||
let mut txs = vec![]; |
||||
for _ in 0..20 { |
||||
let (tx, rx) = channel(); |
||||
txs.push(tx); |
||||
|
||||
thread::spawn(move|| { |
||||
// wait until all the threads are ready to go.
|
||||
rx.recv().unwrap(); |
||||
|
||||
// deschedule to attempt to interleave things as much
|
||||
// as possible (XXX: is this a good test?)
|
||||
let mut r = OsRng::new().unwrap(); |
||||
thread::yield_now(); |
||||
let mut v = [0; 1000]; |
||||
|
||||
for _ in 0..100 { |
||||
r.next_u32(); |
||||
thread::yield_now(); |
||||
r.next_u64(); |
||||
thread::yield_now(); |
||||
r.fill_bytes(&mut v); |
||||
thread::yield_now(); |
||||
} |
||||
}); |
||||
} |
||||
|
||||
// start all the threads
|
||||
for tx in &txs { |
||||
tx.send(()).unwrap(); |
||||
} |
||||
} |
||||
} |
||||
@ -1,108 +0,0 @@
@@ -1,108 +0,0 @@
|
||||
// Copyright 2013 The Rust Project Developers. See the COPYRIGHT
|
||||
// file at the top-level directory of this distribution and at
|
||||
// http://rust-lang.org/COPYRIGHT.
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
||||
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
||||
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
||||
// option. This file may not be copied, modified, or distributed
|
||||
// except according to those terms.
|
||||
|
||||
//! A wrapper around any Read to treat it as an RNG.
|
||||
|
||||
#![allow(dead_code)] |
||||
|
||||
use io::prelude::*; |
||||
use rand::Rng; |
||||
|
||||
/// An RNG that reads random bytes straight from a `Read`. This will
|
||||
/// work best with an infinite reader, but this is not required.
|
||||
///
|
||||
/// # Panics
|
||||
///
|
||||
/// It will panic if it there is insufficient data to fulfill a request.
|
||||
pub struct ReaderRng<R> { |
||||
reader: R |
||||
} |
||||
|
||||
impl<R: Read> ReaderRng<R> { |
||||
/// Create a new `ReaderRng` from a `Read`.
|
||||
pub fn new(r: R) -> ReaderRng<R> { |
||||
ReaderRng { |
||||
reader: r |
||||
} |
||||
} |
||||
} |
||||
|
||||
impl<R: Read> Rng for ReaderRng<R> { |
||||
fn next_u32(&mut self) -> u32 { |
||||
// This is designed for speed: reading a LE integer on a LE
|
||||
// platform just involves blitting the bytes into the memory
|
||||
// of the u32, similarly for BE on BE; avoiding byteswapping.
|
||||
let mut bytes = [0; 4]; |
||||
self.fill_bytes(&mut bytes); |
||||
unsafe { *(bytes.as_ptr() as *const u32) } |
||||
} |
||||
fn next_u64(&mut self) -> u64 { |
||||
// see above for explanation.
|
||||
let mut bytes = [0; 8]; |
||||
self.fill_bytes(&mut bytes); |
||||
unsafe { *(bytes.as_ptr() as *const u64) } |
||||
} |
||||
fn fill_bytes(&mut self, mut v: &mut [u8]) { |
||||
while !v.is_empty() { |
||||
let t = v; |
||||
match self.reader.read(t) { |
||||
Ok(0) => panic!("ReaderRng.fill_bytes: EOF reached"), |
||||
Ok(n) => v = t.split_at_mut(n).1, |
||||
Err(e) => panic!("ReaderRng.fill_bytes: {}", e), |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
#[cfg(test)] |
||||
mod tests { |
||||
use super::ReaderRng; |
||||
use rand::Rng; |
||||
|
||||
#[test] |
||||
fn test_reader_rng_u64() { |
||||
// transmute from the target to avoid endianness concerns.
|
||||
let v = &[0, 0, 0, 0, 0, 0, 0, 1, |
||||
0, 0, 0, 0, 0, 0, 0, 2, |
||||
0, 0, 0, 0, 0, 0, 0, 3][..]; |
||||
let mut rng = ReaderRng::new(v); |
||||
|
||||
assert_eq!(rng.next_u64(), 1u64.to_be()); |
||||
assert_eq!(rng.next_u64(), 2u64.to_be()); |
||||
assert_eq!(rng.next_u64(), 3u64.to_be()); |
||||
} |
||||
#[test] |
||||
fn test_reader_rng_u32() { |
||||
let v = &[0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 3][..]; |
||||
let mut rng = ReaderRng::new(v); |
||||
|
||||
assert_eq!(rng.next_u32(), 1u32.to_be()); |
||||
assert_eq!(rng.next_u32(), 2u32.to_be()); |
||||
assert_eq!(rng.next_u32(), 3u32.to_be()); |
||||
} |
||||
#[test] |
||||
fn test_reader_rng_fill_bytes() { |
||||
let v = [1, 2, 3, 4, 5, 6, 7, 8]; |
||||
let mut w = [0; 8]; |
||||
|
||||
let mut rng = ReaderRng::new(&v[..]); |
||||
rng.fill_bytes(&mut w); |
||||
|
||||
assert!(v == w); |
||||
} |
||||
|
||||
#[test] |
||||
#[should_panic] |
||||
fn test_reader_rng_insufficient_bytes() { |
||||
let mut rng = ReaderRng::new(&[][..]); |
||||
let mut v = [0; 3]; |
||||
rng.fill_bytes(&mut v); |
||||
} |
||||
} |
||||
Loading…
Reference in new issue