@blamejs/pki 0.6.39 → 0.6.41

package/lib/validator-cose.js

@@ -9,20 +9,20 @@ var oid = require("./oid");
 var edwardsPoint = require("./edwards-point");
 var nodeCrypto = require("crypto");
 
-var EC2_CRV_LEN = { 1: 32, 2: 48, 3: 66 };
-var EC2_CRV_OID = { 1: "prime256v1", 2: "secp384r1", 3: "secp521r1" };
-var OKP_CRV = { 6: { oid: "Ed25519", len: 32 }, 7: { oid: "Ed448", len: 57 } };
+var EC2_CRV_LEN = Object.assign(Object.create(null), { 1: 32, 2: 48, 3: 66 });
+var EC2_CRV_OID = Object.assign(Object.create(null), { 1: "prime256v1", 2: "secp384r1", 3: "secp521r1" });
+var OKP_CRV = Object.assign(Object.create(null), { 6: { oid: "Ed25519", len: 32 }, 7: { oid: "Ed448", len: 57 } });
 var RSA_MIN_MODULUS_BITS = 2048;
 var RSA_MAX_EXPONENT_BYTES = 8;
 function _modulusBits(n) { return (n.length - 1) * 8 + (32 - Math.clz32(n[0])); }
 
-var ALG_PROFILE = {
+var ALG_PROFILE = Object.assign(Object.create(null), {
   "-7": { kty: 2, crv: 1 }, "-35": { kty: 2, crv: 2 }, "-36": { kty: 2, crv: 3 },
   "-9": { kty: 2, crv: 1 }, "-51": { kty: 2, crv: 2 }, "-52": { kty: 2, crv: 3 },
   "-8": { kty: 1, crv: 6 }, "-19": { kty: 1, crv: 6 }, "-53": { kty: 1, crv: 7 },
   "-257": { kty: 3 }, "-258": { kty: 3 }, "-259": { kty: 3 },
   "-37": { kty: 3 }, "-38": { kty: 3 }, "-39": { kty: 3 }, "-65535": { kty: 3 },
-};
+});
 
 // @enforced-by validator-shape-reinlined
 // @validator-shape kty\s*===\s*2n

package/lib/validator-sig.js

@@ -15,12 +15,12 @@ function rawToEcdsaDer(raw, coordLen) {
   return asn1.build.sequence([asn1.build.integer(r), asn1.build.integer(s)]);
 }
 
