@blamejs/pki 0.6.40 → 0.6.42

package/lib/guard-bytes.js

@@ -6,7 +6,7 @@ var async = require("./guard-async");
 var identifier = require("./guard-identifier");
 var time = require("./guard-time");
 var intrinsic = require("./guard-intrinsic");
-var util = { types: intrinsic.types };
+var util = intrinsic.assign(intrinsic.create(null), { types: intrinsic.types });
 var _isArray = intrinsic.isArray;
 var _bufferFrom = intrinsic.bufferFrom;
 var _isView = intrinsic.isView;
@@ -65,7 +65,7 @@ function asyncStreamOf(x) {
   if (isByteSource(x) || x == null || (typeof x !== "object" && typeof x !== "function")) return null;
   var acquire = x[_asyncIterator];
   if (typeof acquire !== "function") return null;
-  var stream = {};
+  var stream = intrinsic.create(null);
   stream[_asyncIterator] = function () { return _apply(acquire, x, _NO_ARGS); };
   return stream;
 }

package/lib/guard-compress.js

@@ -15,17 +15,17 @@ var _sizeOf = _intrinsic.sizeOf;
 var _subarray = _intrinsic.uncurry(Uint8Array.prototype.subarray);
 var _hasOwn = _intrinsic.hasOwn;
 
-var DECOMPRESS = {
+var DECOMPRESS = _intrinsic.assign(_intrinsic.create(null), {
   zlib: zlib.inflateSync,
   brotli: zlib.brotliDecompressSync,
   zstd: zlib.zstdDecompressSync,
-};
+});
 
