@blamejs/pki 0.8.1 → 0.8.3

package/lib/schema-pkcs12.js

@@ -396,7 +396,7 @@ function _buildBag(rec, state, ctx) {
 
 /**
  * @primitive  pki.schema.pkcs12.parse
- * @signature  pki.schema.pkcs12.parse(input) -> pfx
+ * @signature  pki.schema.pkcs12.parse(input, caps?) -> pfx
  * @since      0.1.18
  * @status     stable
  * @spec       RFC 7292, RFC 9579
@@ -441,6 +441,11 @@ function _buildBag(rec, state, ctx) {
  *   var der = await pki.pkcs12.build({ key: key, cert: cert }, { password: "changeit" });
  *   var store = pki.schema.pkcs12.parse(der);
  *   store.safeBags.map(function (b) { return b.type; });
+ * @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: "PKCS12", PemError: PemError, ErrorClass: Pkcs12Error,

package/lib/schema-pkcs8.js

@@ -88,7 +88,7 @@ var ENCRYPTED_PRIVATE_KEY_INFO = schema.seq([
 
 /**
  * @primitive  pki.schema.pkcs8.parse
- * @signature  pki.schema.pkcs8.parse(input) -> privateKey
+ * @signature  pki.schema.pkcs8.parse(input, caps?) -> privateKey
  * @since      0.1.9
  * @status     stable
  * @spec       RFC 5208, RFC 5958
@@ -107,12 +107,17 @@ var ENCRYPTED_PRIVATE_KEY_INFO = schema.seq([
  *   var key = pki.schema.pkcs8.parse(der);
  *   key.privateKeyAlgorithm.oid;   // -> "1.3.101.112" (Ed25519)
  *   key.privateKey;                // -> Buffer (the inner key encoding)
+ * @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: "PRIVATE KEY", PemError: PemError, ErrorClass: Pkcs8Error, prefix: "pkcs8", what: "private key", topSchema: PRIVATE_KEY_INFO, ns: NS });
 
 /**
  * @primitive  pki.schema.pkcs8.parseEncrypted
- * @signature  pki.schema.pkcs8.parseEncrypted(input) -> encrypted
+ * @signature  pki.schema.pkcs8.parseEncrypted(input, caps?) -> encrypted
  * @since      0.1.9
  * @status     stable
  * @spec       RFC 5958, RFC 5208
@@ -128,6 +133,11 @@ var parse = pkix.makeParser({ pemLabel: "PRIVATE KEY", PemError: PemError, Error
  *   var der = await pki.key.encrypt(await pki.key.export(pair.privateKey), "s3cr3t");
  *   var enc = pki.schema.pkcs8.parseEncrypted(der);
  *   enc.encryptionAlgorithm.oid;   // -> "1.2.840.113549.1.5.13" (PBES2)
+ * @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 parseEncrypted = pkix.makeParser({ pemLabel: "ENCRYPTED PRIVATE KEY", PemError: PemError, ErrorClass: Pkcs8Error, prefix: "pkcs8", what: "encrypted private key", topSchema: ENCRYPTED_PRIVATE_KEY_INFO, ns: NS });
 

package/lib/schema-pkix.js

@@ -219,15 +219,155 @@ function _isPemArmor(buf) {
   return true;
 }
 
-function decodeRoot(der, opts) {
-  try { return asn1.decode(der, opts.ber ? { ber: true } : undefined); }
+/** @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,
+});
+
+function decodeRoot(der, opts, caps, budget) {
+  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 (budget) {
+        try {
+          budget.trip(opts.what || "the input");
+        } catch (_b) {
+          /* allow:swallow-unverified the latch is the point here; the refusal below carries the cause */
+        }
+      }
+      throw new opts.ErrorClass(opts.prefix + "/too-large",
+        (opts.what || "the input") + " exceeds the decode budget for this parse: " + (e.message || _String(e)), e);
+    }
     throw new opts.ErrorClass(opts.prefix + "/bad-der", (opts.what || "input") + " DER did not decode: " + ((e && e.message) || _String(e)), e);
   }
 }
 
