@blamejs/pki 0.6.39 → 0.6.40

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to `@blamejs/pki` are documented here. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this
 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v0.6.40 — 2026-09-05
+
+Every verify verdict now reaches its caller as the object the verb built, and a list the toolkit assembles carries the entries the toolkit put in it.
+
+### Fixed
+
+- The verdicts of pki.attrcert.verify, pki.crl.verify, pki.csr.verify, pki.ct.verifySctWithLogList, pki.ct.verifySctList, pki.path.validate, pki.path.build, pki.pkcs12.verifyMac, pki.pkcs12.open, pki.webauthn.verify, pki.webauthn.verifyAssertion, pki.cmp.verify, pki.tsp.verify, pki.ocsp.verifyRequest and pki.sigstore.verifyBundle end the prototype lookup for then on themselves. An accessor installed there while a verification was pending could otherwise run with the verdict as its receiver and change what the caller reads.
+- A list a verdict reports is appended to by defining the entry rather than assigning it, so a setter at the appended index cannot take the value and answer the read with something else. This covers the keys, certificates, CRLs and secrets pki.pkcs12.open returns from an authenticated store, the signers pki.cms.verify reports and the countersignatures under them, the per-SCT results and the distinct operators pki.ct.verifySctList counts its policy against, the per-certificate results pki.path.validate reports and the checks under each of them that name which gate refused, the elements of a compound attestation pki.webauthn.verify returns along with the routes its anchoredTo names, the certificate chain and transcript a pki.cmp session returns, and the signer identities pki.smime.verify reports. The arrays a pki.schema parser fills are not covered: a verify verb re-derives its answer from the bytes and refuses a parse result whose fields were rebuilt, so a substituted entry there decides nothing.
+- pki.webauthn.verify builds the fields it learns after the attestation itself is checked into the verdict rather than writing them onto it. bindingChecked, which tells a relying party which of its expectations were enforced, could otherwise be taken by an inherited setter and reported by its getter as a check that never ran. anchoredTo, anchoredElements, metadata, clientData, safetyNet, tpm and compound are built the same way.
+- The results of pki.path.crlChecker(...).check and pki.path.ocspChecker(...).check, the build-only result pki.path.build returns under validate:false, and the results of pki.ct.signSct and pki.ct.fetchLogList carry the same protection. Each is handed to a caller, so each ends the prototype lookup for then on itself.
+- Path validation, CMS verification, timestamp verification, CMP protection verification and Sigstore bundle verification append to every one of their own lists the same way. Each reads its answer back out of those lists, so the name forms a name-constraint check compares, the CRLs a revocation decision scans, the policy-tree nodes that produce the user-constrained set, the candidate certificates a signer identifier selects, the chains a timestamp is trusted through and the path a Fulcio leaf is anchored by are all written where an indexed setter cannot reach them.
+
 ## v0.6.39 — 2026-09-05
 
 A verdict field is created with the verdict rather than written onto it afterward, so a value left on Object.prototype can no longer answer a question the verification never asked.

package/lib/attrcert-sign.js

