@blamejs/pki 0.1.16 → 0.1.18

package/lib/schema-pkix.js

@@ -77,8 +77,17 @@ function _isPemArmor(buf) {
 
 // Decode the DER root, wrapping a codec fault in the caller's <prefix>/bad-der.
 function decodeRoot(der, opts) {
-  try { return asn1.decode(der); }
-  catch (e) { throw new opts.ErrorClass(opts.prefix + "/bad-der", (opts.what || "input") + " DER did not decode: " + ((e && e.message) || String(e)), e); }
+  // A format whose wire encoding is normatively BER (RFC 7292 PKCS#12) opts
+  // in to the codec's ber mode for the WHOLE decode. BER-vs-DER divergence is
+  // not always a decode-time throw — a definite-length constructed IMPLICIT
+  // OCTET STRING decodes strictly and only diverges at the typed reader — so
+  // a strict-first-retry-on-throw boundary would miss legal BER shapes. A
+  // strict-DER input decodes identically under the ber mode, every other
+  // strictness verdict included.
+  try { return asn1.decode(der, opts.ber ? { ber: true } : undefined); }
+  catch (e) {
+    throw new opts.ErrorClass(opts.prefix + "/bad-der", (opts.what || "input") + " DER did not decode: " + ((e && e.message) || String(e)), e);
+  }
 }
 
 // The shared parse entry: coerce -> decode -> walk the top schema. A format's
@@ -166,6 +175,12 @@ function attrValueToString(ns) {
       }
       return "#" + node.bytes.toString("hex");
     }
+  }, function (value) {
+    // encode: a "#hex" escape (RFC 4514 §2.4) round-trips its raw DER verbatim; any
+    // other string encodes as UTF8String (the decode does not preserve the original
+    // string type, so this is the canonical re-encoding, not a byte-exact one).
+    if (typeof value === "string" && value.charAt(0) === "#") return Buffer.from(value.slice(1), "hex");
+    return asn1.build.utf8(value);
   });
 }
 
@@ -193,25 +208,34 @@ function relativeDistinguishedName(ns) {
   // RelativeDistinguishedName ::= SET SIZE (1..MAX) — an empty SET {} is malformed.
   return schema.setOf(attributeTypeAndValue(ns), { assert: "set", min: 1, code: ns.prefix + "/bad-rdn", what: "RelativeDistinguishedName" });
 }
