crypto: reuse uuid buffer

Author: araujogui

lib/internal/crypto/random.js

@@ -348,8 +348,6 @@ let uuidData;
 let uuidNotBuffered;
 let uuidBatch = 0;
 
-let uuidDataV7;
-let uuidBatchV7 = 0;
 let v7LastTimestamp = -1;
 let v7Counter = 0;
 
@@ -434,64 +432,57 @@ function advanceV7(seed) {
   }
 }
 
-function writeTimestampAndCounterV7(buf, offset) {
-  const ts = v7LastTimestamp;
-  const msb = ts / (2 ** 32);
-  buf[offset] = msb >>> 8;
-  buf[offset + 1] = msb;
-  buf[offset + 2] = ts >>> 24;
-  buf[offset + 3] = ts >>> 16;
-  buf[offset + 4] = ts >>> 8;
-  buf[offset + 5] = ts;
-  buf[offset + 6] = (v7Counter >>> 8) & 0x0f;
-  buf[offset + 7] = v7Counter & 0xff;
-}
-
-function getBufferedUUIDv7(monotonic) {
-  uuidDataV7 ??= secureBuffer(16 * kBatchSize);
-  if (uuidDataV7 === undefined)
-    throw new ERR_OPERATION_FAILED('Out of memory');
-
-  if (uuidBatchV7 === 0) randomFillSync(uuidDataV7);
-  uuidBatchV7 = (uuidBatchV7 + 1) % kBatchSize;
-  const offset = uuidBatchV7 * 16;
+function makeUUIDv7(buf, offset, monotonic = false) {
+  let timestamp, randA;
   if (monotonic) {
-    const seed = ((uuidDataV7[offset + 6] & 0x0f) << 8) | uuidDataV7[offset + 7];
+    const seed = ((buf[offset + 6] & 0x0f) << 8) | buf[offset + 7];
     advanceV7(seed);
-    writeTimestampAndCounterV7(uuidDataV7, offset);
+    timestamp = v7LastTimestamp;
+    randA = v7Counter;
   } else {
-    const now = DateNow();
-    const msb = now / (2 ** 32);
-    uuidDataV7[offset] = msb >>> 8;
-    uuidDataV7[offset + 1] = msb;
-    uuidDataV7[offset + 2] = now >>> 24;
-    uuidDataV7[offset + 3] = now >>> 16;
-    uuidDataV7[offset + 4] = now >>> 8;
-    uuidDataV7[offset + 5] = now;
+    timestamp = DateNow();
+    randA = ((buf[offset + 6] & 0x0f) << 8) | buf[offset + 7];
   }
-  return serializeUUID(uuidDataV7, 0x70, 0x80, offset);
+  const kHexBytes = getHexBytes();
+  const msb = timestamp / (2 ** 32);
+  return kHexBytes[msb >>> 8] +
+    kHexBytes[msb & 0xff] +
+    kHexBytes[timestamp >>> 24] +
+    kHexBytes[(timestamp >>> 16) & 0xff] +
+    '-' +
+    kHexBytes[(timestamp >>> 8) & 0xff] +
+    kHexBytes[timestamp & 0xff] +
+    '-' +
+    kHexBytes[(randA >>> 8) | 0x70] +
+    kHexBytes[randA & 0xff] +
+    '-' +
+    kHexBytes[(buf[offset + 8] & 0x3f) | 0x80] +
+    kHexBytes[buf[offset + 9]] +
+    '-' +
+    kHexBytes[buf[offset + 10]] +
+    kHexBytes[buf[offset + 11]] +
+    kHexBytes[buf[offset + 12]] +
+    kHexBytes[buf[offset + 13]] +
+    kHexBytes[buf[offset + 14]] +
+    kHexBytes[buf[offset + 15]];
+}
+
+function getBufferedUUIDv7(monotonic = false) {
+  uuidData ??= secureBuffer(16 * kBatchSize);
+  if (uuidData === undefined)
+    throw new ERR_OPERATION_FAILED('Out of memory');
+
+  if (uuidBatch === 0) randomFillSync(uuidData);
+  uuidBatch = (uuidBatch + 1) % kBatchSize;
+  return makeUUIDv7(uuidData, uuidBatch * 16, monotonic);
 }
 
-function getUnbufferedUUIDv7(monotonic) {
+function getUnbufferedUUIDv7(monotonic = false) {
   uuidNotBuffered ??= secureBuffer(16);
   if (uuidNotBuffered === undefined)
     throw new ERR_OPERATION_FAILED('Out of memory');
   randomFillSync(uuidNotBuffered, 6);
-  if (monotonic) {
-    const seed = ((uuidNotBuffered[6] & 0x0f) << 8) | uuidNotBuffered[7];
-    advanceV7(seed);
-    writeTimestampAndCounterV7(uuidNotBuffered, 0);
-  } else {
-    const now = DateNow();
-    const msb = now / (2 ** 32);
-    uuidNotBuffered[0] = msb >>> 8;
-    uuidNotBuffered[1] = msb;
-    uuidNotBuffered[2] = now >>> 24;
-    uuidNotBuffered[3] = now >>> 16;
-    uuidNotBuffered[4] = now >>> 8;
-    uuidNotBuffered[5] = now;
-  }
-  return serializeUUID(uuidNotBuffered, 0x70, 0x80);
+  return makeUUIDv7(uuidNotBuffered, 0, monotonic);
 }
 
 function randomUUIDv7(options) {