@blamejs/pki 0.8.52 → 0.8.54

package/lib/path-validate.js

@@ -945,16 +945,20 @@ function _flagSet(callerValue, anchorFlags, name) {
   return anchorFlags !== null && anchorFlags[name] === true;
 }
 
-function initialize(certs, params, seeds, anchor, ta) {
+/** @internal `policySwitches` carries the three sec. 6.1.1 inputs as the door read and typed them.
+ *  They are not read off `params` here: normalizing an anchor runs caller accessors for its name,
+ *  key and algorithm, so an options object the caller still holds can carry a different value by
+ *  the time this runs, and the state would be built from a value nothing typed. */
+function initialize(certs, params, seeds, anchor, ta, policySwitches) {
   var n = certs.length;
-  var state = _initialState(certs, params, seeds, anchor, n, ta);
+  var state = _initialState(certs, params, seeds, anchor, n, ta, policySwitches);
   /** @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, ta) {
+function _initialState(certs, params, seeds, anchor, n, ta, policySwitches) {
   /** @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
@@ -969,9 +973,9 @@ function _initialState(certs, params, seeds, anchor, n, ta) {
     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: _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,
+    explicitPolicy: _flagSet(policySwitches.initialExplicitPolicy, ta.policyFlags, "requireExplicitPolicy") ? 0 : n + 1,
+    inhibitAnyPolicy: _flagSet(policySwitches.initialAnyPolicyInhibit, ta.policyFlags, "inhibitAnyPolicy") ? 0 : n + 1,
+    policyMapping: _flagSet(policySwitches.initialPolicyMappingInhibit, ta.policyFlags, "inhibitPolicyMapping") ? 0 : n + 1,
     workingPublicKeyAlgorithm: anchor.algorithm,
     workingPublicKey: anchor.publicKey,
     workingPublicKeyParameters: anchor.parameters || null,
@@ -1286,7 +1290,12 @@ function _revocationRow(row, rv) {
  * The value-carrying options (`time`, `maxPathCerts`,
  * `maxPolicyNodes`, `minRsaModulusBits`, the subtree seeds, `userInitialPolicySet`, `requiredEku`)
  * are validated at the entry point. A mis-shaped value throws `path/bad-input`,
- * so it cannot silently go unapplied. Returns `{ valid, revocationChecked, anchorConstraints,
+ * so it cannot silently go unapplied. `requireRevocation` makes the revocation
+ * determination mandatory, failing the path with `path/revocation-undetermined`
+ * where it could not be made. It and the three sec. 6.1.1 policy inputs
+ * (`initialExplicitPolicy`, `initialAnyPolicyInhibit`,
+ * `initialPolicyMappingInhibit`) each take `true`, `false`, `null` or an absent
+ * option, and any other value throws `path/bad-input` for the same reason. Returns `{ valid, revocationChecked, anchorConstraints,
  * path, results, workingPublicKey, workingPublicKeyAlgorithm,
  * workingPublicKeyParameters, validPolicyGraph, userConstrainedPolicySet }` where `results[i].checks`
  * carries a per-check reason code (`path/*`) for every step. Pure and
@@ -1473,6 +1482,23 @@ async function _validate(path, opts, run, scope) {
   var certs = path.map(function (c, ci) { return coerceCert(c, "validate: path[" + ci + "]"); });
   var n = certs.length;
   if (n < 1) throw E("path/empty-path", "validate: the certification path is empty");
+  /** @internal The four switches that turn a requirement on, each read as the boolean it documents
+   * and read HERE, before any anchor is normalized. An anchor's own copies of the three policy
+   * flags are typed where they are copied, and `_flagSet` compares the caller's value with the
+   * anchor's, so typing one side and not the other would accept at the door what the comparison
+   * refuses. Normalizing an anchor reads its name, key and algorithm, and those reads run caller
+   * code when the anchor carries accessors: the typed values below are what every anchor attempt
+   * is handed, so a requirement cannot be turned off between the attempts. */
+  var policySwitches = {
+    requireRevocation: guard.identifier.booleanOption(opts.requireRevocation, E,
+      "path/bad-input", "validate: opts.requireRevocation"),
+    initialExplicitPolicy: guard.identifier.booleanOption(opts.initialExplicitPolicy, E,
+      "path/bad-input", "validate: opts.initialExplicitPolicy"),
+    initialAnyPolicyInhibit: guard.identifier.booleanOption(opts.initialAnyPolicyInhibit, E,
+      "path/bad-input", "validate: opts.initialAnyPolicyInhibit"),
+    initialPolicyMappingInhibit: guard.identifier.booleanOption(opts.initialPolicyMappingInhibit, E,
+      "path/bad-input", "validate: opts.initialPolicyMappingInhibit"),
+  };
   /** @internal Captured before any anchor is normalized: an anchor field may be an accessor, and
    * that getter runs caller code which could otherwise clear these lists first. */
   var callerPermitted = checkedSubtreeSeeds(opts.initialPermittedSubtrees, "initialPermittedSubtrees");
@@ -1506,6 +1532,14 @@ async function _validate(path, opts, run, scope) {
        * question the caller asked. Copying `opts.identity` across would have each attempt read
        * the caller's own list again, after the awaits the earlier attempts spent. */
       if (identityRefs !== null) o.identity = identityRefs;
+      /** @internal The four switches as this call typed them, carried into every attempt rather
+       * than copied from an options object the caller still holds: the tuples above were built by
+       * reading each anchor, which runs the caller's accessors, so a value copied here would be
+       * whatever those left behind. */
+      o.requireRevocation = policySwitches.requireRevocation;
+      o.initialExplicitPolicy = policySwitches.initialExplicitPolicy;
+      o.initialAnyPolicyInhibit = policySwitches.initialAnyPolicyInhibit;
+      o.initialPolicyMappingInhibit = policySwitches.initialPolicyMappingInhibit;
       return o;
     };
     var lastMatched = null, anyMatched = false;
@@ -1538,7 +1572,7 @@ async function _validate(path, opts, run, scope) {
   var requiredEku = purposeOpts.requiredEku;
   var checkPurpose = purposeOpts.checkPurpose;
 
-  var state = initialize(certs, opts, seeds, anchor, taConstraints);
+  var state = initialize(certs, opts, seeds, anchor, taConstraints, policySwitches);
   state._n = n;
   state.requiredEku = requiredEku;
   /** @internal The verifier comes from the per-call scope the door built, never from `opts`: the option
@@ -1548,7 +1582,7 @@ async function _validate(path, opts, run, scope) {
   var verifierVerify = scope.verify;
   var revocationChecker = opts.revocationChecker || null;
   var softFail = opts.softFail === true;
-  var requireRevocation = opts.requireRevocation === true;
+  var requireRevocation = policySwitches.requireRevocation;
   var failed = false;
   var revocationRan = false, revocationWaived = false, revocationUndetermined = false;
   var prefixAuthentic = true;
@@ -3330,7 +3364,7 @@ async function _fetchAiaIssuers(current, aia) {
  * @opts  direction              Search direction: `"forward"` (default, from the leaf toward an anchor), `"reverse"` (from an anchor toward the leaf, RFC 4158 sec. 3.1, narrower when the anchor set is small and the leaf fans out), or `"auto"` (pick by first-hop fan-out). Reverse building is pool-only and does not combine with `fetchAia`. Every direction hands each assembled path to `validate`, so the direction changes only search order, never which paths are accepted.
  * @opts  maxDepth               Chain-length depth cap (default `C.LIMITS.PATH_BUILD_MAX_DEPTH`).
  * @opts  maxCandidatesConsidered  Total-work cap on candidate expansions (default `C.LIMITS.PATH_BUILD_MAX_CANDIDATES`).
- * @opts  validate               `false` returns the ordered path without validating (pure-builder mode; default `true`).
+ * @opts  validate               `false` returns the ordered path without validating (pure-builder mode; default `true`). It takes `true`, `false`, `null` or an absent option, and any other value is refused `path/bad-input` at the door rather than read as on.
  * @opts  fetchAia               `true` opts in to AIA caIssuers network fetching of a missing intermediate (default `false`, fully offline). Off unless set; when set, a fetch runs only on a pool miss for a non-anchor-adjacent cert, and (with validation on) every fetched cert still flows through `validate`.
  * @opts  transport              The injectable transport seam (`fn(request) -> Promise<{ status, headers, body }>`); tests drive the fetch offline. With none, the default `pki.transport.https` is used, which fails closed unless `opts.tls` carries trust. SSRF: for a caIssuers URL with a DNS hostname, a custom transport is used only if it declares `fn.blocksPrivateAddresses = true`, which vouches that it refuses (and pins) a resolved private / loopback / link-local / special-use address, as the default transport does. Without that marker a DNS-name AIA URL is fail-closed (skipped) and only an IP-literal URL (validated up front) is fetched; set the marker on your transport when it filters resolved addresses.
  * @opts  tls                    The TLS trust for the AIA HTTPS host (`{ anchors, useSystemStore, ... }`). This is distinct from `opts.trustAnchors`, the PKI trust store the path validates against. The default transport refuses an unpinned server.
@@ -3338,7 +3372,7 @@ async function _fetchAiaIssuers(current, aia) {
  * @opts  maxAiaPerCert          Cap on caIssuers URLs tried per certificate (default `C.LIMITS.PATH_AIA_MAX_PER_CERT`).
  * @opts  aiaTimeout             Per-fetch timeout in ms, forwarded to the transport.
  * @opts  maxResponseBytes       Per-fetch response size cap, forwarded to the transport (tightenable downward only).
- * @opts  (validate options)     Every `pki.path.validate` option (`requiredEku`, `revocationChecker`, `checkPurpose`, the initial policy inputs, ...) is forwarded unchanged. When `userInitialPolicySet` is supplied, build returns the accepted path whose user-constrained policy set best satisfies it (RFC 4158 sec. 4 forward policy chaining) rather than the first accepted path; `validate` still gates every path, so this changes only which valid path is chosen. The ranking explores more of the candidate graph than a first-accept build, so it is bounded by `maxCandidatesConsidered` like the rest of the search. Reaching that cap means stop looking, not nothing found: if a valid path was already accepted, build returns the best-policy one of those; it reaches `path/build-limit` only when the cap is hit before any valid path is accepted. An `anyPolicy` entry makes the set unconstrained, so ranking is skipped and the first accepted path is returned.
+ * @opts  (validate options)     Every `pki.path.validate` option (`requiredEku`, `revocationChecker`, `checkPurpose`, the initial policy inputs, ...) is forwarded unchanged. `requireRevocation` and the three policy inputs are typed at this door as well as at `validate`'s, because a build reaches an AIA fetch before it reaches `validate` and a build that assembles no path never calls it. When `userInitialPolicySet` is supplied, build returns the accepted path whose user-constrained policy set best satisfies it (RFC 4158 sec. 4 forward policy chaining) rather than the first accepted path; `validate` still gates every path, so this changes only which valid path is chosen. The ranking explores more of the candidate graph than a first-accept build, so it is bounded by `maxCandidatesConsidered` like the rest of the search. Reaching that cap means stop looking, not nothing found: if a valid path was already accepted, build returns the best-policy one of those; it reaches `path/build-limit` only when the cap is hit before any valid path is accepted. An `anyPolicy` entry makes the set unconstrained, so ranking is skipped and the first accepted path is returned.
  * @example
  *   var pair = await pki.key.generate("Ed25519");
  *   var pemString = await pki.x509.sign({ subject: "Example Root", subjectPublicKey: await pki.key.export(pair.publicKey),
@@ -3372,6 +3406,38 @@ async function build(leaf, opts) {
    * second time and an accessor can answer differently on each read. */
   var checkedTransport = guard.identifier.assertCallableOption(opts, "transport", E, "path/bad-input",
     "build: opts.transport", "(request) -> Promise<{ status, headers, body }>");
+  /** @internal The switches build forwards to `validate` are typed at THIS door too, because build
+   * reaches the network before it reaches `validate`: with `fetchAia` on it fetches AIA issuers
+   * while assembling a chain, and a build that assembles none returns `path/no-path` with no
+   * `validate` call having read them. A door that only the successful route passes through is not
+   * a door. */
+  var FORWARDED_SWITCHES = ["requireRevocation", "initialExplicitPolicy", "initialAnyPolicyInhibit",
+    "initialPolicyMappingInhibit"];
+  var forwardedSwitches = intrinsic.create(null);
+  intrinsic.forEach(FORWARDED_SWITCHES, function (k) {
+    /** @internal Every one of the four is typed and recorded, including the ones the caller left
+     * out. An absent switch recorded as `false` is the same question answered the same way, and
+     * recording it is what stops a later read from finding one that was not there at this door:
+     * reading each anchor runs the caller's accessors, and an accessor can add an option. */
+    forwardedSwitches[k] = guard.identifier.booleanOption(opts[k], E, "path/bad-input", "build: opts." + k);
+  });
+  /** @internal `validate` defaults ON, so absence means on here and the off form is `false`. A
+   * value outside that set is a caller asking for pure-builder mode in a spelling this verb does
+   * not read, and running the validation they asked to skip is as silent as skipping it. */
+  var doValidateOpt = (opts.validate === undefined || opts.validate === null) ? true
+    : guard.identifier.booleanOption(opts.validate, E, "path/bad-input", "build: opts.validate");
+  /** @internal Pure-builder mode runs no validation, so a requirement asked for alongside it is a
+   * requirement nothing will apply. The combination is refused rather than answered with an
+   * ordered path, the same way an asked-for check that its input cannot satisfy is refused. */
+  if (!doValidateOpt) {
+    intrinsic.forEach(FORWARDED_SWITCHES, function (k) {
+      if (forwardedSwitches[k] === true) {
+        throw E("path/bad-input", "build: opts." + k + " asks for a check that only validation " +
+          "applies, and opts.validate is false, which returns the ordered path without validating; " +
+          "drop one of the two");
+      }
+    });
+  }
   var leafCert;
   try { leafCert = coerceCert(leaf); }
   catch (e) { throw E("path/bad-input", "build: the leaf certificate did not parse", e); }
@@ -3409,7 +3475,7 @@ async function build(leaf, opts) {
   // allow:guard-shape-reinlined -- opts.maxDepth here is the path-building chain depth (capped via guard.limits.cap against the PATH_BUILD_MAX_DEPTH ceiling), a different concept from the decode-recursion depth guard.limits.depthCap enforces
   var maxDepth = guard.limits.cap(opts.maxDepth, "build: opts.maxDepth", Math.min(constants.LIMITS.PATH_BUILD_MAX_DEPTH, depthCeiling), { E: E, code: "path/bad-input", min: 0, max: depthCeiling });
   var maxConsidered = guard.limits.cap(opts.maxCandidatesConsidered, "build: opts.maxCandidatesConsidered", poolCeiling, { E: E, code: "path/bad-input", min: 1 });
-  var doValidate = opts.validate !== false;
+  var doValidate = doValidateOpt;
 
   var direction = opts.direction !== undefined ? opts.direction : "forward";
   if (direction !== "forward" && direction !== "reverse" && direction !== "auto") {
@@ -3448,6 +3514,10 @@ async function build(leaf, opts) {
   var forwarded = Object.create(null);
   intrinsic.forEach(intrinsic.keys(_VALIDATE_OPTS), function (k) {
     if (intrinsic.hasOwn(BUILD_ONLY_OPT, k)) return;
+    /** @internal A switch this door typed is forwarded as the value it typed. Reading it off the
+     * options object again would ask a second time, and normalizing an anchor between the two runs
+     * caller accessors, so the value `validate` is handed need not be the one that passed here. */
+    if (intrinsic.hasOwn(forwardedSwitches, k)) { forwarded[k] = forwardedSwitches[k]; return; }
     if (k in opts) forwarded[k] = opts[k];
   });
   if (buildPermRaw != null) forwarded.initialPermittedSubtrees = buildPermSeeds;

package/lib/revocation-fetch.js

@@ -192,9 +192,7 @@ function _no(why) { return { url: null, why: why }; }
  * under a `=== true` test, and the requests would go out carrying no nonce with nothing said. An
  * absent value is the documented default; anything else is a configuration fault. */
 function _booleanOption(value, label) {
-  if (value === undefined || value === null) return false;
-  if (value === true || value === false) return value;
-  throw E("path/bad-input", label + " must be true or false, got " + guard.text.showValue(value));
+  return guard.identifier.booleanOption(value, E, "path/bad-input", label);
 }
 
 /** @internal Whether this transport says it filters the address it resolved. A transport is a

package/lib/scep.js

@@ -849,8 +849,8 @@ function _assertStrongProfile(caps, profile) {
  *
  * @opts
  *   - `transport` -- an injected transport (defaults to `pki.transport.https`); the request is a GET with no body.
- *   - `expectSCEPStandard` -- refuse (`scep/weak-profile`) if the response does not advertise `SCEPStandard`.
- *   - `requireStrongProfile` -- refuse unless AES + SHA-256 + POSTPKIOperation are all advertised.
+ *   - `expectSCEPStandard` -- refuse (`scep/weak-profile`) if the response does not advertise `SCEPStandard`. Takes `true`, `false`, `null` or an absent option; any other value is refused `scep/bad-input`.
+ *   - `requireStrongProfile` -- refuse unless AES + SHA-256 + POSTPKIOperation are all advertised. Read the same way.
  *   - `timeout` / `maxResponseBytes` / `maxRedirects` / `tls` / `allowCrossOriginRedirect` / `proxy` -- transport bounds (`proxy` reaches the CA through a forward HTTP proxy; see pki.transport).
  * @example
  *   // requires: scepTransport -- an injected transport (omit to use pki.transport.https)
@@ -861,7 +861,12 @@ async function getCACaps(baseUrl, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "scep/bad-input", "pki.scep.getCACaps options");
   guard.identifier.assertKnownKeys(opts, _CACAPS_KEYS, _err, "scep/bad-input", "pki.scep.getCACaps has an unknown option: ");
   var checkedTransport = _assertTransport(opts);
-  var profile = { expectSCEPStandard: !!opts.expectSCEPStandard, requireStrongProfile: !!opts.requireStrongProfile };
+  var profile = {
+    expectSCEPStandard: guard.identifier.booleanOption(opts.expectSCEPStandard, _err,
+      "scep/bad-input", "pki.scep.getCACaps opts.expectSCEPStandard"),
+    requireStrongProfile: guard.identifier.booleanOption(opts.requireStrongProfile, _err,
+      "scep/bad-input", "pki.scep.getCACaps opts.requireStrongProfile"),
+  };
   var res = await _client("GET", _scepUrl(baseUrl, "GetCACaps"), null, {}, opts, checkedTransport);
   if (res.status === 200) {
     var caps = parseCapabilities(_requireOk(res, [CT_PLAIN], "GetCACaps"));

package/lib/schema-all.js

@@ -368,7 +368,8 @@ module.exports = {
   },
   sec1: { parse: sec1.parse, encode: sec1.encode, pemDecode: sec1.pemDecode, pemEncode: sec1.pemEncode },
   pkcs12: { parse: pkcs12.parse, pemDecode: pkcs12.pemDecode, pemEncode: pkcs12.pemEncode },
-  cms:  { parse: cms.parse, pemDecode: cms.pemDecode, pemEncode: cms.pemEncode },
+  cms:  { parse: cms.parse, parseAlgorithmProtection: cms.parseAlgorithmProtection,
+    pemDecode: cms.pemDecode, pemEncode: cms.pemEncode },
   ocsp: { parseRequest: ocsp.parseRequest, parseResponse: ocsp.parseResponse, pemDecode: ocsp.pemDecode, pemEncode: ocsp.pemEncode },
   tsp: { parse: tsp.parse, parseResponse: tsp.parseResponse, parseRequest: tsp.parseRequest, parseTstInfo: tsp.parseTstInfo, parseToken: tsp.parseToken, pemDecode: tsp.pemDecode, pemEncode: tsp.pemEncode },
   crmf: { parse: crmf.parse, pemDecode: crmf.pemDecode, pemEncode: crmf.pemEncode,