diff options
Diffstat (limited to 'vendor/rdrand/src')
| -rw-r--r-- | vendor/rdrand/src/changelog.rs | 25 | ||||
| -rw-r--r-- | vendor/rdrand/src/lib.rs | 472 |
2 files changed, 0 insertions, 497 deletions
diff --git a/vendor/rdrand/src/changelog.rs b/vendor/rdrand/src/changelog.rs deleted file mode 100644 index 503f738..0000000 --- a/vendor/rdrand/src/changelog.rs +++ /dev/null @@ -1,25 +0,0 @@ -//! Project changelog - -/// ## Breaking changes -/// -/// Crate gained an enabled-by-default `std` feature. If you relied on rdrand being `core`-able -/// change your dependency to appear as such: -/// -/// ```toml -/// rdrand = { version = "0.4", default-features = false } -/// ``` -/// -/// This is done so that an advantage of the common feature detection functionality could be -/// employed by users that are not constrained by `core`. This functionality is faster, caches the -/// results and is shared between all users of the functionality. -/// -/// For `core` usage the feature detection has also been improved and will not be done if e.g. -/// crate is built with `rdrand` instructions enabled globally. -pub mod r0_4_0 {} - -/// Crate now works on stable! -/// -/// ## Breaking changes -/// -/// * Updated to `rand_core = ^0.3`. -pub mod r0_3_0 {} diff --git a/vendor/rdrand/src/lib.rs b/vendor/rdrand/src/lib.rs deleted file mode 100644 index 423ae21..0000000 --- a/vendor/rdrand/src/lib.rs +++ /dev/null @@ -1,472 +0,0 @@ -// Copyright © 2014, Simonas Kazlauskas <rdrand@kazlauskas.me> -// -// Permission to use, copy, modify, and/or distribute this software for any purpose with or without -// fee is hereby granted, provided that the above copyright notice and this permission notice -// appear in all copies. -// -// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS -// SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE -// AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES -// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, -// NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE -// OF THIS SOFTWARE. -//! An implementation of random number generators based on `rdrand` and `rdseed` instructions. -//! -//! The random number generators provided by this crate are fairly slow (the latency for these -//! instructions is pretty high), but provide high quality random bits. Caveat is: neither AMD’s -//! nor Intel’s designs are public and therefore are not verifiable for lack of backdoors. -//! -//! Unless you know what you are doing, use the random number generators provided by the `rand` -//! crate (such as `OsRng`) instead. -//! -//! Here are a measurements for select processor architectures. Check [Agner’s instruction tables] -//! for up-to-date listings. -//! -//! <table> -//! <tr> -//! <th>Architecture</th> -//! <th colspan="3">Latency (cycles)</th> -//! <th>Maximum throughput (per core)</th> -//! </tr> -//! <tr> -//! <td></td> -//! <td>u16</td> -//! <td>u32</td> -//! <td>u64</td> -//! <td></td> -//! </tr> -//! <tr> -//! <td>AMD Ryzen</td> -//! <td>~1200</td> -//! <td>~1200</td> -//! <td>~2500</td> -//! <td>~12MB/s @ 3.7GHz</td> -//! </tr> -//! <tr> -//! <td>Intel Skylake</td> -//! <td>460</td> -//! <td>460</td> -//! <td>460</td> -//! <td>~72MB/s @ 4.2GHz</td> -//! </tr> -//! <tr> -//! <td>Intel Haswell</td> -//! <td>320</td> -//! <td>320</td> -//! <td>320</td> -//! <td>~110MB/s @ 4.4GHz</td> -//! </tr> -//! </table> -//! -//! [Agner’s instruction tables]: http://agner.org/optimize/ -#![cfg_attr(not(feature = "std"), no_std)] - -extern crate rand_core; - -#[cfg(feature = "std")] -extern crate core; - -pub mod changelog; - -use rand_core::{RngCore, CryptoRng, Error, ErrorKind}; -use core::slice; - -const RETRY_LIMIT: u8 = 127; - -#[cold] -#[inline(never)] -pub(crate) fn busy_loop_fail() -> ! { - panic!("hardware generator failure"); -} - -/// A cryptographically secure statistically uniform, non-periodic and non-deterministic random bit -/// generator. -/// -/// Note that this generator may be implemented using a deterministic algorithm that is reseeded -/// routinely from a non-deterministic entropy source to achieve the desirable properties. -/// -/// This generator is a viable replacement to any generator, however, since nobody has audited -/// Intel or AMD hardware yet, the usual disclaimers as to their suitability apply. -/// -/// It is potentially faster than `OsRng`, but is only supported on more recent Intel (Ivy Bridge -/// and later) and AMD (Ryzen and later) processors. -#[derive(Clone, Copy)] -pub struct RdRand(()); - -/// A cryptographically secure non-deterministic random bit generator. -/// -/// This generator produces high-entropy output and is suited to seed other pseudo-random -/// generators. -/// -/// This instruction currently is only available in Intel Broadwell (and later) and AMD Ryzen -/// processors. -/// -/// This generator is not intended for general random number generation purposes and should be used -/// to seed other generators implementing [rand_core::SeedableRng]. -#[derive(Clone, Copy)] -pub struct RdSeed(()); - -impl CryptoRng for RdRand {} -impl CryptoRng for RdSeed {} - -mod arch { - #[cfg(target_arch = "x86_64")] - pub use core::arch::x86_64::*; - #[cfg(target_arch = "x86")] - pub use core::arch::x86::*; - - #[cfg(target_arch = "x86")] - pub(crate) unsafe fn _rdrand64_step(dest: &mut u64) -> i32 { - let mut ret1: u32 = ::core::mem::uninitialized(); - let mut ret2: u32 = ::core::mem::uninitialized(); - if _rdrand32_step(&mut ret1) != 0 && _rdrand32_step(&mut ret2) != 0 { - *dest = (ret1 as u64) << 32 | (ret2 as u64); - 1 - } else { - 0 - } - } - - #[cfg(target_arch = "x86")] - pub(crate) unsafe fn _rdseed64_step(dest: &mut u64) -> i32 { - let mut ret1: u32 = ::core::mem::uninitialized(); - let mut ret2: u32 = ::core::mem::uninitialized(); - if _rdseed32_step(&mut ret1) != 0 && _rdseed32_step(&mut ret2) != 0 { - *dest = (ret1 as u64) << 32 | (ret2 as u64); - 1 - } else { - 0 - } - } -} - -#[cfg(not(feature = "std"))] -macro_rules! is_x86_feature_detected { - ("rdrand") => {{ - if cfg!(target_feature="rdrand") { - true - } else if cfg!(target_env = "sgx") { - false - } else { - const FLAG : u32 = 1 << 30; - unsafe { ::arch::__cpuid(1).ecx & FLAG == FLAG } - } - }}; - ("rdseed") => {{ - if cfg!(target_feature = "rdseed") { - true - } else if cfg!(target_env = "sgx") { - false - } else { - const FLAG : u32 = 1 << 18; - unsafe { ::arch::__cpuid(7).ebx & FLAG == FLAG } - } - }}; -} - -macro_rules! loop_rand { - ($el: ty, $step: path) => { { - let mut idx = 0; - loop { - let mut el: $el = ::core::mem::uninitialized(); - if $step(&mut el) != 0 { - break Some(el); - } else if idx == RETRY_LIMIT { - break None; - } - idx += 1; - } - } } -} - -macro_rules! impl_rand { - ($gen:ident, $feat:tt, $step16: path, $step32:path, $step64:path, - maxstep = $maxstep:path, maxty = $maxty: ty) => { - impl $gen { - /// Create a new instance of the random number generator. - /// - /// This constructor checks whether the CPU the program is running on supports the - /// instruction necessary for this generator to operate. If the instruction is not - /// supported, an error is returned. - pub fn new() -> Result<Self, Error> { - if is_x86_feature_detected!($feat) { - Ok($gen(())) - } else { - Err(Error::new(rand_core::ErrorKind::Unavailable, - "the instruction is not supported")) - } - } - - /// Generate a single random `u16` value. - /// - /// The underlying instruction may fail for variety reasons (such as actual hardware - /// failure or exhausted entropy), however the exact reason for the failure is not - /// usually exposed. - /// - /// This method will retry calling the instruction a few times, however if all the - /// attempts fail, it will return `None`. - /// - /// In case `None` is returned, the caller should assume that an non-recoverable - /// hardware failure has occured and use another random number genrator instead. - #[inline(always)] - pub fn try_next_u16(&self) -> Option<u16> { - #[target_feature(enable = $feat)] - unsafe fn imp() - -> Option<u16> { - loop_rand!(u16, $step16) - } - unsafe { imp() } - } - - /// Generate a single random `u32` value. - /// - /// The underlying instruction may fail for variety reasons (such as actual hardware - /// failure or exhausted entropy), however the exact reason for the failure is not - /// usually exposed. - /// - /// This method will retry calling the instruction a few times, however if all the - /// attempts fail, it will return `None`. - /// - /// In case `None` is returned, the caller should assume that an non-recoverable - /// hardware failure has occured and use another random number genrator instead. - #[inline(always)] - pub fn try_next_u32(&self) -> Option<u32> { - #[target_feature(enable = $feat)] - unsafe fn imp() - -> Option<u32> { - loop_rand!(u32, $step32) - } - unsafe { imp() } - } - - /// Generate a single random `u64` value. - /// - /// The underlying instruction may fail for variety reasons (such as actual hardware - /// failure or exhausted entropy), however the exact reason for the failure is not - /// usually exposed. - /// - /// This method will retry calling the instruction a few times, however if all the - /// attempts fail, it will return `None`. - /// - /// In case `None` is returned, the caller should assume that an non-recoverable - /// hardware failure has occured and use another random number genrator instead. - /// - /// Note, that on 32-bit targets, there’s no underlying instruction to generate a - /// 64-bit number, so it is emulated with the 32-bit version of the instruction. - #[inline(always)] - pub fn try_next_u64(&self) -> Option<u64> { - #[target_feature(enable = $feat)] - unsafe fn imp() - -> Option<u64> { - loop_rand!(u64, $step64) - } - unsafe { imp() } - } - } - - impl RngCore for $gen { - /// Generate a single random `u32` value. - /// - /// The underlying instruction may fail for variety reasons (such as actual hardware - /// failure or exhausted entropy), however the exact reason for the failure is not - /// usually exposed. - /// - /// # Panic - /// - /// This method will retry calling the instruction a few times, however if all the - /// attempts fail, it will `panic`. - /// - /// In case `panic` occurs, the caller should assume that an non-recoverable - /// hardware failure has occured and use another random number genrator instead. - #[inline(always)] - fn next_u32(&mut self) -> u32 { - if let Some(result) = self.try_next_u32() { - result - } else { - busy_loop_fail() - } - } - - /// Generate a single random `u64` value. - /// - /// The underlying instruction may fail for variety reasons (such as actual hardware - /// failure or exhausted entropy), however the exact reason for the failure is not - /// usually exposed. - /// - /// Note, that on 32-bit targets, there’s no underlying instruction to generate a - /// 64-bit number, so it is emulated with the 32-bit version of the instruction. - /// - /// # Panic - /// - /// This method will retry calling the instruction a few times, however if all the - /// attempts fail, it will `panic`. - /// - /// In case `panic` occurs, the caller should assume that an non-recoverable - /// hardware failure has occured and use another random number genrator instead. - #[inline(always)] - fn next_u64(&mut self) -> u64 { - if let Some(result) = self.try_next_u64() { - result - } else { - busy_loop_fail() - } - } - - /// Fill a buffer `dest` with random data. - /// - /// See `try_fill_bytes` for a more extensive documentation. - /// - /// # Panic - /// - /// This method will panic any time `try_fill_bytes` would return an error. - #[inline(always)] - fn fill_bytes(&mut self, dest: &mut [u8]) { - if let Err(_) = self.try_fill_bytes(dest) { - busy_loop_fail() - } - } - - /// Fill a buffer `dest` with random data. - /// - /// This method will use the most appropriate variant of the instruction available on - /// the machine to achieve the greatest single-core throughput, however it has a - /// slightly higher setup cost than the plain `next_u32` or `next_u64` methods. - /// - /// The underlying instruction may fail for variety reasons (such as actual hardware - /// failure or exhausted entropy), however the exact reason for the failure is not - /// usually exposed. - /// - /// This method will retry calling the instruction a few times, however if all the - /// attempts fail, it will return an error. - /// - /// If an error is returned, the caller should assume that an non-recoverable hardware - /// failure has occured and use another random number genrator instead. - #[inline(always)] - fn try_fill_bytes(&mut self, dest: &mut [u8]) - -> Result<(), Error> { - #[target_feature(enable = $feat)] - unsafe fn imp(dest: &mut [u8]) - -> Result<(), Error> - { - unsafe fn imp_less_fast(mut dest: &mut [u8], word: &mut $maxty, - buffer: &mut &[u8]) - -> Result<(), Error> - { - while !dest.is_empty() { - if buffer.is_empty() { - if let Some(w) = loop_rand!($maxty, $maxstep) { - *word = w; - *buffer = slice::from_raw_parts( - word as *const _ as *const u8, - ::core::mem::size_of::<$maxty>() - ); - } else { - return Err(Error::new(ErrorKind::Unexpected, - "hardware generator failure")); - } - } - - let len = dest.len().min(buffer.len()); - let (copy_src, leftover) = buffer.split_at(len); - let (copy_dest, dest_leftover) = { dest }.split_at_mut(len); - *buffer = leftover; - dest = dest_leftover; - ::core::ptr::copy_nonoverlapping( - copy_src.as_ptr(), copy_dest.as_mut_ptr(), len - ); - } - Ok(()) - } - - let destlen = dest.len(); - if destlen > ::core::mem::size_of::<$maxty>() { - let (left, mid, right) = dest.align_to_mut(); - let mut word = 0; - let mut buffer: &[u8] = &[]; - - for el in mid { - if let Some(val) = loop_rand!($maxty, $maxstep) { - *el = val; - } else { - return Err(Error::new(ErrorKind::Unexpected, - "hardware generator failure")); - } - } - - imp_less_fast(left, &mut word, &mut buffer)?; - imp_less_fast(right, &mut word, &mut buffer) - } else { - let mut word = 0; - let mut buffer: &[u8] = &[]; - imp_less_fast(dest, &mut word, &mut buffer) - } - } - unsafe { imp(dest) } - } - } - } -} - -#[cfg(target_arch = "x86_64")] -impl_rand!(RdRand, "rdrand", - ::arch::_rdrand16_step, ::arch::_rdrand32_step, ::arch::_rdrand64_step, - maxstep = ::arch::_rdrand64_step, maxty = u64); -#[cfg(target_arch = "x86_64")] -impl_rand!(RdSeed, "rdseed", - ::arch::_rdseed16_step, ::arch::_rdseed32_step, ::arch::_rdseed64_step, - maxstep = ::arch::_rdseed64_step, maxty = u64); -#[cfg(target_arch = "x86")] -impl_rand!(RdRand, "rdrand", - ::arch::_rdrand16_step, ::arch::_rdrand32_step, ::arch::_rdrand64_step, - maxstep = ::arch::_rdrand32_step, maxty = u32); -#[cfg(target_arch = "x86")] -impl_rand!(RdSeed, "rdseed", - ::arch::_rdseed16_step, ::arch::_rdseed32_step, ::arch::_rdseed64_step, - maxstep = ::arch::_rdseed32_step, maxty = u32); - -#[test] -fn rdrand_works() { - let _ = RdRand::new().map(|mut r| { - r.next_u32(); - r.next_u64(); - }); -} - -#[test] -fn fill_fills_all_bytes() { - let _ = RdRand::new().map(|mut r| { - let mut peach; - let mut banana; - let mut start = 0; - let mut end = 128; - 'outer: while start < end { - banana = [0; 128]; - for _ in 0..512 { - peach = [0; 128]; - r.fill_bytes(&mut peach[start..end]); - for (b, p) in banana.iter_mut().zip(peach.iter()) { - *b = *b | *p; - } - if (&banana[start..end]).iter().all(|x| *x != 0) { - assert!(banana[..start].iter().all(|x| *x == 0), "all other values must be 0"); - assert!(banana[end..].iter().all(|x| *x == 0), "all other values must be 0"); - if start < 17 { - start += 1; - } else { - end -= 3; - } - continue 'outer; - } - } - panic!("wow, we broke it? {} {} {:?}", start, end, &banana[..]) - } - }); -} - -#[test] -fn rdseed_works() { - let _ = RdSeed::new().map(|mut r| { - r.next_u32(); - r.next_u64(); - }); -} |