Use getrandom crate

src/libstd/Cargo.toml

@@ -24,6 +24,7 @@ compiler_builtins = { version = "0.1.16" }
 profiler_builtins = { path = "../libprofiler_builtins", optional = true }
 unwind = { path = "../libunwind" }
 hashbrown = { version = "0.4.0", features = ['rustc-dep-of-std'] }
+getrandom = "0.1"
 
 [dependencies.backtrace]
 version = "0.3.29"

src/libstd/collections/hash/map.rs

@@ -2445,13 +2445,18 @@ impl RandomState {
  // iteration order allows a form of DOS attack. To counter that we
  // increment one of the seeds on every RandomState creation, giving
  // every corresponding HashMap a different iteration order.
- thread_local!(static KEYS: Cell<(u64, u64)> = {
- Cell::new(sys::hashmap_random_keys())
+ thread_local!(static KEYS: Cell<[u64; 2]> = {
+ let mut buf = [0u8; 16];
+ // we consciously ignore potential errors here
+ let _ = getrandom::getrandom(&mut buf);
+ // SAFETY: it's safe to transmute random 16 bytes to two `u64`s
+ let buf: [u64; 2] = unsafe { core::mem::transmute(buf) };
+ Cell::new(buf)
  });
 
  KEYS.with(|keys| {
- let (k0, k1) = keys.get();
- keys.set((k0.wrapping_add(1), k1));
+ let [k0, k1] = keys.get();
+ keys.set([k0.wrapping_add(1), k1]);
  RandomState { k0: k0, k1: k1 }
  })
  }

src/libstd/sys/cloudabi/mod.rs

@@ -56,11 +56,3 @@ pub unsafe fn abort_internal() -> ! {
 }
 
 pub use libc::strlen;
-
-pub fn hashmap_random_keys() -> (u64, u64) {
- unsafe {
- let mut v = mem::uninitialized();
- libc::arc4random_buf(&mut v as *mut _ as *mut libc::c_void, mem::size_of_val(&v));
- v
- }
-}

src/libstd/sys/redox/mod.rs

@@ -3,7 +3,6 @@
 use crate::io::ErrorKind;
 
 pub use libc::strlen;
-pub use self::rand::hashmap_random_keys;
 
 #[path = "../unix/alloc.rs"]
 pub mod alloc;
@@ -23,7 +22,6 @@ pub mod os;
 pub mod path;
 pub mod pipe;
 pub mod process;
-pub mod rand;
 pub mod rwlock;
 pub mod stack_overflow;
 pub mod stdio;

src/libstd/sys/sgx/mod.rs

@@ -137,21 +137,6 @@ pub unsafe extern "C" fn __rust_abort() {
  abort_internal();
 }
 
-pub fn hashmap_random_keys() -> (u64, u64) {
- fn rdrand64() -> u64 {
- unsafe {
- let mut ret: u64 = crate::mem::uninitialized();
- for _ in 0..10 {
- if crate::arch::x86_64::_rdrand64_step(&mut ret) == 1 {
- return ret;
- }
- }
- rtabort!("Failed to obtain random data");
- }
- }
- (rdrand64(), rdrand64())
-}
-
 pub use crate::sys_common::{AsInner, FromInner, IntoInner};
 
 pub trait TryIntoInner<Inner>: Sized {

src/libstd/sys/unix/mod.rs

@@ -18,7 +18,6 @@ use crate::io::ErrorKind;
 #[cfg(all(not(rustdoc), target_os = "l4re"))] pub use crate::os::linux as platform;
 #[cfg(all(not(rustdoc), target_os = "hermit"))] pub use crate::os::hermit as platform;
 
-pub use self::rand::hashmap_random_keys;
 pub use libc::strlen;
 
 #[macro_use]
@@ -47,7 +46,6 @@ pub mod os;
 pub mod path;
 pub mod pipe;
 pub mod process;
-pub mod rand;
 pub mod rwlock;
 pub mod stack_overflow;
 pub mod thread;

src/libstd/sys/wasi/mod.rs

@@ -84,16 +84,6 @@ pub unsafe fn abort_internal() -> ! {
  libc::abort()
 }
 
-pub fn hashmap_random_keys() -> (u64, u64) {
- let mut ret = (0u64, 0u64);
- unsafe {
- let base = &mut ret as *mut (u64, u64) as *mut libc::c_void;
- let len = mem::size_of_val(&ret);
- cvt_wasi(libc::__wasi_random_get(base, len)).unwrap();
- }
- return ret
-}
-
 #[doc(hidden)]
 pub trait IsMinusOne {
  fn is_minus_one(&self) -> bool;

src/libstd/sys/wasm/mod.rs

@@ -93,15 +93,6 @@ pub unsafe fn abort_internal() -> ! {
  ExitSysCall::perform(1)
 }
 
-// We don't have randomness yet, but I totally used a random number generator to
-// generate these numbers.
-//
-// More seriously though this is just for DOS protection in hash maps. It's ok
-// if we don't do that on wasm just yet.
-pub fn hashmap_random_keys() -> (u64, u64) {
- (1, 2)
-}
-
 // Implement a minimal set of system calls to enable basic IO
 pub enum SysCallIndex {
  Read = 0,

src/libstd/sys/windows/mod.rs

@@ -8,7 +8,6 @@ use crate::path::PathBuf;
 use crate::time::Duration;
 
 pub use libc::strlen;
-pub use self::rand::hashmap_random_keys;
 
 #[macro_use] pub mod compat;
 
@@ -31,7 +30,6 @@ pub mod os_str;
 pub mod path;
 pub mod pipe;
 pub mod process;
-pub mod rand;
 pub mod rwlock;
 pub mod stack_overflow;
 pub mod thread;

src/libstd/sys/windows/pipe.rs

@@ -11,7 +11,6 @@ use crate::sync::atomic::AtomicUsize;
 use crate::sys::c;
 use crate::sys::fs::{File, OpenOptions};
 use crate::sys::handle::Handle;
-use crate::sys::hashmap_random_keys;
 
 ////////////////////////////////////////////////////////////////////////////////
 // Anonymous pipes
@@ -154,7 +153,10 @@ fn random_number() -> usize {
  return N.fetch_add(1, SeqCst)
  }
 
- N.store(hashmap_random_keys().0 as usize, SeqCst);
+ let mut buf = [0u8; 8];
+ getrandom::getrandom(&mut buf).expect("OS RNG failure");
+ let n = u64::from_ne_bytes(buf) as usize;
+ N.store(n, SeqCst);
  }
 }