@blamejs/pki 0.8.3 → 0.8.4

package/lib/schema-pkcs12.js

@@ -188,7 +188,8 @@ var SAFE_BAG = schema.seq([
         }
         if (a.type === OID_LOCAL_KEY_ID) {
           if (seen[a.type] || a.values.length !== 1) throw ctx.E("pkcs12/bad-local-key-id", "localKeyId carries exactly one OCTET STRING value (PKCS#9 SINGLE VALUE)");
-          localKeyId = _octetContent(asn1.decode(a.values[0], { ber: true }), ctx, "a localKeyId value", "pkcs12/bad-local-key-id");
+          localKeyId = _octetContent(pkix.decodeNested(a.values[0], ctx, "a localKeyId value", { ber: true }), ctx,
+            "a localKeyId value", "pkcs12/bad-local-key-id");
         }
         seen[a.type] = true;
       }
@@ -255,7 +256,7 @@ var PFX = schema.seq([
     }
     if (authSafe.contentType === OID_SIGNED_DATA) {
       if (macPresent) throw ctx.E("pkcs12/bad-integrity-mode", "an id-signedData authSafe (public-key integrity) must omit macData (RFC 7292 sec. 4)");
-      var signed = cms.walkSignedData(authSafe.innerNode);
+      var signed = cms.walkSignedData(authSafe.innerNode, ctx);
       if (signed.encapContentInfo.eContentType !== OID_DATA) {
         throw ctx.E("pkcs12/bad-authsafe", "a public-key-integrity authSafe must encapsulate id-data carrying the AuthenticatedSafe (RFC 7292 sec. 4.1)");
       }
@@ -296,7 +297,7 @@ function _privacySafe(content, ctx) {
 }
 
 function _bmpValue(bytes, ctx) {
-  var node = asn1.decode(bytes, { ber: true });
+  var node = pkix.decodeNested(bytes, ctx, "a friendlyName value", { ber: true });
   if (!(node.tagClass === "universal" && node.tagNumber === TAGS.BMP_STRING)) {
     throw ctx.E("pkcs12/bad-friendly-name", "a friendlyName value must be a BMPString (RFC 7292 sec. 4.2)");
   }
@@ -310,12 +311,15 @@ function _walkAuthenticatedSafe(bytes, state, ctx) {
   });
 }
 
-// @internal
-function walkSafeContents(der) {
-  var walked = schema.walk(SAFE_CONTENTS, asn1.decode(der, { ber: true }), NS);
+/** @internal Reads a decrypted SafeContents. `ctx` is the parse context of the door that produced
+ *  the bytes when there is one, so its caps and budget reach the bags; the decrypt path in
+ *  pki.pkcs12.open has none and takes the built-in ceilings. */
+function walkSafeContents(der, ctx) {
+  var ns = schema.withResources(NS, ctx);
+  var walked = schema.walk(SAFE_CONTENTS, pkix.decodeNested(der, ns, "a SafeContents", { ber: true }), ns);
   var state = { budget: { remaining: C.LIMITS.PKCS12_MAX_REDECODES }, bagDepth: 0 };
   var bags = [];
-  for (var i = 0; i < walked.items.length; i++) bags.push(_buildBag(walked.items[i].value.result, state, NS));
+  for (var i = 0; i < walked.items.length; i++) bags.push(_buildBag(walked.items[i].value.result, state, ns));
   return bags;
 }
 
@@ -333,9 +337,9 @@ function _dispatchSafes(asMatch, state, ctx) {
         safeBags.push(_buildBag(contents.items[j].value.result, state, ctx));
       }
     } else if (el.contentType === OID_ENCRYPTED_DATA) {
-      encryptedSafes.push({ type: "encryptedData", content: _privacySafe(cms.walkEncryptedData(el.innerNode), ctx) });
+      encryptedSafes.push({ type: "encryptedData", content: _privacySafe(cms.walkEncryptedData(el.innerNode, ctx), ctx) });
     } else if (el.contentType === OID_ENVELOPED_DATA) {
-      encryptedSafes.push({ type: "envelopedData", content: _privacySafe(cms.walkEnvelopedData(el.innerNode), ctx), envelopedDataDer: el.innerNode.bytes });
+      encryptedSafes.push({ type: "envelopedData", content: _privacySafe(cms.walkEnvelopedData(el.innerNode, ctx), ctx), envelopedDataDer: el.innerNode.bytes });
     } else {
       throw ctx.E("pkcs12/bad-safe-contentinfo-type", "an AuthenticatedSafe element must be id-data, id-encryptedData, or id-envelopedData (RFC 7292 sec. 4.1), got " +
         (ctx.oid.name(el.contentType) || el.contentType));
@@ -351,13 +355,13 @@ function _buildBag(rec, state, ctx) {
   };
   if (rec.bagId === OID_KEY_BAG) {
     bag.type = "keyBag";
-    bag.key = pkcs8.walkPrivateKeyInfo(rec.valueNode);
+    bag.key = pkcs8.walkPrivateKeyInfo(rec.valueNode, ctx);
     bag.keyDer = rec.valueNode.bytes;
     return bag;
   }
   if (rec.bagId === OID_SHROUDED_KEY_BAG) {
     bag.type = "pkcs8ShroudedKeyBag";
-    bag.encrypted = pkcs8.walkEncryptedPrivateKeyInfo(rec.valueNode);
+    bag.encrypted = pkcs8.walkEncryptedPrivateKeyInfo(rec.valueNode, ctx);
     return bag;
   }
   if (rec.bagId === OID_CERT_BAG) {

package/lib/schema-pkcs8.js

@@ -193,8 +193,15 @@ function matches(root) {
 }
 
 
-function walkPrivateKeyInfo(node) { return schema.walk(PRIVATE_KEY_INFO, node, NS).result; }
-function walkEncryptedPrivateKeyInfo(node) { return schema.walk(ENCRYPTED_PRIVATE_KEY_INFO, node, NS).result; }
+/** @internal `ctx` is the walk context of the parse that reached this key, when another format
+ *  carries it. Only its caps and budget cross over: the key is still read in this namespace, so a
+ *  fault in it keeps the PKCS#8 error class and code. */
+function walkPrivateKeyInfo(node, ctx) {
+  return schema.walk(PRIVATE_KEY_INFO, node, schema.withResources(NS, ctx)).result;
+}
+function walkEncryptedPrivateKeyInfo(node, ctx) {
+  return schema.walk(ENCRYPTED_PRIVATE_KEY_INFO, node, schema.withResources(NS, ctx)).result;
+}
 
 module.exports = {
   parse: parse,

package/lib/schema-pkix.js

@@ -222,17 +222,16 @@ function _isPemArmor(buf) {
 /** @internal The codec's resource refusals, as distinct from its malformed-input refusals. A
  *  caller who tightened a cap has to be able to tell "your bytes are wrong" from "your cap is
  *  too small", and only the second is answered by raising the cap. */
-var RESOURCE_REFUSALS = intrinsic.assign(intrinsic.create(null), {
-  "asn1/too-large": 1, "asn1/too-deep": 1, "asn1/too-many-items": 1,
-});
+var _isResourceRefusal = schema.isResourceRefusal;
 
 function decodeRoot(der, opts, caps, budget) {
+  // allow:bare-decode the root decode a door performs, which is where the caller's caps enter.
   try { return asn1.decode(der, _decodeOptions(opts, caps)); }
   catch (e) {
     /** @internal `rawDecodeErrors` keeps the codec's own code for a malformed body, which some
      *  callers pin. A resource refusal is still translated, that code being new. */
-    if (opts.rawDecodeErrors && !(e && RESOURCE_REFUSALS[e.code])) throw e;
-    if (e && RESOURCE_REFUSALS[e.code]) {
+    if (opts.rawDecodeErrors && !_isResourceRefusal(e)) throw e;
+    if (_isResourceRefusal(e)) {
       if (budget) {
         try {
           budget.trip(opts.what || "the input");
@@ -338,12 +337,18 @@ var _emptyOptions = intrinsic.freeze(intrinsic.create(null));
 function runParseWith(input, opts, callerOpts, build) {
   var caps = parseCaps(callerOpts, opts);
   var budget = guard.limits.budget({ maxBytes: caps.maxBytes });
-  var ns = _nsWithBudget(opts.ns, budget);
+  var ns = _nsWithBudget(opts.ns, budget, caps);
   var result;
   try {
     result = build(decodeRoot(coerceToDer(input, opts), opts, caps, budget), ns, caps, budget);
   } catch (e) {
     if (guard.limits.isBudgetExceeded(e)) throw _budgetRefusal(opts, e);
+    /** @internal A refusal that is already this door's own resource verdict has been translated
+     *  once and carries the codec's refusal as its cause; wrapping it again would put a copy of
+     *  the verdict where a caller looks for the cap that was exceeded. */
+    if (budget.exhausted() && !(e && e.code === opts.prefix + "/too-large")) {
+      throw _budgetRefusal(opts, e);
+    }
     throw e;
   }
   if (budget.exhausted()) throw _budgetRefusal(opts, null);
@@ -357,17 +362,31 @@ function runParse(input, opts, callerOpts) {
 }
 
 /** @internal The re-read at the door is what makes the latch worth having: a catch anywhere
- *  under the walk may absorb the exception, and this still refuses. */
+ *  under the walk may absorb the exception or rewrap it as a domain error, and this still
+ *  refuses. The rewrapped error is carried as the cause. */
 function _budgetRefusal(opts, cause) {
   return new opts.ErrorClass(opts.prefix + "/too-large",
     (opts.what || "the input") + " exceeds the decode budget for this parse", cause || undefined);
 }
 
-function _nsWithBudget(ns, budget) {
-  var out = intrinsic.create(null);
-  _forEach(intrinsic.keys(ns), function (k) { out[k] = ns[k]; });
-  out.budget = budget;
-  return out;
+function _nsWithBudget(ns, budget, caps) {
+  return schema.withResources(ns, { budget: budget, caps: caps });
+}
+
+/** @internal The walk context a hand-rolled door builds for the structures it reads out of its
+ *  own input, so the caller's caps reach them the way `runParseWith` makes them reach a factory
+ *  parser's. The door re-reads `budget.exhausted()` before it returns a result. */
+function nestedContext(ns, caps) {
+  var budget = guard.limits.budget({ maxBytes: caps.maxBytes });
+  return { ns: _nsWithBudget(ns, budget, caps), budget: budget };
+}
+
+/** @internal The decode a format performs on a value it has already read out of its input: an
+ *  embedded OCTET STRING payload, an encapsulated protocol body. The engine owns it, because
+ *  `schema.embeddedDer` performs the same decode from inside a walk and the two must apply the
+ *  caller's caps and trip the parse budget the same way. This is the name format modules call. */
+function decodeNested(bytes, ctx, label, opts) {
+  return schema.decodeNested(bytes, ctx, label, opts);
 }
 
 var DN_SHORT = constants.NAMES.DN_SHORT;
@@ -489,6 +508,7 @@ function attrValueToString(ns) {
         throw ns.E(ns.prefix + "/bad-atv", "a #hex attribute value must be a non-empty even run of hex digits (RFC 4514 sec. 2.4)");
       }
       var raw = guard.encoding.hex(hex, null, ns.E, ns.prefix + "/bad-atv", "a #hex attribute value");
+      // allow:bare-decode the encoder side, checking bytes a caller wrote by hand, outside any parse.
       try { asn1.decode(raw); }
       catch (e) { throw ns.E(ns.prefix + "/bad-atv", "a #hex attribute value must encode exactly one DER TLV", e); }
       return raw;
@@ -826,7 +846,7 @@ function decodeIssuingDistributionPointValue(ns, bytes, code) {
     indirect: false, onlyAttr: false, fields: null };
   var m;
   try {
-    m = schema.walk(issuingDistributionPoint(code), asn1.decode(bytes), ns);
+    m = schema.walk(issuingDistributionPoint(code), schema.decodeNested(bytes, ns, "an IssuingDistributionPoint value"), ns);
     if (m.fields.distributionPoint.present) {
       var wrap = m.fields.distributionPoint.node;
       if (!wrap.children || wrap.children.length !== 1) {
@@ -928,15 +948,20 @@ function userNoticeTexts(qualifier) {
   return i === kids.length ? out : [];
 }
 
+/** @internal The readers an extension or attribute value is decoded through. `ctx` is the walk
+ *  context of the parse that reached the value, when one did: the bytes here are an OCTET STRING
+ *  payload the root decode stopped at, so this decode restarts depth and item counting and needs
+ *  the caller's caps handed to it. A caller outside a parse passes none and takes the built-in
+ *  ceilings, which is what `ns` carries. */
 function _decodeHelpers(ns) {
-  function decodeTop(buf, code, what) {
+  function decodeTop(buf, code, what, ctx) {
     var n;
-    try { n = asn1.decode(buf); }
+    try { n = schema.decodeNested(buf, ctx || ns, what); }
     catch (e) { throw ns.E(code, "malformed " + what + " value: " + ((e && e.message) || _String(e)), e); }
     return n;
   }
-  function seqChildren(buf, code, what) {
-    var n = decodeTop(buf, code, what);
+  function seqChildren(buf, code, what, ctx) {
+    var n = decodeTop(buf, code, what, ctx);
     if (n.tagClass !== "universal" || n.tagNumber !== _T.SEQUENCE || !n.children) {
       throw ns.E(code, what + " must be a SEQUENCE (RFC 5280 sec. 4.2.1)");
     }
@@ -1576,6 +1601,8 @@ module.exports = {
   isCborResourceRefusal: isCborResourceRefusal,
   cborParseOpts: cborParseOpts,
   parseOpts: parseOpts,
+  decodeNested: decodeNested,
+  nestedContext: nestedContext,
   makeNS: makeNS,
   versionReader: versionReader,
   DN_SHORT: DN_SHORT,

package/lib/schema-tsp.js

@@ -204,7 +204,7 @@ var TIME_STAMP_RESP = schema.seq([
   schema.optional("timeStampToken", schema.any(), { whenUniversal: [TAGS.SEQUENCE] }),
 ], {
   assert: "sequence", arity: { min: 1 }, code: "tsp/bad-response", what: "TimeStampResp",
-  build: function (m) {
+  build: function (m, ctx) {
     var status = m.fields.status.value.result;
     var present = m.fields.timeStampToken.present;
     var granted = status.status === 0 || status.status === 1;
@@ -215,7 +215,9 @@ var TIME_STAMP_RESP = schema.seq([
       status: status.status,
       statusString: status.statusString,
       failInfo: status.failInfo,
-      timeStampToken: present ? parseToken(m.fields.timeStampToken.value.bytes) : null,
+      /** @internal The token is a second parse of bytes carried inside this one, so it takes the
+       *  caps this door was given rather than the built-in ceilings. */
+      timeStampToken: present ? parseToken(m.fields.timeStampToken.value.bytes, ctx ? ctx.caps : undefined) : null,
     };
   },
 });
@@ -424,12 +426,23 @@ function parseToken(input, callerOpts) {
   if (!hasSigningCert) {
     throw new TspError("tsp/missing-signing-certificate", "a TimeStampToken signerInfo must carry a SigningCertificate or SigningCertificateV2 signed attribute (RFC 3161 sec. 2.4.2, RFC 5816)");
   }
+  /** @internal The TSTInfo is decoded out of the eContent the CMS layer handed back, so it is a
+   *  second decode and takes the caller's caps the way the carrier did. The latch is re-read
+   *  below, because the catch here answers in this domain and would otherwise report a cap that
+   *  was too small as a malformed TSTInfo. */
+  var nested = pkix.nestedContext(NS, caps);
   var tstInfo;
-  try { tstInfo = schema.embeddedDer(TST_INFO, encap.eContent, NS, { code: "tsp/bad-der", what: "the encapsulated TSTInfo" }); }
+  try { tstInfo = schema.embeddedDer(TST_INFO, encap.eContent, nested.ns, { code: "tsp/bad-der", what: "the encapsulated TSTInfo" }); }
   catch (e) {
+    if (nested.budget.exhausted()) {
+      throw new TspError("tsp/too-large", "the timeStampToken exceeds the decode budget for this parse", e);
+    }
     if (e instanceof TspError) throw e;
     throw new TspError("tsp/bad-der", "the encapsulated TSTInfo did not decode: " + ((e && e.message) || String(e)), e);
   }
+  if (nested.budget.exhausted()) {
+    throw new TspError("tsp/too-large", "the timeStampToken exceeds the decode budget for this parse");
+  }
   return { tstInfo: tstInfo.result, eContent: encap.eContent, signerInfo: signed.signerInfos[0], certificates: signed.certificates };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/pki",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "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:9e704e55-ccb2-4ecb-9370-04d6f58aa807",
+  "serialNumber": "urn:uuid:ca3c695a-64b2-4346-9529-6a6c719eb6bb",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-20T04:03:01.349Z",
+    "timestamp": "2026-09-20T06:26:19.862Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/pki@0.8.3",
+      "bom-ref": "@blamejs/pki@0.8.4",
       "type": "application",
       "name": "pki",
-      "version": "0.8.3",
+      "version": "0.8.4",
       "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.8.3",
+      "purl": "pkg:npm/%40blamejs/pki@0.8.4",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/pki@0.8.3",
+      "ref": "@blamejs/pki@0.8.4",
       "dependsOn": []
     }
   ]