@blamejs/pki 0.5.21 → 0.5.23

package/CHANGELOG.md

@@ -4,7 +4,34 @@ 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.5.21 — 2026-08-21
+## v0.5.23 — 2026-08-21
+
+The tables that decide which status codes, revocation reasons, trust bits and extensions this toolkit recognizes now answer from an operation taken at load, and an unsupported HTTP Digest algorithm is refused rather than read off a prototype.
+
+### Changed
+
+- Eighteen further modules -- ACME, EST, CMC, WebAuthn and its metadata reader, Certificate Transparency, trust-store ingest, TLS certificate compression, HPKE, HTTP Digest, the CRL and attribute-certificate signers, and the OCSP, CRL, attribute-certificate and shared PKIX schemas -- are held to the live-read rule, each declaring the reads it still carries as a count that can only fall.
+
+### Fixed
+
+- An HTTP Digest challenge naming an unsupported algorithm is refused with a typed error. The algorithm registry was an ordinary object, so a name matching any member of `Object.prototype` answered the supported-algorithm gate with a value the registry never held: the refusal was skipped and the call ended in an untyped `TypeError`. The registry now carries a null prototype.
+- OCSP response statuses and revocation reasons, CRL reason codes, CCADB trust bits, attribute-certificate critical extensions and object-digest types, Certificate Transparency log states, and the repeated-parameter check on an HTTP Digest challenge all decide membership through a captured operation, so replacing the runtime's own membership test after load cannot widen what they accept.
+
+## v0.5.22 — 2026-08-20
+
+The list tests that decide whether a caller's argument is refused, and which form an extension spec is in, now answer from operations taken at load rather than read when they run.
+
+### Changed
+
+- The DER codec, the PKIX builders and the certificate signer are held to the live-read rule, with the reads each still carries declared as a count that can only fall. Certification-path validation's declared count falls in this release as its list doors convert.
+
+### Fixed
+
+- The DER builder refuses a non-list of children under a captured test. Every structure this toolkit encodes passes through that door, and it was the busiest live read in the library by two orders of magnitude.
+- `pki.x509.sign` picks which form the caller's extension spec is in with a captured test. That choice decides which fields are read and therefore what is signed into the certificate: answering wrongly sends an object down the list arm, and the extensions it carries are never seen. The same test decides whether the spec asserts keyCertSign, which is what makes the issued certificate a CA.
+- The name, key-usage and GeneralNames builders refuse a non-list argument under a captured test, as do certification-path validation's own list doors.
+
+## v0.5.21 — 2026-08-20
 
 The check that holds the crypto engine to load-time captures could be satisfied around, so nine modules had taken the safe primitive at one site and were never held to it anywhere else.
 

package/lib/acme.js

@@ -49,6 +49,11 @@ var frameworkError = require("./framework-error");
 var httpTransport = require("./http-transport");
 var retryAfter = require("./http-retry-after");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Membership is asked through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and either answering wrongly changes whether a field
+// counts as present in a document this client is deciding how to act on.
+var _hasOwn = intrinsic.hasOwn;
 var pkgVersion = require("../package.json").version;
 
 var AcmeError = frameworkError.AcmeError;