-function runParse(input, opts) {
-  return schema.walk(opts.topSchema, decodeRoot(coerceToDer(input, opts), opts), opts.ns).result;
+/** @internal A fresh options object per decode. The strictness a format declares and the caps
+ *  a caller asked for are combined here and nowhere else, so neither can be written onto the
+ *  other's object and outlive this call. */
+function _decodeOptions(opts, caps) {
+  if (!caps) return opts.ber ? { ber: true } : undefined;
+  var out = { maxBytes: caps.maxBytes, maxDepth: caps.maxDepth, maxItems: caps.maxItems };
+  if (opts.ber) out.ber = true;
+  return out;
+}
+
+/** @internal The decode caps a caller may name, each paired with the `C.LIMITS` default that
+ *  is also its ceiling. A cap may tighten and may not loosen: the defaults are the resource
+ *  the toolkit is willing to spend, and a caller raising one past them would be granting
+ *  themselves more than the built-in refusal allows. */
+var PARSE_CAPS = intrinsic.assign(intrinsic.create(null), {
+  maxBytes: "DER_MAX_BYTES",
+  maxDepth: "DER_MAX_DEPTH",
+  maxItems: "DER_MAX_ITEMS",
+});
+
+/** @internal A format that reads something other than DER declares its own ceilings through
+ *  `opts.capLimits`, so the bound a caller is held to is the one their parser actually uses. */
+var CBOR_PARSE_CAPS = intrinsic.assign(intrinsic.create(null), {
+  maxBytes: "CBOR_MAX_BYTES",
+  maxDepth: "CBOR_MAX_DEPTH",
+  maxItems: "CBOR_MAX_ITEMS",
+});
+
+var CBOR_RESOURCE_REFUSALS = intrinsic.assign(intrinsic.create(null), {
+  "cbor/too-large": 1, "cbor/too-deep": 1, "cbor/too-many-items": 1,
+});
+
+function isCborResourceRefusal(e) {
+  return !!(e && typeof e.code === "string" && CBOR_RESOURCE_REFUSALS[e.code] === 1);
+}
+
+function cborParseOpts(ErrorClass, prefix, what) {
+  var out = intrinsic.create(null);
+  out.ErrorClass = ErrorClass;
+  out.prefix = prefix;
+  out.what = what;
+  out.capLimits = CBOR_PARSE_CAPS;
+  return out;
+}
+
+/** @internal A parser door's options, held on a prototype-less object so a computed lookup on
+ *  it answers from what the format declared. Every hand-rolled door builds its options here
+ *  rather than as a literal in its own module. */
+function parseOpts(spec) {
+  var out = intrinsic.create(null);
+  _forEach(intrinsic.keys(spec), function (k) { out[k] = spec[k]; });
+  return out;
+}
+
+/** @internal Reads the caller's caps into a FRESH object. Nothing is written back onto what
+ *  the caller passed, and nothing else is ever written onto the returned one, so a resource
+ *  option cannot become a strictness flag on a shared object. */
+function parseCaps(callerOpts, opts) {
+  var E = function (message) { return new opts.ErrorClass(opts.prefix + "/bad-input", message); };
+  if (callerOpts === undefined || callerOpts === null) callerOpts = _emptyOptions;
+  if (typeof callerOpts !== "object" || intrinsic.isArray(callerOpts) || guard.bytes.isByteSource(callerOpts)) {
+    throw E("parse options must be an object of decode caps");
+  }
+  var capLimits = opts.capLimits || PARSE_CAPS;
+  guard.identifier.assertKnownKeys(callerOpts, capLimits,
+    function (code, message) { return new opts.ErrorClass(code, message); },
+    opts.prefix + "/bad-input", "parse does not take the option ");
+  var caps = intrinsic.create(null);
+  _forEach(intrinsic.keys(capLimits), function (key) {
+    var ceiling = constants.LIMITS[capLimits[key]];
+    var asked = callerOpts[key];
+    if (asked === undefined) { caps[key] = ceiling; return; }
+    if (!intrinsic.isInteger(asked) || asked < 0) {
+      throw E(key + " must be a non-negative integer no greater than " + ceiling);
+    }
+    if (asked > ceiling) {
+      throw E(key + " " + asked + " is above the built-in ceiling " + ceiling + "; a cap may only tighten");
+    }
+    caps[key] = asked;
+  });
+  return caps;
+}
+var _emptyOptions = intrinsic.freeze(intrinsic.create(null));
+
+/** @internal The door every format parser opens, whether it composes the shared factory or
+ *  hand-rolls its walk. `build(rootNode, ns)` does the format's own work; everything around it
+ *  is the part that must not be re-implemented per parser, because each re-implementation is
+ *  another place the caller's caps can go missing or the latch can go unread. */
+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 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);
+    throw e;
+  }
+  if (budget.exhausted()) throw _budgetRefusal(opts, null);
+  return result;
+}
+
+function runParse(input, opts, callerOpts) {
+  return runParseWith(input, opts, callerOpts, function (root, ns) {
+    return schema.walk(opts.topSchema, root, ns).result;
+  });
+}
+
+/** @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. */
+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;
 }
 
 var DN_SHORT = constants.NAMES.DN_SHORT;
