@blamejs/pki 0.5.30 → 0.5.32

package/lib/http-digest.js

@@ -19,6 +19,10 @@ var intrinsic = require("./guard-intrinsic");
 // replaceable properties to answer one thing, and here it decides whether an auth-param repeats --
 // answering false lets the second copy of a nonce overwrite the first.
 var _hasOwn = intrinsic.hasOwn;
+var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
+var _strSlice = intrinsic.uncurry(String.prototype.slice);
+var _fromCharCode = intrinsic.fromCharCode;
+var pkix = require("./schema-pkix");   // the shared JS-\s code-point predicate (pkix.isJsWhitespace)
 
 // Algorithm registry, a data row and not a switch: rank orders the RFC 7616 sec. 3.7
 // "most secure the client can use" selection (SHA-512-256 > SHA-256 > MD5); an unknown algorithm ranks 0.
@@ -41,7 +45,12 @@ var DEFAULT_CODES = {
 // is hashed over its exact bytes. KD(secret, data) = H(secret ":" data).
 function H(hash, s) { return crypto.createHash(hash).update(s, "latin1").digest("hex"); }
 function KD(hash, secret, data) { return H(hash, secret + ":" + data); }
-function _qstr(v) { return "\"" + String(v).replace(/(["\\])/g, "\\$1") + "\""; }
+// Quote a value: wrap in double quotes, backslash-escaping any " or \ (matching /(["\\])/g -> "\\$1").
+function _qstr(v) {
+  var s = String(v), out = "";
+  for (var i = 0; i < s.length; i++) { var c = _charCodeAt(s, i); if (c === 34 || c === 92) out += "\\"; out += _fromCharCode(c); }
+  return "\"" + out + "\"";
+}
 
 // Split a header at commas outside a quoted-string (a quoted comma is a literal, not a delimiter).
 function _commaSplitOutsideQuotes(s) {
@@ -69,7 +78,13 @@ function _firstEqOutsideQuotes(s) {
   }
   return -1;
 }
-function _unq(s) { return s.slice(1, -1).replace(/\\(.)/g, "$1"); }   // only ever called on a well-formed quoted-string (see _closedQuote)
+// Unquote a well-formed quoted-string (only ever called after _closedQuote): drop the surrounding
+// quotes and each escaping backslash (matching s.slice(1,-1).replace(/\\(.)/g, "$1")).
+function _unq(s) {
+  var out = "", last = 1, n = s.length;                       // skip the opening quote at 0
+  for (var i = 1; i < n - 1; i++) { if (_charCodeAt(s, i) === 92) { out += _strSlice(s, last, i); last = i + 1; i += 1; } }
+  return out + _strSlice(s, last, n - 1);                     // trailing content, excluding the closing quote
+}
 // A well-formed quoted-string: opens with ", closes with an unescaped " as the last character (nothing trails
 // it). An unterminated / trailing-garbage quoted-string is malformed (RFC 7230 sec. 3.2.6) and rejected.
 function _closedQuote(s) {
@@ -86,24 +101,62 @@ function _closedQuote(s) {
 // A control octet (RFC 7230 sec. 3.2.6 quoted-string / qdtext forbids CTL except HTAB). Scanned with charCodeAt
 // instead of a control-char regex literal (which eslint no-control-regex correctly refuses).
 function _hasCtl(s) {
-  for (var i = 0; i < s.length; i++) { var c = s.charCodeAt(i); if ((c < 0x20 && c !== 0x09) || c === 0x7f) return true; }
+  for (var i = 0; i < s.length; i++) { var c = _charCodeAt(s, i); if ((c < 0x20 && c !== 0x09) || c === 0x7f) return true; }
   return false;
 }
 
 // Split a WWW-Authenticate header into [{ scheme, paramText }]. A comma-separated segment whose pre-'='
 // text is "token WS token" (a scheme name before the first auth-param key), or a bare token with no '=',
 // STARTS a new challenge; a "key=value" segment is a param continuation of the current challenge.
+// The leading token when `pre` is "token WS more" (/^(\S+)\s+(\S[\s\S]*)$/) -- a scheme name before the
+// first auth-param -- else null. \s is the shared JS-\s predicate (RFC 7230 OWS is a subset).
+function _matchTokenRest(pre) {
+  var n = pre.length, p = 0;
+  while (p < n && !pkix.isJsWhitespace(_charCodeAt(pre, p))) p += 1;              // ^(\S+)
+  if (p === 0) return null;
+  var tokEnd = p;
+  if (p >= n || !pkix.isJsWhitespace(_charCodeAt(pre, p))) return null;          // \s+
+  while (p < n && pkix.isJsWhitespace(_charCodeAt(pre, p))) p += 1;
+  if (p >= n || pkix.isJsWhitespace(_charCodeAt(pre, p))) return null;           // (\S[\s\S]*)$ -- at least one non-\s
+  return _strSlice(pre, 0, tokEnd);
+}
+// The index past a leading "OWS token OWS" (/^\s*\S+\s+/), or 0 when the string does not begin that way.
+// The caller slices from this index (the slice that replaces the removed .replace).
+function _stripTokenIndex(seg) {
+  var n = seg.length, p = 0;
+  while (p < n && pkix.isJsWhitespace(_charCodeAt(seg, p))) p += 1;              // ^\s*
+  var ts = p;
+  while (p < n && !pkix.isJsWhitespace(_charCodeAt(seg, p))) p += 1;             // \S+
+  if (p === ts) return 0;
+  var ws = p;
+  while (p < n && pkix.isJsWhitespace(_charCodeAt(seg, p))) p += 1;              // \s+ (required)
+  return p === ws ? 0 : p;
+}
+// String.prototype.split(/\s+/): the pieces between \s runs (a leading/trailing run yields a "" element).
+function _splitWhitespace(s) {
+  var out = [], i = 0, n = s.length, ps = 0;
+  while (i < n) {
+    if (pkix.isJsWhitespace(_charCodeAt(s, i))) {
+      out[out.length] = _strSlice(s, ps, i);
+      while (i < n && pkix.isJsWhitespace(_charCodeAt(s, i))) i += 1;
+      ps = i;
+    } else i += 1;
+  }
+  out[out.length] = _strSlice(s, ps);
+  return out;
+}
+
 function _splitChallenges(s) {
   var segs = _commaSplitOutsideQuotes(s);
   var out = [], cur = null;
   for (var i = 0; i < segs.length; i++) {
-    var seg = segs[i].replace(/^\s+|\s+$/g, "");
+    var seg = segs[i].trim();
     if (seg === "") continue;
     var eq = _firstEqOutsideQuotes(seg);
-    var pre = (eq < 0 ? seg : seg.slice(0, eq)).replace(/^\s+|\s+$/g, "");
-    var ws = /^(\S+)\s+(\S[\s\S]*)$/.exec(pre);
+    var pre = (eq < 0 ? seg : _strSlice(seg, 0, eq)).trim();
+    var scheme = _matchTokenRest(pre);
     if (eq < 0) { cur = { scheme: seg, paramText: "" }; out.push(cur); }        // a bare scheme token (e.g. "Basic")
-    else if (ws) { cur = { scheme: ws[1], paramText: seg.replace(/^\s*\S+\s+/, "") }; out.push(cur); }   // "scheme firstKey=..."
+    else if (scheme !== null) { cur = { scheme: scheme, paramText: _strSlice(seg, _stripTokenIndex(seg)) }; out.push(cur); }   // "scheme firstKey=..."
     else if (cur) { cur.paramText = cur.paramText ? cur.paramText + "," + seg : seg; }                   // "key=value" continuation
   }
   return out;
@@ -112,12 +165,12 @@ function _splitChallenges(s) {
 function _parseParams(paramText, E, code) {
   var segs = _commaSplitOutsideQuotes(paramText), map = Object.create(null);
   for (var i = 0; i < segs.length; i++) {
-    var seg = segs[i].replace(/^\s+|\s+$/g, "");
+    var seg = segs[i].trim();
     if (seg === "") continue;
     var eq = _firstEqOutsideQuotes(seg);
     if (eq < 0) throw E(code, "malformed Digest auth-param (no '='): " + JSON.stringify(seg));
-    var key = seg.slice(0, eq).replace(/^\s+|\s+$/g, "").toLowerCase();
-    var rawVal = seg.slice(eq + 1).replace(/^\s+|\s+$/g, "");
+    var key = _strSlice(seg, 0, eq).trim().toLowerCase();
+    var rawVal = _strSlice(seg, eq + 1).trim();
     var quoted = rawVal.charAt(0) === "\"";
     if (quoted && !_closedQuote(rawVal)) throw E(code, "an unterminated or trailing-garbage Digest quoted-string (RFC 7230 sec. 3.2.6)");
     if (_hasOwn(map, key)) throw E(code, "repeated Digest auth-param " + JSON.stringify(key));
@@ -138,7 +191,7 @@ function _validateDigest(paramText, E, code) {
   var qop = [];
   if (p.qop) {
     if (!p.qop.quoted) throw E(code, "the Digest qop must be a quoted list (RFC 7616 sec. 3.3)");
-    qop = p.qop.value.split(",").map(function (x) { return x.replace(/^\s+|\s+$/g, "").toLowerCase(); }).filter(Boolean);
+    qop = p.qop.value.split(",").map(function (x) { return x.trim().toLowerCase(); }).filter(Boolean);
     // A qop directive that is present but lists no value (qop="" / qop=", ,") is malformed, and is not the
     // absent-qop (RFC 2069) case. Reject it instead of silently collapsing to a no-qop response the server
     // cannot accept (RFC 7616 sec. 3.3). Only an omitted qop directive selects the legacy no-qop path.
@@ -150,8 +203,8 @@ function _validateDigest(paramText, E, code) {
   // server intended. Surfaced as an array of the listed URIs, or null when omitted or quoted-empty, which per
   // the RFC means "all URIs on the responding server" (the answer may be reused for any same-origin URI, sec. 3.5).
   if (p.domain && !p.domain.quoted) throw E(code, "the Digest domain must be a quoted-string (RFC 7616 sec. 3.3)");
-  var domain = (p.domain && p.domain.value.replace(/^\s+|\s+$/g, "") !== "")
-    ? p.domain.value.replace(/^\s+|\s+$/g, "").split(/\s+/) : null;
+  var domain = (p.domain && p.domain.value.trim() !== "")
+    ? _splitWhitespace(p.domain.value.trim()) : null;
   // charset (RFC 7616 sec. 3.3): the one permitted value is the unquoted token "UTF-8". A quoted charset, or any
   // other value, is malformed, since answering it would hash the credentials in the wrong encoding, so it is
   // rejected (and thus skipped during multi-offer selection in favor of a conforming offer).
@@ -250,7 +303,7 @@ function _octets(s, charset) {
 // Does the string carry any non-ASCII code unit (> U+007F)? Such a UTF-8 username is sent via `username*`.
 function _hasNonAscii(s) {
   s = String(s == null ? "" : s);
-  for (var i = 0; i < s.length; i++) { if (s.charCodeAt(i) > 0x7F) return true; }
+  for (var i = 0; i < s.length; i++) { if (_charCodeAt(s, i) > 0x7F) return true; }
   return false;
 }
 
@@ -264,7 +317,7 @@ function _pctEncodeUtf8(s) {
     if ((b >= 0x30 && b <= 0x39) || (b >= 0x41 && b <= 0x5A) || (b >= 0x61 && b <= 0x7A) ||
         b === 0x21 || b === 0x23 || b === 0x24 || b === 0x26 || b === 0x2B || b === 0x2D ||
         b === 0x2E || b === 0x5E || b === 0x5F || b === 0x60 || b === 0x7C || b === 0x7E) {
-      out += String.fromCharCode(b);
+      out += _fromCharCode(b);
     } else {
       out += "%" + (b < 0x10 ? "0" : "") + b.toString(16).toUpperCase();
     }
@@ -323,7 +376,7 @@ function answer(challenge, params, E) {
   // (a same-origin redirect, an auth-int retry) increments nc; a fresh nonce restarts at 1. The caller supplies
   // the count for this nonce (default 1); formatted as 8 lowercase hex.
   var ncNum = (typeof params.nc === "number" && params.nc >= 1) ? Math.floor(params.nc) : 1;
-  var nc = ("0000000" + ncNum.toString(16)).slice(-8);
+  var nc = _strSlice("0000000" + ncNum.toString(16), -8);
   var response = useQop
     ? KD(alg.hash, HA1, nonce + ":" + nc + ":" + cnonce + ":" + useQop + ":" + HA2)
     : KD(alg.hash, HA1, nonce + ":" + HA2);

package/lib/http-retry-after.js

@@ -19,12 +19,32 @@ var MAX_RETRY_AFTER_SECONDS = constants.TIME.days(365) / constants.TIME.seconds(
 // rfc850-date / asctime-date a recipient must still accept. Gating Date.parse on this grammar keeps its
 // permissiveness (an ISO string like "2026-07-10") from passing as a valid Retry-After header.
 var MONTHS = "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec".split(" ");
-var MONTH = "(?:" + MONTHS.join("|") + ")";
-var HTTP_DATE_FORMS = [
-  new RegExp("^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \\d{2} " + MONTH + " \\d{4} \\d{2}:\\d{2}:\\d{2} GMT$"),
-  new RegExp("^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), \\d{2}-" + MONTH + "-\\d{2} \\d{2}:\\d{2}:\\d{2} GMT$"),
-  new RegExp("^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) " + MONTH + " [ \\d]\\d \\d{2}:\\d{2}:\\d{2} \\d{4}$"),
-];
+var DOW_SHORT = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+var DOW_LONG = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
+
+// The grammar is scanned character by character (no regex): each form is a fixed layout of a
+// day-of-week name, delimiters, an all-digit field, a three-letter month name, and an HH:MM:SS time.
+function _isDigit(ch) { return ch >= "0" && ch <= "9"; }
+// The two-digit / four-digit integer at `i`, or -1 when those positions are not all digits.
+function _digits2(s, i) { return _isDigit(s.charAt(i)) && _isDigit(s.charAt(i + 1)) ? (s.charCodeAt(i) - 48) * 10 + (s.charCodeAt(i + 1) - 48) : -1; }
+function _digits4(s, i) { for (var k = 0; k < 4; k++) if (!_isDigit(s.charAt(i + k))) return -1; return parseInt(s.slice(i, i + 4), 10); }
+// The length of a name from `list` matching `s` at `i` (the day-of-week alternation), or -1.
+function _matchName(s, i, list) { for (var j = 0; j < list.length; j++) { if (s.slice(i, i + list[j].length) === list[j]) return list[j].length; } return -1; }
+// The three-letter month at `i` when it is a real month name, else null.
+function _monthAt(s, i) { return _matchName(s, i, MONTHS) === -1 ? null : s.slice(i, i + 3); }
+// An "HH:MM:SS" time at `i` -> { hh, mi, ss, next } (next = i + 8), or null.
+function _timeAt(s, i) {
+  var hh = _digits2(s, i); if (hh < 0 || s.charAt(i + 2) !== ":") return null;
+  var mi = _digits2(s, i + 3); if (mi < 0 || s.charAt(i + 5) !== ":") return null;
+  var ss = _digits2(s, i + 6); if (ss < 0) return null;
+  return { hh: hh, mi: mi, ss: ss, next: i + 8 };
+}
+// A non-empty run of ASCII digits (matching /^\d+$/, the delay-seconds form).
+function _isAllDigits(s) {
+  if (s.length === 0) return false;
+  for (var i = 0; i < s.length; i++) if (!_isDigit(s.charAt(i))) return false;
+  return true;
+}
 
 // Expand an obsolete RFC 850 two-digit year: HTTP interprets it relative to the receipt year, as the full
 // year with these two digits within [refYear-50, refYear+49] (moved to the past only when it would
@@ -40,29 +60,53 @@ function _rfc850Year(yy, refMs) {
   return full;
 }
 
+// IMF-fixdate (the required form): "Sun, 06 Nov 1994 08:49:37 GMT".
+function _scanImf(s) {
+  var p = _matchName(s, 0, DOW_SHORT);
+  if (p === -1 || s.slice(p, p + 2) !== ", ") return null; p += 2;
+  var dd = _digits2(s, p); if (dd < 0 || s.charAt(p + 2) !== " ") return null; p += 3;
+  var mo = _monthAt(s, p); if (!mo || s.charAt(p + 3) !== " ") return null; p += 4;
+  var yy = _digits4(s, p); if (yy < 0 || s.charAt(p + 4) !== " ") return null; p += 5;
+  var t = _timeAt(s, p); if (!t || s.slice(t.next, t.next + 4) !== " GMT" || t.next + 4 !== s.length) return null;
+  return { day: dd, monName: mo, year: yy, hh: t.hh, mi: t.mi, ss: t.ss };
+}
+// rfc850-date (obsolete, still accepted): "Sunday, 06-Nov-94 08:49:37 GMT" -- a two-digit year expanded
+// relative to the receipt year.
+function _scanRfc850(s, refMs) {
+  var p = _matchName(s, 0, DOW_LONG);
+  if (p === -1 || s.slice(p, p + 2) !== ", ") return null; p += 2;
+  var dd = _digits2(s, p); if (dd < 0 || s.charAt(p + 2) !== "-") return null; p += 3;
+  var mo = _monthAt(s, p); if (!mo || s.charAt(p + 3) !== "-") return null; p += 4;
+  var yy = _digits2(s, p); if (yy < 0 || s.charAt(p + 2) !== " ") return null; p += 3;
+  var t = _timeAt(s, p); if (!t || s.slice(t.next, t.next + 4) !== " GMT" || t.next + 4 !== s.length) return null;
+  return { day: dd, monName: mo, year: _rfc850Year(yy, refMs), hh: t.hh, mi: t.mi, ss: t.ss };
+}
+// asctime-date (obsolete, still accepted): "Sun Nov  6 08:49:37 1994" -- a space-padded one/two-digit day.
+function _scanAsctime(s) {
+  var p = _matchName(s, 0, DOW_SHORT);
+  if (p === -1 || s.charAt(p) !== " ") return null; p += 1;
+  var mo = _monthAt(s, p); if (!mo || s.charAt(p + 3) !== " ") return null; p += 4;
+  var c0 = s.charAt(p);
+  if (!(c0 === " " || _isDigit(c0)) || !_isDigit(s.charAt(p + 1))) return null;
+  var dd = parseInt(s.slice(p, p + 2), 10); if (s.charAt(p + 2) !== " ") return null; p += 3;
+  var t = _timeAt(s, p); if (!t || s.charAt(t.next) !== " ") return null;
+  var yy = _digits4(s, t.next + 1); if (yy < 0 || t.next + 1 + 4 !== s.length) return null;
+  return { day: dd, monName: mo, year: yy, hh: t.hh, mi: t.mi, ss: t.ss };
+}
+
 // Parse an HTTP-date to epoch ms, or NaN when its grammar, calendar, or time is invalid. Built from the
 // extracted fields via Date.UTC (never Date.parse): every HTTP-date is UTC, the asctime form carries
 // no GMT token so delegating would parse it in local time, and the round-trip check rejects an
 // impossible date / time (Date.UTC normalizes Feb 31 -> Mar 2 just as Date.parse would).
 function httpDateMs(s, refMs) {
-  if (!HTTP_DATE_FORMS.some(function (re) { return re.test(s); })) return NaN;
-  var day, monName, year;
-  var asc = /^\w{3} (\w{3}) ([ \d]\d) /.exec(s);                           // asctime: month then day
-  if (asc) { monName = asc[1]; day = parseInt(asc[2], 10); year = parseInt(/(\d{4})$/.exec(s)[1], 10); }
-  else {
-    var dmy = /(\d{2})[ -](\w{3})[ -](\d{2,4})/.exec(s);                   // IMF / rfc850: day month year
-    if (!dmy) return NaN;
-    day = parseInt(dmy[1], 10); monName = dmy[2]; year = parseInt(dmy[3], 10);
-    if (year < 100) year = _rfc850Year(year, refMs);                       // rfc850 two-digit year
-  }
-  var t = /(\d{2}):(\d{2}):(\d{2})/.exec(s);
-  var mon = MONTHS.indexOf(monName);
-  if (!t || mon < 0) return NaN;
-  var hh = parseInt(t[1], 10), mi = parseInt(t[2], 10), ss = parseInt(t[3], 10);
-  var when = Date.UTC(year, mon, day, hh, mi, ss);
+  var f = _scanImf(s) || _scanRfc850(s, refMs) || _scanAsctime(s);
+  if (!f) return NaN;
+  var mon = MONTHS.indexOf(f.monName);
+  if (mon < 0) return NaN;
+  var when = Date.UTC(f.year, mon, f.day, f.hh, f.mi, f.ss);
   var d = new Date(when);
-  if (d.getUTCDate() !== day || d.getUTCMonth() !== mon || d.getUTCFullYear() !== year ||
-      d.getUTCHours() !== hh || d.getUTCMinutes() !== mi || d.getUTCSeconds() !== ss) return NaN;
+  if (d.getUTCDate() !== f.day || d.getUTCMonth() !== mon || d.getUTCFullYear() !== f.year ||
+      d.getUTCHours() !== f.hh || d.getUTCMinutes() !== f.mi || d.getUTCSeconds() !== f.ss) return NaN;
   return when;
 }
 
@@ -78,7 +122,7 @@ function parse(value, opts) {
   opts = opts || {};
   var raStr = String(value).trim();
   var out = { retryAfterSeconds: null, retryAfterDate: null };
-  if (/^\d+$/.test(raStr)) {
+  if (_isAllDigits(raStr)) {
     var n = parseInt(raStr, 10);
     // opts.cap (seconds): a caller that will clamp anyway (e.g. an ARI poll cadence) wants a delay above its
     // ceiling reduced to the ceiling, not rejected, so a valid-but-huge value never discards the response.

package/lib/http-transport.js

@@ -69,14 +69,38 @@ function _budget(value, key, dflt, max, E, code) {
 // form (e.g. what pki.est.cacerts / parseCertsOnly return), is silently ignored there, so the
 // connection would fail server authentication despite a valid anchor. Wrap a DER anchor as PEM
 // (a Buffer already carrying PEM text, or a PEM string, passes through unchanged).
+// The JS regex \s code points representable in a latin1 string (0..255): TAB LF VT FF CR SP NBSP.
+// Built at load so the source stays pure ASCII. The armor scan runs over a latin1 prefix, where these
+// are the only \s characters that can appear, so this is exactly /^\s*/ for that input.
+var _LATIN1_WS = String.fromCharCode(0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x20, 0xa0);
+
+// PEM armor at the START after optional whitespace, decided by character scan (no regex): skip the
+// leading \s run, then require "-----BEGIN ".
+function _looksLikePemArmor(s) {
+  var i = 0;
+  while (i < s.length && _LATIN1_WS.indexOf(s.charAt(i)) !== -1) i += 1;
+  return s.slice(i, i + 11) === "-----BEGIN ";
+}
+// Base64 wrapped to <=64-column lines, each terminated by LF (matching /.{1,64}/g -> "$&\n", which
+// keeps a trailing LF on the final line).
+function _wrap64Lines(s) {
+  var out = "";
+  for (var i = 0; i < s.length; i += 64) out += s.slice(i, i + 64) + "\n";
+  return out;
+}
+// The surrounding "[" "]" of an IPv6 literal removed, else the string unchanged (matching /^\[(.*)\]$/).
+function _stripIpv6Brackets(s) {
+  return (s.length >= 2 && s.charAt(0) === "[" && s.charAt(s.length - 1) === "]") ? s.slice(1, s.length - 1) : s;
+}
+
 function _pemifyAnchor(a) {
   if (typeof a === "string") return a;
   if (Buffer.isBuffer(a)) {
     // Detect PEM by its armor at the START (after optional whitespace) only: a DER certificate begins
     // with the SEQUENCE tag 0x30 and may itself contain the bytes "-----BEGIN" in a subject / extension
     // value, so an anywhere-search would leave such a DER anchor unwrapped and unusable.
-    if (/^\s*-----BEGIN /.test(a.toString("latin1", 0, 64))) return a;
-    var b64 = a.toString("base64").replace(/.{1,64}/g, "$&\n");
+    if (_looksLikePemArmor(a.toString("latin1", 0, 64))) return a;
+    var b64 = _wrap64Lines(a.toString("base64"));
     return "-----BEGIN CERTIFICATE-----\n" + b64 + "-----END CERTIFICATE-----\n";
   }
   return a;
@@ -179,11 +203,41 @@ var _guardedLookup = _makeGuardedLookup(nodeDns.lookup);
 // certificate / identity / handshake failure is a server-authentication failure;
 // anything else is a generic transport error. Every arm threads the raw fault as
 // `.cause`, so the diagnostic survives.
+// SELF.?SIGNED : "self", an optional single non-line-terminator character, then "signed" (in a lowercased string).
+function _hasSelfSigned(l) {
+  for (var i = 0; i + 4 <= l.length; i++) {
+    if (l.charCodeAt(i) === 0x73 && l.charCodeAt(i + 1) === 0x65 && l.charCodeAt(i + 2) === 0x6c && l.charCodeAt(i + 3) === 0x66) {
+      if (l.indexOf("signed", i + 4) === i + 4) return true;
+      var mid = l.charCodeAt(i + 4);
+      if (i + 4 < l.length && mid !== 0x0a && mid !== 0x0d && mid !== 0x2028 && mid !== 0x2029 && l.indexOf("signed", i + 5) === i + 5) return true;
+    }
+  }
+  return false;
+}
+// \bWORD\b : `word` (lowercase) bounded on both sides by a non-word character ([a-z0-9_]) or a string edge.
+function _hasWordBounded(l, word) {
+  var at = l.indexOf(word);
+  while (at !== -1) {
+    var before = at === 0 || !_isLowerWordChar(l.charCodeAt(at - 1));
+    var afterI = at + word.length;
+    var after = afterI === l.length || !_isLowerWordChar(l.charCodeAt(afterI));
+    if (before && after) return true;
+    at = l.indexOf(word, at + 1);
+  }
+  return false;
+}
+function _isLowerWordChar(c) { return (c >= 97 && c <= 122) || (c >= 48 && c <= 57) || c === 95; }
 function _classifyError(e, C) {
   if (e && e.pkiBlockedAddress) return C("blocked-address");
   var s = String((e && e.code) || "") + " " + String((e && e.message) || "");
-  if (/PROTOCOL_VERSION|UNSUPPORTED_PROTOCOL|VERSION_TOO_LOW|WRONG_VERSION|NO_PROTOCOLS_AVAILABLE|INAPPROPRIATE_FALLBACK/i.test(s)) return C("tls-floor");
-  if (/CERT|SELF.?SIGNED|VERIFY|ALTNAME|HOSTNAME|DEPTH_ZERO|LOCAL_ISSUER|HANDSHAKE|\bSSL\b|\bTLS\b/i.test(s)) return C("server-auth-failed");
+  var l = s.toLowerCase();
+  // /PROTOCOL_VERSION|UNSUPPORTED_PROTOCOL|VERSION_TOO_LOW|WRONG_VERSION|NO_PROTOCOLS_AVAILABLE|INAPPROPRIATE_FALLBACK/i
+  if (l.indexOf("protocol_version") !== -1 || l.indexOf("unsupported_protocol") !== -1 || l.indexOf("version_too_low") !== -1 ||
+      l.indexOf("wrong_version") !== -1 || l.indexOf("no_protocols_available") !== -1 || l.indexOf("inappropriate_fallback") !== -1) return C("tls-floor");
+  // /CERT|SELF.?SIGNED|VERIFY|ALTNAME|HOSTNAME|DEPTH_ZERO|LOCAL_ISSUER|HANDSHAKE|\bSSL\b|\bTLS\b/i
+  if (l.indexOf("cert") !== -1 || l.indexOf("verify") !== -1 || l.indexOf("altname") !== -1 || l.indexOf("hostname") !== -1 ||
+      l.indexOf("depth_zero") !== -1 || l.indexOf("local_issuer") !== -1 || l.indexOf("handshake") !== -1 ||
+      _hasSelfSigned(l) || _hasWordBounded(l, "ssl") || _hasWordBounded(l, "tls")) return C("server-auth-failed");
   return C("transport-error");
 }
 
@@ -256,7 +310,7 @@ function httpsTransport(defaults) {
     if (minVersion !== "TLSv1.2" && minVersion !== "TLSv1.3") throw E(C("bad-input"), "tls.minVersion must be 'TLSv1.2' or 'TLSv1.3' (never below the floor), got " + minVersion);
 
     var body = request.body;
-    if (Buffer.isBuffer(body)) body = guard.bytes.view(body, E, C("bad-input"), "the request body");
+    if (guard.bytes.isByteSource(body)) body = guard.bytes.source(body, E, C("bad-input"), "the request body");
 
     // Frame a body-bearing request with a fixed Content-Length computed from the EXACT body, so it is sent
     // length-delimited rather than Transfer-Encoding: chunked (node's default when a body is written with no
@@ -273,7 +327,7 @@ function httpsTransport(defaults) {
 
     // URL.hostname keeps the square brackets on an IPv6 literal ([2001:db8::1]); node's `hostname`
     // option and its IP-detection expect the bare address, so strip the brackets once here.
-    var host = url.hostname.replace(/^\[(.*)\]$/, "$1");
+    var host = _stripIpv6Brackets(url.hostname);
     var options = {
       method: request.method || "GET",
       hostname: host,

package/lib/inspect.js

@@ -121,7 +121,7 @@ function _serial(cert, indent) {
   // 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" + (buf.toString("hex").replace(/^0+/, "") || "0") + ")";
+    return "Serial Number: " + n + " (0x" + (_stripLeadingZeros(buf.toString("hex")) || "0") + ")";
   }
   return "Serial Number:\n" + " ".repeat(indent) + _hexColon(buf, {});
 }
@@ -905,11 +905,22 @@ _CMS_SHAPE[oid.byName("compressedData")] = function (o) { return _isObj(o.compre
 // 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;
+  return s.slice(i);
+}
+function _stripTrailingNewline(s) {
+  return (s.length > 0 && s.charAt(s.length - 1) === "\n") ? s.slice(0, s.length - 1) : s;
+}
+
 function _cmsEmbedded(kind, el, pad) {
   if (el.tagClass === "universal") {
     try {
       var sub = (kind === "CRL") ? crlReport(el.bytes) : certificate(el.bytes);
-      return pad + kind + ":\n" + sub.replace(/\n$/, "").split("\n").map(function (l) { return pad + "    " + l; }).join("\n");
+      return pad + kind + ":\n" + _stripTrailingNewline(sub).split("\n").map(function (l) { return pad + "    " + l; }).join("\n");
     } catch (_e) { /* fall through to the summary */ }
   }
   return pad + kind + " [" + el.tagClass + " " + el.tagNumber + "] (" + el.bytes.length + " bytes)";

package/lib/ip-utils.js

@@ -3,8 +3,8 @@
 "use strict";
 //
 // @internal -- no operator-facing namespace. Textual IP-literal validation, shared so a
-// consumer (pki.lint's commonName-in-SAN check today; a future SAN iPAddress / name-
-// constraint surface) does not hand-roll a partial regex that misses a valid IPv6 form.
+// consumer (pki.lint's commonName-in-SAN check today; the SAN iPAddress GeneralName shorthand
+// and name-constraint surfaces) does not hand-roll a partial regex that misses a valid IPv6 form.
 //
 // The IPv4 grammar is strict per-octet 0-255 (RFC 791); the IPv6 parser follows RFC 4291
 // sec. 2.2 (8 groups of 1-4 hex, one "::" run compressing a contiguous zero run) plus the
@@ -12,43 +12,116 @@
 // This mirrors the vetted validation in the sibling blamejs framework (lib/ip-utils.js);
 // this toolkit keeps its own copy, since Hard rule #1 rules out a runtime dependency.
 
-// Strict RFC 791 dotted-quad: four 0-255 octets. Anchored + per-octet repeat-capped (no
-// ReDoS on unbounded input).
-var IPV4_RE = /^(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$/;
-function isIPv4(s) { return typeof s === "string" && IPV4_RE.test(s); }
+// This parser uses no regular expression. packIpLiteral gates a GeneralName form decision (iPAddress
+// vs dNSName), and a regex is matched through a live, replaceable protocol -- RegExp.prototype.exec /
+// test and String.prototype.match / split consult the regex's own `exec` and the `[Symbol.match]` /
+// `[Symbol.split]` hooks, and RegExp.prototype.compile can mutate a pattern in place -- so co-resident
+// code could steer the decision after load. Instead every byte is read directly through captured string
+// primitives, and separation on a literal is done by scanning with captured indexOf/slice, so nothing the
+// decision rests on is re-dispatchable.
+var intrinsic = require("./guard-intrinsic");
+var _slice = intrinsic.uncurry(String.prototype.slice);
+var _padStart = intrinsic.uncurry(String.prototype.padStart);
+var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
+var _lastIndexOf = intrinsic.uncurry(String.prototype.lastIndexOf);
+var _toLowerCase = intrinsic.toLowerCase;
+var _indexOf = intrinsic.stringIndexOf;
+var _numToString = intrinsic.numberToString;
+var _bufferFrom = intrinsic.bufferFrom;
+var _bufferAlloc = intrinsic.bufferAlloc;
+var _defineProperty = intrinsic.defineProperty;
+var _Number = intrinsic.Number;
+// Every array here is built and read as own elements only. Appending through a captured Object.defineProperty
+// (not `arr[i] = v`) creates an own element, so a co-resident Array.prototype numeric setter is never invoked
+// and the own element shadows any inherited getter on read; and no Array.prototype.map / concat runs, so
+// Array[Symbol.species] is never consulted. Both are routes a hostile prototype could otherwise use to
+// rewrite a packed octet and make a certificate carry an attacker-chosen address. The emitted octets are
+// written straight into a Buffer, whose integer-indexed store bypasses the prototype entirely.
+function _push(arr, v) { _defineProperty(arr, arr.length, { value: v, writable: true, enumerable: true, configurable: true }); }
+// Split on a literal string separator without String.prototype.split, which consults the separator's
+// `[Symbol.split]`; this scans with captured indexOf/slice only.
+function _splitOn(str, sep) {
+  var out = [], from = 0, at;
+  while ((at = _indexOf(str, sep, from)) !== -1) { _push(out, _slice(str, from, at)); from = at + sep.length; }
+  _push(out, _slice(str, from));
+  return out;
+}
+
+function _isDigitCode(c) { return c >= 48 && c <= 57; }                                      // 0-9
+function _isHexCode(c) { return (c >= 48 && c <= 57) || (c >= 97 && c <= 102) || (c >= 65 && c <= 70); }
+
+// A strict RFC 791 dotted-quad octet: 1-3 digits, value 0-255, no leading zero beyond "0" itself.
+function _isOctet(p) {
+  var n = p.length, i, c;
+  if (n < 1 || n > 3) return false;
+  for (i = 0; i < n; i += 1) { c = _charCodeAt(p, i); if (!_isDigitCode(c)) return false; }
+  if (n > 1 && _charCodeAt(p, 0) === 48) return false;   // a leading zero is not the canonical form
+  return _Number(p) <= 255;
+}
+
+// Strict RFC 791 dotted quad: four 0-255 octets, nothing else.
+function isIPv4(s) {
+  if (typeof s !== "string") return false;
+  var parts = _splitOn(s, ".");
+  if (parts.length !== 4) return false;
+  for (var i = 0; i < 4; i += 1) { if (!_isOctet(parts[i])) return false; }
+  return true;
+}
+
+// A single 1-4 hex-digit IPv6 group.
+function _isHexGroup(g) {
+  var n = g.length, i;
+  if (n < 1 || n > 4) return false;
+  for (i = 0; i < n; i += 1) { if (!_isHexCode(_charCodeAt(g, i))) return false; }
+  return true;
+}
+
+// The RFC 4291 sec. 2.5.5.2 dual-stack tail SHAPE: exactly four 1-3 digit groups joined by dots. Validity
+// (0-255 per octet) is a separate isIPv4 check, matching the historical two-step (shape then value).
+function _isDottedQuadShape(t) {
+  var q = _splitOn(t, "."), i, p, j;
+  if (q.length !== 4) return false;
+  for (i = 0; i < 4; i += 1) {
+    p = q[i];
+    if (p.length < 1 || p.length > 3) return false;
+    for (j = 0; j < p.length; j += 1) { if (!_isDigitCode(_charCodeAt(p, j))) return false; }
+  }
+  return true;
+}
 
 // Expand an IPv6 textual address to its 32-hex-character form, or null on any parse failure
 // (bad hex group, group count != 8, more than one "::", an over-length group). Accepts the
 // IPv4-mapped / dual-stack ".d.d.d.d" tail.
 var IPV6_TEXT_MAX_LEN = 45;   // 8 groups x4 hex + 7 colons + a dotted-quad tail headroom
 function expandIpv6Hex(ip) {
-  if (typeof ip !== "string" || ip.length > IPV6_TEXT_MAX_LEN || ip.indexOf(":") === -1) return null;
-  // RFC 4291 sec. 2.5.5.2 IPv4-mapped / dual-stack: fold a trailing dotted-quad into two
-  // 16-bit hex groups before the pure-hex parse.
-  var dual = ip.match(/^(.*):(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/);
-  if (dual) {
-    if (!isIPv4(dual[2])) return null;
-    var v4 = dual[2].split(".").map(Number);
-    ip = dual[1] + ":" + (((v4[0] << 8) | v4[1]).toString(16)) + ":" + (((v4[2] << 8) | v4[3]).toString(16));
+  if (typeof ip !== "string" || ip.length > IPV6_TEXT_MAX_LEN || _indexOf(ip, ":") === -1) return null;
+  // RFC 4291 sec. 2.5.5.2 IPv4-mapped / dual-stack: fold a trailing dotted-quad (the suffix after the
+  // last colon, when it carries a dot) into two 16-bit hex groups before the pure-hex parse.
+  var lastColon = _lastIndexOf(ip, ":");
+  var tail = _slice(ip, lastColon + 1);
+  if (_indexOf(tail, ".") !== -1) {
+    if (!_isDottedQuadShape(tail) || !isIPv4(tail)) return null;
+    var q = _splitOn(tail, "."), o0 = _Number(q[0]), o1 = _Number(q[1]), o2 = _Number(q[2]), o3 = _Number(q[3]);
+    ip = _slice(ip, 0, lastColon) + ":" + _numToString((o0 << 8) | o1, 16) + ":" + _numToString((o2 << 8) | o3, 16);
   }
-  var dbl = ip.split("::");
+  var dbl = _splitOn(ip, "::");
   if (dbl.length > 2) return null;
-  var left = dbl[0] === "" ? [] : dbl[0].split(":");
-  var right = dbl.length === 2 ? (dbl[1] === "" ? [] : dbl[1].split(":")) : [];
+  var left = dbl[0] === "" ? [] : _splitOn(dbl[0], ":");
+  var right = dbl.length === 2 ? (dbl[1] === "" ? [] : _splitOn(dbl[1], ":")) : [];
   if (dbl.length === 1 && left.length !== 8) return null;
   var fill = 8 - left.length - right.length;
   // A "::" run MUST compress at least one zero group (RFC 4291 sec. 2.2 / RFC 5952 sec.
   // 4.2.2): a "::" with fill 0 is a full 8-group address that must not use compression.
   if (dbl.length === 2 ? fill < 1 : fill !== 0) return null;
-  var groups = left, i;
-  for (i = 0; i < fill; i += 1) groups = groups.concat(["0"]);
-  groups = groups.concat(right);
+  var groups = left, i;   // `left` is a fresh own-element array; append through _push (no inherited setter)
+  for (i = 0; i < fill; i += 1) _push(groups, "0");
+  for (i = 0; i < right.length; i += 1) _push(groups, right[i]);
   if (groups.length !== 8) return null;
   var hex = "";
   for (i = 0; i < 8; i += 1) {
     var g = groups[i];
-    if (g.length < 1 || g.length > 4 || !/^[0-9a-f]+$/i.test(g)) return null;
-    hex += g.toLowerCase().padStart(4, "0");
+    if (!_isHexGroup(g)) return null;
+    hex += _padStart(_toLowerCase(g), 4, "0");
   }
   return hex;
 }
@@ -61,9 +134,13 @@ function isIpLiteral(s) { return isIPv4(s) || expandIpv6Hex(s) !== null; }
 // expandIpv6Hex validate, so a SAN/GeneralName iPAddress (RFC 5280 sec. 4.2.1.6, always a bare
 // host address of 4 or 16 octets) can be given as a string instead of a pre-packed Buffer.
 function packIpLiteral(s) {
-  if (isIPv4(s)) return Buffer.from(s.split(".").map(Number));   // each octet already range-checked by IPV4_RE
+  if (isIPv4(s)) {
+    var parts = _splitOn(s, "."), buf = _bufferAlloc(4), i;
+    for (i = 0; i < 4; i += 1) buf[i] = _Number(parts[i]);   // Buffer integer-index store; each octet range-checked by _isOctet
+    return buf;
+  }
   var hex = expandIpv6Hex(s);
-  return hex === null ? null : Buffer.from(hex, "hex");
+  return hex === null ? null : _bufferFrom(hex, "hex");
 }
 
-module.exports = { isIPv4: isIPv4, expandIpv6Hex: expandIpv6Hex, isIpLiteral: isIpLiteral, packIpLiteral: packIpLiteral, IPV4_RE: IPV4_RE };
+module.exports = { isIPv4: isIPv4, expandIpv6Hex: expandIpv6Hex, isIpLiteral: isIpLiteral, packIpLiteral: packIpLiteral };

package/lib/key.js

@@ -441,7 +441,7 @@ function _inferAlgorithm(detected) {
 function _importUsages(name, isPublic) {
   var n = String(name == null ? "" : name).toUpperCase();
   if (n === "X25519" || n === "X448" || n === "ECDH") return isPublic ? [] : ["deriveBits", "deriveKey"];
-  if (/^ML-KEM/.test(n)) return isPublic ? ["encapsulateBits"] : ["decapsulateBits"];
+  if (n.indexOf("ML-KEM") === 0) return isPublic ? ["encapsulateBits"] : ["decapsulateBits"];
   if (n === "RSA-OAEP") return isPublic ? ["encrypt"] : ["decrypt"];
   return isPublic ? ["verify"] : ["sign"];   // signing default (Ed / ECDSA / RSA-* sign / ML-DSA / SLH-DSA)
 }
@@ -449,7 +449,7 @@ function _importUsages(name, isPublic) {
 function _generateUsages(name) {
   var n = String(name == null ? "" : name).toUpperCase();
   if (n === "X25519" || n === "X448" || n === "ECDH") return ["deriveBits", "deriveKey"];
-  if (/^ML-KEM/.test(n)) return ["encapsulateBits", "decapsulateBits"];
+  if (n.indexOf("ML-KEM") === 0) return ["encapsulateBits", "decapsulateBits"];
   if (n === "RSA-OAEP") return ["encrypt", "decrypt"];
   return ["sign", "verify"];
 }

package/lib/lint.js

@@ -97,7 +97,7 @@ function _finding(rule, detail) {
 // would be the check computed and thrown away. Never throws: _ingest's contract is to return a
 // finding for bad DATA and reserve throws for a wrong-TYPE argument.
 function _derivedCert(o) {
-  if (!o || typeof o !== "object" || Buffer.isBuffer(o) || ArrayBuffer.isView(o) || o instanceof ArrayBuffer) return null;
+  if (!o || typeof o !== "object" || guard.bytes.isByteSource(o)) return null;
   try {
     var p = guard.parsed.acceptDerived(o, "certificate", x509.parse, _cfg, "lint/bad-input", "the certificate");
     return guard.parsed.isCert(p) ? p : null;