Add functions to generate random u32 and u64 values (rust-random#544)

These functions can be helpful for seed generation and implementation of
`OsRng`. Additionally, some backends (Hermit, RDRAND, RNDR, WASI p2) can
directly generate random `u32`/`u64` values. Relying on the byte API may
be less efficient in these cases.

Using `u32` and `u64` as function names may seem problematic, but based
on the `fasrand` experience, it works well in practice, provided that
users reference them as `getrandom::u32/u64` without importing them
directly.

Author: newpavlov

src/backends.rs

@@ -116,8 +116,20 @@ cfg_if! {
         mod apple_other;
         pub use apple_other::*;
     } else if #[cfg(all(target_arch = "wasm32", target_os = "wasi"))] {
-        mod wasi;
-        pub use wasi::*;
+        cfg_if! {
+            if #[cfg(target_env = "p1")] {
+                mod wasi_p1;
+                pub use wasi_p1::*;
+            } else if #[cfg(target_env = "p2")] {
+                mod wasi_p2;
+                pub use wasi_p2::*;
+            } else {
+                compile_error!(
+                    "Unknown version of WASI (only previews 1 and 2 are supported) \
+                    or Rust version older than 1.80 was used"
+                );
+            }
+        }
     } else if #[cfg(target_os = "hermit")] {
         mod hermit;
         pub use hermit::*;

src/backends/apple_other.rs

@@ -2,6 +2,8 @@
 use crate::Error;
 use core::{ffi::c_void, mem::MaybeUninit};
 
+pub use crate::util::{inner_u32, inner_u64};
+
 pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
     let dst_ptr = dest.as_mut_ptr().cast::<c_void>();
     let ret = unsafe { libc::CCRandomGenerateBytes(dst_ptr, dest.len()) };

src/backends/custom.rs

@@ -2,6 +2,8 @@
 use crate::Error;
 use core::mem::MaybeUninit;
 
+pub use crate::util::{inner_u32, inner_u64};
+
 pub fn fill_inner(dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {
     extern "Rust" {
         fn __getrandom_v03_custom(dest: *mut u8, len: usize) -> Result<(), Error>;

src/backends/esp_idf.rs

@@ -2,6 +2,8 @@
 use crate::Error;
 use core::{ffi::c_void, mem::MaybeUninit};
 
+pub use crate::util::{inner_u32, inner_u64};
+
 #[cfg(not(target_os = "espidf"))]
 compile_error!("`esp_idf` backend can be enabled only for ESP-IDF targets!");
 

src/backends/fuchsia.rs

@@ -2,6 +2,8 @@
 use crate::Error;
 use core::mem::MaybeUninit;
 
+pub use crate::util::{inner_u32, inner_u64};
+
 #[link(name = "zircon")]
 extern "C" {
     fn zx_cprng_draw(buffer: *mut u8, length: usize);

src/backends/getentropy.rs

@@ -10,6 +10,8 @@
 use crate::Error;
 use core::{ffi::c_void, mem::MaybeUninit};
 
+pub use crate::util::{inner_u32, inner_u64};
+
 #[path = "../util_libc.rs"]
 mod util_libc;
 

src/backends/getrandom.rs

@@ -18,6 +18,8 @@
 use crate::Error;
 use core::{ffi::c_void, mem::MaybeUninit};
 
+pub use crate::util::{inner_u32, inner_u64};
+
 #[path = "../util_libc.rs"]
 mod util_libc;
 

src/backends/hermit.rs

@@ -4,6 +4,32 @@ use core::mem::MaybeUninit;
 
 extern "C" {
     fn sys_read_entropy(buffer: *mut u8, length: usize, flags: u32) -> isize;
+    // Note that `sys_secure_rand32/64` are implemented using `sys_read_entropy`:
+    // https://github.com/hermit-os/kernel/blob/430da84/src/syscalls/entropy.rs#L62-L104
+    // But this may change in future and can depend on compilation target,
+    // so to future-proof we use these "syscalls".
+    fn sys_secure_rand32(value: *mut u32) -> i32;
+    fn sys_secure_rand64(value: *mut u64) -> i32;
+}
+
+pub fn inner_u32() -> Result<u32, Error> {
+    let mut res = MaybeUninit::uninit();
+    let ret = unsafe { sys_secure_rand32(res.as_mut_ptr()) };
+    match ret {
+        0 => Ok(unsafe { res.assume_init() }),
+        -1 => Err(Error::UNSUPPORTED),
+        _ => Err(Error::UNEXPECTED),
+    }
+}
+
+pub fn inner_u64() -> Result<u64, Error> {
+    let mut res = MaybeUninit::uninit();
+    let ret = unsafe { sys_secure_rand64(res.as_mut_ptr()) };
+    match ret {
+        0 => Ok(unsafe { res.assume_init() }),
+        -1 => Err(Error::UNSUPPORTED),
+        _ => Err(Error::UNEXPECTED),
+    }
 }
 
 pub fn fill_inner(mut dest: &mut [MaybeUninit<u8>]) -> Result<(), Error> {

src/backends/linux_android.rs

@@ -2,6 +2,8 @@
 use crate::Error;
 use core::mem::MaybeUninit;
 
+pub use crate::util::{inner_u32, inner_u64};
+
 #[path = "../util_libc.rs"]
 mod util_libc;
 

src/backends/linux_android_with_fallback.rs

@@ -9,6 +9,8 @@ use core::{
 };
 use use_file::util_libc;
 
+pub use crate::util::{inner_u32, inner_u64};
+
 type GetRandomFn = unsafe extern "C" fn(*mut c_void, libc::size_t, libc::c_uint) -> libc::ssize_t;
 
 /// Sentinel value which indicates that `libc::getrandom` either not available,