@blamejs/pki 0.8.12 → 0.8.15

package/lib/http-transport.js

@@ -279,10 +279,10 @@ function _copyableArray(a) {
 function snapshotProxy(p) {
   try {
     if (!_copyableRecord(p)) return p;
-    var out = Object.assign(Object.create(null), p);
-    if (_copyableRecord(p.auth)) out.auth = Object.assign(Object.create(null), p.auth);
+    var out = guard.identifier.ownOptions(p);
+    if (_copyableRecord(p.auth)) out.auth = guard.identifier.ownOptions(p.auth);
     if (_copyableRecord(p.tls)) {
-      out.tls = Object.assign(Object.create(null), p.tls);
+      out.tls = guard.identifier.ownOptions(p.tls);
       var a = p.tls.anchors;
       if (_copyableArray(a)) {
         var copied = [];
@@ -492,7 +492,7 @@ function httpsTransport(defaults) {
     var bodyIsFn = typeof body === "function";
     if (!bodyIsFn && guard.bytes.isByteSource(body)) body = guard.bytes.source(body, E, C("bad-input"), "the request body");
 
-    var reqHeaders = Object.assign(Object.create(null), request.headers || {});
+    var reqHeaders = guard.identifier.ownOptions(request.headers);
     Object.keys(reqHeaders).forEach(function (k) { var lk = k.toLowerCase(); if (lk === "proxy-authorization" || lk === "proxy-connection") delete reqHeaders[k]; });
     if (bodyIsFn) {
       Object.keys(reqHeaders).forEach(function (k) { var lk = k.toLowerCase(); if (lk === "content-length" || lk === "transfer-encoding" || lk === "expect") delete reqHeaders[k]; });
@@ -609,8 +609,7 @@ function httpsTransport(defaults) {
               if (settled) return;
               settled = true;
               clearTimer();
-              var lower = Object.create(null);
-              Object.keys(res.headers || {}).forEach(function (k) { lower[k.toLowerCase()] = res.headers[k]; });
+              var lower = guard.header.lowerCased(res.headers);
               resolve({
                 status: res.statusCode,
                 headers: lower,

package/lib/identity-match.js

@@ -199,9 +199,10 @@ function _reference(r, index) {
  * afterwards would otherwise name an identity nothing compared. A string is already a value; bytes
  * are the copy taken at the door. */
 function _reported(record) {
-  var out = intrinsic.create(null), k;
-  for (k in record) {
-    if (intrinsic.hasOwn(record, k) && record[k] !== undefined) out[k] = record[k];
+  var out = intrinsic.create(null);
+  var names = guard.identifier.optionNames(record);
+  for (var i = 0; i < names.length; i++) {
+    if (record[names[i]] !== undefined) out[names[i]] = record[names[i]];
   }
   return intrinsic.freeze(out);
 }

package/lib/ocsp.js

@@ -390,7 +390,10 @@ function _snapshotSignerKey(key, owned) {
     return copy;
   }
   if (key && typeof key === "object" && (key.mldsa != null || key.trad != null)) {
-    return Object.assign({}, key, { mldsa: _snapshotSignerKey(key.mldsa, owned), trad: _snapshotSignerKey(key.trad, owned) });
+    var ks = guard.identifier.ownOptions(key);
+    ks.mldsa = _snapshotSignerKey(key.mldsa, owned);
+    ks.trad = _snapshotSignerKey(key.trad, owned);
+    return ks;
   }
   return key;
 }
@@ -925,8 +928,7 @@ function httpRequest(der, responderUrl, opts) {
 var HTTP_REQUEST_OPTS = Object.assign(Object.create(null), { method: 1 });
 
 function _frozenHeaders(h) {
-  var out = Object.create(null), k;
-  for (k in h) { if (Object.prototype.hasOwnProperty.call(h, k)) out[k] = h[k]; }
+  var out = guard.identifier.ownOptions(h);
   return Object.freeze(out);
 }
 

package/lib/oid.js

@@ -217,7 +217,7 @@ var FAMILIES = Object.assign(Object.create(null), {
     hmacWithSHA1: 7, hmacWithSHA224: 8, hmacWithSHA256: 9,
     hmacWithSHA384: 10, hmacWithSHA512: 11 } },
 
-  smimeCt: { base: [1, 2, 840, 113549, 1, 9, 16, 1], of: { authData: 2, tSTInfo: 4, compressedData: 9, encKeyWithID: 21, authEnvelopedData: 23 } },
+  smimeCt: { base: [1, 2, 840, 113549, 1, 9, 16, 1], of: { authData: 2, tSTInfo: 4, compressedData: 9, encKeyWithID: 21, authEnvelopedData: 23, trustAnchorList: 34 } },
 
   smimeOri: { base: [1, 2, 840, 113549, 1, 9, 16, 13], of: { kem: 3 } },
 

package/lib/path-validate.js

@@ -804,16 +804,69 @@ function _anchorSubtreeSeeds(anchor) {
   };
 }
 
-function initialize(certs, params, seeds, anchor) {
+/**
+ * @internal An RFC 5914 trust anchor's `certPath` constraints, read off the anchor `pki.trust`
+ * produced. Absent on an anchor from any other source, so every reader below sees empty lists and
+ * nothing changes for a caller who does not use the format.
+ */
+function _anchorRfc5914Constraints(anchor) {
+  var empty = { permitted: [], excluded: [], policySet: null, policyFlags: null, pathLenConstraint: null };
+  var c = anchor === null || anchor === undefined ? undefined : anchor.constraints;
+  if (!c || typeof c !== "object") return empty;
+  var nc = c.nameConstraints;
+  return {
+    permitted: nc && intrinsic.isArray(nc.permitted) ? checkedSubtreeSeeds(nc.permitted, "trustAnchors[].constraints.nameConstraints.permitted") : [],
+    excluded: nc && intrinsic.isArray(nc.excluded) ? checkedSubtreeSeeds(nc.excluded, "trustAnchors[].constraints.nameConstraints.excluded") : [],
+    policySet: intrinsic.isArray(c.policySet) ? c.policySet : null,
+    policyFlags: c.policyFlags && typeof c.policyFlags === "object" ? c.policyFlags : null,
+    pathLenConstraint: intrinsic.isInteger(c.pathLenConstraint) ? c.pathLenConstraint : null,
+  };
+}
+
+/**
+ * @internal RFC 5937 sec. 3.2, the policy set. anyPolicy on either side means "any policy satisfies
+ * me", so intersecting with it leaves the other side's set untouched: filtering it literally would
+ * compare a concrete identifier against the wildcard identifier, find no match, and refuse a path
+ * both sides accept. Only where BOTH name concrete policies is the intersection a comparison, and
+ * an empty result there is a real answer rather than "unconstrained": the two name disjoint policy
+ * spaces, so no policy satisfies both.
+ */
+function _mergedPolicySet(callerSet, anchorSet) {
+  if (anchorSet === null) return callerSet;
+  var callerAny = callerSet === undefined || callerSet === null || contains(callerSet, OID.anyPolicy);
+  var anchorAny = contains(anchorSet, OID.anyPolicy);
+  if (anchorAny && callerAny) return [OID.anyPolicy];
+  if (anchorAny) return intrinsic.map(callerSet, function (p) { return p; });
+  if (callerAny) return intrinsic.map(anchorSet, function (p) { return p; });
+  return intrinsic.filter(anchorSet, function (p) { return contains(callerSet, p); });
+}
+
+/**
+ * @internal RFC 5937 sec. 3.2, the flags. Each is one-directional: a flag the anchor asserts turns
+ * the matching initial value on where it was off and never off where it was on, so an anchor can
+ * only narrow what a caller asked for. That is what makes RFC 5914's "always enforced" safe.
+ */
+function _flagSet(callerValue, anchorFlags, name) {
+  if (callerValue) return true;
+  return anchorFlags !== null && anchorFlags[name] === true;
+}
+
+function initialize(certs, params, seeds, anchor, ta) {
   var n = certs.length;
-  var state = _initialState(certs, params, seeds, anchor, n);
+  var state = _initialState(certs, params, seeds, anchor, n, ta);
   /** @internal The root is the depth-zero anyPolicy node, and it is indexed like any other, so the
    * "is there a node at this depth for this policy" lookup answers for depth zero too. */
   policyLayer(state, 0)[OID.anyPolicy] = state.validPolicyGraph;
   return state;
 }
 
-function _initialState(certs, params, seeds, anchor, n) {
+function _initialState(certs, params, seeds, anchor, n, ta) {
+  /** @internal The anchor's constraints are read HERE rather than merged into a copy of `params`,
+   * because a copy answers only for the own properties the copy loop enumerated. A caller option
+   * defined non-enumerably would be dropped by the copy and the anchor would then WIDEN the
+   * validation, which is the one thing sec. 3.2 does not allow. Reading the caller's object
+   * directly keeps every option live whatever its descriptor. */
+  var anchorPathLen = ta.pathLenConstraint;
   return {
     validPolicyGraph: graphRoot(),
     policyIndex: [],
@@ -822,15 +875,19 @@ function _initialState(certs, params, seeds, anchor, n) {
     minRsaModulusBits: params.minRsaModulusBits !== undefined ? params.minRsaModulusBits : constants.LIMITS.RSA_MIN_MODULUS_BITS,
     permittedGenerations: intrinsic.filter(seeds.permittedGenerations, function (g) { return g.length > 0; }),
     excludedSubtrees: seeds.excluded,
-    explicitPolicy: params.initialExplicitPolicy ? 0 : n + 1,
-    inhibitAnyPolicy: params.initialAnyPolicyInhibit ? 0 : n + 1,
-    policyMapping: params.initialPolicyMappingInhibit ? 0 : n + 1,
+    explicitPolicy: _flagSet(params.initialExplicitPolicy, ta.policyFlags, "requireExplicitPolicy") ? 0 : n + 1,
+    inhibitAnyPolicy: _flagSet(params.initialAnyPolicyInhibit, ta.policyFlags, "inhibitAnyPolicy") ? 0 : n + 1,
+    policyMapping: _flagSet(params.initialPolicyMappingInhibit, ta.policyFlags, "inhibitPolicyMapping") ? 0 : n + 1,
     workingPublicKeyAlgorithm: anchor.algorithm,
     workingPublicKey: anchor.publicKey,
     workingPublicKeyParameters: anchor.parameters || null,
     workingIssuerName: anchor.name,
-    maxPathLength: n,
-    userInitialPolicySet: params.userInitialPolicySet || [OID.anyPolicy],
+    /** @internal RFC 5937 sec. 3.2: "If a basic constraints extension is associated with the trust
+     * anchor and contains a pathLenConstraint value, set the max_path_length state variable equal
+     * to the pathLenConstraint value". Taken as the lower of the two, since sec. 6.1.2's own
+     * initial value is the path length and an anchor may only narrow. */
+    maxPathLength: intrinsic.isInteger(anchorPathLen) && anchorPathLen < n ? anchorPathLen : n,
+    userInitialPolicySet: _mergedPolicySet(params.userInitialPolicySet, ta.policySet) || [OID.anyPolicy],
     results: [],
   };
 }
@@ -1356,16 +1413,22 @@ async function _validate(path, opts, run) {
   guard.limits.cap(opts.maxPolicyNodes, "validate: opts.maxPolicyNodes", undefined, { E: E, code: "path/bad-input", min: 1 });
   _assertUserInitialPolicySet(opts.userInitialPolicySet, "validate");
   var anchorNc = _anchorSubtreeSeeds(anchor);
+  /** @internal RFC 5937 sec. 3.2 says how an RFC 5914 anchor's own constraints reach this
+   * algorithm, and the rule is uniform: the stricter of the anchor's value and the caller's wins.
+   * Its name constraints are a SEPARATE generation from the caller's and from the `nameConstraints`
+   * overlay, because generations intersect and a replacement would let one loosen the other. */
+  var taConstraints = _anchorRfc5914Constraints(anchor);
   var seeds = {
-    permittedGenerations: [callerPermitted, anchorNc.permitted],
-    excluded: intrinsic.concat(callerExcluded, anchorNc.excluded),
+    permittedGenerations: [callerPermitted, anchorNc.permitted, taConstraints.permitted],
+    excluded: intrinsic.concat(intrinsic.concat(callerExcluded, anchorNc.excluded), taConstraints.excluded),
   };
-  var anchorNameConstraintsApplied = anchorNc.permitted.length > 0 || anchorNc.excluded.length > 0;
+  var anchorNameConstraintsApplied = anchorNc.permitted.length > 0 || anchorNc.excluded.length > 0 ||
+    taConstraints.permitted.length > 0 || taConstraints.excluded.length > 0;
   var purposeOpts = resolvePurposeOpts(opts);
   var requiredEku = purposeOpts.requiredEku;
   var checkPurpose = purposeOpts.checkPurpose;
 
-  var state = initialize(certs, opts, seeds, anchor);
+  var state = initialize(certs, opts, seeds, anchor, taConstraints);
   state._n = n;
   state.requiredEku = requiredEku;
   var verifier = opts.verifier || null;
@@ -2497,6 +2560,70 @@ function _precaptureAnchorNameConstraints(list, who) {
   }
   return out;
 }
+var _TA_CONSTRAINT_KEYS = intrinsic.assign(intrinsic.create(null), {
+  nameConstraints: 1, policySet: 1, policyFlags: 1, pathLenConstraint: 1 });
+var _TA_FLAG_KEYS = intrinsic.assign(intrinsic.create(null), {
+  inhibitPolicyMapping: 1, requireExplicitPolicy: 1, inhibitAnyPolicy: 1 });
+/**
+ * @internal An RFC 5914 anchor's own constraints, snapshotted the way every other anchor field is:
+ * read once from its own data property, copied, and never read again. A caller object that answered
+ * one value to the check and another to the enforcement would otherwise decide the namespace and
+ * the policy set a path is held to.
+ */
+function _copyAnchorRfc5914Constraints(c, who) {
+  var label = who + ": a trustAnchor constraints";
+  if (c === null || typeof c !== "object" || intrinsic.isArray(c)) {
+    throw E("path/bad-input", label + " must be a { nameConstraints, policySet, policyFlags, pathLenConstraint } object");
+  }
+  guard.identifier.assertPlainRecord(c, E, "path/bad-input", label);
+  guard.identifier.assertKnownKeys(c, _TA_CONSTRAINT_KEYS, E, "path/bad-input",
+    label + " names nameConstraints, policySet, policyFlags and pathLenConstraint. The unknown key was: ");
+  var out = {};
+  var ncD = intrinsic.getOwnPropertyDescriptor(c, "nameConstraints");
+  if (ncD !== undefined) {
+    if (!intrinsic.hasOwn(ncD, "value")) throw E("path/bad-input", label + ".nameConstraints must be a data property, not an accessor");
+    intrinsic.defineProperty(out, "nameConstraints", { value: _copyAnchorNameConstraints(ncD.value, who + ": a trustAnchor constraints"), enumerable: true, configurable: true, writable: true });
+  }
+  var psD = intrinsic.getOwnPropertyDescriptor(c, "policySet");
+  if (psD !== undefined) {
+    if (!intrinsic.hasOwn(psD, "value")) throw E("path/bad-input", label + ".policySet must be a data property, not an accessor");
+    var ps = psD.value;
+    if (!intrinsic.isArray(ps) || intrinsic.types.isProxy(ps)) throw E("path/bad-input", label + ".policySet must be a plain array of policy identifiers");
+    var psOut = [];
+    for (var i = 0; i < ps.length; i++) {
+      var pd = intrinsic.getOwnPropertyDescriptor(ps, i);
+      if (pd === undefined || !intrinsic.hasOwn(pd, "value")) throw E("path/bad-input", label + ".policySet entry " + i + " must be a data property, not a hole or an accessor");
+      if (typeof pd.value !== "string" || pd.value.length === 0) throw E("path/bad-input", label + ".policySet entries must be dotted-decimal policy identifiers");
+      guard.list.append(psOut, guard.identifier.assertCanonicalOid(pd.value, E, "path/bad-input", label + ".policySet entry " + pd.value));
+    }
+    intrinsic.defineProperty(out, "policySet", { value: psOut, enumerable: true, configurable: true, writable: true });
+  }
+  var pfD = intrinsic.getOwnPropertyDescriptor(c, "policyFlags");
+  if (pfD !== undefined) {
+    if (!intrinsic.hasOwn(pfD, "value")) throw E("path/bad-input", label + ".policyFlags must be a data property, not an accessor");
+    var pf = pfD.value;
+    if (pf === null || typeof pf !== "object" || intrinsic.isArray(pf)) throw E("path/bad-input", label + ".policyFlags must be an object of boolean flags");
+    guard.identifier.assertPlainRecord(pf, E, "path/bad-input", label + ".policyFlags");
+    guard.identifier.assertKnownKeys(pf, _TA_FLAG_KEYS, E, "path/bad-input", label + ".policyFlags names the three RFC 5914 flags. The unknown key was: ");
+    var fOut = {};
+    intrinsic.forEach(intrinsic.keys(_TA_FLAG_KEYS), function (k) {
+      var fd = intrinsic.getOwnPropertyDescriptor(pf, k);
+      if (fd === undefined) return;
+      if (!intrinsic.hasOwn(fd, "value")) throw E("path/bad-input", label + ".policyFlags." + k + " must be a data property, not an accessor");
+      if (typeof fd.value !== "boolean") throw E("path/bad-input", label + ".policyFlags." + k + " must be a boolean");
+      intrinsic.defineProperty(fOut, k, { value: fd.value, enumerable: true, configurable: true, writable: true });
+    });
+    intrinsic.defineProperty(out, "policyFlags", { value: fOut, enumerable: true, configurable: true, writable: true });
+  }
+  var plD = intrinsic.getOwnPropertyDescriptor(c, "pathLenConstraint");
+  if (plD !== undefined) {
+    if (!intrinsic.hasOwn(plD, "value")) throw E("path/bad-input", label + ".pathLenConstraint must be a data property, not an accessor");
+    if (!intrinsic.isInteger(plD.value) || plD.value < 0) throw E("path/bad-input", label + ".pathLenConstraint must be a non-negative integer");
+    intrinsic.defineProperty(out, "pathLenConstraint", { value: plD.value, enumerable: true, configurable: true, writable: true });
+  }
+  return out;
+}
+
 function _copyAnchorNameConstraints(nc, who) {
   if (nc === null || typeof nc !== "object" || intrinsic.isArray(nc)) {
     throw E("path/bad-input", who + ": a trustAnchor nameConstraints must be a { permitted, excluded } object of { tag, base } subtree entries");
@@ -2565,7 +2692,7 @@ function _copyRdnsDeep(rdns) {
 function toAnchor(entry, verb) {
   var who = verb || "build";
   var isTuple = false, alg = null, pubRaw, nameRaw = null, pk = null, purposesSnap, distrustSnap;
-  var subjectDerRaw, labelRaw, mozRaw, ncSnap;
+  var subjectDerRaw, labelRaw, mozRaw, ncSnap, taSnap;
   if (intrinsic.types.isProxy(entry)) {
     throw E("path/bad-input", who + ": a trustAnchor must not be a Proxy");
   }
@@ -2584,6 +2711,8 @@ function toAnchor(entry, verb) {
       distrustSnap = _normalizeConstraintField(dRaw, E, "path/bad-input", who);
       var ncRaw = _captureConstraintMap(entry, "nameConstraints", E, "path/bad-input", who);
       ncSnap = ncRaw == null ? undefined : _copyAnchorNameConstraints(ncRaw, who);
+      var taRaw = _captureConstraintMap(entry, "constraints", E, "path/bad-input", who);
+      taSnap = taRaw == null ? undefined : _copyAnchorRfc5914Constraints(taRaw, who);
       subjectDerRaw = _captureOwnData(entry, "subjectDer");
       labelRaw = _captureOwnData(entry, "label");
       mozRaw = _captureOwnData(entry, "mozillaCaPolicy");
@@ -2652,6 +2781,7 @@ function toAnchor(entry, verb) {
     if (purposesSnap !== undefined) intrinsic.defineProperty(flat, "purposes", { value: purposesSnap, enumerable: true, configurable: true, writable: true });
     if (distrustSnap !== undefined) intrinsic.defineProperty(flat, "distrustAfter", { value: distrustSnap, enumerable: true, configurable: true, writable: true });
     if (ncSnap !== undefined) intrinsic.defineProperty(flat, "nameConstraints", { value: ncSnap, enumerable: true, configurable: true, writable: true });
+    if (taSnap !== undefined) intrinsic.defineProperty(flat, "constraints", { value: taSnap, enumerable: true, configurable: true, writable: true });
     if (subjectDerRaw !== undefined) intrinsic.defineProperty(flat, "subjectDer", { value: subjectDerRaw, enumerable: true, configurable: true, writable: true });
     if (labelRaw !== undefined) intrinsic.defineProperty(flat, "label", { value: labelRaw, enumerable: true, configurable: true, writable: true });
     if (mozRaw !== undefined) intrinsic.defineProperty(flat, "mozillaCaPolicy", { value: mozRaw, enumerable: true, configurable: true, writable: true });
@@ -2667,7 +2797,17 @@ function toAnchor(entry, verb) {
   try { cert = coerceCert(entry); }
   catch (e) { throw E("path/bad-input", who + ": a trustAnchor entry must be a { name, publicKey, algorithm } tuple or a certificate", e); }
   var spki = cert.subjectPublicKeyInfo;
-  return { name: cert.subject, publicKey: spki.bytes, algorithm: spki.algorithm.oid, parameters: spki.algorithm.parameters, subjectDer: cert.subject.bytes };
+  var out = { name: cert.subject, publicKey: spki.bytes, algorithm: spki.algorithm.oid, parameters: spki.algorithm.parameters, subjectDer: cert.subject.bytes };
+  /** @internal The certificate's own basic constraints are associated with the anchor, so its
+   * pathLenConstraint bounds the path below it (RFC 5937 sec. 3.2). Defined rather than assigned,
+   * for the reason every other anchor field is. */
+  var certPathLen = pkix.anchorPathLenFromExtensions(cert.extensions, NS, who + ": the trustAnchor certificate");
+  if (certPathLen !== null) {
+    var c = intrinsic.create(null);
+    c.pathLenConstraint = certPathLen;
+    guard.verdict.set(out, "constraints", c);
+  }
+  return out;
 }
 
 /**
@@ -2903,8 +3043,7 @@ async function _aiaFetchOne(uri, aia) {
     : Buffer.from(res.body == null ? "" : String(res.body), "latin1");
   if (body.length === 0) throw E("path/aia-empty", "an AIA fetch returned an empty body");
   if (body.length > aia.maxResponseBytes) throw E("path/aia-too-large", "an AIA response exceeds the " + aia.maxResponseBytes + "-byte cap");
-  var headers = intrinsic.create(null);
-  Object.keys(res.headers || {}).forEach(function (k) { headers[k.toLowerCase()] = res.headers[k]; });
+  var headers = guard.header.lowerCased(res.headers);
   return _aiaParseBody(body, headers["content-type"], aia.maxCertsPerResponse);
 }
 

package/lib/pki-build.js

@@ -436,7 +436,7 @@ function makeBuilder(ctx) {
   }
   function encodeRdn(rdnSpec) {
     if (!rdnSpec || typeof rdnSpec !== "object" || Buffer.isBuffer(rdnSpec)) throw E("bad-name", "each RDN must be an object of { attributeName: value }");
-    var keys = Object.keys(rdnSpec);
+    var keys = guard.identifier.optionNames(rdnSpec);
     if (!keys.length) throw E("bad-name", "an RDN must carry at least one attribute");
     return b.set(keys.map(function (k) { return encodeAtv(k, rdnSpec[k]); }));
   }

package/lib/revocation-fetch.js

@@ -294,7 +294,7 @@ async function _fetchOne(state, req, what) {
 
 function _contentType(headers) {
   var h = headers || {};
-  var keys = Object.keys(h);
+  var keys = guard.identifier.optionNames(h);
   for (var i = 0; i < keys.length; i++) {
     if (keys[i].toLowerCase() !== "content-type") continue;
     try { return mime.parse(String(h[keys[i]])).type; }

package/lib/scep.js

@@ -68,7 +68,12 @@ var MESSAGE_TYPE = Object.assign(Object.create(null), { CertRep: "3", RenewalReq
 var PKI_STATUS = Object.assign(Object.create(null), { SUCCESS: "0", FAILURE: "2", PENDING: "3" });
 var FAIL_INFO = Object.assign(Object.create(null), { badAlg: "0", badMessageCheck: "1", badRequest: "2", badTime: "3", badCertId: "4" });
 
-function _invert(table) { var o = Object.create(null); for (var k in table) if (Object.prototype.hasOwnProperty.call(table, k)) o[table[k]] = k; return o; }
+function _invert(table) {
+  var o = Object.create(null);
+  var names = guard.identifier.optionNames(table);
+  for (var i = 0; i < names.length; i++) o[table[names[i]]] = names[i];
+  return o;
+}
 var MESSAGE_TYPE_BY_CODE = _invert(MESSAGE_TYPE), PKI_STATUS_BY_CODE = _invert(PKI_STATUS), FAIL_INFO_BY_CODE = _invert(FAIL_INFO);
 
 var _PARSE_SUPPORTED = Object.assign(Object.create(null), { PKCSReq: 1, RenewalReq: 1, CertRep: 1, CertPoll: 1, GetCert: 1, GetCRL: 1 });
@@ -621,10 +626,10 @@ function _trim(s) { var a = 0, e = s.length; while (a < e && _isWs(s.charCodeAt(
 
 function _header(headers, name) {
   if (!headers || typeof headers !== "object") return null;
-  var found = null, seen = 0, k;
-  for (k in headers) {
-    if (!Object.prototype.hasOwnProperty.call(headers, k)) continue;
-    if (_foldLower(String(k)) === name) { found = headers[k]; seen += 1; }
+  var found = null, seen = 0;
+  var hNames = guard.identifier.optionNames(headers);
+  for (var hi = 0; hi < hNames.length; hi++) {
+    if (_foldLower(String(hNames[hi])) === name) { found = headers[hNames[hi]]; seen += 1; }
   }
   if (seen > 1) throw _err("scep/bad-response", "the response carried more than one " + name + " header");
   return found == null ? null : String(found);
@@ -739,7 +744,7 @@ function _client(method, url, body, headers, opts, checked) {
     maxResponseBytes: guard.limits.cap(opts.maxResponseBytes, "maxResponseBytes", C.LIMITS.HTTP_MAX_RESPONSE_BYTES, { E: _err, code: "scep/bad-input", min: 1, max: C.LIMITS.HTTP_MAX_RESPONSE_BYTES }),
     maxRedirects: guard.limits.cap(opts.maxRedirects, "maxRedirects", 5, { E: _err, code: "scep/bad-input", min: 0, max: 32 }),
   };
-  return _drive(method, url, body, Object.assign({}, headers), opts, transport, budgets);
+  return _drive(method, url, body, guard.identifier.ownOptions(headers), opts, transport, budgets);
 }
 function _requireOk(res, expected, what) {
   var status = res.status;
@@ -1056,7 +1061,7 @@ async function _pkiOperation(messageType, baseUrl, opts, verbName) {
   var recipientKey = _captureRecipientKey(opts.recipientKey);
   var signer = { cert: guard.bytes.snapshotSource(opts.signer.cert, ScepError, "scep/bad-input", "signer.cert"), key: opts.signer.key };
   var clientOpts = {
-    tls: opts.tls != null ? Object.assign({}, opts.tls) : opts.tls,
+    tls: opts.tls != null ? guard.identifier.ownOptions(opts.tls) : opts.tls,
     maxRedirects: opts.maxRedirects,
     allowCrossOriginRedirect: opts.allowCrossOriginRedirect,
     timeout: opts.timeout,
@@ -1207,7 +1212,7 @@ async function _queryOperation(messageType, baseUrl, opts, verbName) {
   var recipientKey = _captureRecipientKey(opts.recipientKey);
   var signer = { cert: guard.bytes.snapshotSource(opts.signer.cert, ScepError, "scep/bad-input", "signer.cert"), key: opts.signer.key };
   var want = _resolveQueryTarget(opts);
-  var clientOpts = { tls: opts.tls != null ? Object.assign({}, opts.tls) : opts.tls, maxRedirects: opts.maxRedirects, allowCrossOriginRedirect: opts.allowCrossOriginRedirect, timeout: opts.timeout, maxResponseBytes: opts.maxResponseBytes, proxy: _snapshotProxy(opts.proxy) };
+  var clientOpts = { tls: opts.tls != null ? guard.identifier.ownOptions(opts.tls) : opts.tls, maxRedirects: opts.maxRedirects, allowCrossOriginRedirect: opts.allowCrossOriginRedirect, timeout: opts.timeout, maxResponseBytes: opts.maxResponseBytes, proxy: _snapshotProxy(opts.proxy) };
   if (checkedTransport !== undefined) clientOpts.transport = checkedTransport;
   var senderNonce = nodeCrypto.randomBytes(16);
   var transactionId = opts.transactionId != null ? opts.transactionId : _defaultTransactionId();
@@ -1320,7 +1325,14 @@ async function getCrl(baseUrl, opts) {
 }
 
 var _TRANSPORT_KEYS = Object.assign(Object.create(null), { transport: 1, timeout: 1, maxResponseBytes: 1, maxRedirects: 1, tls: 1, allowCrossOriginRedirect: 1, proxy: 1 });
-function _withKeys(extra) { var o = {}, k; for (k in _TRANSPORT_KEYS) o[k] = 1; for (k in extra) o[k] = 1; return o; }
+function _withKeys(extra) {
+  var o = Object.create(null);
+  var base = guard.identifier.optionNames(_TRANSPORT_KEYS);
+  for (var bi = 0; bi < base.length; bi++) o[base[bi]] = 1;
+  var more = guard.identifier.optionNames(extra);
+  for (var mi = 0; mi < more.length; mi++) o[more[mi]] = 1;
+  return o;
+}
 var _CACAPS_KEYS = _withKeys({ expectSCEPStandard: 1, requireStrongProfile: 1 });
 var _CACERT_KEYS = _withKeys({ expectedFingerprint: 1, fingerprintAlgorithm: 1 });
 var _NEXTCACERT_KEYS = _withKeys({ caCertificate: 1 });

package/lib/schema-all.js

@@ -47,6 +47,7 @@ var tsp = require("./schema-tsp");
 var crmf = require("./schema-crmf");
 var cmp = require("./schema-cmp");
 var csrattrs = require("./schema-csrattrs");
+var trustanchor = require("./schema-trustanchor");
 var attrcert = require("./schema-attrcert");
 var smime = require("./schema-smime");
 var cmc = require("./schema-cmc");
@@ -88,6 +89,12 @@ var FORMATS = [
     detect: csrattrs.matches,
     parse: function (input, caps) { return csrattrs.parse(input, caps); },
   },
+  {
+    name: "trustanchor",
+    module: trustanchor,
+    detect: trustanchor.matches,
+    parse: function (input, caps) { return trustanchor.parse(input, caps); },
+  },
   {
     name: "ocsp-request",
     module: ocsp,
@@ -155,7 +162,7 @@ var FORMATS = [
  * The names of every registered format, in detection order.
  *
  * @example
- *   pki.schema.all();  // -> ["cms", "tsp", "crmf", "cmp", "csrattrs", "ocsp-request", "ocsp-response", "pkcs12", "pkcs8", "csr", "attrcert", "attrcert-v1", "crl", "x509"]
+ *   pki.schema.all();  // -> ["cms", "tsp", "crmf", "cmp", "csrattrs", "trustanchor", "ocsp-request", "ocsp-response", "pkcs12", "pkcs8", "csr", "attrcert", "attrcert-v1", "crl", "x509"]
  */
 function all() { return FORMATS.map(function (f) { return f.name; }); }
 
@@ -368,6 +375,8 @@ module.exports = {
     decodeExtensions: crmf.decodeExtensions, decodeExtension: crmf.decodeExtension },
   cmp: { parse: cmp.parse, pemDecode: cmp.pemDecode, pemEncode: cmp.pemEncode },
   csrattrs: { parse: csrattrs.parse },
+  trustanchor: { parse: trustanchor.parse, parseInfo: trustanchor.parseInfo,
+    pemDecode: trustanchor.pemDecode, pemEncode: trustanchor.pemEncode },
   attrcert: { parse: attrcert.parse, pemDecode: attrcert.pemDecode, pemEncode: attrcert.pemEncode,
     decodeExtensions: attrcert.decodeExtensions, decodeExtension: attrcert.decodeExtension },
   smime: { parseSigningCertificate: smime.parseSigningCertificate, parseSigningCertificateV2: smime.parseSigningCertificateV2, parseSmimeCapabilities: smime.parseSmimeCapabilities, decodeAttribute: smime.decodeAttribute },

package/lib/schema-engine.js

@@ -27,6 +27,7 @@
  */
 
 var asn1 = require("./asn1-der.js");
+var intrinsic = require("./guard-intrinsic");
 
 var TAGS = asn1.TAGS;
 
@@ -339,8 +340,12 @@ function _walkSeq(schema, node, ctx) {
   var kids = _assertShape(schema, node, ctx);
   _assertArity(schema, kids, ctx);
 
-  // allow:registry-table-inherits-object-prototype -- the record a schema's own check and build callbacks read as m.fields, whose keys are the field names that schema declared rather than anything the input supplies
-  var fields = {};
+  /** @internal Prototype-less, so writing a field creates an own property instead of dispatching
+   * through an accessor of the same name on Object.prototype. Every format parser's record is
+   * built here, so a getter-only slot planted under any field name a schema declares would
+   * otherwise throw out of an ordinary parse, and a setter would swallow the decoded value. The
+   * absent-member test below reads it the same way. */
+  var fields = intrinsic.create(null);
   var idx = 0;
   for (var f = 0; f < schema.fields.length; f++) {
     var fld = schema.fields[f];

package/lib/schema-pkix.js

@@ -1456,6 +1456,44 @@ function _extensionRow(ext, opts, index, state, decoded, code, profile) {
  * impossible to READ a certificate carrying a private critical extension, which is what
  * `pki.inspect` and `pki.lint` are for. RFC 5280 sec. 4.2's reject-on-critical rule is the
  * caller's to apply, and the two facts it needs, `critical` and `state`, are on the row. */
+/** @internal RFC 5937 sec. 3.2: "If a basic constraints extension is associated with the trust
+ *  anchor and contains a pathLenConstraint value, set the max_path_length state variable equal to
+ *  the pathLenConstraint value from the basic constraints extension." A trust anchor associates
+ *  one in three ways: the certificate it is supplied as, the `exts` of an RFC 5914
+ *  `TrustAnchorInfo`, and that anchor's `certPath.pathLenConstraint`. The first two are an
+ *  extension list, so both read it here and neither restates the decode. Returns null only where
+ *  the list states no path length. An extension that does not decode is a refusal, not an absent
+ *  limit: nothing validates the anchor's own certificate, so reading an unreadable constraint as
+ *  "no constraint" would leave the anchor less restricted than the store that carries it says. */
+function anchorPathLenFromExtensions(list, ns, label) {
+  if (!intrinsic.isArray(list)) return null;
+  var bcOid = ns.oid.byName("basicConstraints");
+  var decode = certExtensionDecoders(ns).byOid[bcOid];
+  if (typeof decode !== "function") return null;
+  var found = null;
+  _forEach(list, function (ext) {
+    if (!ext || ext.oid !== bcOid || found !== null) return;
+    var value;
+    try { value = decode(ext.value); }
+    catch (e) {
+      throw ns.E(ns.prefix + "/bad-basic-constraints", (label || "the trust anchor") +
+        " carries a basicConstraints extension that does not decode, so the path length it states " +
+        "cannot be read; a trust anchor's constraints are never checked against a path above it, " +
+        "so this is refused rather than read as no constraint", e);
+    }
+    if (value && intrinsic.isInteger(value.pathLenConstraint)) found = value.pathLenConstraint;
+  });
+  return found;
+}
+
+/** @internal The stricter of two path lengths an anchor states, which is the only direction
+ *  RFC 5937 sec. 3.2 allows an anchor to move a validation. */
+function lowerPathLen(a, b) {
+  if (!intrinsic.isInteger(a)) return intrinsic.isInteger(b) ? b : null;
+  if (!intrinsic.isInteger(b)) return a;
+  return a < b ? a : b;
+}
+
 function decodeExtensionList(list, opts) {
   var out = [];
   for (var i = 0; i < list.length; i++) _append(out, decodeOneExtension(list[i], i, opts));
@@ -2409,6 +2447,8 @@ module.exports = {
   scopedCertDecoder: scopedCertDecoder,
   crlExtensionDecoders: crlExtensionDecoders,
   decodeExtensionList: decodeExtensionList,
+  anchorPathLenFromExtensions: anchorPathLenFromExtensions,
+  lowerPathLen: lowerPathLen,
   extensionDoor: extensionDoor,
   _decodeHelpers: _decodeHelpers,
   attribute: attribute,