@@ -211,7 +216,7 @@ function _validate(kind, obj) {
   var spec = SPECS[kind];
   for (var f = 0; f < spec.length; f++) {
     var field = spec[f];
-    var present = Object.prototype.hasOwnProperty.call(obj, field.name);
+    var present = _hasOwn(obj, field.name);
     var required = field.required || (field.requiredWhen && field.requiredWhen(obj));
     if (!present) {
       if (required) throw E("acme/missing-field", "an ACME " + kind + " is missing the required field " + JSON.stringify(field.name));
@@ -383,9 +388,9 @@ var ERROR_NAMESPACE = "urn:ietf:params:acme:error:";
  */
 function validateProblem(obj) {
   if (!_isObject(obj)) throw E("acme/bad-problem", "a problem document must be a JSON object");
-  if (Object.prototype.hasOwnProperty.call(obj, "identifier")) throw E("acme/bad-problem", "a top-level problem document must not carry an identifier (RFC 8555 sec. 6.7.1)");
+  if (_hasOwn(obj, "identifier")) throw E("acme/bad-problem", "a top-level problem document must not carry an identifier (RFC 8555 sec. 6.7.1)");
   if (!_isString(obj.type) || obj.type.indexOf(ERROR_NAMESPACE) !== 0) throw E("acme/bad-problem", "an ACME problem type must be in the " + ERROR_NAMESPACE + " namespace (RFC 8555 sec. 6.7)");
-  if (Object.prototype.hasOwnProperty.call(obj, "subproblems")) {
+  if (_hasOwn(obj, "subproblems")) {
     if (!Array.isArray(obj.subproblems)) throw E("acme/bad-problem", "subproblems must be an array");
     for (var i = 0; i < obj.subproblems.length; i++) {
       var sub = obj.subproblems[i];
@@ -393,7 +398,7 @@ function validateProblem(obj) {
       // A subproblem identifier reflects a submitted order identifier, which MAY be a
       // wildcard (a rejectedIdentifier for a *.example.org order), so it is validated
       // with the order-identifier rule, not the stricter authorization one.
-      if (Object.prototype.hasOwnProperty.call(sub, "identifier")) _validateOrderIdentifier(sub.identifier);
+      if (_hasOwn(sub, "identifier")) _validateOrderIdentifier(sub.identifier);
     }
   }
   return obj;
@@ -455,7 +460,7 @@ function validate(kind, obj) {
  */
 function identify(obj) {
   if (!_isObject(obj)) return "unknown";
-  var has = function (k) { return Object.prototype.hasOwnProperty.call(obj, k); };
+  var has = function (k) { return _hasOwn(obj, k); };
   if (has("protected") && has("signature") && _isString(obj.protected) && _isString(obj.signature)) return "jws";
   if (_isString(obj.type) && obj.type.indexOf(ERROR_NAMESPACE) === 0) return "problem";
   if (has("newNonce") && has("newAccount")) return "directory";
@@ -677,8 +682,8 @@ async function verifyTlsAlpn01(certDer, token, accountJwk, identifier) {
 // `url`, and either `kid` (an account URL) or `jwk` (an embedded public JWK).
 function _outerHeader(o) {
   var h = { alg: o.alg, nonce: o.nonce, url: o.url };
-  if (Object.prototype.hasOwnProperty.call(o, "kid")) h.kid = o.kid;
-  if (Object.prototype.hasOwnProperty.call(o, "jwk")) h.jwk = o.jwk;
+  if (_hasOwn(o, "kid")) h.kid = o.kid;
+  if (_hasOwn(o, "jwk")) h.jwk = o.jwk;
   return h;
 }
 function _payloadBuf(obj) {
@@ -1113,8 +1118,8 @@ function revokeCert(o) {
   return _promised(function () {
   if (!_isObject(o) || !Buffer.isBuffer(o.certificate)) throw E("acme/bad-input", "revokeCert requires a DER certificate Buffer (opts.certificate)");
   x509.parse(o.certificate);                              // structural validation of the target
-  var hasKid = Object.prototype.hasOwnProperty.call(o, "kid");
-  var hasJwk = Object.prototype.hasOwnProperty.call(o, "jwk");
+  var hasKid = _hasOwn(o, "kid");
+  var hasJwk = _hasOwn(o, "jwk");
   if (hasKid === hasJwk) throw E("acme/bad-input", "revokeCert must be signed with EXACTLY ONE of the account kid or the certificate jwk (RFC 8555 sec. 7.6)");
   var payload = { certificate: jose.base64url.encode(o.certificate) };
   if (o.reason !== undefined) {
@@ -1675,7 +1680,7 @@ function _parseLinkValue(raw) {
 // unresolvable target fails closed as acme/bad-link. Scoped to the alternate relation the download consumes.
 function _parseLinkAlternates(headers, base) {
   var raw = null;
-  for (var k in headers) { if (Object.prototype.hasOwnProperty.call(headers, k) && k.toLowerCase() === "link") { raw = headers[k]; break; } }
+  for (var k in headers) { if (_hasOwn(headers, k) && k.toLowerCase() === "link") { raw = headers[k]; break; } }
   if (raw == null) return [];
   var baseUrl = new URL(base), baseOrigin = baseUrl.origin, baseHref = baseUrl.href;   // the download URL
   var fields = Array.isArray(raw) ? raw : [raw], out = [], seen = Object.create(null), totalBytes = 0;

package/lib/asn1-der.js

@@ -34,6 +34,10 @@
 var constants = require("./constants");
 var frameworkError = require("./framework-error");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// The list test at each builder door decides whether a caller's argument is refused. Read at the
+// moment it runs, a replacement answering true admits a non-list and the door it guards is gone.
+var _isArray = intrinsic.isArray;
 
 var Asn1Error = frameworkError.Asn1Error;
 var OidError = frameworkError.OidError;
@@ -966,7 +970,7 @@ var build = {
   // encoder composes, so the minimal-encoding rule lives once (the CHECK side is
   // schema.assertMinimalNamedBits). No bits asserted -> the empty BIT STRING.
   namedBitString: function (positions) {
-    if (!Array.isArray(positions)) throw new Asn1Error("asn1/bad-bit-string", "namedBitString requires an array of bit positions");
+    if (!_isArray(positions)) throw new Asn1Error("asn1/bad-bit-string", "namedBitString requires an array of bit positions");
     var hi = -1, i, p;
     for (i = 0; i < positions.length; i++) {
       p = positions[i];
@@ -1059,7 +1063,7 @@ function _intContent(v, who) {
 }
 
 function _asBufferArray(arr, who) {
-  if (!Array.isArray(arr)) throw new Asn1Error("asn1/bad-children", who + ": expected an array of TLV buffers");
+  if (!_isArray(arr)) throw new Asn1Error("asn1/bad-children", who + ": expected an array of TLV buffers");
   return arr.map(function (b) { return _asBuffer(b, who); });
 }
 

package/lib/attrcert-sign.js

@@ -33,6 +33,11 @@ var attrcert = require("./schema-attrcert");
 var x509 = require("./schema-x509");
 var signScheme = require("./sign-scheme");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Membership is asked through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and either answering true admits a name the table
+// never carried -- here, an unrecognized critical extension counted as one this profile supports.
+var _hasOwn = intrinsic.hasOwn;
 var pkix = require("./schema-pkix");
 var schema = require("./schema-engine");
 require("./path-validate");   // side-effect: path-validate injects its signature engine into attrcert-verify at load
@@ -373,10 +378,10 @@ function _buildAttributes(attrSpec) {
 // carrying, so BOTH extension forms meet it -- the object form and the pre-encoded array form, which
 // is the one that can name a pointer at all. `seen` is the OID-keyed set each branch already builds.
 function _assertRevocationSchemesExclusive(seen) {
-  if (!Object.prototype.hasOwnProperty.call(seen, O("noRevAvail"))) return;
+  if (!_hasOwn(seen, O("noRevAvail"))) return;
   var names = Object.keys(REVOCATION_POINTERS);
   for (var i = 0; i < names.length; i++) {
-    if (Object.prototype.hasOwnProperty.call(seen, names[i])) {
+    if (_hasOwn(seen, names[i])) {
       throw _err("attrcert/bad-input", "an attribute certificate must not carry both noRevAvail and a " +
         REVOCATION_POINTERS[names[i]] + " revocation pointer (RFC 5755 sec. 6)");
     }
@@ -762,7 +767,7 @@ function _unsupportedCritical(ac) {
     if (e.critical !== true) continue;
     // Own-property membership, so an extension OID that happens to name something on Object.prototype
     // cannot read as supported.
-    if (!Object.prototype.hasOwnProperty.call(SUPPORTED_CRITICAL, e.oid)) return e.oid;
+    if (!_hasOwn(SUPPORTED_CRITICAL, e.oid)) return e.oid;
     // A supported OID whose value this build could not interpret is still unusable.
     if (e.decoded === null || e.decoded === undefined || e.decoded.opaque === true) return e.oid;
   }
@@ -887,7 +892,7 @@ function _fixVerifyOptions(opts) {
   var revocationStatus = null;
   if (o.revocationStatus !== undefined) {
     if (typeof o.revocationStatus !== "string" ||
-      !Object.prototype.hasOwnProperty.call(REVOCATION_STATUS, o.revocationStatus)) {
+      !_hasOwn(REVOCATION_STATUS, o.revocationStatus)) {
       throw _err("attrcert/bad-input", 'pki.attrcert.verify opts.revocationStatus must be "notRevoked" or "revoked"');
     }
     revocationStatus = o.revocationStatus;
@@ -916,7 +921,7 @@ function _revocationScheme(ac) {
     var e = ac.extensions[i];
     if (e.name === "noRevAvail") out.noRevAvail = true;
     var p = REVOCATION_POINTERS[e.oid];
-    if (p !== undefined && Object.prototype.hasOwnProperty.call(REVOCATION_POINTERS, e.oid)) out.pointer = p;
+    if (p !== undefined && _hasOwn(REVOCATION_POINTERS, e.oid)) out.pointer = p;
   }
   return out;
 }

package/lib/cmc-build.js

@@ -33,6 +33,10 @@ var cmcFmt = require("./schema-cmc");  // to read the assembled message back bef
 var oid = require("./oid");
 var cmsSign = require("./cms-sign");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which controls a request carries.
+var _hasOwn = intrinsic.hasOwn;
 var frameworkError = require("./framework-error");
 
 var CmcError = frameworkError.CmcError;
@@ -710,7 +714,7 @@ function _copySigners(signer, owned) {
     if (!s || typeof s !== "object") return s;
     var out = {}, k;
     for (k in s) {
-      if (!Object.prototype.hasOwnProperty.call(s, k)) continue;
+      if (!_hasOwn(s, k)) continue;
       out[k] = copyValue(s[k], k === "key");
     }
     return out;
@@ -725,7 +729,7 @@ function _copySigners(signer, owned) {
     if (!v || typeof v !== "object" || typeof v.type === "string") return v;   // CryptoKey / scalar
     var c = {}, ck;
     for (ck in v) {
-      if (!Object.prototype.hasOwnProperty.call(v, ck)) continue;
+      if (!_hasOwn(v, ck)) continue;
       var cv = v[ck];
       c[ck] = (Buffer.isBuffer(cv) || cv instanceof Uint8Array) ? _own(Buffer.from(cv), isSecret) : cv;
     }

package/lib/cmc-verify.js

@@ -25,6 +25,10 @@ var cmc = require("./schema-cmc");
 var cmsVerify = require("./cms-verify");   // PD14: the carrier's signature MUST be verified
 var cmsDecrypt = require("./cms-decrypt"); // ... and an AuthenticatedData carrier by its MAC
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which controls a response carries.
+var _hasOwn = intrinsic.hasOwn;
 var frameworkError = require("./framework-error");
 
 var CmcError = frameworkError.CmcError;
@@ -428,7 +432,7 @@ function _copyAnyBytes(v) {
 
 function _snapshotSent(sent) {
   var out = {}, k;
-  for (k in sent) { if (Object.prototype.hasOwnProperty.call(sent, k)) out[k] = sent[k]; }
+  for (k in sent) { if (_hasOwn(sent, k)) out[k] = sent[k]; }
   // Normalized through the SAME authoring guard pki.cmc.build puts an authored
   // integer through. A Transaction Identifier is an unbounded INTEGER on the wire,
   // so one above Number.MAX_SAFE_INTEGER has already been rounded by the time it
@@ -458,7 +462,7 @@ function _snapshotSent(sent) {
   if (out.recipient && typeof out.recipient === "object") {
     var r = {}, rk;
     for (rk in out.recipient) {
-      if (!Object.prototype.hasOwnProperty.call(out.recipient, rk)) continue;
+      if (!_hasOwn(out.recipient, rk)) continue;
       r[rk] = _copyAnyBytes(out.recipient[rk]);
     }
     out.recipient = r;

package/lib/cmp-verify.js

@@ -935,9 +935,9 @@ function _fixTime(v) {
 }
 function _fixVerifyOptions(opts, made) {
   if (opts == null) opts = {};   // ONLY null / undefined -> the default empty opts (a falsy false/0/"" is a bad config, not a default)
-  // Through the toolkit's own options door, which this verb used to skip in favor of its own two
-  // checks. The door does the thing those could not: it REFUSES an options bag whose fields are
-  // accessors, and refuses one that changes which fields it carries while they are read.
+  // Through the toolkit's own options door rather than a pair of local field checks. The door
+  // REFUSES an options bag whose fields are accessors, and refuses one that changes which fields it
+  // carries while they are read; a local check on each field it needs can do neither.
   //
   // That is what closes this whole class rather than one member of it. An accessor is caller code
   // running inside the call, before the verb has done anything, and from there it can rewrite the

package/lib/cms-verify.js

@@ -829,7 +829,7 @@ function _cloneAnchorValue(v, depth) {
   if (Array.isArray(v)) return v.map(function (e) { return _cloneAnchorValue(e, depth + 1); });
   var out = {}, k;
   for (k in v) {
-    if (!Object.prototype.hasOwnProperty.call(v, k)) continue;
+    if (!intrinsic.hasOwn(v, k)) continue;
     out[k] = _cloneAnchorValue(v[k], depth + 1);
   }
   return out;

package/lib/crl-sign.js

@@ -29,6 +29,11 @@ var crlSchema = require("./schema-crl");
 var x509Schema = require("./schema-x509");
 var signScheme = require("./sign-scheme");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Membership is asked through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and either of them answering true admits a name the
+// table never carried -- here, a reason code the CRL profile does not define.
+var _hasOwn = intrinsic.hasOwn;
 var frameworkError = require("./framework-error");
 var pkix = require("./schema-pkix");
 var schema = require("./schema-engine");
@@ -164,10 +169,10 @@ function _resolveReason(reason, isDelta) {
   var codeNum;
   if (typeof reason === "number") codeNum = reason;
   else if (typeof reason === "string") {
-    if (!Object.prototype.hasOwnProperty.call(REASON_BY_NAME, reason)) throw _err("crl/bad-reason-code", "unknown CRLReason " + JSON.stringify(reason));
+    if (!_hasOwn(REASON_BY_NAME, reason)) throw _err("crl/bad-reason-code", "unknown CRLReason " + JSON.stringify(reason));
     codeNum = REASON_BY_NAME[reason];
   } else throw _err("crl/bad-reason-code", "reason must be a CRLReason name or number");
-  if (!Object.prototype.hasOwnProperty.call(CRL_REASON, String(codeNum))) throw _err("crl/bad-reason-code", "undefined or reserved CRLReason " + codeNum + " (RFC 5280 sec. 5.3.1)");
+  if (!_hasOwn(CRL_REASON, String(codeNum))) throw _err("crl/bad-reason-code", "undefined or reserved CRLReason " + codeNum + " (RFC 5280 sec. 5.3.1)");
   if (codeNum === 8 && !isDelta) throw _err("crl/bad-reason-code", "removeFromCRL(8) may appear only in a delta CRL (RFC 5280 sec. 5.3.1)");
   return codeNum;
 }
@@ -284,7 +289,7 @@ function _buildCrlExtensions(spec, ctx) {
       // fixed criticality (assertValidExtension rejects an explicit critical=FALSE, so 3 children == critical,
       // 2 == non-critical) AND a well-formed value of the right type (INTEGER for cRLNumber/deltaCRLIndicator,
       // else a SEQUENCE), never emitted opaque.
-      if (Object.prototype.hasOwnProperty.call(REQUIRED_CRITICALITY, extnId)) {
+      if (_hasOwn(REQUIRED_CRITICALITY, extnId)) {
         if ((node.children.length === 3) !== REQUIRED_CRITICALITY[extnId]) {
           throw _err("crl/bad-input", "pre-encoded " + (oid.name(extnId) || extnId) + " extension has the wrong criticality (RFC 5280 sec. 5.2 requires it " + (REQUIRED_CRITICALITY[extnId] ? "critical" : "non-critical") + ")");
         }
@@ -387,13 +392,13 @@ function _buildRevoked(entryList, isDelta) {
         // RFC 5280 sec. 5.3 -- a recognized entry extension is held to the profile even via the escape hatch:
         // its fixed criticality AND a well-formed value of the right type (reasonCode an ENUMERATED in the
         // legal set, invalidityDate a GeneralizedTime).
-        if (Object.prototype.hasOwnProperty.call(REQUIRED_ENTRY_CRITICALITY, extnId)) {
+        if (_hasOwn(REQUIRED_ENTRY_CRITICALITY, extnId)) {
           if ((xnode.children.length === 3) !== REQUIRED_ENTRY_CRITICALITY[extnId]) throw _err("crl/bad-input", "pre-encoded entry extension " + (oid.name(extnId) || extnId) + " has the wrong criticality (RFC 5280 sec. 5.3 requires it " + (REQUIRED_ENTRY_CRITICALITY[extnId] ? "critical" : "non-critical") + ")");
           var einner = _extInner(xnode, oid.name(extnId) || extnId);
           if (extnId === O("reasonCode")) {
             if (einner.tagClass !== "universal" || einner.tagNumber !== TAGS.ENUMERATED) throw _err("crl/bad-reason-code", "pre-encoded reasonCode value must be an ENUMERATED (RFC 5280 sec. 5.3.1)");
             var rc = asn1.read.enumerated(einner);
-            if (!Object.prototype.hasOwnProperty.call(CRL_REASON, rc.toString())) throw _err("crl/bad-reason-code", "pre-encoded reasonCode " + rc + " is undefined or reserved (RFC 5280 sec. 5.3.1)");
+            if (!_hasOwn(CRL_REASON, rc.toString())) throw _err("crl/bad-reason-code", "pre-encoded reasonCode " + rc + " is undefined or reserved (RFC 5280 sec. 5.3.1)");
             if (rc === 8n && !isDelta) throw _err("crl/bad-reason-code", "removeFromCRL(8) may appear only in a delta CRL (RFC 5280 sec. 5.3.1)");
           } else if (extnId === O("invalidityDate")) {
             if (einner.tagClass !== "universal" || einner.tagNumber !== TAGS.GENERALIZED_TIME) throw _err("crl/bad-input", "pre-encoded invalidityDate value must be a GeneralizedTime (RFC 5280 sec. 5.3.2)");

package/lib/ct.js

@@ -44,6 +44,11 @@ var asn1 = require("./asn1-der.js");
 var constants = require("./constants.js");
 var frameworkError = require("./framework-error.js");
 var guard = require("./guard-all.js");
+var intrinsic = require("./guard-intrinsic.js");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides whether a log state is one this
+// toolkit trusts -- answering true for a name the table never carried trusts an untrusted log.
+var _hasOwn = intrinsic.hasOwn;
 var ByteReader = require("./byte-reader.js");
 var ByteWriter = require("./byte-writer.js");
 var oid = require("./oid.js");
@@ -650,7 +655,7 @@ var LOG_STATE_TRUST = { pending: "no", qualified: "yes", usable: "yes", readonly
 function _parseLogState(state) {
   if (state == null || typeof state !== "object") throw _ctErr("ct/bad-state", "a CT log entry is missing its state");
   var keys = Object.keys(state);
-  if (keys.length !== 1 || !Object.prototype.hasOwnProperty.call(LOG_STATE_TRUST, keys[0])) {
+  if (keys.length !== 1 || !_hasOwn(LOG_STATE_TRUST, keys[0])) {
     throw _ctErr("ct/bad-state", "a CT log state must carry exactly one recognized member (pending/qualified/usable/readonly/retired/rejected)");
   }
   var name = keys[0], member = state[name];

package/lib/est.js

@@ -72,6 +72,10 @@ var OID_CMC_DATA_RETURN = oid.byName("id-cmc-dataReturn");
 var crmfFmt = require("./schema-crmf");
 var frameworkError = require("./framework-error");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load: written out it reads two replaceable
+// properties to answer one question, and here it decides which fields of a response are copied.
+var _hasOwn = intrinsic.hasOwn;
 var httpTransport = require("./http-transport");
 var httpDigest = require("./http-digest");
 var retryAfter = require("./http-retry-after");
@@ -1592,7 +1596,7 @@ function _assertAgrees(name, supplied, carried) {
 function _copyRecipient(r) {
   if (!r || typeof r !== "object") return r;
   var out = {}, k;
-  for (k in r) { if (Object.prototype.hasOwnProperty.call(r, k)) out[k] = _copyBytes(r[k]); }
+  for (k in r) { if (_hasOwn(r, k)) out[k] = _copyBytes(r[k]); }
   return out;
 }
 
@@ -1606,10 +1610,10 @@ function _copyRecipient(r) {
 // transport function, a tls config).
 function _shallowCopy(o) {
   var out = {}, k;
-  for (k in o) { if (Object.prototype.hasOwnProperty.call(o, k)) out[k] = o[k]; }
+  for (k in o) { if (_hasOwn(o, k)) out[k] = o[k]; }
   if (out.auth && typeof out.auth === "object") {
     var a = {}, ak;
-    for (ak in out.auth) { if (Object.prototype.hasOwnProperty.call(out.auth, ak)) a[ak] = out.auth[ak]; }
+    for (ak in out.auth) { if (_hasOwn(out.auth, ak)) a[ak] = out.auth[ak]; }
     out.auth = a;
   }
   return out;

package/lib/hpke.js

@@ -27,6 +27,10 @@
 var nodeCrypto = require("crypto");
 var frameworkError = require("./framework-error");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which suite parameters are read.
+var _hasOwn = intrinsic.hasOwn;
 
 var HpkeError = frameworkError.HpkeError;
 function _err(code, message, cause) { return new HpkeError(code, message, cause); }
@@ -423,7 +427,7 @@ function _mode(opts, keys, who) {
   guard.identifier.assertKnownKeys(opts, keys, _err, "hpke/bad-input", function (k) {
     var other = (keys === _SETUP_S_KEYS ? _SETUP_R_KEYS : _SETUP_S_KEYS);
     return "unknown HPKE " + who + " option " + JSON.stringify(k) +
-      (Object.prototype.hasOwnProperty.call(other, k)
+      (_hasOwn(other, k)
         ? " -- that option belongs to the other end of the exchange, where it would authenticate or seed; here it would do nothing"
         : "") + " -- accepted: " + Object.keys(keys).sort().join(", ");
   });

package/lib/http-digest.js

@@ -14,14 +14,24 @@
 
 var crypto = require("crypto");
 var constants = require("./constants");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides whether an auth-param repeats --
+// answering false lets the second copy of a nonce overwrite the first.
+var _hasOwn = intrinsic.hasOwn;
 
 // Algorithm registry, a data row and not a switch: rank orders the RFC 7616 sec. 3.7
 // "most secure the client can use" selection (SHA-512-256 > SHA-256 > MD5); an unknown algorithm ranks 0.
-var ALGS = {
+//
+// Null prototype, because the gate on an unknown algorithm is `if (!ALGS[name])`. With an ordinary
+// object literal that question is asked of the prototype chain too, so an algorithm named for any
+// member of Object.prototype answers with a truthy value the table never carried: the
+// unsupported-algorithm refusal is skipped and the descriptor's own fields read as undefined.
+var ALGS = intrinsic.assign(intrinsic.create(null), {
   "SHA-512-256": { hash: "sha512-256", rank: 3, sess: false }, "SHA-512-256-SESS": { hash: "sha512-256", rank: 3, sess: true },
   "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 = {
   unsupportedAlgorithm: "digest/unsupported-algorithm", weakAlgorithm: "digest/weak-algorithm",
   noQop: "digest/no-qop", badChallenge: "digest/bad-challenge",
@@ -110,7 +120,7 @@ function _parseParams(paramText, E, code) {
     var rawVal = seg.slice(eq + 1).replace(/^\s+|\s+$/g, "");
     var quoted = rawVal.charAt(0) === "\"";
     if (quoted && !_closedQuote(rawVal)) throw E(code, "an unterminated or trailing-garbage Digest quoted-string (RFC 7230 sec. 3.2.6)");
-    if (Object.prototype.hasOwnProperty.call(map, key)) throw E(code, "repeated Digest auth-param " + JSON.stringify(key));
+    if (_hasOwn(map, key)) throw E(code, "repeated Digest auth-param " + JSON.stringify(key));
     var value = quoted ? _unq(rawVal) : rawVal;
     // Reject a control octet in any value (CR / LF / NUL / ...): it is a MUST-reject per RFC 7230 qdtext AND a
     // header-injection sink -- an unescaped CR/LF reflected into the outgoing Authorization would split the header.

package/lib/path-validate.js

@@ -771,7 +771,7 @@ function isSubtreeBaseValid(tag, base) {
     case 1: case 2: case 6: return typeof base === "string";                       // rfc822Name / dNSName / URI
     case 7: return (Buffer.isBuffer(base) || base instanceof Uint8Array) &&
                    (base.length === 8 || base.length === 32);                      // iPAddress: address + mask
-    case 4: return base !== null && typeof base === "object" && !!base.rdns && Array.isArray(base.rdns);   // directoryName
+    case 4: return base !== null && typeof base === "object" && !!base.rdns && intrinsic.isArray(base.rdns);   // directoryName
     default: return base !== undefined;
   }
 }
@@ -782,7 +782,7 @@ function isSubtreeBaseValid(tag, base) {
 // disabling the constraint the caller configured -- so it throws instead.
 function checkedSubtreeSeeds(list, optName) {
   if (list === undefined || list === null) return [];
-  if (!Array.isArray(list)) throw E("path/bad-input", "validate: opts." + optName + " must be an array of { tag, base } subtree entries");
+  if (!intrinsic.isArray(list)) throw E("path/bad-input", "validate: opts." + optName + " must be an array of { tag, base } subtree entries");
   return list.map(function (st) {
     if (!st || typeof st !== "object" || !Number.isInteger(st.tag) || st.tag < 0 || st.tag > 8 || !isSubtreeBaseValid(st.tag, st.base)) {
       throw E("path/bad-input", "validate: opts." + optName + " entries must be { tag: <GeneralName tag number 0..8>, base: <that form's constraint value> }");
@@ -1217,7 +1217,7 @@ async function validate(path, opts) {
   guard.identifier.assertKnownKeys(opts, _VALIDATE_OPTS, E, "path/bad-input",
     "pki.path.validate has an unknown option. The anchor here is `trustAnchor`, singular; " +
     "pki.path.build takes `trustAnchors`. The unknown option was: ");
-  if (!Array.isArray(path)) throw E("path/bad-input", "validate: path must be an array of certificates");
+  if (!intrinsic.isArray(path)) throw E("path/bad-input", "validate: path must be an array of certificates");
   // Bound the per-cert asymmetric-verify work BEFORE parsing an untrusted bundle
   // (the policy-tree cap guards CVE-2023-0464-style blow-up; this guards linear
   // crypto amplification from an oversized path). Entry-point tier: throw.
@@ -1242,7 +1242,7 @@ async function validate(path, opts) {
   // Membership is tested with indexOf, so a raw string here would be consulted
   // as a SUBSTRING match -- validated to an array of strings instead.
   if (opts.userInitialPolicySet !== undefined) {
-    var uipsOk = Array.isArray(opts.userInitialPolicySet) && opts.userInitialPolicySet.length > 0 &&
+    var uipsOk = intrinsic.isArray(opts.userInitialPolicySet) && opts.userInitialPolicySet.length > 0 &&
       guard.list.allMatch(opts.userInitialPolicySet, function (p) { return typeof p === "string" && p.length > 0; });
     if (!uipsOk) throw E("path/bad-input", "validate: opts.userInitialPolicySet must be a non-empty array of policy OID strings");
     // Each entry is compared (indexOf) against canonical decoder output, so a
@@ -2643,7 +2643,7 @@ function assertAnchorConstraints(ta, checkPurpose) {
 function resolvePurposeOpts(opts) {
   var requiredEku = null;
   if (opts.requiredEku !== undefined) {
-    if (!Array.isArray(opts.requiredEku) || opts.requiredEku.length === 0) {
+    if (!intrinsic.isArray(opts.requiredEku) || opts.requiredEku.length === 0) {
       throw E("path/bad-input", "validate: opts.requiredEku must be a non-empty array of key-purpose OID names or dotted OID strings");
     }
     requiredEku = opts.requiredEku.map(function (p) {
@@ -2679,7 +2679,7 @@ function toAnchor(entry) {
     // (name matching), publicKey bytes and the algorithm OID (the sec. 6.1.4 key
     // hand-off). trustAnchors is a caller option, so a malformed tuple is a config
     // error and fails closed at entry, not a downstream no-path / soft verdict.
-    if (!Array.isArray(entry.name.rdns) || !Buffer.isBuffer(entry.publicKey) || typeof entry.algorithm !== "string") {
+    if (!intrinsic.isArray(entry.name.rdns) || !Buffer.isBuffer(entry.publicKey) || typeof entry.algorithm !== "string") {
       throw E("path/bad-input", "build: a trustAnchor tuple must be { name: { rdns: [...] }, publicKey: Buffer, algorithm: OID string }");
     }
     return entry;
@@ -2972,7 +2972,7 @@ async function build(leaf, opts) {
 
   var poolInput = opts.candidates !== undefined ? opts.candidates : opts.intermediates;
   if (poolInput === undefined) poolInput = [];
-  if (!Array.isArray(poolInput)) throw E("path/bad-input", "build: opts.candidates must be an array of certificates");
+  if (!intrinsic.isArray(poolInput)) throw E("path/bad-input", "build: opts.candidates must be an array of certificates");
   // A pool larger than the absolute ceiling is rejected at entry (bounds the
   // parse work on an untrusted bundle) -- distinct from the per-search tick
   // budget below, which an operator may set lower to cap the DFS.
@@ -2987,7 +2987,7 @@ async function build(leaf, opts) {
   var poolDerKeys = new Set();
   for (var pdk = 0; pdk < pool.length; pdk++) intrinsic.setAdd(poolDerKeys, certDerKey(pool[pdk]));
 
-  if (!Array.isArray(opts.trustAnchors) || opts.trustAnchors.length === 0) throw E("path/bad-input", "build: opts.trustAnchors must be a non-empty array of anchor tuples or root certificates");
+  if (!intrinsic.isArray(opts.trustAnchors) || opts.trustAnchors.length === 0) throw E("path/bad-input", "build: opts.trustAnchors must be a non-empty array of anchor tuples or root certificates");
   var anchors = opts.trustAnchors.map(toAnchor);
 
   guard.time.assertValid(opts.time, E, "path/bad-input", "build: opts.time (the validity-window check date, forwarded to validate)");
@@ -3081,7 +3081,7 @@ async function build(leaf, opts) {
   // supplied and `opts.softFail` answers for it. Own membership decides only whether a name is
   // build-only, which is a question about this module's own table and never about the caller.
   Object.keys(_VALIDATE_OPTS).forEach(function (k) {
-    if (Object.prototype.hasOwnProperty.call(BUILD_ONLY_OPT, k)) return;
+    if (intrinsic.hasOwn(BUILD_ONLY_OPT, k)) return;
     if (k in opts) forwarded[k] = opts[k];
   });
   function validateOpts(anchor) {

package/lib/pki-build.js

@@ -14,6 +14,10 @@ var asn1 = require("./asn1-der");
 var schema = require("./schema-engine");
 var compositeSig = require("./composite-sig");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Each of these doors refuses a caller argument that is not a list. Read live, a replacement
+// answering true lets a non-list through the check written to stop it.
+var _isArray = intrinsic.isArray;
 var oid = require("./oid");
 var ipUtils = require("./ip-utils");
 var nodeCrypto = require("crypto");
@@ -83,7 +87,7 @@ function makeBuilder(ctx) {
   function encodeName(spec) {
     if (Buffer.isBuffer(spec)) { assertValidNameDer(spec); return spec; }
     if (typeof spec === "string") spec = [{ commonName: spec }];
-    if (!Array.isArray(spec)) throw E("bad-name", "a name must be a string, an array of RDNs, or raw Name DER");
+    if (!_isArray(spec)) throw E("bad-name", "a name must be a string, an array of RDNs, or raw Name DER");
     return b.sequence(spec.map(encodeRdn));
   }
   // Full validation of a raw Name DER: walk it through the exact RDNSequence parser the decoder uses.
@@ -161,7 +165,7 @@ function makeBuilder(ctx) {
 
   // ---- extension-value encoders (the inverse of certExtensionDecoders) ----
   function extKeyUsage(names) {
-    if (!Array.isArray(names) || !names.length) throw E("bad-input", "keyUsage must assert at least one bit (RFC 5280 sec. 4.2.1.3)");
+    if (!_isArray(names) || !names.length) throw E("bad-input", "keyUsage must assert at least one bit (RFC 5280 sec. 4.2.1.3)");
     var positions = names.map(function (n) {
       var pos = KU_BIT[n];
       if (pos == null) throw E("bad-input", "unknown keyUsage bit " + JSON.stringify(n));
@@ -187,7 +191,7 @@ function makeBuilder(ctx) {
     throw E("bad-input", "unknown " + label + " " + JSON.stringify(n) + " (expected a registered name or a dotted-decimal OID)");
   }
   function extExtKeyUsage(names) {
-    if (!Array.isArray(names) || !names.length) throw E("bad-input", "extendedKeyUsage must list at least one KeyPurposeId");
+    if (!_isArray(names) || !names.length) throw E("bad-input", "extendedKeyUsage must list at least one KeyPurposeId");
     return b.sequence(names.map(function (n) { return b.oid(_resolveOid(n, "extendedKeyUsage purpose")); }));
   }
   function validateBcSpec(bc) {
@@ -214,14 +218,14 @@ function makeBuilder(ctx) {
   // RoleSyntax.roleAuthority [0], IetfAttrSyntax.policyAuthority [0]); the [n] node's children ARE the
   // GeneralName members, no inner SEQUENCE wrapper.
   function encodeGeneralNames(entries, implicitTag) {
-    if (!Array.isArray(entries) || !entries.length) throw E("bad-input", "a GeneralNames must carry at least one GeneralName");
+    if (!_isArray(entries) || !entries.length) throw E("bad-input", "a GeneralNames must carry at least one GeneralName");
     var members = entries.map(encodeGeneralName);
     if (implicitTag == null) return b.sequence(members);
     return b.contextConstructed(implicitTag, Buffer.concat(members));
   }
   function extSan(entries) { return encodeGeneralNames(entries); }
   function extCertPolicies(names) {
-    if (!Array.isArray(names) || !names.length) throw E("bad-input", "certificatePolicies must list at least one policy OID");
+    if (!_isArray(names) || !names.length) throw E("bad-input", "certificatePolicies must list at least one policy OID");
     var seen = {};
     return b.sequence(names.map(function (n) {
       var pOid = _resolveOid(n, "certificate policy");
@@ -301,7 +305,7 @@ function makeBuilder(ctx) {
   };
   function requestedExtensions(extSpec, spki) {
     var EXT_DECODERS = ctx.EXT_DECODERS;
-    if (Array.isArray(extSpec)) {
+    if (_isArray(extSpec)) {
       if (!extSpec.length) throw E("bad-input", "the requested extensions list must carry at least one extension");
       var seen = {};
       return b.sequence(extSpec.map(function (e, i) {

package/lib/schema-attrcert.js

@@ -39,6 +39,10 @@ var schema = require("./schema-engine");
 var pkix = require("./schema-pkix");
 var oid = require("./oid");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which object-digest types resolve.
+var _hasOwn = intrinsic.hasOwn;
 var frameworkError = require("./framework-error");
 
 var AttrCertError = frameworkError.AttrCertError;
@@ -69,7 +73,7 @@ var ODT_NAMES = constants.NAMES.OBJECT_DIGEST_TYPE;
 var DIGESTED_OBJECT_TYPE = schema.decode(function (n, ctx) {
   var v = asn1.read.enumerated(n);
   var k = v.toString();
-  if (!Object.prototype.hasOwnProperty.call(ODT_NAMES, k)) {
+  if (!_hasOwn(ODT_NAMES, k)) {
     throw ctx.E("attrcert/bad-digested-object-type", "digestedObjectType " + k + " is not a defined value (RFC 5755 sec. 4.1)");
   }
   // RFC 5755 sec. 7.3 -- a conformant AC MUST NOT use otherObjectTypes(2); the digested

package/lib/schema-crl.js

@@ -28,6 +28,10 @@ var schema = require("./schema-engine");
 var pkix = require("./schema-pkix");
 var oid = require("./oid");
 var frameworkError = require("./framework-error");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which CRLReason values are defined.
+var _hasOwn = intrinsic.hasOwn;
 
 var CrlError = frameworkError.CrlError;
 var PemError = frameworkError.PemError;
@@ -77,7 +81,7 @@ function decodeExt(ext) {
       // read.enumerated asserts the ENUMERATED tag (a bare INTEGER is rejected) --
       // the codec owns the tag check, so this reader need not repeat it.
       var reason = asn1.read.enumerated(asn1.decode(ext.value));
-      if (!Object.prototype.hasOwnProperty.call(CRL_REASONS, reason.toString())) throw new Error("undefined CRLReason " + reason.toString());
+      if (!_hasOwn(CRL_REASONS, reason.toString())) throw new Error("undefined CRLReason " + reason.toString());
       value = Number(reason);
     } else if (ext.oid === OID_INVALIDITY_DATE) { // invalidityDate ::= GeneralizedTime
       var n = asn1.decode(ext.value);

package/lib/schema-ocsp.js

@@ -39,6 +39,11 @@ var pkix = require("./schema-pkix");
 var oid = require("./oid");
 var constants = require("./constants");
 var frameworkError = require("./framework-error");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which response statuses and
+// revocation reasons are defined -- an admitted name names a status RFC 6960 never assigned.
+var _hasOwn = intrinsic.hasOwn;
 
 var OcspError = frameworkError.OcspError;
 var PemError = frameworkError.PemError;
@@ -85,7 +90,7 @@ var GENERALIZED_TIME = pkix.generalizedTime(NS, { code: "ocsp/bad-time", message
 var OCSP_RESPONSE_STATUS = schema.decode(function (n, ctx) {
   var v = asn1.read.enumerated(n);
   var key = v.toString();
-  if (!Object.prototype.hasOwnProperty.call(STATUS_NAMES, key)) throw ctx.E("ocsp/bad-response-status", "undefined OCSPResponseStatus " + key + " (RFC 6960 sec. 4.2.1)");
+  if (!_hasOwn(STATUS_NAMES, key)) throw ctx.E("ocsp/bad-response-status", "undefined OCSPResponseStatus " + key + " (RFC 6960 sec. 4.2.1)");
   return { code: Number(v), name: STATUS_NAMES[key] };
 });
 
@@ -93,7 +98,7 @@ var OCSP_RESPONSE_STATUS = schema.decode(function (n, ctx) {
 var CRL_REASON = schema.decode(function (n, ctx) {
   var v = asn1.read.enumerated(n);
   var key = v.toString();
-  if (!Object.prototype.hasOwnProperty.call(CRL_REASONS, key)) throw ctx.E("ocsp/bad-revocation-reason", "undefined CRLReason " + key + " (RFC 5280 sec. 5.3.1)");
+  if (!_hasOwn(CRL_REASONS, key)) throw ctx.E("ocsp/bad-revocation-reason", "undefined CRLReason " + key + " (RFC 5280 sec. 5.3.1)");
   return CRL_REASONS[key];
 });
 

package/lib/schema-pkix.js

@@ -17,6 +17,11 @@ var asn1 = require("./asn1-der");
 var constants = require("./constants");
 var schema = require("./schema-engine");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which version numbers a format
+// accepts -- shared by every format module, so one admitted name widens all of them at once.
+var _hasOwn = intrinsic.hasOwn;
 // ct is a leaf format module (requires only the codec / oid / constants / error
 // core, never pkix) so the SCT-list extension VALUE decoder registers here as a
 // registry row, not a switch. The one-directional edge keeps the layering acyclic.
@@ -174,7 +179,7 @@ function makeNS(prefix, ErrorClass, oidModule) {
 function versionReader(ns, accept) {
   return schema.decode(function (n) {
     var key = asn1.read.integer(n).toString();
-    if (Object.prototype.hasOwnProperty.call(accept, key)) return accept[key];
+    if (_hasOwn(accept, key)) return accept[key];
     throw ns.E(ns.prefix + "/bad-version", "unsupported version " + key);
   });
 }

package/lib/tls-cert-compress.js

@@ -52,6 +52,10 @@
 
 var C = require("./constants");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which algorithms are supported.
+var _hasOwn = intrinsic.hasOwn;
 var frameworkError = require("./framework-error");
 var validator = require("./validator-all");
 var ByteWriter = require("./byte-writer");
@@ -88,7 +92,7 @@ var LEVEL_OPT = {
 // guard on this runtime. An algorithm the guard cannot decompress must never be offered
 // or accepted: advertising one would mean accepting a message we then cannot open.
 var SUPPORTED = guard.compress.algorithms().filter(function (n) {
-  return Object.prototype.hasOwnProperty.call(ALG_BY_NAME, n) && typeof COMPRESS[n] === "function";
+  return _hasOwn(ALG_BY_NAME, n) && typeof COMPRESS[n] === "function";
 });
 
 // The minimum Certificate message size and the widest opaque<..2^24-1> vector, both owned

package/lib/trust.js

@@ -40,6 +40,10 @@ var constants = require("./constants");
 var errors = require("./framework-error");
 var asn1 = require("./asn1-der");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which trust bits an anchor carries.
+var _hasOwn = intrinsic.hasOwn;
 var x509 = require("./schema-x509");
 
 var TrustError = errors.TrustError;
@@ -604,7 +608,7 @@ function _trustBits(cell) {
     var t = tok.trim();
     if (t === "") return;
     var l = t.toLowerCase();
-    if (!Object.prototype.hasOwnProperty.call(_TRUST_BIT_TOKENS, l)) {
+    if (!_hasOwn(_TRUST_BIT_TOKENS, l)) {
       throw E("trust/bad-csv", "unrecognized Trust Bits token " + JSON.stringify(t));
     }
     var p = _TRUST_BIT_TOKENS[l];

package/lib/webauthn-mds.js

@@ -22,6 +22,10 @@
 var frameworkError = require("./framework-error");
 var x509 = require("./schema-x509");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which status rows an entry carries.
+var _hasOwn = intrinsic.hasOwn;
 var jose = require("./jose");
 var rfc3339 = require("./rfc3339");
 var constants = require("./constants");
@@ -348,7 +352,7 @@ function _verifyMetadataBlob(blob, opts) {
   // reader that skips the list accepts a token on terms it never met. Nothing here processes an
   // extension parameter, so any name is unprocessed, including a standard name, which sec. 4.1.11
   // forbids listing at all.
-  if (Object.prototype.hasOwnProperty.call(header, "crit")) {
+  if (_hasOwn(header, "crit")) {
     var crit = header.crit;
     if (!Array.isArray(crit) || crit.length === 0) {
       throw _err("webauthn/bad-metadata-blob", "the metadata BLOB header crit must be a non-empty array (RFC 7515 sec. 4.1.11)");

package/lib/webauthn.js

@@ -34,6 +34,10 @@ var constants = require("./constants");
 var validator = require("./validator-all");
 var edwardsPoint = require("./edwards-point");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load: written out it reads two replaceable
+// properties to answer one question, and either answering true admits a name the table never had.
+var _hasOwn = intrinsic.hasOwn;
 var jose = require("./jose");
 var mds = require("./webauthn-mds");
 var nodeCrypto = require("crypto");
@@ -2220,7 +2224,7 @@ 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;
-  for (k in input) { if (Object.prototype.hasOwnProperty.call(input, k)) out[k] = input[k]; }
+  for (k in input) { if (_hasOwn(input, k)) out[k] = input[k]; }
   // The SAME set of byte forms the arguments accept. A snapshot list narrower than the accept list
   // leaves whatever falls in the gap aliased across the yield -- which is the one input a widened
   // accept list newly admits, so the two must be written from one predicate.
@@ -2237,7 +2241,7 @@ function _snapshotAssertion(input) {
   } else if (_isPlainObject(out.credentialPublicKey)) {
     var key = {}, kk;
     for (kk in out.credentialPublicKey) {
-      if (!Object.prototype.hasOwnProperty.call(out.credentialPublicKey, kk)) continue;
+      if (!_hasOwn(out.credentialPublicKey, kk)) continue;
       // The read itself can fault: a stored key is a caller-supplied object, so a field may be an
       // accessor, and one that THROWS would escape as a raw error from the very copy whose job is
       // to make the descriptor stop being the caller's. The copy is the boundary, so the fault is

package/lib/x509-sign.js

@@ -27,6 +27,11 @@ var oid = require("./oid");
 var x509 = require("./schema-x509");
 var signScheme = require("./sign-scheme");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// This test picks which FORM the caller's extension spec is in, so it decides which fields are read
+// and therefore what is signed into the certificate. Read live, a replacement answering true sends
+// an object down the list arm and the extensions it carries are never seen.
+var _isArray = intrinsic.isArray;
 var frameworkError = require("./framework-error");
 var schema = require("./schema-engine");
 var pkix = require("./schema-pkix");
@@ -112,7 +117,7 @@ function _akiKeyId(val, ctx) {
 // Extension DER buffers). Enforces the RFC 5280 CA cross-field gates, then emits a deterministic order.
 function _buildExtensions(extSpec, ctx) {
   if (extSpec == null) return [];
-  if (Array.isArray(extSpec)) {
+  if (_isArray(extSpec)) {
     // Validate each pre-encoded extension, reject a duplicate extnID (RFC 5280 sec. 4.2 allows at most one
     // instance of an extension), and decode basicConstraints + keyUsage to apply the same CA
     // cross-field rules the object form enforces (below), so the array escape hatch cannot bypass them.
@@ -161,7 +166,7 @@ function _buildExtensions(extSpec, ctx) {
   if (bc != null) _validateBcSpec(bc);
   var caTrue = !!(bc && bc.cA === true);
   var ku = extSpec.keyUsage;
-  var assertsKeyCertSign = Array.isArray(ku) && ku.indexOf("keyCertSign") >= 0;
+  var assertsKeyCertSign = _isArray(ku) && ku.indexOf("keyCertSign") >= 0;
   // RFC 5280 sec. 4.2.1.3 -- keyCertSign requires basicConstraints cA=TRUE.
   if (assertsKeyCertSign && !caTrue) throw _err("x509/bad-input", "keyUsage keyCertSign requires basicConstraints cA=TRUE (RFC 5280 sec. 4.2.1.3)");
   // RFC 5280 sec. 4.2.1.9 -- pathLenConstraint requires cA=TRUE AND keyCertSign.
@@ -217,7 +222,7 @@ function _assertIssuerIsCa(issuerCert) {
 // pre-encoded array extensions form (used to honor a supplied issuer's pathLenConstraint).
 function _issuedCaInfo(extSpec) {
   if (extSpec == null) return { cA: false, pathLen: null };
-  if (!Array.isArray(extSpec)) {
+  if (!_isArray(extSpec)) {
     var bc = extSpec.basicConstraints;
     return { cA: !!(bc && bc.cA === true), pathLen: bc && bc.pathLen != null ? Number(bc.pathLen) : null };
   }
@@ -234,7 +239,7 @@ function _issuedCaInfo(extSpec) {
 // is decoded to look for an Extension whose extnID is subjectAltName with a TRUE critical flag.
 function _hasCriticalSan(extSpec) {
   if (extSpec == null) return false;
-  if (!Array.isArray(extSpec)) return !!extSpec.subjectAltName;
+  if (!_isArray(extSpec)) return !!extSpec.subjectAltName;
   var sanOid = O("subjectAltName");
   for (var i = 0; i < extSpec.length; i++) {
     var n = asn1.decode(_reqDer(extSpec[i], "extension"));
@@ -362,17 +367,23 @@ function _sign(spec, issuer, opts) {
   if (guard.time.instantOf(spec.notBefore) > guard.time.instantOf(spec.notAfter)) throw _err("x509/bad-input", "notBefore must not be after notAfter (RFC 5280 sec. 4.1.2.5)");
   var validityDer = b.sequence([_timeDer(spec.notBefore, "notBefore"), _timeDer(spec.notAfter, "notAfter")]);
 
-  var exts = _buildExtensions(spec.extensions, { spki: spki, issuerSpki: issuerSpki, issuerCert: issuerCert, subjectEmpty: subjectEmpty });
+  // Read ONCE. Three separate consumers test which form this spec is in -- the encoder, the
+  // empty-subject rule below and the path-length rule under it -- and each answering for its own
+  // read is three chances to answer differently about one certificate. The door deep-copies the
+  // spec, so today they cannot disagree; taking the value once means they still cannot if the
+  // shape of that door ever changes.
+  var extSpec = spec.extensions;
+  var exts = _buildExtensions(extSpec, { spki: spki, issuerSpki: issuerSpki, issuerCert: issuerCert, subjectEmpty: subjectEmpty });
   // RFC 5280 sec. 4.1.2.6 -- an empty subject requires a critical subjectAltName (recognized in both the
   // object form and a pre-encoded array-form extension).
-  if (subjectEmpty && !_hasCriticalSan(spec.extensions)) {
+  if (subjectEmpty && !_hasCriticalSan(extSpec)) {
     throw _err("x509/bad-input", "an empty subject requires a critical subjectAltName (RFC 5280 sec. 4.1.2.6)");
   }
   // Honor a supplied issuer's pathLenConstraint (RFC 5280 sec. 4.2.1.9): a CA certificate issued below
   // it consumes one unit of path length, so pathLen=0 forbids issuing a CA below it, and an issued CA's
   // own pathLenConstraint must leave room within the issuer's remaining depth.
   if (issuerPathLen != null) {
-    var issued = _issuedCaInfo(spec.extensions);
+    var issued = _issuedCaInfo(extSpec);
     // A self-issued CA certificate (subject == issuer, e.g. a CA key rollover) does NOT consume path
     // length (RFC 5280 sec. 6.1 counts only non-self-issued intermediates), so it is permitted even at
     // pathLen 0. Compare canonically (sec. 7.1) via the parsed RDN sequences.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/pki",
-  "version": "0.5.21",
+  "version": "0.5.23",
   "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:353e5368-910e-4a85-a222-14a2add84cee",
+  "serialNumber": "urn:uuid:efde95e7-f09e-4942-88b0-af9566cae79a",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-08-21T02:50:54.975Z",
+    "timestamp": "2026-08-21T04:42:14.069Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/pki@0.5.21",
+      "bom-ref": "@blamejs/pki@0.5.23",
       "type": "application",
       "name": "pki",
-      "version": "0.5.21",
+      "version": "0.5.23",
       "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.5.21",
+      "purl": "pkg:npm/%40blamejs/pki@0.5.23",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/pki@0.5.21",
+      "ref": "@blamejs/pki@0.5.23",
       "dependsOn": []
     }
   ]