@blamejs/pki 0.8.1 → 0.8.3

package/lib/oid.js

@@ -46,8 +46,13 @@ var FAMILIES = Object.assign(Object.create(null), {
   attributeType: { base: [2, 5, 4], of: {
     commonName: 3, surname: 4, serialNumber: 5, countryName: 6,
     localityName: 7, stateOrProvinceName: 8, streetAddress: 9,
-    organizationName: 10, organizationalUnitName: 11, title: 12, givenName: 42,
-    clearance: 55, role: 72 } },
+    organizationName: 10, organizationalUnitName: 11, title: 12,
+    businessCategory: 15, postalCode: 17, name: 41, givenName: 42,
+    initials: 43, generationQualifier: 44, distinguishedNameQualifier: 46,
+    clearance: 55, pseudonym: 65, role: 72, organizationIdentifier: 97 } },
+
+  cabfJurisdiction: { base: [1, 3, 6, 1, 4, 1, 311, 60, 2, 1], of: {
+    jurisdictionLocalityName: 1, jurisdictionStateOrProvinceName: 2, jurisdictionCountryName: 3 } },
 
   certExtension: { base: [2, 5, 29], of: {
     subjectDirectoryAttributes: 9,
@@ -339,7 +344,7 @@ var FAMILIES = Object.assign(Object.create(null), {
   nistKem: { base: [2, 16, 840, 1, 101, 3, 4, 4], of: {
     "id-ml-kem-512": 1, "id-ml-kem-768": 2, "id-ml-kem-1024": 3 } },
 
-  datatype: { base: [0, 9, 2342, 19200300, 100, 1], of: { domainComponent: 25 } },
+  datatype: { base: [0, 9, 2342, 19200300, 100, 1], of: { userId: 1, domainComponent: 25 } },
 
   fidoGenCe: { base: [1, 3, 6, 1, 4, 1, 45724, 1, 1], of: { idFidoGenCeAaguid: 4 } },
 

package/lib/pki-build.js

@@ -265,6 +265,27 @@ function _isDottedOid(s) {
 
 var b = asn1.build;
 
+/** @internal The distinguished-name attributes RFC 5280 App. A.1 types as something other than
+ *  DirectoryString, with the SIZE constraint the module states. Every other attribute is a
+ *  DirectoryString and takes UTF8String. A row here, not a branch, so a newly registered
+ *  attribute whose module entry names a type is a data addition. */
+var ATV_TYPE = intrinsic.assign(intrinsic.create(null), {
+  countryName: { encode: b.printable, tag: asn1.TAGS.PRINTABLE_STRING, size: [2, 2], what: "X520countryName, PrintableString SIZE(2)" },
+  jurisdictionCountryName: { encode: b.printable, tag: asn1.TAGS.PRINTABLE_STRING, size: [2, 2], what: "a jurisdiction country code, PrintableString SIZE(2)" },
+  distinguishedNameQualifier: { encode: b.printable, tag: asn1.TAGS.PRINTABLE_STRING, what: "X520dnQualifier, PrintableString" },
+  serialNumber: { encode: b.printable, tag: asn1.TAGS.PRINTABLE_STRING, size: [1, 64], what: "X520SerialNumber, PrintableString" },
+  emailAddress: { encode: b.ia5, tag: asn1.TAGS.IA5_STRING, size: [1, 255], what: "EmailAddress, IA5String" },
+  domainComponent: { encode: b.ia5, tag: asn1.TAGS.IA5_STRING, what: "DomainComponent, IA5String (RFC 4519 sec. 2.4)" },
+});
+
+/** @internal The DirectoryString CHOICE of RFC 5280 App. A.1. Every attribute the toolkit
+ *  publishes a short name for and does not give its own row above is valued as one, so a
+ *  pre-encoded value for one of them must be a member. An attribute with no published short
+ *  name has a syntax this toolkit does not claim to know, and its value stays opaque. */
+var DIRECTORY_STRING_TAGS = intrinsic.assign(intrinsic.create(null), {});
+[asn1.TAGS.TELETEX_STRING, asn1.TAGS.PRINTABLE_STRING, asn1.TAGS.UNIVERSAL_STRING,
+  asn1.TAGS.UTF8_STRING, asn1.TAGS.BMP_STRING].forEach(function (t) { DIRECTORY_STRING_TAGS[t] = 1; });
+
 var KU_BIT = intrinsic.assign(intrinsic.create(null), {
   digitalSignature: 0, nonRepudiation: 1, contentCommitment: 1, keyEncipherment: 2,
   dataEncipherment: 3, keyAgreement: 4, keyCertSign: 5, cRLSign: 6, encipherOnly: 7, decipherOnly: 8,
@@ -360,19 +381,55 @@ function makeBuilder(ctx) {
     return (y >= 1950 && y <= 2049) ? b.utcTime(date) : b.generalizedTime(date);
   }
 
-  function atvString(attrName, value) {
-    if (attrName === "countryName") {
-      if (String(value).length !== 2) throw E("bad-name", "countryName must be a two-letter ISO 3166 code (PrintableString SIZE(2))");
-      return b.printable(value);
+  function assertAtvValue(attrName, value) {
+    if (value == null || value === "") throw E("bad-name", "the " + attrName + " attribute value must be a non-empty string");
+    var row = ATV_TYPE[attrName];
+    if (!row || !row.size) return;
+    var len = _String(value).length;
+    if (len < row.size[0] || len > row.size[1]) {
+      throw E("bad-name", attrName + " must be " + (row.size[0] === row.size[1]
+        ? "exactly " + row.size[0] + " characters" : row.size[0] + " to " + row.size[1] + " characters") +
+        " (" + row.what + ", RFC 5280 App. A.1)");
     }
-    if (attrName === "emailAddress") return b.ia5(value);
-    return b.utf8(value);
+  }
+  function atvString(attrName, value) {
+    assertAtvValue(attrName, value);
+    var row = ATV_TYPE[attrName];
+    if (!row) return b.utf8(value);
+    return row.encode(value);
   }
   function encodeAtv(attrName, value) {
     if (value == null || value === "") throw E("bad-name", "the " + attrName + " attribute value must be a non-empty string");
     var typeOid = O(attrName);
     if (typeOid == null) throw E("bad-name", "unknown distinguished-name attribute " + guard.text.showValue(attrName));
     var valueTlv;
+    if (typeof value === "string" && _charCodeAt(value, 0) === 0x23) {
+      var raw = guard.encoding.hex(_sliceStr(value, 1), null, rawErr, ctx.prefix + "/bad-name", "a #hex attribute value");
+      guard.der.tlv(raw, rawErr, ctx.prefix + "/bad-name", "a #hex attribute value");
+      var rawNode = asn1.decode(raw);
+      var typeRow = ATV_TYPE[attrName];
+      var universalPrimitive = rawNode.tagClass === "universal" && !rawNode.constructed;
+      if (typeRow && (!universalPrimitive || rawNode.tagNumber !== typeRow.tag)) {
+        throw E("bad-name", "the " + attrName + " #hex value must be encoded as " + typeRow.what);
+      }
+      if (!typeRow && intrinsic.hasOwn(C.NAMES.DN_SHORT, attrName) &&
+          (!universalPrimitive || !DIRECTORY_STRING_TAGS[rawNode.tagNumber])) {
+        throw E("bad-name", "the " + attrName + " #hex value must be a DirectoryString: a TeletexString, PrintableString, UniversalString, UTF8String or BMPString (RFC 5280 App. A.1)");
+      }
+      var rawText;
+      try {
+        rawText = asn1.read.string(rawNode);
+      } catch (_e) {
+        rawText = null;
+      }
+      if (rawText !== null) {
+        try { atvString(attrName, rawText); }
+        catch (e) { if (e instanceof ErrorClass) throw e; throw E("bad-name", "the " + attrName + " #hex value carries characters invalid for that attribute's string type", e); }
+      }
+      return b.sequence([b.oid(typeOid), raw]);
+    }
+    if (typeof value === "string" && _charCodeAt(value, 0) === 0x5c) value = _sliceStr(value, 1);
+    if (value === "") throw E("bad-name", "the " + attrName + " attribute value must be a non-empty string");
     try { valueTlv = atvString(attrName, value); }
     catch (e) { if (e instanceof ErrorClass) throw e; throw E("bad-name", "the " + attrName + " value has characters invalid for its string type", e); }
     return b.sequence([b.oid(typeOid), valueTlv]);

package/lib/schema-all.js

@@ -60,85 +60,85 @@ var FORMATS = [
     name: "cms",
     module: cms,
     detect: cms.matches,
-    parse: function (input) { return cms.parse(input); },
+    parse: function (input, caps) { return cms.parse(input, caps); },
   },
   {
     name: "tsp",
     module: tsp,
     detect: tsp.matches,
-    parse: function (input) { return tsp.parse(input); },
+    parse: function (input, caps) { return tsp.parse(input, caps); },
   },
   {
     name: "crmf",
     module: crmf,
     detect: crmf.matches,
-    parse: function (input) { return crmf.parse(input); },
+    parse: function (input, caps) { return crmf.parse(input, caps); },
   },
   {
     name: "cmp",
     module: cmp,
     detect: cmp.matches,
-    parse: function (input) { return cmp.parse(input); },
+    parse: function (input, caps) { return cmp.parse(input, caps); },
   },
   {
     name: "csrattrs",
     module: csrattrs,
     detect: csrattrs.matches,
-    parse: function (input) { return csrattrs.parse(input); },
+    parse: function (input, caps) { return csrattrs.parse(input, caps); },
   },
   {
     name: "ocsp-request",
     module: ocsp,
     detect: ocsp.matchesRequest,
-    parse: function (input) { return ocsp.parseRequest(input); },
+    parse: function (input, caps) { return ocsp.parseRequest(input, caps); },
   },
   {
     name: "ocsp-response",
     module: ocsp,
     detect: ocsp.matchesResponse,
-    parse: function (input) { return ocsp.parseResponse(input); },
+    parse: function (input, caps) { return ocsp.parseResponse(input, caps); },
   },
   {
     name: "pkcs12",
     module: pkcs12,
     detect: pkcs12.matches,
-    parse: function (input) { return pkcs12.parse(input); },
+    parse: function (input, caps) { return pkcs12.parse(input, caps); },
   },
   {
     name: "pkcs8",
     module: pkcs8,
     detect: pkcs8.matches,
-    parse: function (input) { return pkcs8.parse(input); },
+    parse: function (input, caps) { return pkcs8.parse(input, caps); },
   },
   {
     name: "csr",
     module: csr,
     detect: csr.matches,
-    parse: function (input) { return csr.parse(input); },
+    parse: function (input, caps) { return csr.parse(input, caps); },
   },
   {
     name: "attrcert",
     module: attrcert,
     detect: attrcert.matches,
-    parse: function (input) { return attrcert.parse(input); },
+    parse: function (input, caps) { return attrcert.parse(input, caps); },
   },
   {
     name: "attrcert-v1",
     module: attrcert,
     detect: attrcert.matchesV1,
-    parse: function (input) { return attrcert.parseV1(input); },
+    parse: function (input, caps) { return attrcert.parseV1(input, caps); },
   },
   {
     name: "crl",
     module: crl,
     detect: crl.matches,
-    parse: function (input) { return crl.parse(input); },
+    parse: function (input, caps) { return crl.parse(input, caps); },
   },
   {
     name: "x509",
     module: x509,
     detect: x509.matches,
-    parse: function (input) { return x509.parse(input); },
+    parse: function (input, caps) { return x509.parse(input, caps); },
   },
 ];
 
@@ -159,7 +159,7 @@ function all() { return FORMATS.map(function (f) { return f.name; }); }
 
 /**
  * @primitive  pki.schema.parse
- * @signature  pki.schema.parse(input) -> parsed
+ * @signature  pki.schema.parse(input, caps?) -> parsed
  * @since      0.1.7
  * @status     stable
  * @spec       RFC 5280
@@ -171,6 +171,13 @@ function all() { return FORMATS.map(function (f) { return f.name; }); }
  * the bytes match no registered format; the underlying decode / structural
  * errors of the matched format propagate unchanged.
  *
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. They bound the detection decode
+ *     and the decode of whichever format matches, and a parse that exceeds one is refused
+ *     with the `/too-large` code of that format.
+ *
  * @example
  *   var pair = await pki.key.generate("Ed25519");
  *   var der = await pki.x509.sign({ subject: "example.com", subjectPublicKey: await pki.key.export(pair.publicKey),
@@ -178,11 +185,15 @@ function all() { return FORMATS.map(function (f) { return f.name; }); }
  *     { key: await pki.key.export(pair.privateKey) });
  *   var parsed = pki.schema.parse(der);  // cert -> the pki.schema.x509 shape
  */
-function parse(input) {
+function parse(input, callerOpts) {
+  /** @internal The caps are validated once here and the snapshot is what the chosen format
+   *  receives, so the detection decode and the format's own decode are held to the same
+   *  figures a caller named, read once. */
+  var caps = pkix.parseCaps(callerOpts, ENTRY);
   var der = pkix.coerceToDer(input, ENTRY);
-  var root = pkix.decodeRoot(der, ENTRY);
+  var root = pkix.decodeRoot(der, ENTRY, caps);
   for (var i = 0; i < FORMATS.length; i++) {
-    if (FORMATS[i].detect(root)) return FORMATS[i].parse(der);
+    if (FORMATS[i].detect(root)) return FORMATS[i].parse(der, caps);
   }
   throw new SchemaError("schema/unknown-format", "input does not match any registered PKI format (" + all().join(", ") + ")");
 }

package/lib/schema-attrcert.js

@@ -248,7 +248,7 @@ var ATTRIBUTE_CERTIFICATE = pkix.signedEnvelope(NS, ACINFO, {
 
 /**
  * @primitive  pki.schema.attrcert.parse
- * @signature  pki.schema.attrcert.parse(input) -> attributeCertificate
+ * @signature  pki.schema.attrcert.parse(input, caps?) -> attributeCertificate
  * @since      0.1.14
  * @status     stable
  * @spec       RFC 5755, X.509
@@ -279,25 +279,32 @@ var ATTRIBUTE_CERTIFICATE = pkix.signedEnvelope(NS, ACINFO, {
  *   var ac = pki.schema.attrcert.parse(der);
  *   ac.attributes[0].name;   // "role"
  *   ac.validity.notAfterTime;// Date
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
-var PARSE_OPTS = intrinsic.assign(intrinsic.create(null), { pemLabel: "ATTRIBUTE CERTIFICATE", PemError: PemError, ErrorClass: AttrCertError, prefix: "attrcert", what: "attribute certificate" });
+var PARSE_OPTS = intrinsic.assign(intrinsic.create(null), { pemLabel: "ATTRIBUTE CERTIFICATE", PemError: PemError, ErrorClass: AttrCertError, prefix: "attrcert", what: "attribute certificate", ns: NS });
 
 function _legacyV1Error() {
   return new AttrCertError("attrcert/legacy-v1-not-supported", "AttributeCertificateV1 (X.509-1997) is obsolete and not parsed by this build (RFC 5755 sec. 1)");
 }
 
-function _parseAc(input) {
-  var root = pkix.decodeRoot(pkix.coerceToDer(input, PARSE_OPTS), PARSE_OPTS);
-  if (matchesV1(root)) throw _legacyV1Error();
-  return schema.walk(ATTRIBUTE_CERTIFICATE, root, NS).result;
+function _parseAc(input, callerOpts) {
+  return pkix.runParseWith(input, PARSE_OPTS, callerOpts, function (root, ns) {
+    if (matchesV1(root)) throw _legacyV1Error();
+    return schema.walk(ATTRIBUTE_CERTIFICATE, root, ns).result;
+  });
 }
 
 var parse = guard.parsed.recordingParser("attributeCertificate", _parseAc,
   AttrCertError, "attrcert/bad-input", "an attribute certificate");
 
-function parseV1(input) {
-  pkix.decodeRoot(pkix.coerceToDer(input, PARSE_OPTS), PARSE_OPTS);
-  throw _legacyV1Error();
+function parseV1(input, callerOpts) {
+  return pkix.runParseWith(input, PARSE_OPTS, callerOpts, function () {
+    throw _legacyV1Error();
+  });
 }
 
 /**

package/lib/schema-c509.js

@@ -1563,7 +1563,7 @@ function _reconstructDer(r, sigNode) {
 
 /**
  * @primitive  pki.schema.c509.parse
- * @signature  pki.schema.c509.parse(bytes) -> { certificateType, serialNumber, serialNumberHex, ... }
+ * @signature  pki.schema.c509.parse(bytes, caps?) -> { certificateType, serialNumber, serialNumberHex, ... }
  * @since      0.2.30
  * @status     stable
  * @spec       draft-ietf-cose-cbor-encoded-cert, RFC 8949, RFC 9090, RFC 5280
@@ -1583,11 +1583,27 @@ function _reconstructDer(r, sigNode) {
  *     "hex");
  *   var c = pki.schema.c509.parse(bytes);
  *   c.certificateType; // 3
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
-function parse(input) {
+var _PARSE_OPTS = pkix.cborParseOpts(C509Error, "c509", "the C509 certificate");
+
+function parse(input, callerOpts) {
+  var caps = pkix.parseCaps(callerOpts, _PARSE_OPTS);
   var root;
-  try { root = cbor.decode(input); }
-  catch (e) { throw _err("c509/not-a-certificate", "the input is not well-formed deterministic CBOR", e); }
+  try {
+    root = cbor.decode(input, { maxBytes: caps.maxBytes, maxDepth: caps.maxDepth, maxItems: caps.maxItems });
+  } catch (e) {
+    /** @internal A resource refusal from the CBOR reader says the cap was too small. Reading it
+     *  as "these bytes are not a certificate" would send a caller to look at the wrong thing. */
+    if (pkix.isCborResourceRefusal(e)) {
+      throw _err("c509/too-large", "the C509 certificate exceeds the decode budget for this parse: " + ((e && e.message) || ""), e);
+    }
+    throw _err("c509/not-a-certificate", "the input is not well-formed deterministic CBOR", e);
+  }
   if (root.majorType !== 4 || !root.children) throw _err("c509/not-a-certificate", "a C509 certificate must be a CBOR array");
   var f = root.children;
   if (f.length !== 11) throw _err("c509/bad-tbs", "a C509 certificate must be an array of exactly 11 elements, got " + f.length);

package/lib/schema-cmc.js

@@ -646,7 +646,7 @@ function _finishBody(body, where) {
 
 /**
  * @primitive  pki.schema.cmc.parsePkiData
- * @signature  pki.schema.cmc.parsePkiData(der) -> parsed
+ * @signature  pki.schema.cmc.parsePkiData(der, caps?) -> parsed
  * @since      0.4.16
  * @status     stable
  * @spec       RFC 5272 sec. 3.2.1
@@ -664,17 +664,23 @@ function _finishBody(body, where) {
  *   var der = b.sequence([b.sequence([]), b.sequence([]), b.sequence([]), b.sequence([])]);
  *   var d = pki.schema.cmc.parsePkiData(der);
  *   d.controls.length;   // 0 -- present and empty, which is legal
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
-function parsePkiData(input) {
-  var root = asn1.decode(guard.bytes.isByteSource(input) ? guard.bytes.source(input, E, "cmc/bad-input", "the CMC DER") : Buffer.from(input));
-  var body = schema.walk(PKI_DATA, root, NS).result;
-  body.bytes = root.bytes;
-  return _finishBody(body, "pkiData");
+function parsePkiData(input, callerOpts) {
+  return pkix.runParseWith(input, _BODY_PARSE_OPTS, callerOpts, function (root, ns) {
+    var body = schema.walk(PKI_DATA, root, ns).result;
+    body.bytes = root.bytes;
+    return _finishBody(body, "pkiData");
+  });
 }
 
 /**
  * @primitive  pki.schema.cmc.parsePkiResponse
- * @signature  pki.schema.cmc.parsePkiResponse(der) -> parsed
+ * @signature  pki.schema.cmc.parsePkiResponse(der, caps?) -> parsed
  * @since      0.4.16
  * @status     stable
  * @spec       RFC 5272 sec. 4.2.1
@@ -690,17 +696,33 @@ function parsePkiData(input) {
  *   var der = b.sequence([b.sequence([]), b.sequence([]), b.sequence([])]);
  *   var r = pki.schema.cmc.parsePkiResponse(der);
  *   r.statuses.length;   // 0 -- no status control means success is assumed
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
-function parsePkiResponse(input) {
-  var root = asn1.decode(guard.bytes.isByteSource(input) ? guard.bytes.source(input, E, "cmc/bad-input", "the CMC DER") : Buffer.from(input));
-  var body = schema.walk(PKI_RESPONSE, root, NS).result;
-  body.bytes = root.bytes;
-  return _finishBody(body, "pkiResponse");
+function parsePkiResponse(input, callerOpts) {
+  return pkix.runParseWith(input, _BODY_PARSE_OPTS, callerOpts, function (root, ns) {
+    var body = schema.walk(PKI_RESPONSE, root, ns).result;
+    body.bytes = root.bytes;
+    return _finishBody(body, "pkiResponse");
+  });
 }
 
+/** @internal The door options for the two body parsers, which read a bare DER body rather than
+ *  a CMS carrier, so they take no PEM label. `rawDecodeErrors` keeps the codec's own code for a
+ *  malformed body, which callers already pin. */
+var _CARRIER_PARSE_OPTS = pkix.parseOpts({ ErrorClass: CmcError, prefix: "cmc", what: "the CMC message" });
+
+var _BODY_PARSE_OPTS = pkix.parseOpts({
+  ns: NS, ErrorClass: CmcError, PemError: CmcError, prefix: "cmc",
+  what: "the CMC body", pemLabel: null, rawDecodeErrors: true,
+});
+
 /**
  * @primitive  pki.schema.cmc.parse
- * @signature  pki.schema.cmc.parse(input) -> parsed
+ * @signature  pki.schema.cmc.parse(input, caps?) -> parsed
  * @since      0.4.16
  * @status     stable
  * @spec       RFC 5272, RFC 6402
@@ -724,17 +746,31 @@ function parsePkiResponse(input) {
  *   var sd = b.sequence([b.integer(3n), b.set([]), encap, b.set([])]);
  *   var der = b.sequence([b.oid("1.2.840.113549.1.7.2"), b.explicit(0, sd)]);
  *   pki.schema.cmc.parse(der).kind;   // "pkiData"
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
-function parse(input) {
+function parse(input, callerOpts) {
+  /** @internal Before the branch, because the already-parsed arm reaches no decode and would
+   *  otherwise hold a caller to the option contract only when they passed bytes. The snapshot
+   *  is what travels onward: handing the caller's own object to the CMS parser would read each
+   *  cap a second time, and a value read twice need not answer the same way twice. */
+  var caps = pkix.parseCaps(callerOpts, _CARRIER_PARSE_OPTS);
   var alreadyParsed = input && typeof input === "object" && !ArrayBuffer.isView(input) &&
     !guard.bytes.isByteSource(input) && input.encapContentInfo != null;
   var parsedCms;
   if (alreadyParsed) { parsedCms = input; }
   else {
     /** @internal Bytes that are not a CMS message at all are a CMC message this cannot read, and every
-     * other format parser answers for its own input in its own domain. */
-    try { parsedCms = cms.parse(input); }
+     * other format parser answers for its own input in its own domain. A resource refusal is the one
+     * exception: it is not a statement about the bytes, so it keeps its own code. */
+    try { parsedCms = cms.parse(input, caps); }
     catch (e) {
+      if (e && typeof e.code === "string" && e.code.indexOf("/too-large") !== -1) {
+        throw E("cmc/too-large", "the CMC message exceeds the decode budget for this parse: " + (e.message || ""), e);
+      }
       throw E("cmc/bad-der",
         "a CMC message is carried in a CMS SignedData or AuthenticatedData, and these bytes are not " +
         "one: " + ((e && e.message) || "malformed") + " (RFC 5272 sec. 3.2 / 4.2)", e);

package/lib/schema-cmp.js

@@ -751,7 +751,7 @@ var readName = _valueParser("Name", pkix.name(NS));
 
 /**
  * @primitive  pki.schema.cmp.parse
- * @signature  pki.schema.cmp.parse(input) -> pkiMessage
+ * @signature  pki.schema.cmp.parse(input, caps?) -> pkiMessage
  * @since      0.1.19
  * @status     stable
  * @spec       RFC 9810, RFC 9483, RFC 9481
@@ -805,6 +805,11 @@ var readName = _valueParser("Name", pkix.name(NS));
  *   var m = pki.schema.cmp.parse(der);
  *   m.body.arm;             // "ir", "ip", "error", ...
  *   m.header.transactionID; // raw Buffer or null
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
 var parse = pkix.makeParser({
   pemLabel: "CMP", PemError: PemError, ErrorClass: CmpError,

package/lib/schema-cms.js

@@ -934,7 +934,7 @@ var CONTENT_INFO = schema.seq([
 
 /**
  * @primitive  pki.schema.cms.parse
- * @signature  pki.schema.cms.parse(input) -> content
+ * @signature  pki.schema.cms.parse(input, caps?) -> content
  * @since      0.1.10
  * @status     stable
  * @spec       RFC 5652, RFC 5083, RFC 9629
@@ -972,6 +972,11 @@ var CONTENT_INFO = schema.seq([
  *   var cms = pki.schema.cms.parse(der);
  *   cms.signerInfos[0].sid.serialNumberHex;   // -> "0a1b"
  *   cms.encapContentInfo.eContent;            // -> Buffer | null (detached)
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
 var parse = pkix.makeRecordingParser({ pemLabel: "CMS", PemError: PemError, ErrorClass: CmsError, prefix: "cms", what: "CMS ContentInfo", topSchema: CONTENT_INFO, ns: NS }, "cms");
 

package/lib/schema-crl.js

@@ -157,7 +157,7 @@ var CERTIFICATE_LIST = pkix.signedEnvelope(NS, TBS_CERTLIST, {
 
 /**
  * @primitive  pki.schema.crl.parse
- * @signature  pki.schema.crl.parse(input) -> crl
+ * @signature  pki.schema.crl.parse(input, caps?) -> crl
  * @since      0.1.7
  * @status     stable
  * @spec       RFC 5280
@@ -180,6 +180,11 @@ var CERTIFICATE_LIST = pkix.signedEnvelope(NS, TBS_CERTLIST, {
  *     { cert: caCert, key: key });
  *   var crl = pki.schema.crl.parse(der);
  *   crl.revokedCertificates[0].serialNumberHex;  // -> "0a3f"
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
 var parse = pkix.makeRecordingParser({ pemLabel: "X509 CRL", PemError: PemError, ErrorClass: CrlError, prefix: "crl", what: "CRL", topSchema: CERTIFICATE_LIST, ns: NS }, "crl");
 

package/lib/schema-crmf.js

@@ -311,7 +311,7 @@ var CERT_REQ_MESSAGES = schema.seqOf(CERT_REQ_MSG, {
 
 /**
  * @primitive  pki.schema.crmf.parse
- * @signature  pki.schema.crmf.parse(input) -> certReqMessages
+ * @signature  pki.schema.crmf.parse(input, caps?) -> certReqMessages
  * @since      0.1.17
  * @status     stable
  * @spec       RFC 4211
@@ -348,6 +348,11 @@ var CERT_REQ_MESSAGES = schema.seqOf(CERT_REQ_MSG, {
  *     { key: await pki.key.export(pair.privateKey) });
  *   var m = pki.schema.crmf.parse(der);
  *   m.messages[0].certReq.certTemplate.subject.dn;   // "CN=req.example"
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
 var parse = pkix.makeRecordingParser({
   pemLabel: null, PemError: PemError, ErrorClass: CrmfError, prefix: "crmf",

package/lib/schema-csr.js

@@ -121,7 +121,7 @@ var CERTIFICATION_REQUEST = pkix.signedEnvelope(NS, CERTIFICATION_REQUEST_INFO,
 
 /**
  * @primitive  pki.schema.csr.parse
- * @signature  pki.schema.csr.parse(input) -> csr
+ * @signature  pki.schema.csr.parse(input, caps?) -> csr
  * @since      0.1.8
  * @status     stable
  * @spec       RFC 2986
@@ -147,6 +147,11 @@ var CERTIFICATION_REQUEST = pkix.signedEnvelope(NS, CERTIFICATION_REQUEST_INFO,
  *   var csr = pki.schema.csr.parse(der);
  *   csr.subject.dn;             // -> "CN=req.example"
  *   csr.attributes[0].type;     // -> "1.2.840.113549.1.9.14"
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
 var parse = pkix.makeRecordingParser({ pemLabel: "CERTIFICATE REQUEST", PemError: PemError, ErrorClass: CsrError, prefix: "csr", what: "certification request", topSchema: CERTIFICATION_REQUEST, ns: NS }, "csr");
 

package/lib/schema-csrattrs.js

@@ -244,7 +244,7 @@ var CSR_ATTRS = schema.seqOf(ATTR_OR_OID, {
 
 /**
  * @primitive  pki.schema.csrattrs.parse
- * @signature  pki.schema.csrattrs.parse(der) -> { items }
+ * @signature  pki.schema.csrattrs.parse(der, caps?) -> { items }
  * @since      0.1.24
  * @status     stable
  * @spec       RFC 8951, RFC 9908, RFC 7030
@@ -269,6 +269,11 @@ var CSR_ATTRS = schema.seqOf(ATTR_OR_OID, {
  *   ]);
  *   var a = pki.schema.csrattrs.parse(der);
  *   a.items[0].kind;   // -> "oid" | "attribute"
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
 var parse = pkix.makeParser({ pemLabel: null, PemError: frameworkError.PemError, ErrorClass: CsrattrsError, prefix: "csrattrs", what: "CsrAttrs", topSchema: CSR_ATTRS, ns: NS });
 

package/lib/schema-ocsp.js

@@ -431,7 +431,7 @@ var OCSP_REQUEST = schema.seq([
 
 /**
  * @primitive  pki.schema.ocsp.parseRequest
- * @signature  pki.schema.ocsp.parseRequest(input) -> ocspRequest
+ * @signature  pki.schema.ocsp.parseRequest(input, caps?) -> ocspRequest
  * @since      0.1.11
  * @status     stable
  * @spec       RFC 6960
@@ -458,12 +458,17 @@ var OCSP_REQUEST = schema.seq([
  *   var der = await pki.ocsp.buildRequest({ cert: leafDer, issuer: caDer }, {});
  *   var req = pki.schema.ocsp.parseRequest(der);
  *   req.requestList[0].certID.serialNumberHex;   // -> "1332"
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
 var parseRequest = pkix.makeParser({ pemLabel: "OCSP REQUEST", PemError: PemError, ErrorClass: OcspError, prefix: "ocsp", what: "OCSP request", topSchema: OCSP_REQUEST, ns: NS });
 
 /**
  * @primitive  pki.schema.ocsp.parseResponse
- * @signature  pki.schema.ocsp.parseResponse(input) -> ocspResponse
+ * @signature  pki.schema.ocsp.parseResponse(input, caps?) -> ocspResponse
  * @since      0.1.11
  * @status     stable
  * @spec       RFC 6960
@@ -495,6 +500,11 @@ var parseRequest = pkix.makeParser({ pemLabel: "OCSP REQUEST", PemError: PemErro
  *   var res = pki.schema.ocsp.parseResponse(der);
  *   res.responseStatus.name;                       // -> "successful"
  *   res.basicResponse.responses[0].certStatus.type; // -> "good" | "revoked" | "unknown"
+ * @opts
+ *   - `maxBytes` / `maxDepth` / `maxItems` (number) -- decode caps for this parse. Each
+ *     defaults to the matching `pki.C.LIMITS` figure and may only be set lower; a value
+ *     above it, or an option outside this set, is refused. A parse that exceeds one is
+ *     refused with the `/too-large` code of this format.
  */
 var parseResponse = pkix.makeRecordingParser({ pemLabel: "OCSP RESPONSE", PemError: PemError, ErrorClass: OcspError, prefix: "ocsp", what: "OCSP response", topSchema: OCSP_RESPONSE, ns: NS }, "ocspResponse");