@blamejs/pki 0.6.38 → 0.6.40

package/lib/pkcs12-build.js

@@ -556,12 +556,12 @@ async function verifyMac(pfx, password, opts) {
   var m = _storeFromBytes(pfx);
   var valid = await _verifyMacOfStore(m, password, opts);
   var isHmac = m.mac.kind === "hmac";
-  return {
+  return guard.verdict.of({
     valid: valid,
     macAlgorithm: m.mac.kind,
     macAlgorithmName: isHmac ? _toLower(m.mac.hashName || "") : m.mac.pbmac1.schemeName,
     iterationCount: isHmac ? m.mac.iterations : m.mac.pbmac1.kdf.iterationCount,
-  };
+  });
 }
 
 async function _verifyMacOfStore(m, password, opts) {
@@ -669,13 +669,15 @@ async function open(pfx, password, opts) {
   } else if (!opts.allowUnauthenticated) {
     throw _err("pkcs12/no-integrity", "the store carries no integrity MAC (integrityMode " + m.integrityMode + "); set opts.allowUnauthenticated to open it anyway");
   }
-  var out = { valid: macVerified || m.integrityMode === "public-key", integrityMode: m.integrityMode, macVerified: macVerified, signers: signers, keys: [], certs: [], crls: [], secrets: [] };
+  var out = guard.verdict.of({ valid: macVerified || m.integrityMode === "public-key", integrityMode: m.integrityMode, macVerified: macVerified, signers: signers, keys: [], certs: [], crls: [], secrets: [] });
   var i;
   var kdfBudget = { rounds: KDF_MAX_ROUNDS };
   for (i = 0; i < m.safeBags.length; i++) _openBag(m.safeBags[i], password, opts, out, 0, kdfBudget);
   for (i = 0; i < m.encryptedSafes.length; i++) await _openEncryptedSafe(m.encryptedSafes[i], password, opts, out, 0, kdfBudget);
   if (opts.keys === "crypto") {
-    for (i = 0; i < out.keys.length; i++) out.keys[i].key = await key.import(out.keys[i].pkcs8, { algorithm: opts.importAlgorithm });
+    for (i = 0; i < out.keys.length; i++) {
+      guard.verdict.set(out.keys[i], "key", await key.import(out.keys[i].pkcs8, { algorithm: opts.importAlgorithm }));
+    }
   }
   return out;
 }