@@ -717,7 +717,7 @@ function _verify(ac, issuer, opts) {
   var trust = _resolveIssuer(issuer);
 
   var acIssuer = _acIssuerName(parsed);
-  var result = {
+  var result = guard.verdict.of({
     holder: parsed.holder,
     issuer: acIssuer,
     attributes: parsed.attributes,
@@ -735,7 +735,7 @@ function _verify(ac, issuer, opts) {
     valid: false,
     verified: false,
     reason: undefined,
-  };
+  });
 
   return Promise.resolve(attrcertVerify.verifyAcSignature(parsed, trust.spki)).then(function (sigOk) {
     result.signatureValid = sigOk === true;

package/lib/cmp-session.js

@@ -507,7 +507,7 @@ function session(opts) {
         if (!Buffer.isBuffer(c)) return;
         var k = c.toString("base64");
         if (caPubsSeen[k]) {
-          if (isGrantLeg) { for (var pi = 0; pi < caPubsAccum.length; pi++) { if (caPubsAccum[pi].toString("base64") === k) { caPubsAccum.push(caPubsAccum.splice(pi, 1)[0]); if (pi < caPubsWaitingCount) caPubsWaitingCount--; break; } } }
+          if (isGrantLeg) { for (var pi = 0; pi < caPubsAccum.length; pi++) { if (caPubsAccum[pi].toString("base64") === k) { guard.list.append(caPubsAccum, caPubsAccum.splice(pi, 1)[0]); if (pi < caPubsWaitingCount) caPubsWaitingCount--; break; } } }
           return;
         }
         try { x509.parse(c); } catch (e) { throw _err("cmp/bad-cert-response", "an authenticated caPubs entry is not a valid X.509 certificate", e); }
@@ -522,7 +522,7 @@ function session(opts) {
         if (caPubsAccum.length >= CAPUBS_MAX || caPubsBytes + c.length > caPubsByteBudget) return;
         caPubsSeen[k] = 1;
         caPubsBytes += c.length;
-        caPubsAccum.push(Buffer.from(c));
+        guard.list.append(caPubsAccum, Buffer.from(c));
         if (!isGrantLeg) caPubsWaitingCount++;
       });
       if (isGrantLeg) return { state: "granted", resp: resp, code: code };
@@ -592,7 +592,7 @@ function session(opts) {
     var len = Buffer.isBuffer(entry.bytes) ? entry.bytes.length : 0;
     var over = transcriptBytes + len > transcriptCap;
     if (!over) transcriptBytes += len;
-    transcript.push(over
+    guard.list.append(transcript, over
       ? guard.verdict.of(entry, { byteLength: len, bytes: null, truncated: true })
       : guard.verdict.of(entry));
   }
@@ -703,7 +703,7 @@ function session(opts) {
       var k = _certIdentity(c);
       if (k != null && seenChain[k]) return;
       if (k != null) seenChain[k] = 1;
-      chain.push(c);
+      guard.list.append(chain, c);
     });
     await _validateLeaf(leaf, caPubsAccum);
     var info = { status: PKI_STATUS_NAMES[granted.code] || granted.code, grantedWithMods: granted.code === 1 };

package/lib/cmp-verify.js

@@ -77,7 +77,7 @@ var _engine = null;
 function setEngine(engine) { _engine = engine; }
 
 function _verdict(m, type, protectionAlg, valid, trusted, code, reason, signer) {
-  var v = {
+  return guard.verdict.of({
     valid: valid,
     trusted: trusted,
     protectionType: type,
@@ -88,9 +88,7 @@ function _verdict(m, type, protectionAlg, valid, trusted, code, reason, signer)
     recipNonce: m.header.recipNonce || null,
     header: m.header,
     body: m.body,
-  };
-  if (code) { v.code = code; v.reason = reason; }
-  return v;
+  }, code ? { code: code, reason: reason } : null);
 }
 function _ok(m, type, alg, trusted, signer) { return _verdict(m, type, alg, true, trusted, null, null, signer); }
 function _fail(m, type, alg, code, reason, signer) { return _verdict(m, type, alg, false, false, code, reason, signer || null); }
@@ -438,7 +436,7 @@ async function _verifySignature(m, protectedPart, protectionAlg, protection, opt
 
   if (opts.trustAnchors == null) return _ok(m, "signature", protectionAlg, false, signer);
   var trust = await _chainSigner(signer, m, opts, extra);
-  if (trust.chain) signer.chain = trust.chain;
+  if (trust.chain) guard.verdict.set(signer, "chain", trust.chain);
   return _verdict(m, "signature", protectionAlg, true, trust.trusted, trust.trusted ? null : "cmp/untrusted-signer", trust.reason, signer);
 }
 
@@ -521,9 +519,7 @@ function _boundExtraCerts(extra) {
 
 var _defineOwn = Object.defineProperty;
 var _Date = Date;
-function _append(arr, v) {
-  _defineOwn(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true });
-}
+var _append = guard.list.append;
 
 function _certList(v) {
   if (v == null) return [];

package/lib/cms-verify.js

@@ -111,9 +111,9 @@ function _findSignerCerts(sid, parsedCerts) {
   for (var i = 0; i < parsedCerts.length; i++) {
     var c = parsedCerts[i];
     if (sid.subjectKeyIdentifier != null) {
-      if (c.ski && intrinsic.bufferEquals(c.ski, _toBuf(sid.subjectKeyIdentifier, "sid.subjectKeyIdentifier"))) intrinsic.push(out, c);
+      if (c.ski && intrinsic.bufferEquals(c.ski, _toBuf(sid.subjectKeyIdentifier, "sid.subjectKeyIdentifier"))) guard.list.append(out, c);
     } else if (sid.issuer && sid.serialNumberHex != null) {
-      if (c.cert.serialNumberHex === sid.serialNumberHex && guard.name.dnEqual(c.cert.issuer.rdns, sid.issuer.rdns, _err, "cms/bad-name", "the signer certificate issuer")) intrinsic.push(out, c);
+      if (c.cert.serialNumberHex === sid.serialNumberHex && guard.name.dnEqual(c.cert.issuer.rdns, sid.issuer.rdns, _err, "cms/bad-name", "the signer certificate issuer")) guard.list.append(out, c);
     }
   }
   return out;
@@ -391,10 +391,10 @@ async function _verifyCountersignatures(si, parsedCerts) {
   var values = [];
   intrinsic.forEach(si.unsignedAttrs || [], function (a) {
     if (a.type !== OID_COUNTERSIGNATURE) return;
-    intrinsic.forEach(a.values, function (v) { intrinsic.push(values, v && v.bytes ? v.bytes : v); });
+    intrinsic.forEach(a.values, function (v) { guard.list.append(values, v && v.bytes ? v.bytes : v); });
   });
   var out = [];
-  for (var _cp = 0; _cp < values.length; _cp++) intrinsic.push(out, await _verifyOneCountersig(values[_cp], targetSig, parsedCerts));
+  for (var _cp = 0; _cp < values.length; _cp++) guard.list.append(out, await _verifyOneCountersig(values[_cp], targetSig, parsedCerts));
   return out;
 }
 
@@ -495,7 +495,7 @@ async function _resolveContentDigests(parsed, streamSource) {
   var names = [], seen = {};
   intrinsic.forEach(parsed.signerInfos, function (si) {
     var dn = si.digestAlgorithm.name;
-    if (si.signedAttrsBytes && _supportedDigest(dn) && !seen[dn]) { seen[dn] = 1; intrinsic.push(names, dn); }
+    if (si.signedAttrsBytes && _supportedDigest(dn) && !seen[dn]) { seen[dn] = 1; guard.list.append(names, dn); }
   });
   if (!names.length) return {};
   var ds;
@@ -546,7 +546,7 @@ async function _verify(input, opts) {
     var siOne = parsed.signerInfos[_sp];
     var verdict = await _verifyOne(siOne, content, eContentType, parsedCerts, null, digestByName);
     var counters = await _verifyCountersignatures(siOne, parsedCerts);
-    intrinsic.push(signers, guard.verdict.of(verdict, {
+    guard.list.append(signers, guard.verdict.of(verdict, {
       countersignatures: counters,
       unsignedAttrs: _surfaceUnsignedAttrs(siOne),
       signedAttributesPresent: !!siOne.signedAttrsBytes,
@@ -677,7 +677,7 @@ function _addCert(out, der) {
   try {
     cert = x509.parse(buf);
   } catch (_e2) { return; }
-  out.push({ cert: cert, der: buf, ski: _certSki(cert) });
+  guard.list.append(out, { cert: cert, der: buf, ski: _certSki(cert) });
 }
 
 /**

package/lib/crl-sign.js

@@ -525,14 +525,14 @@ function _verify(crl, issuer) {
   return crlVerify.verifyCrlSignature(parsed, resolved.spki).then(function (sigOk) {
     var signatureValid = sigOk === true;
     var valid = issuerMaySign && signatureValid;
-    var out = { valid: valid, issuerMaySign: issuerMaySign, signatureValid: signatureValid, issuer: parsed.issuer };
-    if (!valid) {
-      out.code = !issuerMaySign ? "crl/issuer-may-not-sign" : "crl/bad-signature";
-      out.reason = !issuerMaySign
-        ? "the issuer certificate is not this CRL's issuer, or its keyUsage does not assert cRLSign (RFC 5280 sec. 4.2.1.3)"
-        : "the CRL signature did not verify under the issuer key";
-    }
-    return out;
+    return guard.verdict.of(
+      { valid: valid, issuerMaySign: issuerMaySign, signatureValid: signatureValid, issuer: parsed.issuer },
+      valid ? null : {
+        code: !issuerMaySign ? "crl/issuer-may-not-sign" : "crl/bad-signature",
+        reason: !issuerMaySign
+          ? "the issuer certificate is not this CRL's issuer, or its keyUsage does not assert cRLSign (RFC 5280 sec. 4.2.1.3)"
+          : "the CRL signature did not verify under the issuer key",
+      });
   });
 }
 

package/lib/csr-sign.js

@@ -205,14 +205,14 @@ function verify(request) { return guard.async.deferred(function () { return _ver
 function _verify(request) {
   var parsed = _coerceCsr(request);
   return Promise.resolve(csrVerify.verifyCsrSignature(parsed)).then(function (ok) {
-    return {
+    return guard.verdict.of({
       valid: ok === true,
       verified: ok === true,
       subject: parsed.subject,
       subjectPublicKeyInfo: parsed.subjectPublicKeyInfo,
       attributes: parsed.attributes,
       certificationRequestInfoBytes: parsed.certificationRequestInfoBytes,
-    };
+    });
   });
 }
 

package/lib/ct.js

@@ -551,7 +551,7 @@ async function signSct(entry, logKey, opts) {
   var priv = await subtle.importKey("pkcs8", mat.pkcs8, imp, false, ["sign"]);
   var sigRaw = Buffer.from(await subtle.sign(sign, priv, preimage));
   var signature = ecdsaDer ? validator.sig.rawToEcdsaDer(sigRaw, coordLen) : sigRaw;
-  return {
+  return guard.verdict.of({
     version: 0,
     logId: logId, logIdHex: logId.toString("hex"),
     timestamp: timestamp,
@@ -559,7 +559,7 @@ async function signSct(entry, logKey, opts) {
     hashAlg: hashAlg, sigAlg: sigAlg,
     signatureAlgorithm: { hash: hashAlg, hashName: HASH_ALGORITHMS[hashAlg] || null, signature: sigAlg, signatureName: SIGNATURE_ALGORITHMS[sigAlg] || null },
     signature: signature,
-  };
+  });
 }
 
 
@@ -766,14 +766,14 @@ async function verifySctWithLogList(entry, sct, logList, opts) {
   var c = _classifyLog(sct, logList, entry, opts);
   if (c.status !== "ok") throw _ctErr(c.code, c.message);
   var valid = await verifySct(entry, sct, c.log.key);
-  return {
+  return guard.verdict.of({
     valid: valid,
     logId: c.log.logId,
     logIdHex: c.log.logIdHex,
     operator: c.log.operator,
     logState: c.log.state.name,
     timestamp: sct.timestamp,
-  };
+  });
 }
 
 var _VERIFY_SCT_LIST_OPTS = { minScts: 1, minOperators: 1, certNotAfter: 1, at: 1 };
@@ -860,37 +860,37 @@ async function verifySctList(entry, list, logList, opts) {
     try { c = _classifyLog(sct, logList, entry, opts); }
     catch (e) {
       if (!(e && e.isPkiError)) throw e;
-      row.code = e.code; row.reason = e.message; intrinsic.push(results, row); continue;
+      row.code = e.code; row.reason = e.message; guard.list.append(results, row); continue;
     }
     if (c.log) { row.operator = c.log.operator; row.logState = c.log.state.name; }
-    if (c.status !== "ok") { row.code = c.code; row.reason = c.message; intrinsic.push(results, row); continue; }
+    if (c.status !== "ok") { row.code = c.code; row.reason = c.message; guard.list.append(results, row); continue; }
     var ok;
     try { ok = await verifySct(entry, sct, c.log.key); }
     catch (e) {
       if (!(e && e.isPkiError)) throw e;
-      row.code = e.code; row.reason = e.message; intrinsic.push(results, row); continue;
+      row.code = e.code; row.reason = e.message; guard.list.append(results, row); continue;
     }
     if (ok === true && atMs != null && sct.timestamp > atMs) {
       row.code = "ct/future-timestamp"; row.reason = "the SCT timestamp is later than the validation time (RFC 6962 sec. 5.2)";
-      intrinsic.push(results, row); continue;
+      guard.list.append(results, row); continue;
     }
     row.valid = ok === true;
     if (row.valid && !seenLogs[sct.logIdHex]) {
       seenLogs[sct.logIdHex] = true;
       validScts++;
-      if (c.log.operator != null && !seenOps[c.log.operator]) { seenOps[c.log.operator] = true; intrinsic.push(operators, c.log.operator); }
+      if (c.log.operator != null && !seenOps[c.log.operator]) { seenOps[c.log.operator] = true; guard.list.append(operators, c.log.operator); }
     }
-    intrinsic.push(results, row);
+    guard.list.append(results, row);
   }
   var operatorCount = operators.length;
   var policyOk = validScts >= minScts && operatorCount >= minOperators;
-  return {
+  return guard.verdict.of({
     valid: policyOk,
     policyOk: policyOk, totalScts: scts.length + unknownScts, validScts: validScts, unknownScts: unknownScts,
     operatorCount: operatorCount, operators: operators, required: { minScts: minScts, minOperators: minOperators },
     results: results,
     reason: policyOk ? null : ("CT policy not met: " + validScts + " valid SCT(s) from " + operatorCount + " distinct operator(s); require at least " + minScts + " SCT(s) from at least " + minOperators + " operator(s)"),
-  };
+  });
 }
 
 function _asParsedCert(v, field) {
@@ -1143,10 +1143,10 @@ async function fetchLogList(opts) {
   var ok = await verifyLogListSignature(jsonRes.body, sigRes.body, opts.signerKey);
   if (ok !== true) throw _ctErr("ct/log-list-untrusted", "the CT log-list detached signature did not verify against the pinned distributor key -- the fetched list is untrusted and was not parsed");
   var parsed = parseLogList(jsonRes.body);
-  return {
+  return guard.verdict.of({
     logs: parsed.logs, byLogId: parsed.byLogId, version: parsed.version, timestamp: parsed.timestamp,
     raw: { json: jsonRes.body, sig: sigRes.body }, status: jsonRes.status, contentType: jsonRes.contentType, tls: jsonRes.tls,
-  };
+  });
 }
 
 module.exports = {

package/lib/guard-bytes.js

@@ -41,7 +41,7 @@ var _mapSet = intrinsic.mapSet;
 var _taSet = intrinsic.typedArraySet;
 var _Set = intrinsic.Set;
 var _Map = intrinsic.Map;
-function _append(arr, v) { _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true }); }
+var _append = require("./guard-list").append;
 
 function _ownArrayIndices(v, n) {
   var keys = _ownKeys(v);

package/lib/guard-identifier.js

@@ -38,7 +38,7 @@ var _Number = intrinsic.Number;
 var _BigInt = intrinsic.BigInt;
 var _Object = intrinsic.Object;
 var _BufferProto = intrinsic.BufferProto;
-function _append(arr, v) { _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true }); }
+var _append = require("./guard-list").append;
 
 function _isDottedDecimal(str) {
   if (str.length === 0) return false;

package/lib/guard-json.js

@@ -12,7 +12,7 @@ var _hasOwn = require("./guard-intrinsic").hasOwn;
 var _Number = require("./guard-intrinsic").Number;
 var _isFinite = require("./guard-intrinsic").isFinite;
 var _stringify = require("./guard-intrinsic").stringify;
-function _append(arr, v) { _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true }); }
+var _append = require("./guard-list").append;
 var limits = require("./guard-limits");
 
 function _hexVal(c) {

package/lib/guard-list.js

@@ -4,6 +4,21 @@
 // @internal
 
 var _freeze = require("./guard-intrinsic").freeze;
+var _defineProperty = require("./guard-intrinsic").defineProperty;
+var _isArray = require("./guard-intrinsic").isArray;
+
+var MAX_ARRAY_LENGTH = 4294967295;
+
+// @enforced-by guard-shape-reinlined
+// @guard-shape defineProperty\(\s*\w+\s*,\s*\w+\.length\s*,\s*\{\s*value:
+// @guard-via guard\.list\.append\(
+function append(list, value) {
+  if (!_isArray(list)) throw new TypeError("guard.list.append: the receiver must be an array");
+  var n = list.length;
+  if (n >= MAX_ARRAY_LENGTH) throw new RangeError("guard.list.append: the array is at its maximum length");
+  _defineProperty(list, n, { value: value, writable: true, enumerable: true, configurable: true });
+  return list;
+}
 
 // @enforced-by behavioral -- `.indexOf(x) !== -1` has no rename-proof form that separates a
 function contains(list, value) {
@@ -34,6 +49,7 @@ function allMatch(list, predicate) {
 }
 
 module.exports = _freeze({
+  append: append,
   contains: contains,
   containsAll: containsAll,
   anyMatches: anyMatches,

package/lib/guard-parsed.js

@@ -20,7 +20,7 @@ var _weakSet = require("./guard-intrinsic").weakSet;
 var _weakHas = require("./guard-intrinsic").weakHas;
 var _WeakMap = require("./guard-intrinsic").WeakMap;
 var _defineProperty = require("./guard-intrinsic").defineProperty;
-function _append(arr, v) { _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true }); }
+var _append = require("./guard-list").append;
 
 function _isBytes(x) {
   return bytes.isByteSource(x);

package/lib/guard-verdict.js

@@ -38,4 +38,10 @@ function carries(obj, key) {
   return obj != null && _hasOwn(_Object(obj), key);
 }
 
-module.exports = _freeze({ of: of, carries: carries });
+// @enforced-by behavioral -- for a target that cannot be rebuilt, an Error carrying a field a
+function set(target, key, value) {
+  _defineProperty(target, key, { value: value, enumerable: true, configurable: true, writable: true });
+  return target;
+}
+
+module.exports = _freeze({ of: of, carries: carries, set: set });

package/lib/ip-utils.js

@@ -15,7 +15,7 @@ var _bufferFrom = intrinsic.bufferFrom;
 var _bufferAlloc = intrinsic.bufferAlloc;
 var _defineProperty = intrinsic.defineProperty;
 var _Number = intrinsic.Number;
-function _push(arr, v) { _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true }); }
+var _push = require("./guard-list").append;
 function _splitOn(str, sep) {
   var out = [], from = 0, at;
   while ((at = _indexOf(str, sep, from)) !== -1) { _push(out, _slice(str, from, at)); from = at + sep.length; }