-var CURVE_FIELD_BYTES = { "P-256": 32, "P-384": 48, "P-521": 66 };
-var CURVE_ORDER = {
+var CURVE_FIELD_BYTES = Object.assign(Object.create(null), { "P-256": 32, "P-384": 48, "P-521": 66 });
+var CURVE_ORDER = Object.assign(Object.create(null), {
   "P-256": BigInt("0xFFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551"),
   "P-384": BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973"),
   "P-521": BigInt("0x01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409"),
-};
+});
 
 // @enforced-by behavioral -- a DER ECDSA-Sig-Value decode has no rename-proof code shape distinct
 function ecdsaDerToP1363(der, curve, E, code) {

package/lib/validator-tpm.js

@@ -8,9 +8,9 @@ var guard = require("./guard-all");
 
 var TPM_GENERATED_VALUE = 0xff544347;
 var TPM_ST_ATTEST_CERTIFY = 0x8017;
-var TPM_ALG = { RSA: 0x0001, SHA1: 0x0004, SHA256: 0x000b, SHA384: 0x000c, SHA512: 0x000d, NULL: 0x0010, ECC: 0x0023 };
-var TPM_ALG_HASH = {}; TPM_ALG_HASH[TPM_ALG.SHA1] = "sha1"; TPM_ALG_HASH[TPM_ALG.SHA256] = "sha256"; TPM_ALG_HASH[TPM_ALG.SHA384] = "sha384"; TPM_ALG_HASH[TPM_ALG.SHA512] = "sha512";
-var TPM_CURVE_TO_COSE = {}; TPM_CURVE_TO_COSE[0x0003] = 1; TPM_CURVE_TO_COSE[0x0004] = 2; TPM_CURVE_TO_COSE[0x0005] = 3;
+var TPM_ALG = Object.assign(Object.create(null), { RSA: 0x0001, SHA1: 0x0004, SHA256: 0x000b, SHA384: 0x000c, SHA512: 0x000d, NULL: 0x0010, ECC: 0x0023 });
+var TPM_ALG_HASH = Object.create(null); TPM_ALG_HASH[TPM_ALG.SHA1] = "sha1"; TPM_ALG_HASH[TPM_ALG.SHA256] = "sha256"; TPM_ALG_HASH[TPM_ALG.SHA384] = "sha384"; TPM_ALG_HASH[TPM_ALG.SHA512] = "sha512";
+var TPM_CURVE_TO_COSE = Object.create(null); TPM_CURVE_TO_COSE[0x0003] = 1; TPM_CURVE_TO_COSE[0x0004] = 2; TPM_CURVE_TO_COSE[0x0005] = 3;
 
 function _ucmp(a, b) {
   function strip(x) { var i = 0; while (i < x.length - 1 && x[i] === 0) i++; return x.subarray(i); }
@@ -32,6 +32,7 @@ var TPMA_OBJECT_RESERVED = 0xfff0f009;
 
 // @enforced-by behavioral -- a bit-position table lookup has no rename-proof code shape; the RED
 function _decodeAttributes(oa) {
+  // allow:registry-table-inherits-object-prototype -- the attributes record an operator reads as result.tpm.attributes by field name, whose keys are the fixed TPMA_OBJECT_BITS list rather than anything the attestation supplies
   var out = {};
   Object.keys(TPMA_OBJECT_BITS).forEach(function (n) { out[n] = ((oa >>> TPMA_OBJECT_BITS[n]) & 1) === 1; });
   return out;
@@ -112,7 +113,7 @@ function normalizeObjectAttributePolicy(policy, E, code) {
   if (policy === undefined) return null;
   if (!policy || typeof policy !== "object" || Array.isArray(policy)) throw new E(code, "opts.tpmPolicy must be an object");
   guard.identifier.assertKnownKeys(policy, _TPM_POLICY_KEYS, function (c, m) { return new E(c, m); }, code, "opts.tpmPolicy has an unknown key ");
-  var want = {};
+  var want = Object.create(null);
   if (policy.profile !== undefined) {
     var preset = TPM_POLICY_PROFILES[guard.text.keyOf(policy.profile)];
     if (!preset) throw new E(code, "opts.tpmPolicy.profile " + guard.text.showValue(policy.profile) + " is not a defined profile");

package/lib/webauthn.js

@@ -59,7 +59,7 @@ function _ucmp(a, b) {
   return Buffer.compare(strip(a), strip(b)) === 0;
 }
 function _isInteger(node) { return !!node && !node.constructed && node.tagClass === "universal" && node.tagNumber === asn1.TAGS.INTEGER; }
-var COSE_ALG_HASH = { "-7": "sha256", "-9": "sha256", "-257": "sha256", "-37": "sha256", "-35": "sha384", "-51": "sha384", "-258": "sha384", "-38": "sha384", "-36": "sha512", "-52": "sha512", "-259": "sha512", "-39": "sha512", "-65535": "sha1" };
+var COSE_ALG_HASH = intrinsic.assign(intrinsic.create(null), { "-7": "sha256", "-9": "sha256", "-257": "sha256", "-37": "sha256", "-35": "sha384", "-51": "sha384", "-258": "sha384", "-38": "sha384", "-36": "sha512", "-52": "sha512", "-259": "sha512", "-39": "sha512", "-65535": "sha1" });
 function _coseAlgHash(alg, E) {
   var h = COSE_ALG_HASH[String(alg)];
   if (!h) throw E("webauthn/unsupported-algorithm", "no hash mapping for COSE algorithm " + alg);
@@ -154,7 +154,7 @@ function parseCoseKey(bytes) {
 }
 
 
-var COSE_ALG = {
+var COSE_ALG = intrinsic.assign(intrinsic.create(null), {
   "-7":   { imp: { name: "ECDSA", namedCurve: "P-256" }, verify: { name: "ECDSA", hash: "SHA-256" }, ecdsa: 32 },
   "-35":  { imp: { name: "ECDSA", namedCurve: "P-384" }, verify: { name: "ECDSA", hash: "SHA-384" }, ecdsa: 48 },
   "-36":  { imp: { name: "ECDSA", namedCurve: "P-521" }, verify: { name: "ECDSA", hash: "SHA-512" }, ecdsa: 66 },
@@ -171,7 +171,7 @@ var COSE_ALG = {
   "-38":  { imp: { name: "RSA-PSS", hash: "SHA-384" }, verify: { name: "RSA-PSS", saltLength: 48 }, ecdsa: 0 },
   "-39":  { imp: { name: "RSA-PSS", hash: "SHA-512" }, verify: { name: "RSA-PSS", saltLength: 64 }, ecdsa: 0 },
   "-65535": { imp: { name: "RSASSA-PKCS1-v1_5", hash: "SHA-1" }, verify: { name: "RSASSA-PKCS1-v1_5" }, ecdsa: 0 },
-};
+});
 
 function _derEcdsaToRaw(der, curve) { return validator.sig.ecdsaDerToP1363(der, curve, WebauthnError, "webauthn/bad-signature"); }
 
@@ -186,7 +186,7 @@ function _verifySig(alg, sig, spkiBytes, message, E) {
     .then(function (key) { return subtle.verify(ver, key, s, message); })
     .catch(function (e) { throw _err("webauthn/verify-error", "the attestation signature could not be evaluated", e); });
 }
-var ED_OID_NAME = {};
+var ED_OID_NAME = intrinsic.create(null);
 ED_OID_NAME[oid.byName("Ed25519")] = "Ed25519";
 ED_OID_NAME[oid.byName("Ed448")] = "Ed448";
 function _edName(spkiBytes, E) {
@@ -325,7 +325,7 @@ function _attRead(map, key, reader, what) {
 function _algOf(attStmt) { return Number(_attRead(attStmt, "alg", cbor.read.int, "an integer")); }
 function _sigOf(attStmt) { return _attRead(attStmt, "sig", cbor.read.byteString, "a byte string"); }
 function _requireAttShape(attStmt, allowed, required) {
-  var have = {};
+  var have = intrinsic.create(null);
   cbor.read.map(attStmt).forEach(function (kv) {
     if (kv[0].majorType !== 3) throw _err("webauthn/bad-att-stmt", "the attestation statement has a non-text-string field key");
     have[cbor.read.textString(kv[0])] = true;
@@ -333,7 +333,7 @@ function _requireAttShape(attStmt, allowed, required) {
   Object.keys(have).forEach(function (k) { if (allowed.indexOf(k) === -1) throw _err("webauthn/bad-att-stmt", "the attestation statement carries an unexpected field '" + k + "'"); });
   required.forEach(function (k) { if (!have[k]) throw _err("webauthn/bad-att-stmt", "the attestation statement is missing the '" + k + "' field"); });
 }
-var ATT_STMT_MAJOR = { compound: 4 };
+var ATT_STMT_MAJOR = intrinsic.assign(intrinsic.create(null), { compound: 4 });
 
 var _AAGUID_SIGNED_BY_FMT = Object.assign(Object.create(null), { "fido-u2f": false });
 function _aaguidIsSigned(fmt) { return _AAGUID_SIGNED_BY_FMT[fmt] !== false; }
@@ -353,7 +353,7 @@ function _cloneParsed(v, depth) {
   if (Array.isArray(v)) return v.map(function (x) { return _cloneParsed(x, depth + 1); });
   if (guard.time.isDate(v)) return new Date(guard.time.instantOf(v));
   if (v && typeof v === "object") {
-    var out = {};
+    var out = intrinsic.create(null);
     Object.keys(v).forEach(function (k) { out[k] = _cloneParsed(v[k], depth + 1); });
     return out;
   }
@@ -395,8 +395,8 @@ function _applyCallerRoots(res, supplied, vopts, onlyPaths) {
       .map(function (el) { return { tp: el.trustPath, at: el.chainValidatedAt }; })
     : (res.trustPath && res.trustPath.length ? [{ tp: res.trustPath, at: res.chainValidatedAt }] : []));
   if (!onlyPaths) {
-    res.anchoredElements = { total: (res.fmt === "compound" && Array.isArray(res.compound)) ? res.compound.length : 1,
-      anchored: paths.length };
+    res = guard.verdict.of(res, { anchoredElements: { total: (res.fmt === "compound" && Array.isArray(res.compound)) ? res.compound.length : 1,
+      anchored: paths.length } });
   }
   if (!paths.length) {
     throw _err("webauthn/anchor-not-applicable",
@@ -410,8 +410,7 @@ function _applyCallerRoots(res, supplied, vopts, onlyPaths) {
         "attestation trust path (against the roots supplied as opts.rootCertificates)");
     });
   }, Promise.resolve()).then(function () {
-    res.anchoredTo = _anchoredRoutes(res, "rootCertificates");
-    return res;
+    return guard.verdict.of(res, { anchoredTo: _anchoredRoutes(res, "rootCertificates") });
   });
 }
 
@@ -425,7 +424,7 @@ function _safetyNetAnchored(res) {
 
 function _anchoredRoutes(res, base) {
   var routes = base ? base.split("+") : [];
-  if (_safetyNetAnchored(res) && routes.indexOf("safetyNetRoots") < 0) routes.push("safetyNetRoots");
+  if (_safetyNetAnchored(res) && routes.indexOf("safetyNetRoots") < 0) guard.list.append(routes, "safetyNetRoots");
   return routes.length ? routes.join("+") : null;
 }
 
@@ -502,13 +501,13 @@ function _readX5c(attStmt) {
     try { return x509.parse(der); } catch (e) { throw _err("webauthn/bad-att-stmt", "an x5c certificate is not a well-formed X.509 certificate", e); }
   });
 }
-var _exts = { find: _findExt, decode: _decodeExt };
+var _exts = intrinsic.assign(intrinsic.create(null), { find: _findExt, decode: _decodeExt });
 function _requireV3(cert) { validator.attcert.requireV3(cert, WebauthnError, "webauthn/bad-att-cert"); }
 function _checkPackedCert(cert) { validator.attcert.packedCert(cert, _exts, WebauthnError, "webauthn/bad-att-cert"); }
 function _checkAikCert(cert) { validator.attcert.aikCert(cert, _exts, WebauthnError, "webauthn/bad-att-cert"); }
 function _checkAaguidExt(cert, aaguid) { validator.attcert.aaguidExt(cert, aaguid, _exts, WebauthnError, "webauthn/bad-att-cert", "webauthn/aaguid-mismatch"); }
 
-var VERIFIERS = {
+var VERIFIERS = intrinsic.assign(intrinsic.create(null), {
   packed: function (att, clientDataHash) {
     var isX5c = !!cbor.read.mapGet(att.attStmt, "x5c");
     _requireAttShape(att.attStmt, isX5c ? ["alg", "sig", "x5c"] : ["alg", "sig"], isX5c ? ["alg", "sig", "x5c"] : ["alg", "sig"]);
@@ -604,9 +603,8 @@ var VERIFIERS = {
       _checkAikCert(aik);
       _checkAaguidExt(aik, att.authData.aaguid);
       validator.tpm.assertObjectAttributePolicy(pub, tpmPolicy, WebauthnError, "webauthn/tpm-policy", "webauthn/bad-tpm");
-      var tpmRes = _result("tpm", "AttCA", chain, att);
-      tpmRes.tpm = { objectAttributes: pub.objectAttributes, attributes: pub.attributes, authPolicy: pub.authPolicy };
-      return tpmRes;
+      return guard.verdict.of(_result("tpm", "AttCA", chain, att),
+        { tpm: { objectAttributes: pub.objectAttributes, attributes: pub.attributes, authPolicy: pub.authPolicy } });
     });
   },
 
@@ -680,9 +678,8 @@ var VERIFIERS = {
           ? new Date(payload.timestampMs) : undefined);
       return _safetyNetChainTrusted(chain, roots, chainAt);
     }).then(function () {
-      var res = _result("android-safetynet", "Basic", chain, att);
-      res.safetyNet = signals;
-      if (chainAt !== undefined) res.chainValidatedAt = chainAt;
+      var res = guard.verdict.of(_result("android-safetynet", "Basic", chain, att), { safetyNet: signals });
+      if (chainAt !== undefined) res = guard.verdict.of(res, { chainValidatedAt: chainAt });
       return res;
     });
   },
@@ -710,14 +707,12 @@ var VERIFIERS = {
     return elements.reduce(function (p, e) {
       return p.then(function () {
         return Promise.resolve().then(function () { return VERIFIERS[e.fmt](e.att, clientDataHash, opts); })
-          .then(function (r) { out.push(r); }, function (err) {
+          .then(function (r) { guard.list.append(out, r); }, function (err) {
             throw _err("webauthn/compound-element-failed", "compound element " + e.index + " (format '" + e.fmt + "') did not verify", err);
           });
       });
     }, Promise.resolve()).then(function () {
-      var res = _result("compound", "Compound", [], att);
-      res.compound = out;
-      return res;
+      return guard.verdict.of(_result("compound", "Compound", [], att), { compound: out });
     });
   },
 
@@ -727,7 +722,7 @@ var VERIFIERS = {
     }
     return Promise.resolve(_result("none", "None", [], att));
   },
-};
+});
 
 function _isPlainObject(v) { return !!v && typeof v === "object" && !Array.isArray(v); }
 
@@ -761,7 +756,7 @@ function _safetyNetChainTrusted(chain, roots, time) {
 }
 
 function _result(fmt, attestationType, chain, att) {
-  return {
+  return guard.verdict.of({
     valid: true, attestationVerified: true, fmt: fmt, attestationType: attestationType,
     trustPath: (chain || []).slice().reverse(),
     aaguid: att.authData.aaguid,
@@ -772,7 +767,7 @@ function _result(fmt, attestationType, chain, att) {
     flags: att.authData.flags,
     rpIdHash: att.authData.rpIdHash,
     extensions: att.authData.extensions,
-  };
+  });
 }
 
 function _appleNonce(extValue) {
@@ -969,37 +964,41 @@ function verify(attestationObject, clientDataHash, opts) {
   } catch (e) { return Promise.reject(e); }
   return Promise.resolve().then(function () { return verifier(att, clientDataHash, vopts); })
     .then(function (res) {
-      res.clientData = clientData;
-      return res;
+      return guard.verdict.of(res, { clientData: clientData });
     })
     .then(function (res) {
       if (vopts.metadata === undefined) {
         if (vopts.rootCertificates !== undefined) return _applyCallerRoots(res, vopts.rootCertificates, vopts);
-        res.anchoredTo = _anchoredRoutes(res, null);
-        var sn = _safetyNetAnchored(res);
+        var anchored = guard.verdict.of(res, { anchoredTo: _anchoredRoutes(res, null) });
+        var sn = _safetyNetAnchored(anchored);
         if (sn) {
-          res.anchoredElements = { total: (res.fmt === "compound" && Array.isArray(res.compound)) ? res.compound.length : 1,
-            anchored: sn };
+          anchored = guard.verdict.of(anchored, { anchoredElements: {
+            total: (anchored.fmt === "compound" && Array.isArray(anchored.compound)) ? anchored.compound.length : 1,
+            anchored: sn } });
         }
-        return res;
+        return anchored;
       }
       return Promise.resolve().then(function () { return _applyMetadata(res, att, vopts); })
-        .then(function (out) { out.anchoredTo = _anchoredRoutes(out, "metadata"); return out; }, function (e) {
+        .then(function (out) { return guard.verdict.of(out, { anchoredTo: _anchoredRoutes(out, "metadata") }); }, function (e) {
           if (!e || e.code !== "webauthn/metadata-not-found" || vopts.rootCertificates === undefined) throw e;
           return Promise.resolve(_applyCallerRoots(res, vopts.rootCertificates, vopts, e.missedPaths))
-            .then(function (out) {
+            .then(function (withRoots) {
+              /** @internal The element coverage the metadata attempt measured is the whole
+               * statement's, so it travels on the error rather than being recomputed from the
+               * fallback's own paths. */
+              var out = e.anchoredElements ? guard.verdict.of(withRoots, { anchoredElements: e.anchoredElements }) : withRoots;
               var applied = e.appliedEntries || [];
               if (!applied.length) return out;
               var primary = applied[0];
-              out.metadata = { aaguid: primary.entry.aaguid, keyIdentifiers: primary.entry.keyIdentifiers || [],
+              var withMd = guard.verdict.of(out, { metadata: { aaguid: primary.entry.aaguid,
+                keyIdentifiers: primary.entry.keyIdentifiers || [],
                 entry: primary.entry, entries: applied.map(function (a) { return a.entry; }),
-                anchors: primary.anchors.length };
-              out.anchoredTo = _anchoredRoutes(out, "metadata+rootCertificates");
-              return out;
+                anchors: primary.anchors.length } });
+              return guard.verdict.of(withMd, { anchoredTo: _anchoredRoutes(withMd, "metadata+rootCertificates") });
             });
         });
     })
-    .then(function (res) { res.bindingChecked = bindingChecked; return res; });
+    .then(function (res) { return guard.verdict.of(res, { bindingChecked: bindingChecked }); });
 }
 
 function _applyMetadata(res, att, opts) {
@@ -1011,8 +1010,9 @@ function _applyMetadata(res, att, opts) {
     ? res.compound.filter(function (el) { return el.trustPath && el.trustPath.length; })
       .map(function (el) { return { tp: el.trustPath, fmt: el.fmt, at: el.chainValidatedAt }; })
     : (res.trustPath && res.trustPath.length ? [{ tp: res.trustPath, fmt: res.fmt, at: res.chainValidatedAt }] : []);
-  res.anchoredElements = { total: (res.fmt === "compound" && Array.isArray(res.compound)) ? res.compound.length : 1,
-    anchored: paths.length };
+  res = guard.verdict.of(res, { anchoredElements: {
+    total: (res.fmt === "compound" && Array.isArray(res.compound)) ? res.compound.length : 1,
+    anchored: paths.length } });
   if (!paths.length) {
     throw _err("webauthn/metadata-not-applicable", "opts.metadata was supplied, but this attestation carries no trust path to anchor (format '" + res.fmt + "')");
   }
@@ -1036,7 +1036,7 @@ function _applyMetadata(res, att, opts) {
     }
     var anchors = mds.metadataAnchors(entry, { metadata: md, time: at, certificate: tp[tp.length - 1] });
     if (!anchors.length) throw _err("webauthn/metadata-no-anchor", "the metadata entry for " + identifier + " supplies no attestation root certificate");
-    applied.push({ entry: entry, anchors: anchors, identifier: identifier });
+    guard.list.append(applied, { entry: entry, anchors: anchors, identifier: identifier });
     return { anchors: anchors, identifier: identifier };
   }
   var at = opts.time !== undefined ? opts.time : new Date();
@@ -1046,13 +1046,17 @@ function _applyMetadata(res, att, opts) {
   var missedPaths = [];
   for (var gi = 0; gi < paths.length; gi++) {
     try {
-      governed.push({ info: paths[gi], g: govern(paths[gi]) });
+      guard.list.append(governed, { info: paths[gi], g: govern(paths[gi]) });
     } catch (ge) {
-      if (ge && ge.code === "webauthn/metadata-not-found") { missed = missed || ge; missedPaths.push(paths[gi]); continue; }
+      if (ge && ge.code === "webauthn/metadata-not-found") { missed = missed || ge; guard.list.append(missedPaths, paths[gi]); continue; }
       throw ge;
     }
   }
-  if (missed) { missed.missedPaths = missedPaths; missed.appliedEntries = applied; }
+  if (missed) {
+    guard.verdict.set(missed, "missedPaths", missedPaths);
+    guard.verdict.set(missed, "appliedEntries", applied);
+    guard.verdict.set(missed, "anchoredElements", res.anchoredElements);
+  }
   return governed.reduce(function (p, item) {
     return p.then(function () {
       var g = item.g, info = item.info;
@@ -1064,10 +1068,10 @@ function _applyMetadata(res, att, opts) {
     .then(function () {
       if (missed) throw missed;
       var primary = applied[0];
-      res.metadata = { aaguid: primary.entry.aaguid, keyIdentifiers: primary.entry.keyIdentifiers || [],
+      return guard.verdict.of(res, { metadata: { aaguid: primary.entry.aaguid,
+        keyIdentifiers: primary.entry.keyIdentifiers || [],
         entry: primary.entry, entries: applied.map(function (a) { return a.entry; }),
-        anchors: primary.anchors.length };
-      return res;
+        anchors: primary.anchors.length } });
     });
 }
 
@@ -1469,7 +1473,7 @@ var _ASSERT_OPTS = Object.assign(Object.create(null), {
 function _snapshotAssertion(input) {
   if (!_isPlainObject(input)) throw _err("webauthn/bad-input", "pki.webauthn.verifyAssertion takes an options object");
   guard.identifier.assertKnownKeys(input, _ASSERT_OPTS, _err, "webauthn/bad-input", "verifyAssertion input has an unknown key ");
-  var out = {}, k;
+  var out = intrinsic.create(null), k;
   for (k in input) { if (_hasOwn(input, k)) out[k] = input[k]; }
   ["authenticatorData", "clientDataJSON", "clientDataHash", "signature", "expectedChallenge"].forEach(function (f) {
     if (_isBufferSource(out[f])) out[f] = guard.bytes.snapshotSource(out[f], WebauthnError, "webauthn/bad-input", f);
@@ -1478,7 +1482,7 @@ function _snapshotAssertion(input) {
     out.credentialPublicKey = guard.bytes.snapshotSource(out.credentialPublicKey, WebauthnError,
       "webauthn/bad-input", "credentialPublicKey");
   } else if (_isPlainObject(out.credentialPublicKey)) {
-    var key = {}, kk;
+    var key = intrinsic.create(null), kk;
     for (kk in out.credentialPublicKey) {
       if (!_hasOwn(out.credentialPublicKey, kk)) continue;
       var v;
@@ -1558,7 +1562,7 @@ function verifyAssertion(input) {
           signCountChecked = true;
         }
       }
-      return {
+      return guard.verdict.of({
         valid: true,
         signatureVerified: true,
         signCount: authData.signCount,
@@ -1568,7 +1572,7 @@ function verifyAssertion(input) {
         extensions: authData.extensions,
         clientData: clientData,
         bindingChecked: bindingChecked,
-      };
+      });
     });
   });
 }

package/lib/webcrypto.js

@@ -116,7 +116,7 @@ function _normalizeAlg(algorithm, who) {
   if (!alg || typeof alg.name !== "string") {
     throw new WebCryptoError("webcrypto/syntax", (who || "operation") + ": algorithm must be a string or an object with a name");
   }
-  var out = {};
+  var out = intrinsic.create(null);
   for (var k in alg) { if (_hasOwn(alg, k)) out[k] = alg[k]; }
   out.name = _toUpperCase(alg.name);
   return out;
@@ -125,7 +125,7 @@ function _normalizeAlg(algorithm, who) {
 var _STD_ALG_NAME = intrinsic.assign(intrinsic.create(null), { "RSASSA-PKCS1-V1_5": "RSASSA-PKCS1-v1_5", "ED25519": "Ed25519", "ED448": "Ed448" });
 function _stdName(name) { return _STD_ALG_NAME[name] || name; }
 
-var HASH_NODE = {
+var HASH_NODE = intrinsic.assign(intrinsic.create(null), {
   "SHA-1":   "sha1",
   "SHA-224": "sha224",
   "SHA-256": "sha256",
@@ -134,12 +134,12 @@ var HASH_NODE = {
   "SHA3-256": "sha3-256",
   "SHA3-384": "sha3-384",
   "SHA3-512": "sha3-512",
-};
+});
 
-var XOF_NODE = {
+var XOF_NODE = intrinsic.assign(intrinsic.create(null), {
   "SHAKE128": { node: "shake128", length: 32 },
   "SHAKE256": { node: "shake256", length: 64 },
-};
+});
 
 function _hashNode(h, who) {
   var name = (typeof h === "string") ? h : (h && h.name);
@@ -148,10 +148,10 @@ function _hashNode(h, who) {
   return node;
 }
 
-var HMAC_BLOCK_BITS = {
+var HMAC_BLOCK_BITS = intrinsic.assign(intrinsic.create(null), {
   "SHA-1": 512, "SHA-256": 512, "SHA-384": 1024, "SHA-512": 1024,
   "SHA3-256": 1088, "SHA3-384": 832, "SHA3-512": 576,
-};
+});
 
 function _hmacLengthBits(alg, who) {
   var name = (typeof alg.hash === "string") ? alg.hash : (alg.hash && alg.hash.name);
@@ -859,7 +859,7 @@ function _nodeKey(fn, who) {
   }
 }
 
-var ML_KEM_INNER = {};
+var ML_KEM_INNER = intrinsic.create(null);
 ["id-ml-kem-512", "id-ml-kem-768", "id-ml-kem-1024"].forEach(function (n) {
   var row = oid.kemParams(n);
   ML_KEM_INNER[oid.byName(n)] = { ek: row.ek, dk: row.dk };
@@ -891,7 +891,7 @@ function _validateMlKemInner(innerBytes, sizes) {
   throw new WebCryptoError("webcrypto/data", "an ML-KEM private key must be the seed, expandedKey, or both CHOICE (RFC 9935 sec. 6)");
 }
 
-var PKCS8_INNER_VALIDATORS = {};
+var PKCS8_INNER_VALIDATORS = intrinsic.create(null);
 _forEach(_keys(ML_KEM_INNER), function (o) { PKCS8_INNER_VALIDATORS[o] = function (inner) { _validateMlKemInner(inner, ML_KEM_INNER[o]); }; });
 
 function _preValidatePkcs8(p8, name) {
@@ -974,14 +974,22 @@ function _importRawPublic(name, alg, raw, extractable, usages) {
   throw new WebCryptoError("webcrypto/not-supported", "importKey raw: unsupported public-key algorithm " + _stringify(name));
 }
 
+/** @internal Each inner set is asked whether it holds the key's own type, so it answers from its own
+ * entries alone: a type naming an Object.prototype member would otherwise resolve to a truthy
+ * inherited value and pass a key the algorithm does not accept. */
+function _typeSet(names) {
+  var t = intrinsic.create(null);
+  _forEach(names, function (n) { t[n] = 1; });
+  return t;
+}
 var IMPORT_KEY_TYPE = intrinsic.assign(intrinsic.create(null), {
-  "RSASSA-PKCS1-V1_5": { rsa: 1 }, "RSA-PSS": { rsa: 1, "rsa-pss": 1 }, "RSA-OAEP": { rsa: 1 },
-  "ECDSA": { ec: 1 }, "ECDH": { ec: 1 },
-  "ED25519": { ed25519: 1 }, "ED448": { ed448: 1 },
-  "X25519": { x25519: 1 }, "X448": { x448: 1 },
+  "RSASSA-PKCS1-V1_5": _typeSet(["rsa"]), "RSA-PSS": _typeSet(["rsa", "rsa-pss"]), "RSA-OAEP": _typeSet(["rsa"]),
+  "ECDSA": _typeSet(["ec"]), "ECDH": _typeSet(["ec"]),
+  "ED25519": _typeSet(["ed25519"]), "ED448": _typeSet(["ed448"]),
+  "X25519": _typeSet(["x25519"]), "X448": _typeSet(["x448"]),
 });
 [ML_DSA_NODE, ML_KEM_NODE, SLH_DSA_NODE].forEach(function (m) {
-  _forEach(_keys(m), function (webName) { var t = {}; t[m[webName]] = 1; IMPORT_KEY_TYPE[webName] = t; });
+  _forEach(_keys(m), function (webName) { IMPORT_KEY_TYPE[webName] = _typeSet([m[webName]]); });
 });
 function _algFromImport(name, alg, keyObject) {
   var wantType = IMPORT_KEY_TYPE[name];

package/lib/x509-sign.js

@@ -40,18 +40,18 @@ function O(n) { return oid.byName(n); }
 
 var OID_SKI = O("subjectKeyIdentifier");
 
-var KNOWN_SPEC_KEYS = {
+var KNOWN_SPEC_KEYS = intrinsic.assign(intrinsic.create(null), {
   subject: 1, subjectPublicKey: 1, notBefore: 1, notAfter: 1, serialNumber: 1, extensions: 1,
-};
-var KNOWN_ISSUER_CERT_KEYS = { key: 1, cert: 1 };
-var KNOWN_ISSUER_EXPLICIT_KEYS = { key: 1, name: 1, publicKey: 1 };
-var KNOWN_SIGN_OPTS = { digestAlgorithm: 1, pem: 1, pss: 1 };
+});
+var KNOWN_ISSUER_CERT_KEYS = intrinsic.assign(intrinsic.create(null), { key: 1, cert: 1 });
+var KNOWN_ISSUER_EXPLICIT_KEYS = intrinsic.assign(intrinsic.create(null), { key: 1, name: 1, publicKey: 1 });
+var KNOWN_SIGN_OPTS = intrinsic.assign(intrinsic.create(null), { digestAlgorithm: 1, pem: 1, pss: 1 });
 
-var KNOWN_EXT_KEYS = {
+var KNOWN_EXT_KEYS = intrinsic.assign(intrinsic.create(null), {
   subjectKeyIdentifier: 1, authorityKeyIdentifier: 1, keyUsage: 1, keyUsageCritical: 1,
   extendedKeyUsage: 1, extendedKeyUsageCritical: 1, basicConstraints: 1, subjectAltName: 1,
   certificatePolicies: 1, certificatePoliciesCritical: 1,
-};
+});
 
 var _b = pkiBuild.makeBuilder({ ErrorClass: CertificateError, prefix: "x509", O: O, NS: NS, NAME_SCHEMA: NAME_SCHEMA, SPKI_SCHEMA: SPKI_SCHEMA, EXT_DECODERS: EXT_DECODERS });
 var _encodeName = _b.encodeName, _isEmptyName = _b.isEmptyName, _reqDer = _b.reqDer,
@@ -80,7 +80,7 @@ function _akiKeyId(val, ctx) {
 function _buildExtensions(extSpec, ctx) {
   if (extSpec == null) return [];
   if (_isArray(extSpec)) {
-    var seenExt = {}, arrCa = false, arrKeyCertSign = false, arrPathLen = false;
+    var seenExt = intrinsic.create(null), arrCa = false, arrKeyCertSign = false, arrPathLen = false;
     var oidBc = O("basicConstraints"), oidKu = O("keyUsage");
     var arr = extSpec.map(function (e, i) {
       var der = _reqDer(e, "extension");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/pki",
-  "version": "0.6.39",
+  "version": "0.6.41",
   "description": "Pure-JavaScript PKI toolkit that owns its stack — X.509, ASN.1/DER, CMS, PQC-first.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",

package/sbom.cdx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:b1c86284-d109-4852-8e85-dc5992b74178",
+  "serialNumber": "urn:uuid:c14ed2d9-f3d5-4322-88e1-51afbe3a3fbe",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-05T11:25:26.514Z",
+    "timestamp": "2026-09-06T02:19:25.175Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/pki@0.6.39",
+      "bom-ref": "@blamejs/pki@0.6.41",
       "type": "application",
       "name": "pki",
-      "version": "0.6.39",
+      "version": "0.6.41",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "Pure-JavaScript PKI toolkit that owns its stack — X.509, ASN.1/DER, CMS, PQC-first.",
-      "purl": "pkg:npm/%40blamejs/pki@0.6.39",
+      "purl": "pkg:npm/%40blamejs/pki@0.6.41",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/pki@0.6.39",
+      "ref": "@blamejs/pki@0.6.41",
       "dependsOn": []
     }
   ]