wasm32: Unify error codes an implementations

Right now, while our implementations for stdweb and wasm-bindgen use
similar APIs, they do not use similar implementations. This change:

  - Switches to using the same error codes for both implementations
  - Uses error codes that detail exactly what API is missing
  - Cleans up the implemetnations to make them much more readable
  - Consitantly use thread_local in both implementations

This makes issues easier to debug and the code easier to understand.

Signed-off-by: Joe Richey <[email protected]>

Author: josephlr

custom/stdweb/src/lib.rs

@@ -10,64 +10,52 @@
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 compile_error!("This crate is only for the `wasm32-unknown-unknown` target");
 
-use std::sync::Once;
+use std::thread_local;
 
 use stdweb::js;
 
 use getrandom::{register_custom_getrandom, Error};
 
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, PartialEq)]
 enum RngSource {
     Browser,
     Node,
 }
 
+thread_local!(
+    static RNG_SOURCE: Result<RngSource, Error> = getrandom_init();
+);
+
 register_custom_getrandom!(getrandom_inner);
 
 fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
-    static ONCE: Once = Once::new();
-    static mut RNG_SOURCE: Result<RngSource, Error> = Ok(RngSource::Node);
-
-    // SAFETY: RNG_SOURCE is only written once, before being read.
-    ONCE.call_once(|| unsafe {
-        RNG_SOURCE = getrandom_init();
-    });
-    getrandom_fill(unsafe { RNG_SOURCE }?, dest)
+    RNG_SOURCE.with(|&source| getrandom_fill(source?, dest))
 }
 
 fn getrandom_init() -> Result<RngSource, Error> {
-    let result = js! {
-        try {
-            if (
-                typeof self === "object" &&
-                typeof self.crypto === "object" &&
-                typeof self.crypto.getRandomValues === "function"
-            ) {
-                return { success: true, ty: 1 };
-            }
-
-            if (typeof require("crypto").randomBytes === "function") {
-                return { success: true, ty: 2 };
-            }
-
-            return { success: false, error: new Error("not supported") };
-        } catch(err) {
-            return { success: false, error: err };
-        }
-    };
-
-    if js! { return @{ result.as_ref() }.success } == true {
-        let ty = js! { return @{ result }.ty };
-
-        if ty == 1 {
+    if js! { return typeof self === "object"; } == true {
+        // We are in a Browser or WebWorker
+        let supported = js! { return typeof self.crypto === "object"; };
+        if supported == true {
             Ok(RngSource::Browser)
-        } else if ty == 2 {
-            Ok(RngSource::Node)
         } else {
-            unreachable!()
+            Err(Error::WEB_CRYPTO)
         }
     } else {
-        Err(Error::STDWEB_NO_RNG)
+        // We are in Node.js
+        let supported = js! {
+            try {
+                require("crypto");
+                return true;
+            } catch(err) {
+                return false;
+            }
+        };
+        if supported == true {
+            Ok(RngSource::Node)
+        } else {
+            Err(Error::NODE_CRYPTO)
+        }
     }
 }
 
@@ -76,32 +64,28 @@ fn getrandom_fill(source: RngSource, dest: &mut [u8]) -> Result<(), Error> {
         let len = chunk.len() as u32;
         let ptr = chunk.as_mut_ptr() as i32;
 
-        let result = match source {
-            RngSource::Browser => js! {
-                try {
-                    let array = new Uint8Array(@{ len });
-                    self.crypto.getRandomValues(array);
-                    HEAPU8.set(array, @{ ptr });
+        let success = js! {
+            try {
+                let array = new Uint8Array(@{ len });
 
-                    return { success: true };
-                } catch(err) {
-                    return { success: false, error: err };
+                if @{ source == RngSource::Browser } {
+                    self.crypto.getRandomValues(array);
+                } else {
+                    require("crypto").randomFillSync(array);
                 }
-            },
-            RngSource::Node => js! {
-                try {
-                    let bytes = require("crypto").randomBytes(@{ len });
-                    HEAPU8.set(new Uint8Array(bytes), @{ ptr });
 
-                    return { success: true };
-                } catch(err) {
-                    return { success: false, error: err };
-                }
-            },
+                HEAPU8.set(array, @{ ptr });
+                return true;
+            } catch(err) {
+                return false;
+            }
         };
 
-        if js! { return @{ result.as_ref() }.success } != true {
-            return Err(Error::STDWEB_RNG_FAILED);
+        if success != true {
+            return match source {
+                RngSource::Browser => Err(Error::WEB_GET_RANDOM_VALUES),
+                RngSource::Node => Err(Error::NODE_RANDOM_FILL_SYNC),
+            };
         }
     }
     Ok(())

custom/wasm-bindgen/src/lib.rs

@@ -9,14 +9,12 @@
 #[cfg(not(all(target_arch = "wasm32", target_os = "unknown")))]
 compile_error!("This crate is only for the `wasm32-unknown-unknown` target");
 
-use core::cell::RefCell;
 use std::thread_local;
 
 use wasm_bindgen::prelude::*;
 
 use getrandom::{register_custom_getrandom, Error};
 
-#[derive(Clone, Debug)]
 enum RngSource {
     Node(NodeCrypto),
     Browser(BrowserCrypto),
@@ -25,20 +23,21 @@ enum RngSource {
 // JsValues are always per-thread, so we initialize RngSource for each thread.
 //   See: https://github.com/rustwasm/wasm-bindgen/pull/955
 thread_local!(
-    static RNG_SOURCE: RefCell<Option<RngSource>> = RefCell::new(None);
+    static RNG_SOURCE: Result<RngSource, Error> = getrandom_init();
 );
 
 register_custom_getrandom!(getrandom_inner);
 
 fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
-    RNG_SOURCE.with(|f| {
-        let mut source = f.borrow_mut();
-        if source.is_none() {
-            *source = Some(getrandom_init()?);
-        }
-
-        match source.as_ref().unwrap() {
-            RngSource::Node(n) => n.random_fill_sync(dest),
+    RNG_SOURCE.with(|result| {
+        let source = result.as_ref().map_err(|&e| e)?;
+
+        match source {
+            RngSource::Node(n) => {
+                if n.random_fill_sync(dest).is_err() {
+                    return Err(Error::NODE_RANDOM_FILL_SYNC);
+                }
+            }
             RngSource::Browser(n) => {
                 // see https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
                 //
@@ -47,7 +46,9 @@ fn getrandom_inner(dest: &mut [u8]) -> Result<(), Error> {
                 // > A QuotaExceededError DOMException is thrown if the
                 // > requested length is greater than 65536 bytes.
                 for chunk in dest.chunks_mut(65536) {
-                    n.get_random_values(chunk)
+                    if n.get_random_values(chunk).is_err() {
+                        return Err(Error::WEB_GET_RANDOM_VALUES);
+                    }
                 }
             }
         };
@@ -63,20 +64,15 @@ fn getrandom_init() -> Result<RngSource, Error> {
         // assume we're in an older web browser and the OS RNG isn't available.
 
         let crypto: BrowserCrypto = match (self_.crypto(), self_.ms_crypto()) {
-            (crypto, _) if !crypto.is_undefined() => crypto.into(),
-            (_, crypto) if !crypto.is_undefined() => crypto.into(),
-            _ => return Err(Error::BINDGEN_CRYPTO_UNDEF),
+            (crypto, _) if !crypto.is_undefined() => crypto,
+            (_, crypto) if !crypto.is_undefined() => crypto,
+            _ => return Err(Error::WEB_CRYPTO),
         };
-
-        // Test if `crypto.getRandomValues` is undefined as well
-        if crypto.get_random_values_fn().is_undefined() {
-            return Err(Error::BINDGEN_GRV_UNDEF);
-        }
-
         return Ok(RngSource::Browser(crypto));
     }
 
-    return Ok(RngSource::Node(MODULE.require("crypto")));
+    let crypto = MODULE.require("crypto").map_err(|_| Error::NODE_CRYPTO)?;
+    Ok(RngSource::Node(crypto))
 }
 
 #[wasm_bindgen]
@@ -86,33 +82,23 @@ extern "C" {
     fn get_self() -> Result<Self_, JsValue>;
 
     type Self_;
-    #[wasm_bindgen(method, getter, js_name = "msCrypto", structural)]
-    fn ms_crypto(me: &Self_) -> JsValue;
-    #[wasm_bindgen(method, getter, structural)]
-    fn crypto(me: &Self_) -> JsValue;
+    #[wasm_bindgen(method, getter, js_name = "msCrypto")]
+    fn ms_crypto(me: &Self_) -> BrowserCrypto;
+    #[wasm_bindgen(method, getter)]
+    fn crypto(me: &Self_) -> BrowserCrypto;
 
-    #[derive(Clone, Debug)]
     type BrowserCrypto;
-
-    // TODO: these `structural` annotations here ideally wouldn't be here to
-    // avoid a JS shim, but for now with feature detection they're
-    // unavoidable.
-    #[wasm_bindgen(method, js_name = getRandomValues, structural, getter)]
-    fn get_random_values_fn(me: &BrowserCrypto) -> JsValue;
-    #[wasm_bindgen(method, js_name = getRandomValues, structural)]
-    fn get_random_values(me: &BrowserCrypto, buf: &mut [u8]);
-
-    #[derive(Clone, Debug)]
-    type NodeCrypto;
-
-    #[wasm_bindgen(method, js_name = randomFillSync, structural)]
-    fn random_fill_sync(me: &NodeCrypto, buf: &mut [u8]);
-
-    type NodeModule;
+    #[wasm_bindgen(method, js_name = getRandomValues, catch)]
+    fn get_random_values(me: &BrowserCrypto, buf: &mut [u8]) -> Result<(), JsValue>;
 
     #[wasm_bindgen(js_name = module)]
     static MODULE: NodeModule;
 
-    #[wasm_bindgen(method)]
-    fn require(this: &NodeModule, s: &str) -> NodeCrypto;
+    type NodeModule;
+    #[wasm_bindgen(method, catch)]
+    fn require(this: &NodeModule, s: &str) -> Result<NodeCrypto, JsValue>;
+
+    type NodeCrypto;
+    #[wasm_bindgen(method, js_name = randomFillSync, catch)]
+    fn random_fill_sync(crypto: &NodeCrypto, buf: &mut [u8]) -> Result<(), JsValue>;
 }

src/error.rs

@@ -37,16 +37,16 @@ impl Error {
     pub const FAILED_RDRAND: Error = internal_error(5);
     /// RDRAND instruction unsupported on this target.
     pub const NO_RDRAND: Error = internal_error(6);
-    /// Using `wasm-bindgen`, browser does not support `self.crypto`.
-    pub const BINDGEN_CRYPTO_UNDEF: Error = internal_error(7);
-    /// Using `wasm-bindgen`, browser does not support `crypto.getRandomValues`.
-    pub const BINDGEN_GRV_UNDEF: Error = internal_error(8);
-    /// Using `stdweb`, no cryptographic RNG is available.
-    pub const STDWEB_NO_RNG: Error = internal_error(9);
-    /// Using `stdweb`, invoking a cryptographic RNG failed.
-    pub const STDWEB_RNG_FAILED: Error = internal_error(10);
+    /// The browser does not have support for `self.crypto`.
+    pub const WEB_CRYPTO: Error = internal_error(7);
+    /// The browser does not have support for `crypto.getRandomValues`.
+    pub const WEB_GET_RANDOM_VALUES: Error = internal_error(8);
     /// On VxWorks, call to `randSecure` failed (random number generator is not yet initialized).
     pub const VXWORKS_RAND_SECURE: Error = internal_error(11);
+    /// NodeJS does not have support for the `crypto` module.
+    pub const NODE_CRYPTO: Error = internal_error(12);
+    /// NodeJS does not have support for `crypto.randomFillSync`.
+    pub const NODE_RANDOM_FILL_SYNC: Error = internal_error(13);
 
     /// Codes below this point represent OS Errors (i.e. positive i32 values).
     /// Codes at or above this point, but below [`Error::CUSTOM_START`] are
@@ -152,15 +152,15 @@ fn internal_desc(error: Error) -> Option<&'static str> {
     match error {
         Error::UNSUPPORTED => Some("getrandom: this target is not supported"),
         Error::ERRNO_NOT_POSITIVE => Some("errno: did not return a positive value"),
-        Error::IOS_SEC_RANDOM => Some("SecRandomCopyBytes: iOS Secuirty framework failure"),
+        Error::IOS_SEC_RANDOM => Some("SecRandomCopyBytes: iOS Security framework failure"),
         Error::WINDOWS_RTL_GEN_RANDOM => Some("RtlGenRandom: Windows system function failure"),
         Error::FAILED_RDRAND => Some("RDRAND: failed multiple times: CPU issue likely"),
         Error::NO_RDRAND => Some("RDRAND: instruction not supported"),
-        Error::BINDGEN_CRYPTO_UNDEF => Some("wasm-bindgen: self.crypto is undefined"),
-        Error::BINDGEN_GRV_UNDEF => Some("wasm-bindgen: crypto.getRandomValues is undefined"),
-        Error::STDWEB_NO_RNG => Some("stdweb: no randomness source available"),
-        Error::STDWEB_RNG_FAILED => Some("stdweb: failed to get randomness"),
+        Error::WEB_CRYPTO => Some("Web API self.crypto is unavailable"),
+        Error::WEB_GET_RANDOM_VALUES => Some("Web API crypto.getRandomValues is unavailable"),
         Error::VXWORKS_RAND_SECURE => Some("randSecure: VxWorks RNG module is not initialized"),
+        Error::NODE_CRYPTO => Some("Node.js crypto module is unavailable"),
+        Error::NODE_RANDOM_FILL_SYNC => Some("Node.js API crypto.randomFillSync is unavailable"),
         _ => None,
     }
 }