feat: add crypto.randomUUID function

Author: Jake Champion

c-dependencies/js-compute-runtime/builtins/crypto.cpp

@@ -52,8 +52,115 @@ bool Crypto::get_random_values(JSContext *cx, unsigned argc, JS::Value *vp) {
   return true;
 }
 
+/*
+  FROM RFC 4122
+  The formal definition of the UUID string representation is
+  provided by the following ABNF [7]:
+
+  UUID                   = time-low "-" time-mid "-"
+                            time-high-and-version "-"
+                            clock-seq-and-reserved
+                            clock-seq-low "-" node
+  time-low               = 4hexOctet
+  time-mid               = 2hexOctet
+  time-high-and-version  = 2hexOctet
+  clock-seq-and-reserved = hexOctet
+  clock-seq-low          = hexOctet
+  node                   = 6hexOctet
+  hexOctet               = hexDigit hexDigit
+  hexDigit =
+        "0" / "1" / "2" / "3" / "4" / "5" / "6" / "7" / "8" / "9" /
+        "a" / "b" / "c" / "d" / "e" / "f" /
+        "A" / "B" / "C" / "D" / "E" / "F"
+*/
+struct UUID {
+  uint32_t time_low;
+  uint16_t time_mid;
+  uint16_t time_high_and_version;
+  uint8_t clock_seq_and_reserved;
+  uint8_t clock_seq_low;
+  uint8_t node[6];
+};
+
+/*
+  FROM RFC 4122
+  4.1.3.  Version
+
+  The version number is in the most significant 4 bits of the time
+  stamp (bits 4 through 7 of the time_hi_and_version field).
+
+  The following table lists the currently-defined versions for this
+  UUID variant.
+
+  Msb0  Msb1  Msb2  Msb3   Version  Description
+
+    0     0     0     1        1    The time-based version
+                                    specified in this document.
+
+    0     0     1     0        2    DCE Security version, with
+                                    embedded POSIX UIDs.
+
+    0     0     1     1        3    The name-based version
+                                    specified in this document
+                                    that uses MD5 hashing.
+
+    0     1     0     0        4    The randomly or pseudo-
+                                    randomly generated version
+                                    specified in this document.
+
+    0     1     0     1        5    The name-based version
+                                    specified in this document
+                                    that uses SHA-1 hashing.
+*/
+/*
+  FROM RFC 4122
+  The version 4 UUID is meant for generating UUIDs from truly-random or
+  pseudo-random numbers.
+
+  The algorithm is as follows:
+
+  Set the two most significant bits (bits 6 and 7) of the clock_seq_hi_and_reserved to zero and one,
+  respectively.
+
+  Set the four most significant bits (bits 12 through 15) of the time_hi_and_version field to the
+  4-bit version number from Section 4.1.3.
+
+  Set all the other bits to randomly (or pseudo-randomly) chosen values.
+*/
+bool Crypto::random_uuid(JSContext *cx, unsigned argc, JS::Value *vp) {
+  JS::CallArgs args = CallArgsFromVp(argc, vp);
+  UUID id;
+  random_get(reinterpret_cast<int32_t>(&id), sizeof(id));
+
+  // Set the two most significant bits (bits 6 and 7) of the clock_seq_hi_and_reserved to zero and
+  // one, respectively.
+  id.clock_seq_and_reserved &= 0x3f;
+  id.clock_seq_and_reserved |= 0x80;
+  // Set the four most significant bits (bits 12 through 15) of the time_hi_and_version field to the
+  // 4-bit version number from Section 4.1.3.
+  id.time_high_and_version &= 0x0fff;
+  id.time_high_and_version |= 0x4000;
+
+  const char *fmt = "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x";
+  char buf[80];
+  std::snprintf(buf, sizeof(buf) - 1, fmt, id.time_low, (uint32_t)id.time_mid,
+                (uint32_t)id.time_high_and_version, (uint32_t)id.clock_seq_and_reserved,
+                (uint32_t)id.clock_seq_low, (uint32_t)id.node[0], (uint32_t)id.node[1],
+                (uint32_t)id.node[2], (uint32_t)id.node[3], (uint32_t)id.node[4],
+                (uint32_t)id.node[5]);
+  JS::RootedString str(cx, JS_NewStringCopyN(cx, buf, 36));
+
+  if (!str) {
+    return false;
+  }
+
+  args.rval().setString(str);
+  return true;
+}
+
 const JSFunctionSpec Crypto::methods[] = {
-    JS_FN("getRandomValues", get_random_values, 1, JSPROP_ENUMERATE), JS_FS_END};
+    JS_FN("getRandomValues", get_random_values, 1, JSPROP_ENUMERATE),
+    JS_FN("randomUUID", random_uuid, 0, JSPROP_ENUMERATE), JS_FS_END};
 
 const JSPropertySpec Crypto::properties[] = {JS_PS_END};
 

c-dependencies/js-compute-runtime/builtins/crypto.h

@@ -14,6 +14,7 @@ class Crypto : public BuiltinNoConstructor<Crypto> {
   static const JSPropertySpec properties[];
 
   static bool get_random_values(JSContext *cx, unsigned argc, JS::Value *vp);
+  static bool random_uuid(JSContext *cx, unsigned argc, JS::Value *vp);
   static bool create(JSContext *cx, JS::HandleObject global);
 };
 

documentation/docs/globals/crypto/randomUUID.mdx

@@ -0,0 +1,23 @@
+---
+hide_title: false
+hide_table_of_contents: false
+pagination_next: null
+pagination_prev: null
+---
+# Crypto.randomUUID()
+
+The **`randomUUID()`** method is used to generate a v4 [UUID](https://developer.mozilla.org/en-US/docs/Glossary/UUID) using a cryptographically secure random number generator.
+
+## Syntax
+
+```js
+randomUUID()
+```
+
+### Parameters
+
+None.
+
+### Return value
+
+A string containing a randomly generated, 36 character long v4 UUID.

tests/wpt-harness/expectations/WebCryptoAPI/randomUUID.https.any.js.json

@@ -0,0 +1,11 @@
+{
+  "namespace format": {
+    "status": "PASS"
+  },
+  "version set": {
+    "status": "PASS"
+  },
+  "variant set": {
+    "status": "PASS"
+  }
+}

tests/wpt-harness/tests.json

@@ -176,6 +176,7 @@
   "url/urlsearchparams-sort.any.js",
   "url/urlsearchparams-stringifier.any.js",
   "WebCryptoAPI/getRandomValues.any.js",
+  "WebCryptoAPI/randomUUID.https.any.js",
   "html/webappapis/structured-clone/structured-clone.any.js",
   "html/webappapis/timers/clearinterval-from-callback.any.js",
   "html/webappapis/timers/cleartimeout-clearinterval.any.js",