@blamejs/pki 0.6.14 → 0.6.16

package/lib/inspect.js

@@ -35,23 +35,15 @@ var schemaAll = require("./schema-all");
 var pkix = require("./schema-pkix");
 var guard = require("./guard-all");
 
-// Display-naming conventions are centralized in pki.C.NAMES (shared with the strict
-// parsers so the labels can't drift); this module only composes them.
 var NAMES = constants.NAMES;
 
 var InspectError = frameworkError.InspectError;
 function _err(code, message, cause) { return new InspectError(code, message, cause); }
 
-// A dedicated namespace + decoder set: the shared RFC 5280 extension decoders,
-// composed exactly as path-validate / acme compose them. Decode failures here are
-// caught by the renderer and fall back to a hex dump (inspection is best-effort).
 var NS = pkix.makeNS("inspect", InspectError, oid);
 var EXT_DECODERS = pkix.certExtensionDecoders(NS).byOid;
-// Dispatch on the stable OID, not the display name: pki.oid.register() can override a built-in
-// name, which would silently skip the userNotice rendering and hex-dump the notice instead.
 var OID_UNOTICE = oid.byName("unotice");
 
-// ---- formatting helpers ------------------------------------------------------
 
 var HEX = "0123456789abcdef";
 function _hexColon(buf, opts) {
@@ -62,7 +54,6 @@ function _hexColon(buf, opts) {
     hex.push(opts.upper ? s.toUpperCase() : s);
   }
   if (!opts.wrap) return hex.join(":");
-  // Wrap at `opts.wrap` bytes per line, each line indented by `opts.indent`.
   var pad = " ".repeat(opts.indent || 0), lines = [];
   for (var j = 0; j < hex.length; j += opts.wrap) {
     var chunk = hex.slice(j, j + opts.wrap).join(":");
@@ -71,31 +62,15 @@ function _hexColon(buf, opts) {
   return lines.join("\n");
 }
 
-// Coverage residual: two _hexColon default arms are unreachable through the public API.
-//   * `opts = opts || {}`. All call sites pass an explicit opts object literal, so the
-//     `|| {}` default never fires.
-//   * `" ".repeat(opts.indent || 0)`. Every wrap-mode caller passes a positive indent
-//     (pad.length + 8 >= 8, or inner.length == 16), so `opts.indent` is never falsy.
 
-// Control-byte neutralization for a GeneralName string value routes through the
-// guard family (the guard-shape-reinlined detector protects the shape).
 // @guard-via guard\.name\.escape
 var _clean = guard.name.escapeControlBytes;
 
-// The DN display string. pki.schema.pkix already assembles a fully RFC 4514-escaped
-// dn (short names from pki.C.NAMES.DN_SHORT, values escaped via guard.name.escapeDnValue,
-// with the '#'-hex / leading-'\' sentinel handled), so reuse it and never re-escape
-// the already-escaped values (which would double-escape a leading '#' / '\').
 function _dnString(name) { return (name && name.dn) || ""; }
 
 var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
 function _two(n) { return (n < 10 ? "0" : "") + n; }
-// OpenSSL date: "Jul  4 07:00:27 2026 GMT" (month, space-padded day, time, year, GMT).
 function _date(iso) {
-  // Rebuilt from the instant the value holds, so every field below is read off a Date of this
-  // realm. The calendar methods are ordinary ones a subclass answers, and a parsed structure can
-  // carry a Date a caller supplied, so reading them off that value let it decide the date printed
-  // beside a certificate rather than the one the certificate carries.
   var held = guard.time.isDate(iso) ? guard.time.instantOf(iso) : Date.parse(String(iso));
   if (isNaN(held)) return String(iso);
   var d = new Date(held);
@@ -107,18 +82,12 @@ function _date(iso) {
 
 function _algName(a) { return (a && (a.name || a.oid)) || "unknown"; }
 
-// ---- serial + public key -----------------------------------------------------
 
 function _serial(cert, indent) {
   var hex = cert.serialNumberHex || "";
   if (hex.length % 2) hex = "0" + hex;
   var buf = Buffer.from(hex, "hex");
-  // Strip a single DER positive-sign 00 byte (present when the value's high bit is
-  // set) so the printed serial is the integer value, matching OpenSSL, and not the
-  // encoding's leading octet.
   if (buf.length > 1 && buf[0] === 0x00 && (buf[1] & 0x80)) buf = buf.subarray(1);
-  // Small non-negative serials render inline as decimal (0xhex), like OpenSSL;
-  // anything larger renders as a colon-hex block.
   if (buf.length <= 6) {
     var n = parseInt(buf.toString("hex") || "0", 16);
     return "Serial Number: " + n + " (0x" + (_stripLeadingZeros(buf.toString("hex")) || "0") + ")";
@@ -128,9 +97,6 @@ function _serial(cert, indent) {
 
 var CURVE_BITS = { "P-256": 256, "P-384": 384, "P-521": 521, "prime256v1": 256, "secp384r1": 384, "secp521r1": 521 };
 var NIST_NAME = NAMES.NIST_CURVE;
-// Every RSA-family key algorithm carries the same SPKI subjectPublicKey, an
-// RSAPublicKey SEQUENCE { modulus, publicExponent } (RFC 4055 sec. 1.2 for
-// id-RSASSA-PSS / id-RSAES-OAEP), so all decode to modulus + exponent, not raw bytes.
 var RSA_KEY_ALGS = { rsaEncryption: 1, rsassaPss: 1, rsaesOaep: 1 };
 function _keyBlock(spki, pad) {
   var algName = _algName(spki.algorithm);
@@ -141,7 +107,7 @@ function _keyBlock(spki, pad) {
   if (algName === "ecPublicKey" || algName === "id-ecPublicKey") {
     var curveName = null;
     try { curveName = oid.name(asn1.read.oid(asn1.decode(spki.algorithm.parameters))); }
-    catch (_e) { /* unknown curve */ }
+    catch (_e) { }
     var bits = CURVE_BITS[curveName] || (pub ? ((pub.length - 1) / 2) * 8 : 0);
     out.push(inner + "Public-Key: (" + bits + " bit)");
     if (pub) { out.push(inner + "pub:"); out.push(_hexColon(pub, { wrap: 16, indent: (pad.length + 8) })); }
@@ -150,39 +116,29 @@ function _keyBlock(spki, pad) {
   }
   if (RSA_KEY_ALGS[algName]) {
     try {
-      var rsa = asn1.decode(pub);   // RSAPublicKey ::= SEQUENCE { modulus INTEGER, publicExponent INTEGER }
+      var rsa = asn1.decode(pub);
       var modBig = asn1.read.integer(rsa.children[0]);
       var expBig = asn1.read.integer(rsa.children[1]);
       var modHex = modBig.toString(16); if (modHex.length % 2) modHex = "0" + modHex;
       var modBuf = Buffer.from(modHex, "hex");
-      // Bit length is the value's, not the byte count's (a 0x7f.. modulus is 127-bit,
-      // not 128), and the DER sign-padding 00 is present only when the top bit is set.
       out.push(inner + "Public-Key: (" + modBig.toString(2).length + " bit)");
       out.push(inner + "Modulus:");
       var modDisplay = (modBuf.length && (modBuf[0] & 0x80)) ? Buffer.concat([Buffer.from([0x00]), modBuf]) : modBuf;
       out.push(_hexColon(modDisplay, { wrap: 16, indent: (pad.length + 8) }));
       out.push(inner + "Exponent: " + expBig.toString(10) + " (0x" + expBig.toString(16) + ")");
       return out.join("\n");
-    } catch (_e) { /* fall through to raw */ }
+    } catch (_e) { }
   }
-  // EdDSA / ML-DSA / SLH-DSA / anything else: show the raw public-key bytes.
   if (pub) { out.push(inner + "Public-Key: (" + (pub.length * 8) + " bit)"); out.push(inner + "pub:"); out.push(_hexColon(pub, { wrap: 16, indent: (pad.length + 8) })); }
   return out.join("\n");
 }
 
-// ---- extensions --------------------------------------------------------------
 
-// Display-naming conventions from pki.C.NAMES (see constants.js); an entry absent
-// from a table falls back to the registered name / OID.
 var EXT_LABEL = NAMES.EXTENSION;
 var KU_LABEL = NAMES.KEY_USAGE;
 var EKU_LABEL = NAMES.EXT_KEY_USAGE;
 var GN_KIND = NAMES.GENERAL_NAME;
 
-// An iPAddress octet string -> a readable address, matching OpenSSL: 4 bytes as a
-// dotted-quad, 16 as (non-compressed, uppercase) IPv6, and the name-constraints
-// 8/32-byte address+mask forms as "addr/mask". Never emits a raw octet (a stray
-// 0x0a would inject a newline into the report); an odd length falls back to hex.
 function _ipString(buf) {
   if (!Buffer.isBuffer(buf)) return "";
   if (buf.length === 4) return buf[0] + "." + buf[1] + "." + buf[2] + "." + buf[3];
@@ -196,18 +152,6 @@ function _ipString(buf) {
   return _hexColon(buf, {});
 }
 
-// Format a decoded GeneralName ({tagClass, tagNumber, value, bytes}) the way
-// OpenSSL labels each choice. A directoryName carries a full DN (RFC 4514-escaped
-// via _dnString); an iPAddress is a Buffer rendered as an address (never raw bytes);
-// an otherName / unknown choice falls back to hex so a hostile value can never break
-// the report's line structure. The string choices (DNS / URI / email) are
-// control-byte-escaped -- which stops the severe case, a forged report line -- but
-// their structural separators are left as-is, matching OpenSSL (a GeneralName has no
-// RFC 4514-equivalent escaping profile, and escaping a legitimate comma in a URI
-// would misrepresent it).
-// The DN of a decoded directoryName GeneralName value. Shared so every renderer that meets this
-// form (the SAN/AKI GeneralName path and the AIA/SIA accessLocation path, which carry different
-// decoded shapes) prints the same DN, with neither falling back to a bare tag number.
 function _gnDn(value) {
   return (value && Array.isArray(value.rdns)) ? _dnString(value) : ((value && value.dn) || "");
 }
@@ -224,8 +168,6 @@ function _gn(g) {
   return kind + ":" + v;
 }
 
-// Format a GeneralName still in its raw DER TLV (a CRL distribution point leaves
-// its fullName entries undecoded): decode the context tag and render its content.
 function _gnRaw(buf) {
   if (!Buffer.isBuffer(buf)) return "";
   try {
@@ -233,35 +175,12 @@ function _gnRaw(buf) {
     var t = node.tagNumber;
     if (t === 1 || t === 2 || t === 6) return GN_KIND[t] + ":" + _clean(node.content.toString("latin1"));
     if (t === 7) return "IP Address:" + _ipString(node.content);
-    return _hexColon(buf, {});   // dirName / otherName / registeredID -> best-effort hex
+    return _hexColon(buf, {});
     // allow:swallow-unverified drop-silent display fallback (tier-3): fullName GNs reach here as
-    // schema-validated TLVs so asn1.decode cannot throw -- an unreachable defensive best-effort hex render.
   } catch (_e) { return _hexColon(buf, {}); }
 }
 
-// Coverage residual: the GeneralName render fallbacks are unreachable because the strict
-// generalName decoder and each caller already narrow the shape (the _gnRaw catch above is
-// separately documented).
-//   * _ipString `if (!Buffer.isBuffer(buf)) return "";`. Every caller passes a Buffer (the
-//     recursion slices a Buffer, _gn guards Buffer.isBuffer(g.value), _gnRaw passes
-//     asn1.decode(...).content).
-//   * _ipString trailing `return _hexColon(buf, {});`. generalName enforces iPAddress to
-//     4/16 octets (8/32 for a name-constraints subtree base), so length is only ever 4/8/16/32.
-//   * _gn `if (!g || typeof g !== "object") return "";`. Every _gn call maps a decoder-produced
-//     GeneralName object; the decoders never emit a null element.
-//   * _gn directoryName `: ((g.value && g.value.dn) || "")`. A decoded directoryName [4] always
-//     carries a Name with an rdns array, so the rdns arm is always taken.
-//   * _gn otherName `: "<unsupported>"`. A decoded GeneralName always carries its raw bytes TLV.
-//   * _gn `|| ("tag" + t)`. GeneralName CHOICE tags are 0..8, all mapped in NAMES.GENERAL_NAME;
-//     generalName rejects a tag outside 0..8.
-//   * _gn `? _hexColon(g.value, {})`. iPAddress [7] is the only choice whose decoded value is a
-//     Buffer, handled at the t === 7 branch before this ternary; other tags' value is string or null.
-//   * _gn trailing `: ""`. A decoded GeneralName always carries a bytes Buffer, so the
-//     Buffer.isBuffer(g.bytes) arm is always taken.
-//   * _gnRaw `if (!Buffer.isBuffer(buf)) return "";`. The sole caller (the CRL-DP fullName loop)
-//     guards Buffer.isBuffer(nm) before calling _gnRaw.
 
-// Shared value renderers reused by more than one extension key.
 function _renderAltName(decoded, inner) {
   return inner + (decoded.names || []).map(_gn).join(", ");
 }
@@ -277,8 +196,6 @@ function _renderCrlDp(decoded, inner) {
       dpLines.push(inner + "Relative Name (to CRL issuer)");
       wrote = true;
     }
-    // The reasons BIT STRING scopes which revocation reasons this DP covers; dropping
-    // it would make a scoped revocation source look generally applicable.
     if (dp.reasons && Buffer.isBuffer(dp.reasons.bytes)) {
       var rf = [], rb = dp.reasons.bytes;
       for (var bit = 1; bit < rb.length * 8; bit++) {
@@ -286,8 +203,6 @@ function _renderCrlDp(decoded, inner) {
       }
       if (rf.length) { dpLines.push(inner + "Reasons: " + rf.join(", ")); wrote = true; }
     }
-    // A DistributionPoint may carry only cRLIssuer (an indirect CRL, no
-    // distributionPoint): render the issuer GeneralNames, never drop them.
     if (dp.cRLIssuer && Array.isArray(dp.cRLIssuer.names)) {
       dpLines.push(inner + "CRL Issuer:");
       dp.cRLIssuer.names.forEach(function (g) { dpLines.push(inner + "  " + _gn(g)); });
@@ -298,24 +213,7 @@ function _renderCrlDp(decoded, inner) {
   return dpLines.join("\n");
 }
 
-// Coverage residual -- the shared alt-name / CRL-DP render fallbacks are unreachable because the
-// strict decoders already narrow the shape:
-//   * _renderAltName `(decoded.names || [])` -- the subjectAltName/issuerAltName decoder always
-//     yields a names array.
-//   * _renderCrlDp `(decoded || [])`. The cRLDistributionPoints/freshestCRL decoder always
-//     yields an array.
-//   * _renderCrlDp `: _gn(nm)`. distributionPointName surfaces fullName entries as raw
-//     GeneralName Buffers, so Buffer.isBuffer(nm) is always true.
-//   * _renderCrlDp `if (!wrote) ... "(distribution point)"`. crlDistributionPoints throws unless
-//     a distributionPoint (always fullName/rdn) or cRLIssuer (sets wrote) is present, so !wrote
-//     never holds.
 
-// Declarative extension-value renderer registry: extension name -> (decoded, inner) ->
-// text. Data-driven dispatch (the schema family's "registry, not switch" shape) so a
-// new extension is a row, never another hand-coded branch, and the set an
-// operator sees rendered is visible in one place. An extension with no row here
-// hex-dumps its raw value (best-effort); each row's output is pinned by an
-// inspect.test.js conformance vector.
 var EXT_RENDERERS = {
   keyUsage: function (decoded, inner) {
     return inner + Object.keys(KU_LABEL).filter(function (k) { return decoded[k]; }).map(function (k) { return KU_LABEL[k]; }).join(", ");
@@ -324,7 +222,7 @@ var EXT_RENDERERS = {
     return inner + decoded.map(function (o) {
       var n = null;
       try { n = oid.name(o); }
-      catch (_e) { /* unregistered EKU OID */ }
+      catch (_e) { }
       return EKU_LABEL[n] || n || o;
     }).join(", ");
   },
@@ -336,15 +234,15 @@ var EXT_RENDERERS = {
   qcStatements: function (decoded, inner) {
     return decoded.map(function (s) {
       var label = inner + (s.name || s.statementId), info = s.info;
-      if (!info) return label;                                                              // presence-only (QcCompliance / QcSSCD)
+      if (!info) return label;
       if (info.opaque) return label + " (opaque)";
-      if (typeof info.amount !== "undefined") return label + ": " + info.amount + " " + info.currency + (info.exponent ? " x10^" + info.exponent : "");   // QcLimitValue
-      if (typeof info.years !== "undefined") return label + ": " + info.years + " years";   // QcRetentionPeriod
-      if (info.typeNames) return label + ": " + info.typeNames.map(function (n, i) { return n || info.types[i]; }).join(", ");         // QcType
-      if (info.methodNames) return label + ": " + info.methodNames.map(function (n, i) { return n || info.methods[i]; }).join(", ");   // QcIdentMethod
-      if (info.locations) return label + ": " + info.locations.map(function (l) { return l.url + " (" + l.language + ")"; }).join(", "); // QcPDS
-      if (info.countries) return label + ": " + info.countries.join(", ");                  // QcCClegislation / QcQSCDlegislation
-      if (typeof info.semanticsIdentifier !== "undefined") {                                // SemanticsInformation (id-qcs)
+      if (typeof info.amount !== "undefined") return label + ": " + info.amount + " " + info.currency + (info.exponent ? " x10^" + info.exponent : "");
+      if (typeof info.years !== "undefined") return label + ": " + info.years + " years";
+      if (info.typeNames) return label + ": " + info.typeNames.map(function (n, i) { return n || info.types[i]; }).join(", ");
+      if (info.methodNames) return label + ": " + info.methodNames.map(function (n, i) { return n || info.methods[i]; }).join(", ");
+      if (info.locations) return label + ": " + info.locations.map(function (l) { return l.url + " (" + l.language + ")"; }).join(", ");
+      if (info.countries) return label + ": " + info.countries.join(", ");
+      if (typeof info.semanticsIdentifier !== "undefined") {
         var nra = info.nameRegistrationAuthorities && info.nameRegistrationAuthorities.length;
         return label + (info.semanticsIdentifier ? ": " + info.semanticsIdentifier : "") + (nra ? " (" + nra + " NRA)" : "");
       }
@@ -371,33 +269,18 @@ var EXT_RENDERERS = {
     decoded.forEach(function (p) {
       lines.push(inner + "Policy: " + p.policyIdentifier);
       if (!Buffer.isBuffer(p.qualifiersBytes)) return;
-      // Render each PolicyQualifierInfo { policyQualifierId, qualifier }: a printable
-      // qualifier (a CPS URI is an IA5String) shows as text, else a hex dump, and is never
-      // dropped (which would make a qualified policy look unqualified).
       try {
         (asn1.decode(p.qualifiersBytes).children || []).forEach(function (pqi) {
           var qid = asn1.read.oid(pqi.children[0]), q = pqi.children[1];
           var label = null;
           try { label = oid.name(qid); }
-          catch (_e) { /* unregistered qualifier */ }
-          // A userNotice is a constructed SEQUENCE, so the printable-content test below can never
-          // read it and it would hex-dump -- leaving the operator unable to read the very text the
-          // qualifier exists to display. Render its DisplayText members through the shared pkix
-          // reader (the same one pki.lint measures), so both agree on what the notice says.
+          catch (_e) { }
           if (qid === OID_UNOTICE) {
-            // Render only when every member decoded under its declared string type. A null text means
-            // the value did not, and showing the members that happened to decode would present a
-            // partial notice as a complete one, so the whole qualifier falls through to the hex
-            // dump, where the operator sees the bytes the certificate actually holds.
-            // A null noticeNumbers means the reference did not fully decode, and is refused for the
-            // same reason as a null text: a partially decoded notice must not be shown as a whole one.
             var texts = pkix.userNoticeTexts(q);
             if (texts.length && texts.every(function (t) {
               return t.text !== null && (t.field !== "organization" || t.noticeNumbers !== null);
             })) {
               texts.forEach(function (t) {
-                // A NoticeReference is identified by organization AND number, so the numbers ride with
-                // the organization -- printing the text alone would drop the key that names the notice.
                 var nums = (t.noticeNumbers && t.noticeNumbers.length) ? " #" + t.noticeNumbers.join(", ") : "";
                 lines.push(inner + "  " + (label || qid) + " " + t.field + ": " + _clean(t.text) + nums);
               });
@@ -418,24 +301,15 @@ var EXT_RENDERERS = {
   cRLDistributionPoints: _renderCrlDp,
   freshestCRL: _renderCrlDp,
   authorityInfoAccess: function (decoded, inner) {
-    // AccessDescription list: <accessMethod> - <accessLocation>. The method resolves to its name (caIssuers /
-    // ocsp); the accessLocation is a GeneralName (a URI in the common case). An unregistered method / an
-    // uncommon accessLocation tag falls back to the raw OID / bracketed tag, and the entry is never dropped.
     var LABEL = { caIssuers: "CA Issuers", ocsp: "OCSP" };
     return (decoded || []).map(function (ad) {
       var m = null;
       try { m = oid.name(ad.accessMethod); } catch (_e) { /* allow:swallow-unverified display best-effort: an unregistered accessMethod OID falls back to the raw dotted OID below (inspection is best-effort, never a verdict) */ }
       var loc = ad.accessLocation || {}, lv;
-      // The string choices (URI/DNS/email) are IA5String values already control-byte-rejected at decode by the
-      // CVE-2009-2408 guard, so they are safe to emit directly. The iPAddress choice is a raw 4/16-byte Buffer,
-      // so render it through _ipString (never raw) and a byte such as 0x0a cannot inject a line and spoof a field.
       if (loc.tag === 6) lv = "URI:" + loc.value;
       else if (loc.tag === 2) lv = "DNS:" + loc.value;
       else if (loc.tag === 1) lv = "email:" + loc.value;
       else if (loc.tag === 7) lv = "IP:" + _ipString(loc.value);
-      // A directoryName accessLocation carries a decoded Name, so print the DN. Without this it fell
-      // to the bracketed-tag fallback and rendered a bare "[4]", hiding the responder/issuer identity
-      // the entry exists to convey -- while the same form already printed as DirName elsewhere.
       else if (loc.tag === 4) lv = "DirName:" + _gnDn(loc.value);
       else lv = typeof loc.value === "string" ? loc.value : "[" + loc.tag + "]";
       return inner + (LABEL[m] || m || ad.accessMethod) + " - " + lv;
@@ -482,9 +356,6 @@ var EXT_RENDERERS = {
     return inner + _hexColon(Buffer.isBuffer(decoded) ? decoded : (decoded.bytes || Buffer.alloc(0)), { upper: true });
   },
   authorityKeyIdentifier: function (decoded, inner) {
-    // Any of the three fields may be present; the issuer+serial form carries no
-    // keyIdentifier, so render whichever the decoder populated, never claiming
-    // "keyid:(none)" and dropping the certificate's real authority identifier.
     var akiLines = [];
     if (Buffer.isBuffer(decoded.keyIdentifier)) akiLines.push(inner + "keyid:" + _hexColon(decoded.keyIdentifier, { upper: true }));
     if (decoded.authorityCertIssuer && Array.isArray(decoded.authorityCertIssuer.names)) {
@@ -499,52 +370,15 @@ var EXT_RENDERERS = {
     return akiLines.length ? akiLines.join("\n") : inner + "keyid:(none)";
   },
 };
-// [MS-WCCE] szOID-APPLICATION_CERT_POLICIES decodes as certificatePolicies, so it renders identically.
 EXT_RENDERERS.msApplicationPolicies = EXT_RENDERERS.certificatePolicies;
 
-// Coverage residual -- the EXT_RENDERERS entry fallbacks are unreachable because each shared
-// decoder (and asn1.read.oid) already narrows the shape before the renderer runs:
-//   * extKeyUsage `catch (_e) { /* unregistered EKU OID */ }` and certificatePolicies
-//     `catch (_e) { /* unregistered qualifier */ }`. oid.name returns undefined (never throws)
-//     for a well-formed unregistered OID; it throws only on a non-dotted argument, and both OIDs
-//     come from asn1.read.oid (always a valid dotted OID).
-//   * certificatePolicies `(asn1.decode(p.qualifiersBytes).children || [])`. asn1.decode of the
-//     assertPolicyQualifiers-validated qualifiers SEQUENCE always yields a children array.
-//   * certificatePolicies `: Buffer.alloc(0)`. assertPolicyQualifiers requires every
-//     PolicyQualifierInfo to be a 2-child SEQUENCE, so pqi.children[1] is always a present node
-//     carrying a bytes Buffer.
-//   * certificatePolicies outer `catch (_e) { ... _hexColon(p.qualifiersBytes, {}) ... }`.
-//     certificatePolicies already validated qualifiersBytes as a SEQUENCE of 2-child PQIs each
-//     leading with a valid OID, so the re-decode + asn1.read.oid cannot throw.
-//   * policyConstraints `: inner + "(empty)"`. policyConstraints rejects an empty SEQUENCE
-//     (>= 1 context field), so requireExplicitPolicy or inhibitPolicyMapping is non-null;
-//     pc.length is never 0.
-//   * SCT `(decoded.scts || [])` / `(decoded.unknownScts || [])`. ct.parseSctList always returns
-//     both arrays.
-//   * SCT `: 0`. Every scts entry is a decoded v1 SCT with numeric version 0 (unknown-version
-//     SCTs go to unknownScts and are not iterated here).
-//   * SCT `: inner + "(empty SCT list)"`. ct.parseSctList rejects an empty list and routes every
-//     SerializedSCT into scts/unknownScts, so at least one line is always emitted.
-//   * subjectKeyIdentifier `: (decoded.bytes || Buffer.alloc(0))`. The subjectKeyIdentifier
-//     decoder returns the KeyIdentifier as a Buffer, so Buffer.isBuffer(decoded) is always true.
-//   * authorityKeyIdentifier `: BigInt(decoded.authorityCertSerialNumber)`. The AKI decoder reads
-//     authorityCertSerialNumber via asn1.read.integerImplicit (a bigint), so typeof === "bigint"
-//     is always true.
 
 function _renderExtValue(ext, decoded, inner) {
   var fn = EXT_RENDERERS[ext.name];
-  return fn ? fn(decoded, inner) : null;   // no registered renderer -> caller hex-dumps
+  return fn ? fn(decoded, inner) : null;
 }
 
-// Fallback for an extension with no decoder or a decode failure. Best-effort,
-// more useful than OpenSSL's raw-octet dump: a directly-printable value shows as a
-// string; a DER-wrapped character string is decoded and shown; otherwise a hex
-// dump. Never throws.
-var _STRING_TAGS = { 12: 1, 19: 1, 22: 1, 20: 1, 26: 1, 27: 1, 30: 1 }; // UTF8/Printable/IA5/Teletex/Visible/General/BMP
-// A value renders as text only when every byte is a printable, non-control ASCII
-// character. A control byte (a bare CR / LF / TAB, etc.) is rejected here so a
-// hostile private-extension value cannot forge or overwrite report lines in a
-// terminal or log -- such a value falls through to the hex dump instead.
+var _STRING_TAGS = { 12: 1, 19: 1, 22: 1, 20: 1, 26: 1, 27: 1, 30: 1 };
 function _printable(buf) {
   return buf.length > 0 && buf.every(function (b) { return b >= 0x20 && b < 0x7f; });
 }
@@ -557,7 +391,7 @@ function _fallback(value, inner) {
       var s = asn1.read.string(n);
       if (_printable(Buffer.from(s, "utf8"))) return inner + s;
     }
-  } catch (_e) { /* not DER / not a string -> hex */ }
+  } catch (_e) { }
   return _hexColon(value, { wrap: 16, indent: inner.length });
 }
 
@@ -570,18 +404,12 @@ function _extension(ext, pad) {
     try {
       var body = _renderExtValue(ext, decoder(ext.value), inner);
       if (body != null) return header + "\n" + body;
-    } catch (_e) { /* fall through to the raw fallback */ }
+    } catch (_e) { }
   }
   return header + "\n" + _fallback(ext.value, inner);
 }
 
-// ---- input coercion ----------------------------------------------------------
 
-// A genuine pki.schema.x509.parse result carries this whole shape. The fast path
-// accepts a pre-parsed certificate to skip re-parsing, but a bare or partial object
-// with only a tbsBytes property is not a certificate: without this check the renderer
-// would dereference a missing field (c.validity.notBefore, ...) and throw a raw
-// TypeError instead of the documented typed inspect/bad-input (the API's error contract).
 function _looksParsed(o) {
   return typeof o.version === "number" && typeof o.serialNumberHex === "string" &&
     o.signatureAlgorithm && typeof o.signatureAlgorithm === "object" &&
@@ -593,7 +421,7 @@ function _looksParsed(o) {
 function _parse(input) {
   if (input && typeof input === "object" && !Buffer.isBuffer(input) && input.tbsBytes) {
     if (!_looksParsed(input)) throw _err("inspect/bad-input", "input has a tbsBytes property but is not a complete pki.schema.x509.parse result");
-    return input;   // a genuine already-parsed certificate
+    return input;
   }
   var der;
   if (Buffer.isBuffer(input)) der = input;
@@ -607,7 +435,6 @@ function _parse(input) {
   catch (e) { throw _err("inspect/bad-certificate", "input is not a well-formed X.509 certificate", e); }
 }
 
-// ---- public: certificate -----------------------------------------------------
 
 /**
  * @primitive pki.inspect.certificate
@@ -646,8 +473,6 @@ function certificate(input) {
   L.push("        Subject: " + _dnString(c.subject));
   L.push("        Subject Public Key Info:");
   L.push(_keyBlock(c.subjectPublicKeyInfo, "            "));
-  // Coverage residual -- `c.extensions || []` is unreachable: both input paths guarantee an array
-  // (x509.parse yields one; the pre-parsed fast path requires Array.isArray(extensions) in _looksParsed).
   if ((c.extensions || []).length) {
     L.push("        X509v3 extensions:");
     c.extensions.forEach(function (ext) { L.push(_extension(ext, "            ")); });
@@ -658,11 +483,7 @@ function certificate(input) {
   return L.join("\n") + "\n";
 }
 
-// ---- CRL / CSR / CMS coercion (the _parse model, per format) -----------------
 
-// Each fast-path completeness check mirrors _looksParsed: a bare/partial object
-// with only the marker field is NOT a parsed result, so it throws the documented
-// typed inspect/bad-input rather than dereferencing a missing field.
 function _looksParsedCrl(o) {
   return typeof o.version === "number" && o.issuer && typeof o.issuer === "object" &&
     o.thisUpdate != null && Array.isArray(o.revokedCertificates) && Array.isArray(o.crlExtensions) &&
@@ -675,29 +496,16 @@ function _looksParsedCsr(o) {
 }
 function _looksParsedCms(o) {
   if (typeof o.contentType !== "string" || typeof o.contentTypeName !== "string" || typeof o.version !== "number") return false;
-  // A real parse result is one of the six dispatched content types AND carries that type's
-  // required structural fields (_CMS_SHAPE). An unrecognized contentType, or a recognized one
-  // missing its fields, is not a parse result: fail closed as inspect/bad-input, not a partial render.
   var shape = _CMS_SHAPE[o.contentType];
   return shape ? shape(o) : false;
 }
-// The shared inspect coercion boundary, composed by every direct inspector AND any():
-// pemLabel:null unwraps a PEM string OR a PEM-armored Buffer (a .pem read with
-// fs.readFileSync) under ANY block label -- so an aliased label (PKCS7 for CMS,
-// CRL for an X509 CRL) routes like any() instead of hitting a canonical-label
-// mismatch -- while a raw DER Buffer / Uint8Array passes through the detached-store guard.
 var _INSPECT_ENTRY = { pemLabel: null, PemError: InspectError, ErrorClass: InspectError, prefix: "inspect" };
-// A parameterized _parse clone: marker field, fast-path completeness check, then
-// the shared label-agnostic coercion to DER, then parse(der) inside try.
 function _coerce(input, spec) {
   if (input && typeof input === "object" && !Buffer.isBuffer(input) && !(input instanceof Uint8Array) && input[spec.marker] !== undefined) {
     if (!spec.looksParsed(input)) throw _err("inspect/bad-input", "input has a " + spec.marker + " property but is not a complete " + spec.parsedName + " result");
     return input;
   }
   var der;
-  // Compose the ONE coercion every format parser + any() use, so a PEM string and a
-  // PEM-armored Buffer unwrap under any label (not just the format's canonical one)
-  // and a detached-store Buffer fails closed here, not divergently per inspector.
   try { der = pkix.coerceToDer(input, _INSPECT_ENTRY); }
   catch (e) { throw _err("inspect/bad-input", "input must be a parsed " + spec.what + ", a DER Buffer, or a PEM block", e); }
   try { return spec.parse(der); }
@@ -707,40 +515,22 @@ function _parseCrl(input) { return _coerce(input, { marker: "thisUpdate", looksP
 function _parseCsr(input) { return _coerce(input, { marker: "certificationRequestInfoBytes", looksParsed: _looksParsedCsr, parsedName: "pki.schema.csr.parse", parse: csr.parse, badCode: "inspect/bad-csr", what: "PKCS#10 certification request" }); }
 function _parseCms(input) { return _coerce(input, { marker: "contentType", looksParsed: _looksParsedCms, parsedName: "pki.schema.cms.parse", parse: cms.parse, badCode: "inspect/bad-cms", what: "CMS message" }); }
 
-// ---- shared attribute-value renderer (CSR attributes + CMS signed/unsigned) ---
 
-// Attribute/extension dispatch keys on the STABLE OID, never the display name a
-// pki.oid.register() override can change (the schema stores the overridden name).
 var OID_EXTENSION_REQUEST = oid.byName("extensionRequest");
 var OID_CONTENT_TYPE = oid.byName("contentType");
 var OID_MESSAGE_DIGEST = oid.byName("messageDigest");
 var OID_SIGNING_TIME = oid.byName("signingTime");
 
-// Decode the known content-binding attribute types for display; anything else, or
-// a decode failure, falls back to printable-or-hex. Never throws once parsed.
-// Keyed on the attribute's OID (stable), not its display name (register-mutable).
 function _attrValue(typeOid, rawDer, inner) {
   try {
     if (typeOid === OID_CONTENT_TYPE) { var ct = asn1.read.oid(asn1.decode(rawDer)); return inner + (oid.name(ct) || ct); }
     if (typeOid === OID_MESSAGE_DIGEST) return _hexColon(asn1.read.octetString(asn1.decode(rawDer)), { wrap: 16, indent: inner.length });
     if (typeOid === OID_SIGNING_TIME) return inner + _date(asn1.read.time(asn1.decode(rawDer)));
-  } catch (_e) { /* fall through to the raw fallback */ }
+  } catch (_e) { }
   return _fallback(rawDer, inner);
 }
 
-// ---- CRL report --------------------------------------------------------------
 
-// The CRL decoder PRE-DECODES three extension values to a JS type (not the raw
-// Buffer the shared _extension consumes): cRLNumber -> BigInt, reasonCode ->
-// Number, invalidityDate -> Date. Dispatch on the STABLE OID exactly as the decoder
-// does (schema-crl decodeExt), NOT the display name -- pki.oid.register() can override
-// a built-in name, which would skip these branches and hand _extension a non-Buffer
-// value (rendering "(empty)" for the CRL number or reason). deltaCRLIndicator is a
-// raw-Buffer extension the decoder does NOT pre-decode, but its value is a bare INTEGER
-// (BaseCRLNumber) the operator needs in decimal to relate a delta CRL to its base -- so
-// decode it here for display (best-effort: a malformed value falls through to hex).
-// Delegate every other raw-value extension (AKI / IDP / freshestCRL / certificateIssuer)
-// to the shared _extension verbatim.
 var OID_CRL_NUMBER = oid.byName("cRLNumber");
 var OID_REASON_CODE = oid.byName("reasonCode");
 var OID_INVALIDITY_DATE = oid.byName("invalidityDate");
@@ -754,7 +544,7 @@ function _crlExtension(ext, pad) {
   if (ext.oid === OID_INVALIDITY_DATE && guard.time.isDate(ext.value)) return header + "\n" + inner + _date(ext.value);
   if (ext.oid === OID_DELTA_CRL_INDICATOR && Buffer.isBuffer(ext.value)) {
     try { return header + "\n" + inner + "BaseCRLNumber: " + String(asn1.read.integer(asn1.decode(ext.value))); }
-    catch (_e) { /* malformed BaseCRLNumber -> fall through to the shared _extension (hex) */ }
+    catch (_e) { }
   }
   return _extension(ext, pad);
 }
@@ -815,12 +605,9 @@ function crlReport(input) {
   return L.join("\n") + "\n";
 }
 
-// ---- CSR report --------------------------------------------------------------
 
 function _attribute(attr, pad) {
   var inner = pad + "    ";
-  // extensionRequest carries decoded RFC 5280 extensions (the cert-extension shape)
-  // -> render each through the shared _extension, identically to a certificate's.
   if (attr.type === OID_EXTENSION_REQUEST && Array.isArray(attr.extensions)) {
     var lines = [pad + "Requested Extensions:"];
     attr.extensions.forEach(function (ext) { lines.push(_extension(ext, inner)); });
@@ -867,46 +654,18 @@ function csrReport(input) {
   return L.join("\n") + "\n";
 }
 
-// ---- CMS report --------------------------------------------------------------
 
-// Dispatch on the STABLE contentType OID, never the display name: pki.oid.register()
-// lets an application override the built-in "signedData" name, and dispatching on the
-// mutable name would then misroute a valid SignedData to the generic summary.
 var OID_SIGNED_DATA = oid.byName("signedData");
-// pki.schema.cms.parse dispatches ONLY these six RFC 5652 content types (every other
-// OID throws cms/unsupported- or cms/unknown-content-type -- it never yields an object).
-// Each maps to a predicate over the REQUIRED (non-OPTIONAL) fields of its top-level
-// SEQUENCE, so the parsed-object fast path in _looksParsedCms accepts a genuine parse
-// result but a partial/hand-built object (the type OID + name + version, none of the
-// structural fields) fails closed as inspect/bad-input -- the documented boundary.
 function _isObj(x) { return !!x && typeof x === "object"; }
 var _CMS_SHAPE = {};
-_CMS_SHAPE[OID_SIGNED_DATA] = function (o) { return Array.isArray(o.digestAlgorithms) && _isObj(o.encapContentInfo) && Array.isArray(o.signerInfos); };            // sec. 5.1
-_CMS_SHAPE[oid.byName("envelopedData")] = function (o) { return Array.isArray(o.recipientInfos) && _isObj(o.encryptedContentInfo); };                                // sec. 6.1
-_CMS_SHAPE[oid.byName("encryptedData")] = function (o) { return _isObj(o.encryptedContentInfo); };                                                                  // sec. 8
-_CMS_SHAPE[oid.byName("authData")] = function (o) { return Array.isArray(o.recipientInfos) && _isObj(o.macAlgorithm) && _isObj(o.encapContentInfo) && Buffer.isBuffer(o.mac); }; // sec. 9.1
-_CMS_SHAPE[oid.byName("authEnvelopedData")] = function (o) { return Array.isArray(o.recipientInfos) && _isObj(o.encryptedContentInfo) && Buffer.isBuffer(o.mac); };                // RFC 5083 (build surfaces encryptedContentInfo)
-_CMS_SHAPE[oid.byName("compressedData")] = function (o) { return _isObj(o.compressionAlgorithm) && _isObj(o.encapContentInfo); };                                   // RFC 3274
+_CMS_SHAPE[OID_SIGNED_DATA] = function (o) { return Array.isArray(o.digestAlgorithms) && _isObj(o.encapContentInfo) && Array.isArray(o.signerInfos); };
+_CMS_SHAPE[oid.byName("envelopedData")] = function (o) { return Array.isArray(o.recipientInfos) && _isObj(o.encryptedContentInfo); };
+_CMS_SHAPE[oid.byName("encryptedData")] = function (o) { return _isObj(o.encryptedContentInfo); };
+_CMS_SHAPE[oid.byName("authData")] = function (o) { return Array.isArray(o.recipientInfos) && _isObj(o.macAlgorithm) && _isObj(o.encapContentInfo) && Buffer.isBuffer(o.mac); };
+_CMS_SHAPE[oid.byName("authEnvelopedData")] = function (o) { return Array.isArray(o.recipientInfos) && _isObj(o.encryptedContentInfo) && Buffer.isBuffer(o.mac); };
+_CMS_SHAPE[oid.byName("compressedData")] = function (o) { return _isObj(o.compressionAlgorithm) && _isObj(o.encapContentInfo); };
 
-// Coverage residuals in the report assemblers -- verified-hard-to-reach, not gaps:
-//   * The `x.bytes || x` / `oid.name(o) || o` / `a.name || oid.name || a.type` fallbacks are
-//     belts for shapes the strict parsers never produce (a parsed CSR always carries
-//     signatureValue.bytes; a decoded algorithm always names its OID) -- they mirror
-//     certificate()'s own defensive fallbacks.
-//   * The embedded-CRL delegation and the CONTEXT-tagged embedded-element summary need a CMS
-//     carrying a crls element or an attribute-certificate CHOICE alternative, and the
-//     AuthenticatedData macAlgorithm / countersignature-unsignedAttrs arms need CMS shapes the
-//     toolkit's own producers (cms.sign / encrypt / compress) do not emit; every such arm is
-//     driven best-effort (never throws) and its structural sibling (embedded Certificate,
-//     envelopedData recipientInfo, CompressedData compressionAlgorithm, signed attributes) is
-//     covered.
 
-// An embedded certificate/CRL element {bytes,tagClass,tagNumber}: a UNIVERSAL
-// SEQUENCE is a real Certificate/CertificateList -> delegate to the full sub-report
-// (guarded; a one-line summary on any failure); a CONTEXT-tagged CHOICE alternative
-// (attribute certificate / other) renders a one-line tag+size summary, never parsed.
-// Leading "0" characters removed, and a single trailing "\n" removed -- both by character scan
-// (no regex): display helpers, matching the /^0+/ and /\n$/ replacements they succeed.
 function _stripLeadingZeros(s) {
   var i = 0;
   while (i < s.length && s.charAt(i) === "0") i += 1;
@@ -921,7 +680,7 @@ function _cmsEmbedded(kind, el, pad) {
     try {
       var sub = (kind === "CRL") ? crlReport(el.bytes) : certificate(el.bytes);
       return pad + kind + ":\n" + _stripTrailingNewline(sub).split("\n").map(function (l) { return pad + "    " + l; }).join("\n");
-    } catch (_e) { /* fall through to the summary */ }
+    } catch (_e) { }
   }
   return pad + kind + " [" + el.tagClass + " " + el.tagNumber + "] (" + el.bytes.length + " bytes)";
 }
@@ -977,15 +736,12 @@ function _signerInfo(si, pad) {
  *   var cmsDer = await pki.cms.sign(Buffer.from("hello"), { cert: cert, key: key });
  *   pki.inspect.cms(cmsDer).split("\n")[0]; // "CMS ContentInfo:"
  */
-// A ContentInfo whose content type pki.schema.cms.parse does not dispatch (id-data,
-// digestedData, ...) is a VALID CMS the parser defers, not a malformed message -- render an
-// outer-only summary (the named content type) rather than failing the report.
 function _cmsOuterSummary(input) {
   var ct = null;
   try {
     var der = pkix.coerceToDer(input, _INSPECT_ENTRY);
     ct = asn1.read.oid(asn1.decode(der).children[0]);
-  } catch (_e) { /* best-effort: name unknown */ }
+  } catch (_e) { }
   return "CMS ContentInfo:\n    Content Type: " + (ct ? (oid.name(ct) || ct) + " (" + ct + ")" : "unknown") +
     "\n    (content type not further parsed; outer ContentInfo only)\n";
 }
@@ -994,9 +750,6 @@ function cmsReport(input) {
   var m;
   try { m = _parseCms(input); }
   catch (e) {
-    // A ContentInfo whose contentType the parser does not dispatch is a valid CMS, not a malformed
-    // message: a known-but-deferred type (cms/unsupported-content-type, e.g. id-data) or a private/
-    // unregistered OID (cms/unknown-content-type). Either renders the outer-only summary.
     var cc = e && e.cause && e.cause.code;
     if (e && e.code === "inspect/bad-cms" && (cc === "cms/unsupported-content-type" || cc === "cms/unknown-content-type")) return _cmsOuterSummary(input);
     throw e;
@@ -1017,7 +770,6 @@ function cmsReport(input) {
     (m.crls || []).forEach(function (el) { L.push(_cmsEmbedded("CRL", el, "        ")); });
     (m.signerInfos || []).forEach(function (si) { L.push(_signerInfo(si, "        ")); });
   } else {
-    // Non-SignedData: a stable top-field summary (no plaintext to show); never throws.
     L.push("    " + (m.contentTypeName || "content") + ":");
     if (m.version != null) L.push("        Version: " + m.version);
     (m.recipientInfos || []).forEach(function (ri) { L.push("        RecipientInfo: " + (ri.type || "?") + (ri.ridType ? " (" + ri.ridType + ")" : "")); });
@@ -1031,7 +783,6 @@ function cmsReport(input) {
   return L.join("\n") + "\n";
 }
 
-// ---- unified detect-and-dispatch ---------------------------------------------
 
 var _INSPECT_BY_FORMAT = { x509: certificate, crl: crlReport, csr: csrReport, cms: cmsReport };
 
@@ -1058,12 +809,10 @@ var _INSPECT_BY_FORMAT = { x509: certificate, crl: crlReport, csr: csrReport, cm
  *   pki.inspect.any(der);  // routes to the right report by detected format
  */
 function any(input) {
-  // Unwrap to DER ONCE (any PEM label), detect from the DER, then route the DER Buffer -- the
-  // renderer parses a Buffer directly and never re-applies its own strict PEM label.
   var der, fmt;
   try {
     der = pkix.coerceToDer(input, _INSPECT_ENTRY);
-    fmt = schemaAll.detectFormat(der);   // decodes the root -- a non-DER Buffer throws here, not at coerce
+    fmt = schemaAll.detectFormat(der);
   } catch (e) { throw _err("inspect/bad-input", "input is not a decodable DER Buffer or PEM string", e); }
   if (fmt === null) throw _err("inspect/bad-input", "input does not match any registered PKI format");
   var render = _INSPECT_BY_FORMAT[fmt];
@@ -1077,8 +826,5 @@ module.exports = {
   csr: csrReport,
   cms: cmsReport,
   any: any,
-  // The extension names certificate() renders to their decoded values (vs the raw
-  // hex fallback). The inspect test asserts this covers every extension the shared
-  // decoders decode, so a newly-decodable extension cannot silently hex-dump.
   renderedExtensions: Object.keys(EXT_RENDERERS),
 };