fix(stdlib): crypto.getHashes/getCiphers/getCurves/getCipherInfo through a dynamic receiver

changelog.d/11176-crypto-inventory-dynamic-dispatch.md

@@ -0,0 +1,15 @@
+Fix `crypto.getHashes()`, `getCiphers()`, `getCurves()` and `getCipherInfo()`
+returning `undefined` when the `crypto` receiver is not a statically known
+`node:crypto` reference: a `let` assigned from `require`, a detached method
+value, or a module held in an object. Those calls reach
+`js_crypto_native_dispatch` in `perry-stdlib/src/crypto/random.rs`, which had
+no arm for the four names. It now routes them to the same helpers the direct
+lowering uses.
+
+undici 8.9.0's `subresource-integrity.js` calls `crypto.getHashes()` this way
+at module init and reads `.length`. Under `PERRY_NO_AUTO_OPTIMIZE=1` that made
+every `require('undici')` throw "Cannot read properties of undefined (reading
+'length')". This is part of #11046. The auto-optimize failure reported there is
+the `Socket.read()` gap (#10908). Covered by
+`test-files/test_gap_11046_crypto_inventory_dynamic_receiver.cts` and a
+dispatcher unit test.

crates/perry-stdlib/src/crypto/random.rs

@@ -392,6 +392,17 @@ pub unsafe extern "C" fn js_crypto_native_dispatch(
             js_crypto_check_prime_async(arg(0), undefined, arg(1))
         }
         "checkPrime" | "checkPrimeSync" => js_crypto_check_prime_sync(arg(0), arg(1)),
+        // #11046: the inventory helpers are reached through this dispatcher
+        // whenever the receiver is not a statically-known `node:crypto`
+        // reference — `let crypto; crypto = require('node:crypto');
+        // crypto.getHashes()` (undici's subresource-integrity feature probe),
+        // a detached `const f = crypto.getHashes; f()`, or `crypto` held in an
+        // object. Without these arms they fell to `_ => undefined`, and
+        // undici's `cryptoHashes.length` threw at module init.
+        "getHashes" => pointer_value(js_crypto_get_hashes() as *mut u8),
+        "getCiphers" => pointer_value(js_crypto_get_ciphers() as *mut u8),
+        "getCurves" => pointer_value(js_crypto_get_curves() as *mut u8),
+        "getCipherInfo" => js_crypto_get_cipher_info(arg(0), arg(1)),
         "getFips" => 0.0,
         "setFips" => undefined,
         "secureHeapUsed" => pointer_value(js_crypto_secure_heap_used() as *mut u8),
@@ -746,6 +757,47 @@ mod tests {
         assert_eq!(result.to_bits(), 0.0f64.to_bits());
     }
 
+    /// #11046: a `crypto` receiver the compiler cannot prove is `node:crypto`
+    /// (undici's `let crypto; crypto = require('node:crypto')`) reaches the
+    /// inventory helpers only through this dispatcher. Each must answer an
+    /// array, never `undefined`, and `getCipherInfo` must answer the same
+    /// object/`undefined` split as the direct helper.
+    #[test]
+    fn crypto_native_dispatch_answers_inventories() {
+        for method in ["getHashes", "getCiphers", "getCurves"] {
+            let result = unsafe {
+                js_crypto_native_dispatch(method.as_ptr(), method.len(), std::ptr::null(), 0)
+            };
+            let value = perry_runtime::JSValue::from_bits(result.to_bits());
+            assert!(
+                value.is_pointer(),
+                "{method} must answer an array, got {result:?}"
+            );
+            let arr = perry_runtime::js_nanbox_get_pointer(result)
+                as *const perry_runtime::array::ArrayHeader;
+            assert!(
+                unsafe { (*arr).length } > 0,
+                "{method} must answer a non-empty inventory"
+            );
+        }
+        let method = b"getCipherInfo";
+        let known = [js_str("aes-256-cbc"), undefined()];
+        let result = unsafe {
+            js_crypto_native_dispatch(method.as_ptr(), method.len(), known.as_ptr(), known.len())
+        };
+        assert!(perry_runtime::JSValue::from_bits(result.to_bits()).is_pointer());
+        let unknown = [js_str("no-such-cipher"), undefined()];
+        let result = unsafe {
+            js_crypto_native_dispatch(
+                method.as_ptr(),
+                method.len(),
+                unknown.as_ptr(),
+                unknown.len(),
+            )
+        };
+        assert_eq!(result.to_bits(), undefined().to_bits());
+    }
+
     #[test]
     fn random_fill_sync_native_uint8_view_preserves_metadata() {
         let owner = perry_runtime::native_arena::js_native_arena_alloc(96);

test-files/test_gap_11046_crypto_inventory_dynamic_receiver.cts

@@ -0,0 +1,48 @@
+// #11046: `crypto.getHashes()` / `getCiphers()` / `getCurves()` /
+// `getCipherInfo()` reached through a receiver the compiler cannot prove is
+// `node:crypto`. undici's subresource-integrity module does exactly this at
+// module init:
+//
+//   let crypto
+//   if (runtimeFeatures.has('crypto')) {
+//     crypto = require('node:crypto')
+//     const cryptoHashes = crypto.getHashes()
+//     if (cryptoHashes.length === 0) { ... }
+//
+// The statically-known `NativeModuleRef` form lowers straight to the runtime
+// helper, but the dynamic form goes through the runtime's native-module
+// dispatcher, which had no arm for these names and returned `undefined`, so
+// `cryptoHashes.length` threw "Cannot read properties of undefined (reading
+// 'length')" and every `require('undici')` failed.
+
+// 1. undici's exact shape: a `let` assigned from require, then a feature probe.
+let crypto: any;
+crypto = require("node:crypto");
+const cryptoHashes = crypto.getHashes();
+console.log("let getHashes:", Array.isArray(cryptoHashes), cryptoHashes.length > 0);
+const tokens = new Map([["sha256", 0], ["sha384", 1], ["sha512", 2]]);
+for (const algorithm of tokens.keys()) {
+  if (cryptoHashes.includes(algorithm) === false) {
+    tokens.delete(algorithm);
+  }
+}
+console.log("supported SRI algorithms:", [...tokens.keys()].join(","));
+
+// 2. The other inventories through the same dynamic receiver.
+const ciphers = crypto.getCiphers();
+console.log("getCiphers:", Array.isArray(ciphers), ciphers.includes("aes-256-gcm"), ciphers.includes("aes-128-cbc"));
+const curves = crypto.getCurves();
+console.log("getCurves:", Array.isArray(curves), curves.includes("prime256v1"), curves.includes("secp384r1"));
+const info = crypto.getCipherInfo("aes-256-cbc");
+console.log("getCipherInfo:", info.name, info.mode, info.keyLength, info.ivLength, info.blockSize);
+console.log("getCipherInfo unknown:", crypto.getCipherInfo("no-such-cipher"));
+
+// 3. Detached method values and a receiver held in an object.
+const getHashes = crypto.getHashes;
+console.log("detached:", typeof getHashes, Array.isArray(getHashes()), getHashes().includes("sha1"));
+const holder: any = { c: require("node:crypto") };
+console.log("held:", Array.isArray(holder.c.getHashes()), holder.c.getCurves().length > 0);
+
+// 4. Control: the statically-known receiver (already worked).
+const direct = require("node:crypto");
+console.log("const receiver:", Array.isArray(direct.getHashes()), direct.getHashes().includes("sha384"));