@@ -403,7 +543,8 @@ function name(ns, opts) {
       _forEach(rdnItem.value.items, function (atvItem) {
         var a = atvItem.value.result;
         _push(atvs, a);
-        var label = (a.name && _hasOwn(DN_SHORT, a.name) && DN_SHORT[a.name]) || a.name || a.type;
+        var label = (a.name && _hasOwn(DN_SHORT, a.name) && DN_SHORT[a.name]) ||
+          (guard.name.isAttributeDescriptor(a.name) ? a.name : a.type);
         _push(atvParts, label + "=" + _dnDisplayValue(a.value));
       });
       _push(rdns, atvs);
@@ -1355,7 +1496,7 @@ function rootSequenceChildren(root, minLen, maxLen) {
 }
 
 function makeParser(opts) {
-  return function (input) { return runParse(input, opts); };
+  return function (input, callerOpts) { return runParse(input, opts, callerOpts); };
 }
 
 function makeRecordingParser(opts, kind) {
@@ -1429,6 +1570,12 @@ module.exports = {
   isPemArmor: _isPemArmor,
   decodeRoot: decodeRoot,
   runParse: runParse,
+  runParseWith: runParseWith,
+  parseCaps: parseCaps,
+  CBOR_PARSE_CAPS: CBOR_PARSE_CAPS,
+  isCborResourceRefusal: isCborResourceRefusal,
+  cborParseOpts: cborParseOpts,
+  parseOpts: parseOpts,
   makeNS: makeNS,
   versionReader: versionReader,
   DN_SHORT: DN_SHORT,

package/lib/schema-smime.js

@@ -187,7 +187,7 @@ var SMIME_CAPABILITIES = schema.seqOf(SMIME_CAPABILITY, {
 
 /**
  * @primitive  pki.schema.smime.parseSigningCertificate
- * @signature  pki.schema.smime.parseSigningCertificate(der) -> { certs, policies }
+ * @signature  pki.schema.smime.parseSigningCertificate(der, caps?) -> { certs, policies }
  * @since      0.1.22
  * @status     stable
  * @spec       RFC 5035, RFC 2634
@@ -207,6 +207,11 @@ var SMIME_CAPABILITIES = schema.seqOf(SMIME_CAPABILITY, {
  *   var av = b.sequence([b.sequence([essCertId])]);                     // SigningCertificate { certs }
  *   var sc = pki.schema.smime.parseSigningCertificate(av);
  *   sc.certs[0].hashAlgorithm.name;    // "sha1" (implied)
+ * @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 parseSigningCertificate = pkix.makeParser({ pemLabel: null, PemError: PemError, ErrorClass: SmimeError, prefix: "smime", what: "SigningCertificate", topSchema: SIGNING_CERTIFICATE, ns: NS });
 
@@ -236,7 +241,7 @@ var parseSigningCertificateV2 = pkix.makeParser({ pemLabel: null, PemError: PemE
 
 /**
  * @primitive  pki.schema.smime.parseSmimeCapabilities
- * @signature  pki.schema.smime.parseSmimeCapabilities(der) -> { capabilities }
+ * @signature  pki.schema.smime.parseSmimeCapabilities(der, caps?) -> { capabilities }
  * @since      0.1.22
  * @status     stable
  * @spec       RFC 8551
@@ -253,6 +258,11 @@ var parseSigningCertificateV2 = pkix.makeParser({ pemLabel: null, PemError: PemE
  *   var cap = b.sequence([b.oid(pki.oid.byName("aes256-CBC"))]);
  *   var caps = pki.schema.smime.parseSmimeCapabilities(b.sequence([cap]));
  *   caps.capabilities[0].name;    // "aes256-CBC"
+ * @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 parseSmimeCapabilities = pkix.makeParser({ pemLabel: null, PemError: PemError, ErrorClass: SmimeError, prefix: "smime", what: "SMIMECapabilities", topSchema: SMIME_CAPABILITIES, ns: NS });
 

package/lib/schema-tsp.js

@@ -46,6 +46,8 @@ var PemError = frameworkError.PemError;
 
 var NS = pkix.makeNS("tsp", TspError, oid);
 
+var _TOKEN_PARSE_OPTS = pkix.parseOpts({ ErrorClass: TspError, prefix: "tsp", what: "the timeStampToken" });
+
 var ALGORITHM_IDENTIFIER = pkix.algorithmIdentifier(NS);
 var EXTENSION = pkix.extension(NS);
 
@@ -250,7 +252,7 @@ var TIME_STAMP_REQ = schema.seq([
 
 /**
  * @primitive  pki.schema.tsp.parseRequest
- * @signature  pki.schema.tsp.parseRequest(input) -> timeStampReq
+ * @signature  pki.schema.tsp.parseRequest(input, caps?) -> timeStampReq
  * @since      0.2.19
  * @status     stable
  * @spec       RFC 3161
@@ -268,12 +270,17 @@ var TIME_STAMP_REQ = schema.seq([
  *   var req = pki.schema.tsp.parseRequest(der);
  *   req.certReq;                        // -> boolean
  *   req.messageImprint.hashedMessage;   // -> Buffer (the raw digest)
+ * @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: null, PemError: PemError, ErrorClass: TspError, prefix: "tsp", what: "TimeStampReq", topSchema: TIME_STAMP_REQ, ns: NS });
 
 /**
  * @primitive  pki.schema.tsp.parseTstInfo
- * @signature  pki.schema.tsp.parseTstInfo(input) -> tstInfo
+ * @signature  pki.schema.tsp.parseTstInfo(input, caps?) -> tstInfo
  * @since      0.1.13
  * @status     stable
  * @spec       RFC 3161
@@ -299,12 +306,17 @@ var parseRequest = pkix.makeParser({ pemLabel: null, PemError: PemError, ErrorCl
  *   var tst = pki.schema.tsp.parseTstInfo(der);
  *   tst.genTime;                       // -> Date
  *   tst.messageImprint.hashedMessage;  // -> Buffer (the raw digest)
+ * @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 parseTstInfo = pkix.makeParser({ pemLabel: null, PemError: PemError, ErrorClass: TspError, prefix: "tsp", what: "TSTInfo", topSchema: TST_INFO, ns: NS });
 
 /**
  * @primitive  pki.schema.tsp.parse
- * @signature  pki.schema.tsp.parse(input) -> timeStampResp
+ * @signature  pki.schema.tsp.parse(input, caps?) -> timeStampResp
  * @since      0.1.13
  * @status     stable
  * @spec       RFC 3161
@@ -329,12 +341,17 @@ var parseTstInfo = pkix.makeParser({ pemLabel: null, PemError: PemError, ErrorCl
  *   var res = pki.schema.tsp.parse(der);
  *   res.status;                              // -> 0 (granted)
  *   res.timeStampToken.tstInfo.genTime;      // -> Date (a granted token is decoded)
+ * @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: PemError, ErrorClass: TspError, prefix: "tsp", what: "TimeStampResp", topSchema: TIME_STAMP_RESP, ns: NS });
 
 /**
  * @primitive  pki.schema.tsp.parseToken
- * @signature  pki.schema.tsp.parseToken(input) -> tstInfo
+ * @signature  pki.schema.tsp.parseToken(input, caps?) -> tstInfo
  * @since      0.1.13
  * @status     stable
  * @spec       RFC 3161, RFC 5652
@@ -364,13 +381,28 @@ var parse = pkix.makeParser({ pemLabel: null, PemError: PemError, ErrorClass: Ts
  *   var token = pki.schema.tsp.parseToken(tokenDer);
  *   token.tstInfo.genTime;   // -> Date
  *   token.signerInfo.sid;    // -> the TSA signer identifier
+ * @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 parseToken(input) {
+function parseToken(input, callerOpts) {
+  /** @internal The caller's options are this door's to answer for, so they are read here rather
+   *  than inside the CMS parser: a complaint about an option must not come back wearing the
+   *  delegate's verdict about the content. The snapshot travels onward, because handing the
+   *  caller's own object to the CMS parser would read each cap a second time. */
+  var caps = pkix.parseCaps(callerOpts, _TOKEN_PARSE_OPTS);
   var der = pkix.coerceToDer(input, { pemLabel: null, PemError: PemError, ErrorClass: TspError, prefix: "tsp" });
   var signed;
-  try { signed = cms.parse(der); }
+  try { signed = cms.parse(der, caps); }
   catch (e) {
     if (e instanceof TspError) throw e;
+    /** @internal A resource refusal says the cap was too small, not that the token is malformed,
+     *  so it keeps that meaning rather than becoming a statement about the bytes. */
+    if (e && typeof e.code === "string" && e.code.indexOf("/too-large") !== -1) {
+      throw new TspError("tsp/too-large", "the timeStampToken exceeds the decode budget for this parse: " + (e.message || ""), e);
+    }
     throw new TspError("tsp/bad-token", "the timeStampToken did not decode as a CMS SignedData: " + ((e && e.message) || String(e)), e);
   }
   if (signed.contentTypeName !== "signedData") {

package/lib/schema-x509.js

@@ -165,7 +165,7 @@ var CERTIFICATE = pkix.signedEnvelope(NS, CERTIFICATE_TBS, {
 
 /**
  * @primitive  pki.schema.x509.parse
- * @signature  pki.schema.x509.parse(input) -> certificate
+ * @signature  pki.schema.x509.parse(input, caps?) -> certificate
  * @since      0.1.7
  * @status     stable
  * @spec       RFC 5280, X.509
@@ -194,6 +194,11 @@ var CERTIFICATE = pkix.signedEnvelope(NS, CERTIFICATE_TBS, {
  *   cert.subject.dn;                 // "CN=example.com, O=Example"
  *   cert.validity.notAfter;          // Date
  *   cert.signatureAlgorithm.name;    // "Ed25519" (the algorithm the issuer signed with)
+ * @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", PemError: PemError, ErrorClass: CertificateError, prefix: "x509", what: "certificate", topSchema: CERTIFICATE, ns: NS }, "certificate");
 

package/lib/x509-sign.js

@@ -23,6 +23,9 @@ var signScheme = require("./sign-scheme");
 var guard = require("./guard-all");
 var intrinsic = require("./guard-intrinsic");
 var _isArray = intrinsic.isArray, _bufferEquals = intrinsic.bufferEquals;
+var _dnCharCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
+var _dnKeys = intrinsic.keys;
+var _dnHasOwn = intrinsic.hasOwn;
 var frameworkError = require("./framework-error");
 var schema = require("./schema-engine");
 var pkix = require("./schema-pkix");
@@ -788,4 +791,100 @@ function _extension(name, value, opts) {
   return _ext(row.oid, critical, valueDer);
 }
 
-module.exports = { sign: sign, randomSerial: randomSerial, extension: extension };
+/**
+ * @primitive  pki.x509.parseDn
+ * @signature  pki.x509.parseDn(dn) -> { rdns, dn, bytes }
+ * @since      0.8.2
+ * @status     stable
+ * @spec       RFC 4514
+ * @related    pki.x509.sign, pki.schema.x509.parse
+ *
+ * Read a distinguished-name string into the `Name` a builder takes, using the attribute names
+ * and value escaping of RFC 4514 sec. 2.4 and sec. 3. It is the inverse of the `dn` string
+ * every parsed name carries: `bytes` is the encoded `Name`, ready to hand to `pki.x509.sign`
+ * as a `subject` or `issuer`, and `dn` is the string re-emitted from what was read, which for
+ * a string this toolkit produced is the string it was given.
+ *
+ * Components are read in the order they are written, so the first one written is the first
+ * element of the encoded `Name`. That is the order every `dn` here is emitted in, and the
+ * order `openssl x509 -subject` prints. RFC 4514 sec. 2.1 specifies the opposite order, so a
+ * string from a directory tool that follows it names the components from last to first;
+ * reverse them before parsing one.
+ *
+ * The string form does not carry the ASN.1 string type of each value, so a parsed value takes
+ * the type this toolkit encodes that attribute with: `PrintableString` for `countryName`,
+ * `IA5String` for `emailAddress`, `UTF8String` otherwise. A name written by something that
+ * chose different types will re-encode to different bytes, which is why RFC 4514 sec. 2.4
+ * defines the `#`-prefixed hex form: a value given that way is the exact DER of the
+ * `AttributeValue` and round-trips byte for byte.
+ *
+ * Malformed input throws `x509/bad-dn`. A non-string throws `x509/bad-input`.
+ *
+ * `bytes` is raw `Name` DER, the form `spec.subject` and `spec.issuer` take alongside a string
+ * or an array of RDNs, so a name read from a string can be signed without rebuilding it.
+ *
+ * @example
+ *   var name = pki.x509.parseDn("C=US, O=Example Inc, CN=leaf");
+ *   name.rdns.length;               // -> 3
+ *   name.rdns[0][0].name;           // -> "countryName"
+ *   name.dn;                        // -> "C=US, O=Example Inc, CN=leaf"
+ *   Buffer.isBuffer(name.bytes);    // -> true
+ */
+function parseDn(dn) {
+  if (typeof dn !== "string") throw _err("x509/bad-input", "pki.x509.parseDn takes a distinguished-name string");
+  var components = guard.name.parseDnString(dn, _err, "x509/bad-dn", "the distinguished name");
+  var spec = [];
+  for (var i = 0; i < components.length; i++) {
+    var rdn = components[i], out = intrinsic.create(null);
+    for (var j = 0; j < rdn.length; j++) {
+      var atv = rdn[j];
+      var attrName;
+      try { attrName = _dnAttrName(atv.type); }
+      catch (e) {
+        if (e instanceof CertificateError && e.code === "x509/bad-dn") throw e;
+        throw _err("x509/bad-dn", "the distinguished name has an attribute type that does not resolve: " + guard.text.showValue(atv.type), e);
+      }
+      if (_dnHasOwn(out, attrName)) {
+        throw _err("x509/bad-dn", "the distinguished name repeats " + attrName + " inside one relative distinguished name");
+      }
+      out[attrName] = atv.hex === null ? _dnLiteralValue(atv.value) : "#" + atv.hex;
+    }
+    guard.list.append(spec, out);
+  }
+  var bytes, read;
+  try {
+    bytes = _b.encodeName(spec);
+    read = schema.walk(NAME_SCHEMA, asn1.decode(bytes), NS).result;
+  } catch (e) {
+    throw _err("x509/bad-dn", "the distinguished name does not encode: " + (e && e.message), e);
+  }
+  return { rdns: read.rdns, dn: read.dn, bytes: bytes };
+}
+
+function _dnAttrName(type) {
+  if (oid.isDottedDecimal(type)) {
+    var byOid = oid.name(type);
+    if (!byOid) throw _err("x509/bad-dn", "the distinguished name names an unregistered attribute OID " + type);
+    return byOid;
+  }
+  var wanted = guard.name.lowerAscii(type);
+  var shortNames = pkix.DN_SHORT;
+  var keys = _dnKeys(shortNames);
+  for (var i = 0; i < keys.length; i++) {
+    if (guard.name.lowerAscii(shortNames[keys[i]]) === wanted || guard.name.lowerAscii(keys[i]) === wanted) return keys[i];
+  }
+  var table = oid.all();
+  var dotted = _dnKeys(table);
+  for (var j = 0; j < dotted.length; j++) {
+    var registered = table[dotted[j]];
+    if (guard.name.lowerAscii(registered) === wanted) return registered;
+  }
+  throw _err("x509/bad-dn", "the distinguished name names an unknown attribute " + guard.text.showValue(type));
+}
+
+function _dnLiteralValue(value) {
+  var first = _dnCharCodeAt(value, 0);
+  return (first === 0x23 || first === 0x5c) ? "\\" + value : value;
+}
+
+module.exports = { sign: sign, randomSerial: randomSerial, extension: extension, parseDn: parseDn };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/pki",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "Pure-JavaScript PKI toolkit that owns its stack — X.509, ASN.1/DER, CMS, PQC-first.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",
@@ -68,7 +68,9 @@
     "test": "node test/smoke.js",
     "lint": "eslint --max-warnings 0 .",
     "fuzz": "npm ci --prefix fuzz && npx --prefix fuzz jazzer fuzz/asn1-der.fuzz.js -- -max_total_time=60",
-    "gates": "node test/layer-0-primitives/codebase-patterns.test.js && node scripts/validate-source-comment-blocks.js && node scripts/check-api-snapshot.js && node scripts/check-spelling-consistency.js && node scripts/check-engine-floor.js",
+    "gates": "node test/layer-0-primitives/codebase-patterns.test.js && node scripts/validate-source-comment-blocks.js && node scripts/check-api-snapshot.js && node scripts/check-spelling-consistency.js && node scripts/check-engine-floor.js && node scripts/check-cve-vectors.js && node scripts/check-rfc-currency.js",
+    "check:cve-vectors": "node scripts/check-cve-vectors.js",
+    "check:rfc-currency": "node scripts/check-rfc-currency.js",
     "check:engine-floor": "node scripts/check-engine-floor.js",
     "check:spelling": "node scripts/check-spelling-consistency.js",
     "coverage": "c8 --include=lib/** --include=index.js --reporter=text-summary --reporter=lcov node test/smoke.js",

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:e0552083-e17a-4a74-b1fc-ea82fcb57a1e",
+  "serialNumber": "urn:uuid:9e704e55-ccb2-4ecb-9370-04d6f58aa807",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-19T23:58:45.411Z",
+    "timestamp": "2026-09-20T04:03:01.349Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/pki@0.8.1",
+      "bom-ref": "@blamejs/pki@0.8.3",
       "type": "application",
       "name": "pki",
-      "version": "0.8.1",
+      "version": "0.8.3",
       "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.1",
+      "purl": "pkg:npm/%40blamejs/pki@0.8.3",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/pki@0.8.1",
+      "ref": "@blamejs/pki@0.8.3",
       "dependsOn": []
     }
   ]