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,20 @@ 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];
+            // in case of `Error::UNAVAILABLE` we use a constant value
+            match getrandom::getrandom(&mut buf) {
+                Ok(()) | Err(Error::UNAVAILABLE) => (),
+                Err(err) => panic!("getrandom failure: {:?}", err),
+            }
+            let n = u128::from_ne_bytes(buf);
+            Cell::new([n as u64, (n >> 64) as u64])
         });
 
         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; mem::size_of::<usize>()];
+        getrandom::getrandom(&mut buf).expect("OS RNG failure");
+        let n = usize::from_ne_bytes(buf);
+        N.store(n, SeqCst);
     }
 }