-var _PROBE_COMPRESS = {
+var _PROBE_COMPRESS = _intrinsic.assign(_intrinsic.create(null), {
   zlib: zlib.deflateSync,
   brotli: zlib.brotliCompressSync,
   zstd: zlib.zstdCompressSync,
-};
+});
 
 function _reportsTruncation(name) {
   var compress = _PROBE_COMPRESS[name];
@@ -47,7 +47,7 @@ function _reportsTruncation(name) {
   return !cutAccepted;
 }
 
-var SAFE = {};
+var SAFE = _intrinsic.create(null);
 _intrinsic.forEach(_objectKeys(DECOMPRESS), function (n) { if (_reportsTruncation(n)) SAFE[n] = true; });
 
 // @enforced-by guard-shape-reinlined

package/lib/guard-identifier.js

@@ -2,7 +2,7 @@
 // Copyright (c) blamejs contributors
 "use strict";
 var intrinsic = require("./guard-intrinsic");
-var util = { types: intrinsic.types };
+var util = intrinsic.assign(intrinsic.create(null), { types: intrinsic.types });
 // @internal
 
 var _isArray = intrinsic.isArray;
@@ -32,6 +32,7 @@ var _Set = intrinsic.Set;
 var _Map = intrinsic.Map;
 var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
 var _strSplit = intrinsic.uncurry(String.prototype.split);
+var _fnToString = intrinsic.uncurry(Function.prototype.toString);
 var _hasOwn = intrinsic.hasOwn;
 var _String = intrinsic.String;
 var _Number = intrinsic.Number;
@@ -390,7 +391,50 @@ function _settle(opts, E, code, label) {
   return opts;
 }
 
+/** @internal An injectable callback option, refused unless it is callable. A value that is present
+ * but not a function reaches the call site otherwise, where the operator gets a bare TypeError
+ * naming no option; and one read as absent sends the caller to whatever default the boundary
+ * installs, which for a transport is a real network client the caller was trying to replace. Take a
+ * value only when it is known to be present; `assertCallableOption` decides presence.
+ *
+ * Callable is all this asks. A class constructor answers "function" to typeof and still throws when
+ * called, but no test here separates one from an ordinary function: freezing a function leaves its
+ * prototype non-writable exactly as a class's is, and reading the source text mistakes a method
+ * named `class` for the keyword. The boundary that calls the value reports that throw as its own
+ * typed error (`guard.async.invoked`), which covers a class however it is disguised, binding it
+ * included, and rejects nothing a caller can legitimately pass. */
+// @enforced-by behavioral -- the shape is a typeof test against a string literal, and the pattern
+// @enforced-by behavioral -- scanner blanks every literal, so "function" cannot be told from
+// @enforced-by behavioral -- "string" or "object"; a lexical rule would flag every type check in
+// @enforced-by behavioral -- lib. The per-verb vectors across est, scep, acme, cmp and ct are the
+// @enforced-by behavioral -- guard: each drives the shipped verb and asserts the typed refusal.
+function assertCallable(value, E, code, label, shape) {
+  var wanted = label + " must be a function" + (shape ? " " + shape : "");
+  if (value === undefined) {
+    throw E(code, wanted + ", got undefined");
+  }
+  if (typeof value !== "function") {
+    throw E(code, wanted + ", got " + (value === null ? "null" : typeof value));
+  }
+  return value;
+}
+
+/** @internal The option form: an option counts as supplied when a name lookup finds the key, so a
+ * merge that produced `{ transport: undefined }` is a value the caller set rather than an option it
+ * left out. Presence is asked the way the boundary asks for the value, which is a plain lookup, so
+ * an inherited option from a defaults bag is checked rather than skipped; testing own keys alone
+ * would let an inherited null pass here and then be read as absent, selecting the default client.
+ * Only a key no lookup finds falls through to that default. */
+// @enforced-by behavioral -- the per-verb vectors across est, scep, acme, cmp, ct and path drive the
+// @enforced-by behavioral -- shipped verb and assert the typed refusal for each unusable value
+function assertCallableOption(opts, key, E, code, label, shape) {
+  if (opts == null || !(key in _Object(opts))) return undefined;
+  return assertCallable(opts[key], E, code, label, shape);
+}
+
 module.exports = intrinsic.freeze({
+  assertCallable: assertCallable,
+  assertCallableOption: assertCallableOption,
   assertCanonicalOid: assertCanonicalOid,
   assertKnownKeys: assertKnownKeys,
   assertPlainRecord: assertPlainRecord,

package/lib/guard-name.js

@@ -4,6 +4,11 @@
 // @internal
 
 var intrinsic = require("./guard-intrinsic");
+var _append = require("./guard-list").append;
+var _assertCanonicalOid = require("./guard-identifier").assertCanonicalOid;
+var _ipUtils = require("./ip-utils");
+var _isIPv4 = _ipUtils.isIPv4;
+var _expandIpv6Hex = _ipUtils.expandIpv6Hex;
 
 var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
 var _charAt = intrinsic.uncurry(String.prototype.charAt);
@@ -11,6 +16,7 @@ var _toLowerCase = intrinsic.uncurry(String.prototype.toLowerCase);
 var _toUpperCase = intrinsic.uncurry(String.prototype.toUpperCase);
 var _strSlice = intrinsic.uncurry(String.prototype.slice);
 var _lastIndexOf = intrinsic.uncurry(String.prototype.lastIndexOf);
+var _indexOf = intrinsic.uncurry(String.prototype.indexOf);
 var _numToString = intrinsic.uncurry(Number.prototype.toString);
 var _create = intrinsic.create;
 var _hasOwn = intrinsic.hasOwn;
@@ -152,7 +158,7 @@ function escapeControlBytes(str) {
   return out;
 }
 
-var DN_SPECIAL = { 0x2c: 1, 0x2b: 1, 0x22: 1, 0x5c: 1, 0x3c: 1, 0x3e: 1, 0x3b: 1 };
+var DN_SPECIAL = intrinsic.assign(intrinsic.create(null), { 0x2c: 1, 0x2b: 1, 0x22: 1, 0x5c: 1, 0x3c: 1, 0x3e: 1, 0x3b: 1 });
 // @enforced-by behavioral -- the escaping has no rename-proof code shape distinct
 function escapeDnValue(v) {
   var s = _String(v), out = "";
@@ -197,9 +203,274 @@ function lowerAscii(s) {
   return out;
 }
 
+function _charTable(chars) {
+  var t = _create(null);
+  for (var i = 0; i < chars.length; i++) t[_charCodeAt(chars, i)] = true;
+  return t;
+}
+var _FQDN_TABLE = _charTable("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.-");
+var _DIGDOT_TABLE = _charTable("0123456789.");
+function _allCharsIn(s, table) {
+  if (s.length === 0) return false;
+  for (var i = 0; i < s.length; i++) if (!table[_charCodeAt(s, i)]) return false;
+  return true;
+}
+
+function stripTrailingDot(s) { return _charAt(s, s.length - 1) === "." ? _strSlice(s, 0, -1) : s; }
+
+/** @internal A host name of two or more labels that is not an address, which is the form a URI
+ * name constraint is compared by (RFC 5280 sec. 4.2.1.10). */
+function isFqdnHost(host) {
+  var h = stripTrailingDot(host);
+  if (h === "" || _indexOf(h, ".") === -1) return false;
+  if (!_allCharsIn(h, _FQDN_TABLE)) return false;
+  if (_allCharsIn(h, _DIGDOT_TABLE)) return false;
+  return true;
+}
+
+var _LDH_ALNUM = _charTable("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
+var MAX_LABEL = 63;
+var MAX_HOST = 253;
+var MAX_LOCAL_PART = 64;
+
+/** @internal One label of a host name (RFC 1034 sec. 3.5, RFC 1123 sec. 2.1): letters, digits and
+ * hyphens, with a hyphen at neither edge, and 63 characters at most. */
+function _isHostLabel(s, from, to) {
+  var n = to - from;
+  if (n === 0 || n > MAX_LABEL) return false;
+  if (!_LDH_ALNUM[_charCodeAt(s, from)] || !_LDH_ALNUM[_charCodeAt(s, to - 1)]) return false;
+  for (var i = from + 1; i < to - 1; i++) {
+    var c = _charCodeAt(s, i);
+    if (!_LDH_ALNUM[c] && c !== 0x2d) return false;
+  }
+  return true;
+}
+
+/** @internal A host name written as labels separated by dots, carrying no trailing dot: the caller
+ * strips the one dot the comparison strips, so a second one is an empty label and is refused. */
+function _isHostName(s) {
+  if (s.length === 0 || s.length > MAX_HOST) return false;
+  var start = 0;
+  for (var i = 0; i <= s.length; i++) {
+    if (i === s.length || _charCodeAt(s, i) === 0x2e) {
+      if (!_isHostLabel(s, start, i)) return false;
+      start = i + 1;
+    }
+  }
+  return true;
+}
+
+var _ATEXT_TABLE = _charTable("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!#$%&'*+-/=?^_`{|}~");
+
+/** @internal A quoted local part (RFC 5321 sec. 4.1.2 Quoted-string): printable ASCII between
+ * quotes, where a backslash escapes the character after it. */
+function _isQuotedLocal(s) {
+  var n = s.length;
+  if (n < 2 || _charCodeAt(s, n - 1) !== 0x22) return false;
+  for (var i = 1; i < n - 1; i++) {
+    var c = _charCodeAt(s, i);
+    if (c === 0x5c) {
+      i += 1;
+      if (i >= n - 1) return false;
+      var e = _charCodeAt(s, i);
+      if (e < 0x20 || e > 0x7e) return false;
+      continue;
+    }
+    if (c < 0x20 || c > 0x7e || c === 0x22) return false;
+  }
+  return true;
+}
+
+/** @internal The local part of a mailbox (RFC 5321 sec. 4.1.2): either a quoted string, or atoms
+ * separated by dots, which is the form a certificate's mailbox is compared against. */
+function _isMailboxLocal(s) {
+  if (s.length === 0 || s.length > MAX_LOCAL_PART) return false;
+  if (_charCodeAt(s, 0) === 0x22) return _isQuotedLocal(s);
+  var pieceLen = 0;
+  for (var i = 0; i < s.length; i++) {
+    var c = _charCodeAt(s, i);
+    if (c === 0x2e) {
+      if (pieceLen === 0) return false;
+      pieceLen = 0;
+      continue;
+    }
+    if (!_ATEXT_TABLE[c]) return false;
+    pieceLen += 1;
+  }
+  return pieceLen > 0;
+}
+
+var _IPV6_TAG = "ipv6:";
+/** @internal An address literal (RFC 5321 sec. 4.1.3), the other form a mailbox may name its domain
+ * in: an IPv4 address in brackets, or an IPv6 address behind the tag that introduces one. The
+ * comparison holds a mailbox constraint's domain to an exact match, so a literal is a domain it can
+ * reach a verdict on. */
+function _isAddressLiteral(s) {
+  var n = s.length;
+  if (n < 3 || _charCodeAt(s, 0) !== 0x5b || _charCodeAt(s, n - 1) !== 0x5d) return false;
+  var inner = _strSlice(s, 1, n - 1);
+  if (_toLowerCase(_strSlice(inner, 0, _IPV6_TAG.length)) === _IPV6_TAG) {
+    return _expandIpv6Hex(_strSlice(inner, _IPV6_TAG.length)) !== null;
+  }
+  return _isIPv4(inner);
+}
+
+/** @internal The two halves of a mailbox, `null` when it carries no separator and the string
+ * "ambiguous" when it carries more than one. This is the split the rfc822Name comparison runs, so a
+ * constraint the comparison cannot separate is one this answers the same way. */
+function splitMailbox(addr) {
+  var first = _indexOf(addr, "@");
+  if (first === -1) return null;
+  if (first !== _lastIndexOf(addr, "@")) return "ambiguous";
+  return [_strSlice(addr, 0, first), _strSlice(addr, first + 1)];
+}
+
+/** @internal A host name, optionally written as a subtree with a leading dot, and with the one
+ * trailing dot the comparison strips. */
+function _hostConstraintBody(s) {
+  var h = stripTrailingDot(s);
+  return _charAt(h, 0) === "." ? _strSlice(h, 1) : h;
+}
+
+/** @internal Why a name-constraint base cannot be enforced, or null when it can. A base outside the
+ * form its tag names is not a narrower namespace: an empty dNSName base matches every name, and a
+ * base holding characters no host name can hold matches none, so the same value that reads as a
+ * restriction either lifts one or applies to nothing. The comparisons this mirrors are in
+ * lib/path-validate.js, and a base refused here is one they would answer with no verdict. */
+function constraintBaseRefusal(tag, base) {
+  if (typeof base !== "string") return "must be a string for tag " + tag;
+  if (tag === 1) {
+    var mb = splitMailbox(base);
+    if (mb === null) {
+      if (_isAddressLiteral(base)) return null;
+      return _isHostName(_hostConstraintBody(base)) ? null
+        : "must be a mailbox, a host name, or a host name written as a subtree with a leading dot";
+    }
+    if (mb === "ambiguous") {
+      return "carries more than one at-sign, so the comparison cannot tell which one separates the mailbox";
+    }
+    if (!_isMailboxLocal(mb[0])) return "must carry the local part of a mailbox before its at-sign";
+    if (_isAddressLiteral(mb[1])) return null;
+    return _isHostName(stripTrailingDot(mb[1])) ? null
+      : "must end in the host name or bracketed address literal of a mailbox";
+  }
+  if (tag === 2) {
+    return _isHostName(_hostConstraintBody(base)) ? null
+      : "must be a host name, optionally written as a subtree with a leading dot";
+  }
+  if (tag === 6) {
+    var h = _hostConstraintBody(_toLowerCase(base));
+    var dotted = _isHostName(h) && _indexOf(h, ".") !== -1 && !_allCharsIn(h, _DIGDOT_TABLE);
+    return dotted ? null
+      : "must be a dotted host name, which is the part of a URI a certificate is compared by";
+  }
+  return null;
+}
+
+var _ATV_KEYS = ["type", "value", "name"];
+
+/** @internal A distinguished name a caller supplied, copied into fresh plain objects by reading
+ * descriptors only. A Proxy answers its own reads and an accessor runs caller code, so either one
+ * at any level is refused before anything is copied: a name that decides what it says while it is
+ * being read can show a narrow value to a check and a wide one to the use, and where the name is a
+ * namespace restriction that is the difference between a certificate being refused and admitted. */
+function copyDnRdns(rdns, E, code, who) {
+  assertPlainDnRdns(rdns, E, code, who);
+  /** @internal A name of no relative names is a prefix of every name, so as a constraint it reaches
+   * the same verdict on all of them. */
+  if (rdns.length === 0) throw E(code, who + " must name at least one relative distinguished name");
+  var out = [];
+  for (var i = 0; i < rdns.length; i++) {
+    var rd = intrinsic.getOwnPropertyDescriptor(rdns, i);
+    if (rd === undefined) throw E(code, who + " index " + i + " is a hole or is inherited; every entry must be its own");
+    var rdn = rd.value;
+    if (!_isArray(rdn)) throw E(code, who + "[" + i + "] must be an array of attributes");
+    if (rdn.length === 0) throw E(code, who + "[" + i + "] must carry at least one attribute");
+    var rdnOut = [];
+    for (var j = 0; j < rdn.length; j++) {
+      var ad = intrinsic.getOwnPropertyDescriptor(rdn, j);
+      if (ad === undefined) throw E(code, who + "[" + i + "] index " + j + " is a hole or is inherited; every entry must be its own");
+      var atv = ad.value;
+      if (atv === null || typeof atv !== "object") throw E(code, who + "[" + i + "][" + j + "] must be an attribute object carrying a type and a value");
+      var atvOut = {};
+      for (var k = 0; k < _ATV_KEYS.length; k++) {
+        var fd = intrinsic.getOwnPropertyDescriptor(atv, _ATV_KEYS[k]);
+        if (fd === undefined) continue;
+        intrinsic.defineProperty(atvOut, _ATV_KEYS[k], { value: fd.value, enumerable: true, configurable: true, writable: true });
+      }
+      if (!_hasOwn(atvOut, "type") || !_hasOwn(atvOut, "value")) {
+        throw E(code, who + "[" + i + "][" + j + "] must carry its type and value as own data properties");
+      }
+      /** @internal Every attribute a certificate's name is compared against is a string compared to
+       * a string, so an attribute holding anything else is equal to nothing it will ever meet, and
+       * NaN is not even equal to itself. A name built out of those is not a narrower namespace. */
+      _assertCanonicalOid(atvOut.type, E, code, who + "[" + i + "][" + j + "].type");
+      if (typeof atvOut.value !== "string") {
+        throw E(code, who + "[" + i + "][" + j + "].value must be a string, the form a name is compared in");
+      }
+      assertNoControlBytes(atvOut.value, E, code, who + "[" + i + "][" + j + "].value");
+      _append(rdnOut, atvOut);
+    }
+    _append(out, rdnOut);
+  }
+  return out;
+}
+
+/** @internal The shape check the copy above relies on. */
+function assertPlainDnRdns(rdns, E, code, who) {
+  if (intrinsic.types.isProxy(rdns)) throw E(code, who + " must be a plain array, not a Proxy");
+  for (var i = 0; i < rdns.length; i++) {
+    var rd = intrinsic.getOwnPropertyDescriptor(rdns, i);
+    if (rd === undefined) continue;
+    if (!_hasOwn(rd, "value")) throw E(code, who + " entry " + i + " must be a data property, not an accessor");
+    var rdn = rd.value;
+    if (!_isArray(rdn)) continue;
+    if (intrinsic.types.isProxy(rdn)) throw E(code, who + "[" + i + "] must be a plain array, not a Proxy");
+    for (var j = 0; j < rdn.length; j++) {
+      var ad = intrinsic.getOwnPropertyDescriptor(rdn, j);
+      if (ad === undefined) continue;
+      if (!_hasOwn(ad, "value")) throw E(code, who + "[" + i + "] entry " + j + " must be a data property, not an accessor");
+      var atv = ad.value;
+      if (atv === null || typeof atv !== "object") continue;
+      if (intrinsic.types.isProxy(atv)) throw E(code, who + "[" + i + "][" + j + "] must not be a Proxy");
+      if (_isArray(atv)) throw E(code, who + "[" + i + "][" + j + "] must be an attribute object, not an array");
+      for (var k = 0; k < _ATV_KEYS.length; k++) {
+        var fd = intrinsic.getOwnPropertyDescriptor(atv, _ATV_KEYS[k]);
+        if (fd !== undefined && !_hasOwn(fd, "value")) {
+          throw E(code, who + "[" + i + "][" + j + "]." + _ATV_KEYS[k] + " must be a data property, not an accessor");
+        }
+      }
+    }
+  }
+}
+
+/** @internal The `rdns` of a directoryName base, captured the same way. An inherited Proxy answers
+ * `in` through its has trap, which is caller code running inside a read meant to be getter-free, so
+ * the prototype chain is walked before the property is asked for at all. Returns undefined when the
+ * base carries no rdns array, which the caller reads as "not a directoryName base". */
+function capturedRdns(base, E, code, who) {
+  if (intrinsic.types.isProxy(base)) throw E(code, who + " must not be a Proxy");
+  var baseProto = intrinsic.getPrototypeOf(base);
+  while (baseProto !== null) {
+    if (intrinsic.types.isProxy(baseProto)) throw E(code, who + " must not inherit from a Proxy");
+    baseProto = intrinsic.getPrototypeOf(baseProto);
+  }
+  var d = intrinsic.getOwnPropertyDescriptor(base, "rdns");
+  if (d === undefined) {
+    if ("rdns" in base) throw E(code, who + " rdns must be an own data property, not inherited");
+    return undefined;
+  }
+  if (!_hasOwn(d, "value")) throw E(code, who + " rdns must be a data property, not an accessor");
+  if (!_isArray(d.value)) return undefined;
+  return copyDnRdns(d.value, E, code, who + " rdns");
+}
+
 module.exports = intrinsic.freeze({
+  capturedRdns: capturedRdns, copyDnRdns: copyDnRdns,
   assertNoControlBytes: assertNoControlBytes, assertPrintableIa5: assertPrintableIa5,
   dnEqual: dnEqual, rdnEqual: rdnEqual, emailEqual: emailEqual, dpnCorresponds: dpnCorresponds,
   escapeControlBytes: escapeControlBytes, escapeDnValue: escapeDnValue,
   lowerAscii: lowerAscii,
+  stripTrailingDot: stripTrailingDot, isFqdnHost: isFqdnHost, splitMailbox: splitMailbox,
+  constraintBaseRefusal: constraintBaseRefusal,
 });

package/lib/guard-time.js

@@ -3,7 +3,9 @@
 "use strict";
 // @internal
 
-var util = { types: require("./guard-intrinsic").types };
+var _create = require("./guard-intrinsic").create;
+var _assign = require("./guard-intrinsic").assign;
+var util = _assign(_create(null), { types: require("./guard-intrinsic").types });
 var _freeze = require("./guard-intrinsic").freeze;
 var _isNaN = Number.isNaN;
 var _Date = Date;

package/lib/hpke.js

@@ -102,8 +102,8 @@ function _labeledExpand(kdf, suiteId, prk, label, info, len) {
 }
 
 
-var OKP_SPKI = { X25519: "302a300506032b656e032100", X448: "3042300506032b656f033900" };
-var OKP_PKCS8 = { X25519: "302e020100300506032b656e04220420", X448: "3046020100300506032b656f043a0438" };
+var OKP_SPKI = intrinsic.assign(intrinsic.create(null), { X25519: "302a300506032b656e032100", X448: "3042300506032b656f033900" });
+var OKP_PKCS8 = intrinsic.assign(intrinsic.create(null), { X25519: "302e020100300506032b656e04220420", X448: "3046020100300506032b656f043a0438" });
 
 function _importPublic(kem, raw) {
   if (!Buffer.isBuffer(raw) || raw.length !== kem.Npub) {
@@ -318,9 +318,9 @@ function _recipPrivate(suite, sk) {
   }
 }
 
-var _COMMON_KEYS = { mode: 1, info: 1, psk: 1, pskId: 1 };
+var _COMMON_KEYS = intrinsic.assign(intrinsic.create(null), { mode: 1, info: 1, psk: 1, pskId: 1 });
 function _withCommon(extra) {
-  var out = {};
+  var out = intrinsic.create(null);
   Object.keys(_COMMON_KEYS).forEach(function (k) { out[k] = 1; });
   Object.keys(extra).forEach(function (k) { out[k] = 1; });
   return out;
@@ -348,12 +348,12 @@ function _mode(opts, keys, who) {
 }
 
 // @module @intro; a data registry, not a callable primitive).
-var suites = {
-  KEM: { DHKEM_P256_HKDF_SHA256: 0x0010, DHKEM_P521_HKDF_SHA512: 0x0012, DHKEM_X25519_HKDF_SHA256: 0x0020, DHKEM_X448_HKDF_SHA512: 0x0021 },
-  KDF: { HKDF_SHA256: 0x0001, HKDF_SHA512: 0x0003 },
-  AEAD: { AES_128_GCM: 0x0001, AES_256_GCM: 0x0002, CHACHA20_POLY1305: 0x0003, EXPORT_ONLY: 0xFFFF },
-  MODE: { BASE: MODE_BASE, PSK: MODE_PSK, AUTH: MODE_AUTH, AUTH_PSK: MODE_AUTH_PSK },
-};
+var suites = intrinsic.assign(intrinsic.create(null), {
+  KEM: intrinsic.assign(intrinsic.create(null), { DHKEM_P256_HKDF_SHA256: 0x0010, DHKEM_P521_HKDF_SHA512: 0x0012, DHKEM_X25519_HKDF_SHA256: 0x0020, DHKEM_X448_HKDF_SHA512: 0x0021 }),
+  KDF: intrinsic.assign(intrinsic.create(null), { HKDF_SHA256: 0x0001, HKDF_SHA512: 0x0003 }),
+  AEAD: intrinsic.assign(intrinsic.create(null), { AES_128_GCM: 0x0001, AES_256_GCM: 0x0002, CHACHA20_POLY1305: 0x0003, EXPORT_ONLY: 0xFFFF }),
+  MODE: intrinsic.assign(intrinsic.create(null), { BASE: MODE_BASE, PSK: MODE_PSK, AUTH: MODE_AUTH, AUTH_PSK: MODE_AUTH_PSK }),
+});
 
 
 /**

package/lib/http-digest.js

@@ -17,10 +17,10 @@ var ALGS = intrinsic.assign(intrinsic.create(null), {
   "SHA-256": { hash: "sha256", rank: 2, sess: false }, "SHA-256-SESS": { hash: "sha256", rank: 2, sess: true },
   "MD5": { hash: "md5", rank: 1, sess: false }, "MD5-SESS": { hash: "md5", rank: 1, sess: true },
 });
-var DEFAULT_CODES = {
+var DEFAULT_CODES = intrinsic.assign(intrinsic.create(null), {
   unsupportedAlgorithm: "digest/unsupported-algorithm", weakAlgorithm: "digest/weak-algorithm",
   noQop: "digest/no-qop", badChallenge: "digest/bad-challenge",
-};
+});
 
 function H(hash, s) { return crypto.createHash(hash).update(s, "latin1").digest("hex"); }
 function KD(hash, secret, data) { return H(hash, secret + ":" + data); }

package/lib/http-transport.js

@@ -440,7 +440,7 @@ function httpsTransport(defaults) {
     var bodyIsFn = typeof body === "function";
     if (!bodyIsFn && guard.bytes.isByteSource(body)) body = guard.bytes.source(body, E, C("bad-input"), "the request body");
 
-    var reqHeaders = Object.assign({}, request.headers || {});
+    var reqHeaders = Object.assign(Object.create(null), request.headers || {});
     Object.keys(reqHeaders).forEach(function (k) { var lk = k.toLowerCase(); if (lk === "proxy-authorization" || lk === "proxy-connection") delete reqHeaders[k]; });
     if (bodyIsFn) {
       Object.keys(reqHeaders).forEach(function (k) { var lk = k.toLowerCase(); if (lk === "content-length" || lk === "transfer-encoding" || lk === "expect") delete reqHeaders[k]; });
@@ -553,7 +553,7 @@ function httpsTransport(defaults) {
               if (settled) return;
               settled = true;
               clearTimer();
-              var lower = {};
+              var lower = Object.create(null);
               Object.keys(res.headers || {}).forEach(function (k) { lower[k.toLowerCase()] = res.headers[k]; });
               resolve({
                 status: res.statusCode,
@@ -595,7 +595,7 @@ function httpsTransport(defaults) {
       if (!prep.proxy) { issue(prep.options); return; }
 
       var pinfo = prep.proxy;
-      var pheaders = { Host: pinfo.originAuthority, Connection: "keep-alive" };
+      var pheaders = Object.assign(Object.create(null), { Host: pinfo.originAuthority, Connection: "keep-alive" });
       if (pinfo.auth) pheaders["Proxy-Authorization"] = _basicProxyHeader(pinfo.auth);
       var connectOpts = { host: pinfo.host, port: pinfo.port, method: "CONNECT", path: pinfo.originAuthority, headers: pheaders, agent: false };
       var cr;

package/lib/inspect.js

@@ -95,9 +95,9 @@ function _serial(cert, indent) {
   return "Serial Number:\n" + " ".repeat(indent) + _hexColon(buf, {});
 }
 
-var CURVE_BITS = { "P-256": 256, "P-384": 384, "P-521": 521, "prime256v1": 256, "secp384r1": 384, "secp521r1": 521 };
+var CURVE_BITS = Object.assign(Object.create(null), { "P-256": 256, "P-384": 384, "P-521": 521, "prime256v1": 256, "secp384r1": 384, "secp521r1": 521 });
 var NIST_NAME = NAMES.NIST_CURVE;
-var RSA_KEY_ALGS = { rsaEncryption: 1, rsassaPss: 1, rsaesOaep: 1 };
+var RSA_KEY_ALGS = Object.assign(Object.create(null), { rsaEncryption: 1, rsassaPss: 1, rsaesOaep: 1 });
 function _keyBlock(spki, pad) {
   var algName = _algName(spki.algorithm);
   var out = [pad + "Public Key Algorithm: " + algName];
@@ -214,7 +214,7 @@ function _renderCrlDp(decoded, inner) {
 }
 
 
-var EXT_RENDERERS = {
+var EXT_RENDERERS = Object.assign(Object.create(null), {
   keyUsage: function (decoded, inner) {
     return inner + Object.keys(KU_LABEL).filter(function (k) { return decoded[k]; }).map(function (k) { return KU_LABEL[k]; }).join(", ");
   },
@@ -301,7 +301,7 @@ var EXT_RENDERERS = {
   cRLDistributionPoints: _renderCrlDp,
   freshestCRL: _renderCrlDp,
   authorityInfoAccess: function (decoded, inner) {
-    var LABEL = { caIssuers: "CA Issuers", ocsp: "OCSP" };
+    var LABEL = Object.assign(Object.create(null), { caIssuers: "CA Issuers", ocsp: "OCSP" });
     return (decoded || []).map(function (ad) {
       var m = null;
       try { m = oid.name(ad.accessMethod); } catch (_e) { /* allow:swallow-unverified display best-effort: an unregistered accessMethod OID falls back to the raw dotted OID below (inspection is best-effort, never a verdict) */ }
@@ -369,7 +369,7 @@ var EXT_RENDERERS = {
     }
     return akiLines.length ? akiLines.join("\n") : inner + "keyid:(none)";
   },
-};
+});
 EXT_RENDERERS.msApplicationPolicies = EXT_RENDERERS.certificatePolicies;
 
 
@@ -378,7 +378,7 @@ function _renderExtValue(ext, decoded, inner) {
   return fn ? fn(decoded, inner) : null;
 }
 
-var _STRING_TAGS = { 12: 1, 19: 1, 22: 1, 20: 1, 26: 1, 27: 1, 30: 1 };
+var _STRING_TAGS = Object.assign(Object.create(null), { 12: 1, 19: 1, 22: 1, 20: 1, 26: 1, 27: 1, 30: 1 });
 function _printable(buf) {
   return buf.length > 0 && buf.every(function (b) { return b >= 0x20 && b < 0x7f; });
 }
@@ -499,7 +499,7 @@ function _looksParsedCms(o) {
   var shape = _CMS_SHAPE[o.contentType];
   return shape ? shape(o) : false;
 }
-var _INSPECT_ENTRY = { pemLabel: null, PemError: InspectError, ErrorClass: InspectError, prefix: "inspect" };
+var _INSPECT_ENTRY = Object.assign(Object.create(null), { pemLabel: null, PemError: InspectError, ErrorClass: InspectError, prefix: "inspect" });
 function _coerce(input, spec) {
   if (input && typeof input === "object" && !Buffer.isBuffer(input) && !(input instanceof Uint8Array) && input[spec.marker] !== undefined) {
     if (!spec.looksParsed(input)) throw _err("inspect/bad-input", "input has a " + spec.marker + " property but is not a complete " + spec.parsedName + " result");
@@ -657,7 +657,7 @@ function csrReport(input) {
 
 var OID_SIGNED_DATA = oid.byName("signedData");
 function _isObj(x) { return !!x && typeof x === "object"; }
-var _CMS_SHAPE = {};
+var _CMS_SHAPE = Object.create(null);
 _CMS_SHAPE[OID_SIGNED_DATA] = function (o) { return Array.isArray(o.digestAlgorithms) && _isObj(o.encapContentInfo) && Array.isArray(o.signerInfos); };
 _CMS_SHAPE[oid.byName("envelopedData")] = function (o) { return Array.isArray(o.recipientInfos) && _isObj(o.encryptedContentInfo); };
 _CMS_SHAPE[oid.byName("encryptedData")] = function (o) { return _isObj(o.encryptedContentInfo); };
@@ -784,7 +784,7 @@ function cmsReport(input) {
 }
 
 
-var _INSPECT_BY_FORMAT = { x509: certificate, crl: crlReport, csr: csrReport, cms: cmsReport };
+var _INSPECT_BY_FORMAT = Object.assign(Object.create(null), { x509: certificate, crl: crlReport, csr: csrReport, cms: cmsReport });
 
 /**
  * @primitive pki.inspect.any