crypto: improve random synchronous number generation performance

Instead of creating a RandomBytesJob object, it calls CSPRNG()
directly now.

Assisted-by: Claude Code
Signed-off-by: Mert Can Altin <mertgold60@gmail.com>

Author: mertcanaltin

lib/internal/crypto/random.js

@@ -34,6 +34,7 @@ const {
   CheckPrimeJob,
   kCryptoJobAsync,
   kCryptoJobSync,
+  randomFillSync: randomFillSyncImpl,
   secureBuffer,
 } = internalBinding('crypto');
 
@@ -175,16 +176,7 @@ function randomFillSync(buf, offset = 0, size) {
   if (size === 0)
     return buf;
 
-  const job = new RandomBytesJob(
-    kCryptoJobSync,
-    buf,
-    offset,
-    size);
-
-  const err = job.run()[0];
-  if (err)
-    throw err;
-
+  randomFillSyncImpl(buf, offset, size);
   return buf;
 }
 

src/crypto/crypto_random.cc

@@ -214,13 +214,44 @@ MaybeLocal<Value> CheckPrimeTraits::EncodeOutput(Environment* env,
 }
 
 namespace Random {
+static void RandomFillSync(const FunctionCallbackInfo<Value>& args) {
+  Environment* env = Environment::GetCurrent(args);
+  CHECK(IsAnyBufferSource(args[0]));  // Buffer to fill
+  CHECK(args[1]->IsUint32());         // Offset
+  CHECK(args[2]->IsUint32());         // Size
+
+  ArrayBufferOrViewContents<unsigned char> in(args[0]);
+
+  const uint32_t byte_offset = args[1].As<Uint32>()->Value();
+  const uint32_t size = args[2].As<Uint32>()->Value();
+  CHECK_GE(byte_offset + size, byte_offset);  // Overflow check.
+  CHECK_LE(byte_offset + size, in.size());    // Bounds check.
+
+  env->PrintSyncTrace();
+  ClearErrorOnReturn clear_error_on_return;
+  if (ncrypto::CSPRNG(in.data() + byte_offset, size)) return;
+
+  CryptoErrorStore errors;
+  errors.Capture();
+  if (errors.Empty()) {
+    errors.Insert(NodeCryptoError::DERIVING_BITS_FAILED);
+    errors.SetNodeErrorCode("ERR_CRYPTO_OPERATION_FAILED");
+  }
+  Local<Value> exception;
+  if (errors.ToException(env).ToLocal(&exception)) {
+    env->isolate()->ThrowException(exception);
+  }
+}
+
 void Initialize(Environment* env, Local<Object> target) {
+  SetMethod(env->context(), target, "randomFillSync", RandomFillSync);
   RandomBytesJob::Initialize(env, target);
   RandomPrimeJob::Initialize(env, target);
   CheckPrimeJob::Initialize(env, target);
 }
 
 void RegisterExternalReferences(ExternalReferenceRegistry* registry) {
+  registry->Register(RandomFillSync);
   RandomBytesJob::RegisterExternalReferences(registry);
   RandomPrimeJob::RegisterExternalReferences(registry);
   CheckPrimeJob::RegisterExternalReferences(registry);

test/parallel/test-crypto-randomfillsync-trace-sync-io.js

@@ -0,0 +1,23 @@
+'use strict';
+const common = require('../common');
+if (!common.hasCrypto)
+  common.skip('missing crypto');
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+
+// randomFillSync() should be reported by --trace-sync-io when it runs after
+// the first event loop turn.
+
+if (process.argv[2] === 'child') {
+  setImmediate(() => {
+    require('crypto').randomFillSync(Buffer.alloc(16));
+  });
+  return;
+}
+
+const { stderr, status } = spawnSync(process.execPath,
+                                     ['--trace-sync-io', __filename, 'child'],
+                                     { encoding: 'utf8' });
+assert.strictEqual(status, 0);
+assert.match(stderr, /WARNING: Detected use of sync API[\s\S]*randomFillSync/);

typings/internalBinding/crypto.d.ts

@@ -1002,6 +1002,7 @@ export interface CryptoBinding {
   privateEncrypt: InternalCryptoBinding.PublicKeyCipher;
   publicDecrypt: InternalCryptoBinding.PublicKeyCipher;
   publicEncrypt: InternalCryptoBinding.PublicKeyCipher;
+  randomFillSync(buf: ArrayBufferLike | ArrayBufferView, offset: number, size: number): void;
   resetRootCertStore(): void;
   secureBuffer(length: number): Uint8Array | undefined;
   secureHeapUsed(): bigint | undefined;