-function name(ns) {
-  return schema.seqOf(relativeDistinguishedName(ns), {
-    assert: "sequence", code: ns.prefix + "/bad-name", what: "Name",
-    build: function (m) {
-      var rdns = [], parts = [];
-      m.items.forEach(function (rdnItem) {
-        var atvs = [], atvParts = [];
-        rdnItem.value.items.forEach(function (atvItem) {
-          var a = atvItem.value.result; // atvItem.value = the atv seq-match; .result = its build result
-          atvs.push(a);
-          var label = (a.name && DN_SHORT[a.name]) || a.name || a.type;
-          atvParts.push(label + "=" + _escapeDnValue(a.value));
-        });
-        rdns.push(atvs);
-        parts.push(atvParts.join("+"));
+// opts.implicitTag (optional): read the Name as a [tag] IMPLICIT RDNSequence — the
+// context tag REPLACES the universal SEQUENCE tag, so the node is a context-class
+// constructed [tag] whose children ARE the RDN SETs (the CRMF CertTemplate issuer
+// [3] / subject [5] IMPLICIT arm, RFC 4211 §5). With no opts the shape is a bare
+// universal SEQUENCE OF, byte-identical to every existing caller.
+function name(ns, opts) {
+  opts = opts || {};
+  function nameBuild(m) {
+    var rdns = [], parts = [];
+    m.items.forEach(function (rdnItem) {
+      var atvs = [], atvParts = [];
+      rdnItem.value.items.forEach(function (atvItem) {
+        var a = atvItem.value.result; // atvItem.value = the atv seq-match; .result = its build result
+        atvs.push(a);
+        var label = (a.name && DN_SHORT[a.name]) || a.name || a.type;
+        atvParts.push(label + "=" + _escapeDnValue(a.value));
       });
-      return { rdns: rdns, dn: parts.join(", ") };
-    },
-  });
+      rdns.push(atvs);
+      parts.push(atvParts.join("+"));
+    });
+    return { rdns: rdns, dn: parts.join(", ") };
+  }
+  if (opts.implicitTag != null) {
+    return schema.implicitSeqOf(opts.implicitTag, relativeDistinguishedName(ns), {
+      code: ns.prefix + "/bad-name", what: "Name", build: nameBuild });
+  }
+  return schema.seqOf(relativeDistinguishedName(ns), {
+    assert: "sequence", code: ns.prefix + "/bad-name", what: "Name", build: nameBuild });
 }
 
 // GeneralName ::= CHOICE (RFC 5280 §4.2.1.6). A validate-and-surface-raw leaf for a
@@ -623,12 +647,20 @@ function extension(ns) {
     return { oid: extnID, name: ns.oid.name(extnID) || null, critical: critical, value: asn1.read.octetString(valueNode) };
   });
 }
-function extensions(ns) {
-  return schema.seqOf(extension(ns), {
-    assert: "sequence", min: 1, code: ns.prefix + "/bad-extensions", what: "Extensions",
-    unique: function (item) { return item.value.oid; }, dupCode: ns.prefix + "/duplicate-extension",
+// opts.implicitTag (optional): read Extensions as a [tag] IMPLICIT SEQUENCE OF
+// Extension — the context tag REPLACES the universal SEQUENCE tag, for the CRMF
+// CertTemplate extensions [9] (RFC 4211 §5). With no opts the shape is a bare
+// universal SEQUENCE OF, byte-identical to every existing caller.
+function extensions(ns, opts) {
+  opts = opts || {};
+  var EXT = extension(ns);
+  var extOpts = {
+    min: 1, code: ns.prefix + "/bad-extensions", what: "Extensions",
+    unique: function (it) { return it.value.oid; }, dupCode: ns.prefix + "/duplicate-extension",
     build: function (m) { return m.items.map(function (it) { return it.value; }); },
-  });
+  };
+  if (opts.implicitTag != null) return schema.implicitSeqOf(opts.implicitTag, EXT, extOpts);
+  return schema.seqOf(EXT, Object.assign({ assert: "sequence" }, extOpts));
 }
 
 // SubjectPublicKeyInfo ::= SEQUENCE { algorithm AlgorithmIdentifier,
@@ -636,17 +668,26 @@ function extensions(ns) {
 // universal SEQUENCE — a context-tagged or SET-tagged constructed node carrying
 // two well-formed children is NOT a SubjectPublicKeyInfo. Shared by the
 // certificate and CSR parsers.
-function spki(ns) {
+// opts.implicitTag (optional): read the SubjectPublicKeyInfo as a [tag] IMPLICIT
+// SEQUENCE (a context-class constructed node whose children are algorithm +
+// subjectPublicKey), for the CRMF CertTemplate publicKey [6] (RFC 4211 §5). With no
+// opts the shape is a universal SEQUENCE, byte-identical to every existing caller.
+function spki(ns, opts) {
+  opts = opts || {};
   return schema.seq([
     schema.field("algorithm", algorithmIdentifier(ns)),
     schema.field("subjectPublicKey", schema.bitString()),
   ], {
-    assert: "sequence", arity: { exact: 2 }, code: ns.prefix + "/bad-spki", what: "SubjectPublicKeyInfo",
+    assert: opts.implicitTag != null ? "implicit" : "sequence", implicitTag: opts.implicitTag,
+    arity: { exact: 2 }, code: ns.prefix + "/bad-spki", what: "SubjectPublicKeyInfo",
     build: function (m) {
       return {
         algorithm: m.fields.algorithm.value.result,
         publicKey: { unusedBits: m.fields.subjectPublicKey.value.unusedBits, bytes: m.fields.subjectPublicKey.value.bytes },
-        bytes: m.node.bytes,
+        // `bytes` is the importable SubjectPublicKeyInfo DER. In IMPLICIT [tag]
+        // mode the wire node leads with the context tag, so recover the SEQUENCE
+        // encoding a consumer imports / hashes rather than the [tag] wire form.
+        bytes: opts.implicitTag != null ? asn1.sequenceTlv(m.node) : m.node.bytes,
       };
     },
   });
@@ -660,7 +701,8 @@ function spki(ns) {
 function attribute(ns) {
   return schema.seq([
     schema.field("type", schema.oidLeaf()),
-    schema.field("values", schema.setOf(schema.any(), { assert: "set", min: 1, code: ns.prefix + "/bad-attribute-values", what: "attribute values" })),
+    schema.field("values", schema.setOf(schema.any(), { assert: "set", min: 1, max: constants.LIMITS.ATTRIBUTE_MAX_VALUES,
+      code: ns.prefix + "/bad-attribute-values", what: "attribute values" })),
   ], {
     assert: "sequence", arity: { exact: 2 }, code: ns.prefix + "/bad-attribute", what: "Attribute",
     build: function (m, ctx) {

package/lib/schema-tsp.js

@@ -359,7 +359,7 @@ function parseToken(input) {
     throw new TspError("tsp/multi-signer", "a TimeStampToken must contain exactly one (TSA) signerInfo (RFC 3161 §2.4.2)");
   }
   var tstInfo;
-  try { tstInfo = schema.walk(TST_INFO, asn1.decode(encap.eContent), NS); }
+  try { tstInfo = schema.embeddedDer(TST_INFO, encap.eContent, NS, { code: "tsp/bad-der", what: "the encapsulated TSTInfo" }); }
   catch (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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/pki",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "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:69692b51-d096-4124-9a0c-886b9a5ad78e",
+  "serialNumber": "urn:uuid:a14a33cf-8c68-40d3-92b0-6f17ef343543",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-07-06T19:48:47.311Z",
+    "timestamp": "2026-07-09T03:55:56.855Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/pki@0.1.16",
+      "bom-ref": "@blamejs/pki@0.1.18",
       "type": "application",
       "name": "pki",
-      "version": "0.1.16",
+      "version": "0.1.18",
       "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.1.16",
+      "purl": "pkg:npm/%40blamejs/pki@0.1.18",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/pki@0.1.16",
+      "ref": "@blamejs/pki@0.1.18",
       "dependsOn": []
     }
   ]