@@ -685,19 +687,19 @@ function _openBag(bag, password, opts, out, depth, budget) {
     case "keyBag":
       try { pkcs8.parse(bag.keyDer); }
       catch (e) { throw _err("pkcs12/bad-der", "a plaintext keyBag PrivateKeyInfo is not canonical DER", e); }
-      out.keys.push({ pkcs8: bag.keyDer, encrypted: false, friendlyName: bag.friendlyName, localKeyId: bag.localKeyId });
+      guard.list.append(out.keys, { pkcs8: bag.keyDer, encrypted: false, friendlyName: bag.friendlyName, localKeyId: bag.localKeyId });
       break;
     case "pkcs8ShroudedKeyBag":
-      out.keys.push({ pkcs8: _decryptShroudedKey(bag.encrypted, password, opts, budget), encrypted: true, friendlyName: bag.friendlyName, localKeyId: bag.localKeyId });
+      guard.list.append(out.keys, { pkcs8: _decryptShroudedKey(bag.encrypted, password, opts, budget), encrypted: true, friendlyName: bag.friendlyName, localKeyId: bag.localKeyId });
       break;
     case "certBag":
-      out.certs.push({ cert: bag.certValue, certType: bag.certType, friendlyName: bag.friendlyName, localKeyId: bag.localKeyId });
+      guard.list.append(out.certs, { cert: bag.certValue, certType: bag.certType, friendlyName: bag.friendlyName, localKeyId: bag.localKeyId });
       break;
     case "crlBag":
-      out.crls.push({ crl: bag.crlValue, crlType: bag.crlType, friendlyName: bag.friendlyName, localKeyId: bag.localKeyId });
+      guard.list.append(out.crls, { crl: bag.crlValue, crlType: bag.crlType, friendlyName: bag.friendlyName, localKeyId: bag.localKeyId });
       break;
     case "secretBag":
-      out.secrets.push({ secretTypeId: bag.secretTypeId, secretTypeName: bag.secretTypeName, secretValue: bag.secretValue, friendlyName: bag.friendlyName, localKeyId: bag.localKeyId });
+      guard.list.append(out.secrets, { secretTypeId: bag.secretTypeId, secretTypeName: bag.secretTypeName, secretValue: bag.secretValue, friendlyName: bag.friendlyName, localKeyId: bag.localKeyId });
       break;
     case "safeContentsBag":
       if (depth + 1 > C.LIMITS.PKCS12_MAX_BAG_DEPTH) throw _err("pkcs12/too-deep", "safeContentsBag nesting exceeds the depth cap " + C.LIMITS.PKCS12_MAX_BAG_DEPTH);

package/lib/sigstore.js

@@ -360,10 +360,19 @@ function _normRoots(fulcioRoots) {
 
 function _pathToAnchor(leaf, anchor, intBySubject) {
   var anchorSubj = _dn(anchor, "subject");
-  var path = [leaf], cur = leaf, seen = {}, guardN = 0;
+  /** @internal Issuers are collected leaf-first and the path is assembled once, so no element is
+   * ever moved to a new index: an indexed setter has nothing to intercept and cannot replace the
+   * leaf the preceding signature checks authenticated. */
+  var above = [], cur = leaf, seen = {}, guardN = 0;
+  function assemble() {
+    var path = [];
+    for (var k = above.length - 1; k >= 0; k--) guard.list.append(path, above[k]);
+    guard.list.append(path, leaf);
+    return path;
+  }
   while (guardN++ < 16) {
     var issuerDn = _dn(cur, "issuer");
-    if (issuerDn === anchorSubj) return path;
+    if (issuerDn === anchorSubj) return assemble();
     var cands = intBySubject[issuerDn] || [];
     var next = null;
     for (var j = 0; j < cands.length; j++) {
@@ -372,7 +381,7 @@ function _pathToAnchor(leaf, anchor, intBySubject) {
     }
     if (!next) return null;
     seen[_dn(next, "subject")] = 1;
-    path.unshift(next);
+    guard.list.append(above, next);
     cur = next;
   }
   return null;
@@ -382,7 +391,7 @@ async function _verifyChain(leaf, chainDers, fulcioRoots, timeMs) {
   var roots = _normRoots(fulcioRoots);
   var bundleLinks = chainDers.slice(1).map(function (d, i) { return _parseCert(d, "bundle intermediate [" + i + "]"); });
   var intBySubject = {};
-  function addInt(c) { (intBySubject[_dn(c, "subject")] = intBySubject[_dn(c, "subject")] || []).push(c); }
+  function addInt(c) { guard.list.append(intBySubject[_dn(c, "subject")] = intBySubject[_dn(c, "subject")] || [], c); }
   roots.forEach(function (r) { addInt(r.cert); });
   bundleLinks.forEach(addInt);
   var candidates = roots.filter(function (r) { return _inWindow(timeMs, r.validFor); });
@@ -446,7 +455,7 @@ function _sanValue(ext) {
       }
       val = { type: "otherName", oid: asn1.read.oid(n.children[0]), value: v };
     }
-    if (val) names.push(val);
+    if (val) guard.list.append(names, val);
   }
   if (names.length > 1) throw _err("sigstore/bad-certificate", "the Fulcio certificate carries multiple SAN identities");
   return names[0] || null;
@@ -582,7 +591,7 @@ async function verifyBundle(bundle, opts) {
 
   var st = _statement(payload, env.payloadType, opts.predicateType);
 
-  return {
+  return guard.verdict.of({
     valid: true,
     verified: true,
     payload: payload,
@@ -596,7 +605,7 @@ async function verifyBundle(bundle, opts) {
     integratedTime: integratedTime,
     logIndex: rekor.logIndex,
     logId: rekor.logId,
-  };
+  });
 }
 
 module.exports = {

package/lib/smime.js

@@ -334,7 +334,7 @@ function _signerEmails(certDer) {
     catch (sanFailed) { out.unreadable++; out.reason = sanFailed.code || "bad-san"; }
     if (dec === null) return;
     (dec.names || []).forEach(function (n) {
-      if (n.tagNumber === 1) { out.addresses.push(String(n.value)); return; }
+      if (n.tagNumber === 1) { guard.list.append(out.addresses, String(n.value)); return; }
       if (n.tagNumber !== 0) return;
       var typeId = n.value && typeof n.value === "object" ? n.value.typeId : undefined;
       if (typeId === undefined) { out.unreadable++; return; }
@@ -346,7 +346,7 @@ function _signerEmails(certDer) {
   (rdns || []).forEach(function (rdn) {
     (rdn || []).forEach(function (attr) {
       if (!attr || attr.type !== EMAIL_ADDRESS_ATTR || typeof attr.value !== "string") return;
-      if (out.addresses.indexOf(attr.value) === -1) out.addresses.push(attr.value);
+      if (out.addresses.indexOf(attr.value) === -1) guard.list.append(out.addresses, attr.value);
     });
   });
   return out;
@@ -362,7 +362,7 @@ function _senderSurface(signers, outerEnt, expectedSender) {
   }
   else {
     var froms = [];
-    outerEnt.headers.forEach(function (h) { if (h.lname === "from") froms.push(h.value.trim()); });
+    outerEnt.headers.forEach(function (h) { if (h.lname === "from") guard.list.append(froms, h.value.trim()); });
     if (froms.length === 1) { expected = _addrSpec(froms[0]); source = expected === null ? null : "from"; }
   }
   var identities = [], undecidable = false, sawIdentity = false;
@@ -371,7 +371,7 @@ function _senderSurface(signers, outerEnt, expectedSender) {
     var e = s.cert ? _signerEmails(s.cert) : null;
     if (e === null) { undecidable = true; return; }
     if (e.unreadable > 0) { undecidable = true; sawIdentity = true; }
-    e.addresses.forEach(function (a) { sawIdentity = true; if (identities.indexOf(a) === -1) identities.push(a); });
+    e.addresses.forEach(function (a) { sawIdentity = true; if (identities.indexOf(a) === -1) guard.list.append(identities, a); });
   });
   if (expected === null) return { checked: false, expected: null, source: null, identities: identities, match: null };
   if (!sawIdentity) return { checked: true, expected: expected, source: source, identities: identities, match: null };
@@ -630,7 +630,7 @@ async function verify(message, opts) {
     var inner;
     try { inner = _toBuf(schemaCms.parse(p7m).encapContentInfo.eContent); }
     catch (e) { throw _err("smime/bad-mime", "the pkcs7-mime SignedData has no encapsulated content", e); }
-    return Object.assign({ valid: res.valid, trusted: res.trusted, signers: res.signers, form: "pkcs7-mime", content: inner, micalg: null, sender: _senderSurface(res.signers, ent, opts.expectedSender) }, _hpSurface(inner, ent, "clear", res.valid, opts.legacyHeaderProtection === true));
+    return guard.verdict.of({ valid: res.valid, trusted: res.trusted, signers: res.signers, form: "pkcs7-mime", content: inner, micalg: null, sender: _senderSurface(res.signers, ent, opts.expectedSender) }, _hpSurface(inner, ent, "clear", res.valid, opts.legacyHeaderProtection === true));
   }
   if (ct.type === "multipart/signed") {
     if (ct.params.protocol && !_isPkcs7(ct.params.protocol, "signature")) throw _err("smime/bad-multipart", "multipart/signed protocol must be application/pkcs7-signature");
@@ -651,7 +651,7 @@ async function verify(message, opts) {
     if (opts.strictMicalg && micalg && _micalgSet(micalg) !== (_micalgOf(p7s) || "")) {
       throw _err("smime/micalg-mismatch", "the multipart/signed micalg " + JSON.stringify(micalg) + " disagrees with the SignerInfo digests");
     }
-    return Object.assign({ valid: res2.valid, trusted: res2.trusted, signers: res2.signers, form: "multipart/signed", content: parts[0], micalg: micalg, sender: _senderSurface(res2.signers, ent, opts.expectedSender) }, _hpSurface(parts[0], ent, "clear", res2.valid, opts.legacyHeaderProtection === true));
+    return guard.verdict.of({ valid: res2.valid, trusted: res2.trusted, signers: res2.signers, form: "multipart/signed", content: parts[0], micalg: micalg, sender: _senderSurface(res2.signers, ent, opts.expectedSender) }, _hpSurface(parts[0], ent, "clear", res2.valid, opts.legacyHeaderProtection === true));
   }
   throw _err("smime/unsupported-type", "not a signed S/MIME message (Content-Type " + JSON.stringify(ct.type) + ")");
 }

package/lib/tsp-sign.js

@@ -171,9 +171,9 @@ function _sign(messageImprint, tsa, opts) {
   var genTime = guard.time.isDate(opts.genTime) ? opts.genTime : new Date();
   var serial = guard.range.authoredInteger(opts.serialNumber, _err, "tsp/bad-input", "serialNumber");
   var fields = [b.integer(1n), _policy(opts.policy), imprint, b.integer(serial), b.generalizedTime(genTime)];
-  if (opts.accuracy) fields.push(_accuracy(opts.accuracy));
-  if (opts.ordering === true) fields.push(b.boolean(true));
-  if (opts.nonce != null) fields.push(b.integer(guard.range.authoredInteger(opts.nonce, _err, "tsp/bad-input", "nonce")));
+  if (opts.accuracy) guard.list.append(fields,_accuracy(opts.accuracy));
+  if (opts.ordering === true) guard.list.append(fields,b.boolean(true));
+  if (opts.nonce != null) guard.list.append(fields,b.integer(guard.range.authoredInteger(opts.nonce, _err, "tsp/bad-input", "nonce")));
   var tstInfo = b.sequence(fields);
 
   var signCert = { type: "signingCertificateV2", values: [_signingCertV2(certDer, certHashAlg)] };
@@ -199,10 +199,10 @@ function _accuracy(a) {
     if (typeof sec !== "number" && typeof sec !== "bigint") throw _err("tsp/bad-input", "Accuracy seconds must be a non-negative integer, got " + guard.text.showValue(sec));
     var s = intrinsic.Number(sec);
     if (!Number.isInteger(s) || s < 0 || s > 0x7fffffff) throw _err("tsp/bad-input", "Accuracy seconds must be a non-negative integer");
-    f.push(b.integer(BigInt(s)));
+    guard.list.append(f,b.integer(BigInt(s)));
   }
-  if (mil != null) f.push(b.contextPrimitive(0, _subMilliBytes(mil, "millis")));
-  if (mic != null) f.push(b.contextPrimitive(1, _subMilliBytes(mic, "micros")));
+  if (mil != null) guard.list.append(f,b.contextPrimitive(0, _subMilliBytes(mil, "millis")));
+  if (mic != null) guard.list.append(f,b.contextPrimitive(1, _subMilliBytes(mic, "micros")));
   return b.sequence(f);
 }
 function _subMilliBytes(n, label) {
@@ -276,10 +276,10 @@ function request(messageImprint, opts) {
   _assertImprint(mi);
   var imprint = b.sequence([_hashAlgId(mi.hashAlgorithm), b.octetString(guard.bytes.source(mi.hashedMessage, TspError, "tsp/bad-input", "messageImprint.hashedMessage"))]);
   var fields = [b.integer(1n), imprint];
-  if (opts.reqPolicy != null) fields.push(_policy(opts.reqPolicy));
-  if (opts.nonce != null) fields.push(b.integer(guard.range.authoredInteger(opts.nonce, _err, "tsp/bad-input", "nonce")));
+  if (opts.reqPolicy != null) guard.list.append(fields,_policy(opts.reqPolicy));
+  if (opts.nonce != null) guard.list.append(fields,b.integer(guard.range.authoredInteger(opts.nonce, _err, "tsp/bad-input", "nonce")));
   if (opts.certReq != null && typeof opts.certReq !== "boolean") throw _err("tsp/bad-input", "certReq must be a boolean");
-  if (opts.certReq === true) fields.push(b.boolean(true));
+  if (opts.certReq === true) guard.list.append(fields,b.boolean(true));
   if (opts.extensions != null) {
     if (!Array.isArray(opts.extensions) || !guard.list.allMatch(opts.extensions, function (e) { return guard.bytes.isByteSource(e); })) throw _err("tsp/bad-input", "extensions must be an array of encoded Extension DER buffers");
     var seenExt = {};
@@ -291,7 +291,7 @@ function request(messageImprint, opts) {
       seenExt[extnId] = true;
       return der;
     });
-    if (encoded.length) fields.push(b.contextConstructed(0, Buffer.concat(encoded)));
+    if (encoded.length) guard.list.append(fields,b.contextConstructed(0, Buffer.concat(encoded)));
   }
   var der = b.sequence(fields);
   return opts.pem ? schemaTsp.pemEncode(der, "TIMESTAMP REQUEST") : der;
@@ -364,14 +364,14 @@ function response(token, opts) {
   if (opts.statusString != null) {
     var texts = Array.isArray(opts.statusString) ? opts.statusString : [opts.statusString];
     if (!texts.length) throw _err("tsp/bad-input", "statusString must carry at least one PKIFreeText element (RFC 4210 SEQUENCE SIZE 1..MAX)");
-    siFields.push(b.sequence(texts.map(function (t) { return b.utf8(String(t)); })));
+    guard.list.append(siFields,b.sequence(texts.map(function (t) { return b.utf8(String(t)); })));
   }
   if (opts.failInfo != null) {
     if (status !== 2) throw _err("tsp/unexpected-failinfo", "failInfo is present only when the status is rejection(2) (RFC 3161 sec. 2.4.2)");
-    siFields.push(_failInfoBits(opts.failInfo));
+    guard.list.append(siFields,_failInfoBits(opts.failInfo));
   }
   var respFields = [b.sequence(siFields)];
-  if (token != null) respFields.push(b.raw(_tokenDer(token)));
+  if (token != null) guard.list.append(respFields, b.raw(_tokenDer(token)));
   var der = b.sequence(respFields);
   return opts.pem ? schemaTsp.pemEncode(der, "TIMESTAMP RESPONSE") : der;
 }
@@ -508,12 +508,12 @@ function _buildTsaChains(leaf, pool) {
   var chains = [];
   function dfs(current, acc, used) {
     if (chains.length >= MAX_TSA_CHAINS) return;
-    chains.push(acc.slice());
+    guard.list.append(chains, acc.slice());
     for (var i = 0; i < pool.length && chains.length < MAX_TSA_CHAINS; i++) {
       if (used[i]) continue;
       if (pool[i].serialNumberHex === current.serialNumberHex && guard.name.dnEqual(pool[i].issuer.rdns, current.issuer.rdns, _err, "tsp/bad-tsa-certificate", "the TSA certificate issuer")) continue;
       if (guard.name.dnEqual(pool[i].subject.rdns, current.issuer.rdns, _err, "tsp/bad-tsa-certificate", "the TSA certificate subject")) {
-        used[i] = true; acc.push(pool[i]);
+        used[i] = true; guard.list.append(acc, pool[i]);
         dfs(pool[i], acc, used);
         acc.pop(); used[i] = false;
       }
@@ -605,7 +605,7 @@ async function verify(token, data, opts) {
   var revocationChecked = false;
   var anchorConstraints = null;
   function fail(code, reason) {
-    return { valid: false, trusted: false, revocationChecked: revocationChecked, anchorConstraints: anchorConstraints, code: code, reason: reason || null, genTime: tst.genTime, accuracy: tst.accuracy, serialNumber: tst.serialNumber, serialNumberHex: tst.serialNumberHex, policy: tst.policy, policyName: tst.policyName, nonce: tst.nonce, tsa: tst.tsa, tstInfo: tst, signer: null };
+    return guard.verdict.of({ valid: false, trusted: false, revocationChecked: revocationChecked, anchorConstraints: anchorConstraints, code: code, reason: reason || null, genTime: tst.genTime, accuracy: tst.accuracy, serialNumber: tst.serialNumber, serialNumberHex: tst.serialNumberHex, policy: tst.policy, policyName: tst.policyName, nonce: tst.nonce, tsa: tst.tsa, tstInfo: tst, signer: null });
   }
   var cmsRes = await cmsVerify.verify(tokenDer, { certs: opts.certs });
   var signer = cmsRes.signers[0];
@@ -642,7 +642,7 @@ async function verify(token, data, opts) {
     var ceilT = (tst.genTimeFraction != null && _hasNonZeroDigit(tst.genTimeFraction.slice(3))) ? new Date(guard.time.instantOf(floorT) + 1) : floorT;
     try {
       var pool = (parsed.certificates || []).filter(function (c) { return c.tagClass === "universal"; }).map(function (c) { return pkiX509.parse(c.bytes); });
-      (opts.certs || []).forEach(function (c) { pool.push(pkiX509.parse(c)); });
+      (opts.certs || []).forEach(function (c) { guard.list.append(pool, pkiX509.parse(c)); });
       async function validateAt(chain, when) {
         var res = await pathValidate.validate(chain, {
           time: when, trustAnchors: opts.trustAnchors, requiredEku: ["timeStamping"], checkPurpose: "timeStamping", revocationChecker: opts.revocationChecker,
@@ -662,13 +662,13 @@ async function verify(token, data, opts) {
     anchorConstraints = pathRes.anchorConstraints;
     trusted = true;
   }
-  return {
+  return guard.verdict.of({
     valid: true, trusted: trusted, revocationChecked: revocationChecked, anchorConstraints: anchorConstraints,
     genTime: tst.genTime, accuracy: tst.accuracy,
     serialNumber: tst.serialNumber, serialNumberHex: tst.serialNumberHex,
     policy: tst.policy, policyName: tst.policyName, nonce: tst.nonce, tsa: tst.tsa,
     tstInfo: tst, signer: { cert: tsaCertDer, sid: signer.sid },
-  };
+  });
 }
 
 module.exports = { sign: sign, request: request, parseRequest: parseRequest, response: response, parseResponse: parseResponse, verify: verify };

package/lib/webauthn.js

@@ -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;
 }
 
@@ -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 });
     });
   },
 
@@ -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 } });
     });
 }
 
@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/pki",
-  "version": "0.6.38",
+  "version": "0.6.40",
   "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:adf5e979-6804-475f-a0d0-8aef04be0317",
+  "serialNumber": "urn:uuid:2af62d9e-82a4-4f11-8c8c-7b2c8b1ae891",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-05T07:57:13.454Z",
+    "timestamp": "2026-09-05T15:01:32.918Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/pki@0.6.38",
+      "bom-ref": "@blamejs/pki@0.6.40",
       "type": "application",
       "name": "pki",
-      "version": "0.6.38",
+      "version": "0.6.40",
       "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.38",
+      "purl": "pkg:npm/%40blamejs/pki@0.6.40",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/pki@0.6.38",
+      "ref": "@blamejs/pki@0.6.40",
       "dependsOn": []
     }
   ]