@blamejs/pki 0.8.55 → 0.8.57

package/lib/trust.js

@@ -44,10 +44,25 @@ var intrinsic = require("./guard-intrinsic");
 var _hasOwn = intrinsic.hasOwn;
 var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
 var _strSlice = intrinsic.uncurry(String.prototype.slice);
+/** @internal The operations a Trust Bits cell is read through. The token lookup GRANTS a purpose, so
+ * read off the live prototype these decide what an anchor is trusted for: measured, with the fold
+ * replaced for one token, a row stating only `Email` produced an anchor carrying `serverAuth`. */
+var _strSplit = intrinsic.uncurry(String.prototype.split);
+var _strTrim = intrinsic.uncurry(String.prototype.trim);
+var _charAt = intrinsic.uncurry(String.prototype.charAt);
+var _arrIndexOf = intrinsic.uncurry(Array.prototype.indexOf);
+var _arrJoin = intrinsic.uncurry(Array.prototype.join);
+var _arrEvery = intrinsic.uncurry(Array.prototype.every);
 var x509 = require("./schema-x509");
 var pkix = require("./schema-pkix");
 var oid = require("./oid");
 var nodeFs = require("fs");
+/** @internal The three file operations a CA bundle is read with, captured at load. The bytes they
+ * return become the host's trust anchors, so a replaced `readSync` substitutes the anchor set
+ * itself, which is a wider result than any single verdict. The exports are writable. */
+var _fsOpenSync = nodeFs.openSync;
+var _fsReadSync = nodeFs.readSync;
+var _fsCloseSync = nodeFs.closeSync;
 var nodeTls = require("tls");
 var trustanchorSchema = require("./schema-trustanchor");
 
@@ -65,10 +80,10 @@ var PURPOSE_ATTRS = [
   ["CKA_TRUST_CODE_SIGNING", "codeSigning"],
 ];
 
-var CKT_RECOGNIZED = Object.create(null);
-["CKT_NSS_TRUSTED_DELEGATOR", "CKT_NSS_TRUSTED", "CKT_NSS_MUST_VERIFY_TRUST",
-  "CKT_NSS_TRUST_UNKNOWN", "CKT_NSS_NOT_TRUSTED", "CKT_NSS_VALID_DELEGATOR"]
-  .forEach(function (t) { CKT_RECOGNIZED[t] = true; });
+var CKT_RECOGNIZED = intrinsic.create(null);
+intrinsic.forEach(["CKT_NSS_TRUSTED_DELEGATOR", "CKT_NSS_TRUSTED", "CKT_NSS_MUST_VERIFY_TRUST",
+  "CKT_NSS_TRUST_UNKNOWN", "CKT_NSS_NOT_TRUSTED", "CKT_NSS_VALID_DELEGATOR"],
+  function (t) { CKT_RECOGNIZED[t] = true; });
 var CKT_DELEGATOR = "CKT_NSS_TRUSTED_DELEGATOR";
 
 function _isNameChar(c) { return (c >= 65 && c <= 90) || (c >= 48 && c <= 57) || c === 95; }
@@ -105,16 +120,21 @@ function _unquote(s) {
   return _strSlice(s, 1, n - 1);
 }
 
+/** @internal Each piece is APPENDED with the operation that defines an own property. An index
+ *  assignment writes through Set, which walks the prototype for a numeric setter, so an accessor
+ *  installed on `Array.prototype` takes the piece and the index reads back as whatever its getter
+ *  answers: substituting a line of a certdata trust object replaced its `CK_TRUST` token, and a root
+ *  the file marks NOT_TRUSTED produced an anchor trusted as a delegator for server authentication. */
 function _splitWhitespace(s) {
   var out = [], i = 0, n = s.length, pieceStart = 0;
   while (i < n) {
     if (_isWsCode(_charCodeAt(s, i))) {
-      out[out.length] = _strSlice(s, pieceStart, i);
+      intrinsic.append(out, _strSlice(s, pieceStart, i));
       while (i < n && _isWsCode(_charCodeAt(s, i))) i += 1;
       pieceStart = i;
     } else i += 1;
   }
-  out[out.length] = _strSlice(s, pieceStart);
+  intrinsic.append(out, _strSlice(s, pieceStart));
   return out;
 }
 
@@ -129,15 +149,15 @@ function _splitLines(text) {
   while (i < n) {
     var c = _charCodeAt(text, i);
     if (c === 13) {
-      out[out.length] = _strSlice(text, start, i);
+      intrinsic.append(out, _strSlice(text, start, i));
       if (i + 1 < n && _charCodeAt(text, i + 1) === 10) i += 1;
       i += 1; start = i;
     } else if (c === 10) {
-      out[out.length] = _strSlice(text, start, i);
+      intrinsic.append(out, _strSlice(text, start, i));
       i += 1; start = i;
     } else i += 1;
   }
-  out[out.length] = _strSlice(text, start);
+  intrinsic.append(out, _strSlice(text, start));
   return out;
 }
 
@@ -164,25 +184,28 @@ function _readOctalBody(lines, idx) {
   var out = [];
   var cap = LIMITS.TRUST_MAX_OCTAL_BYTES;
   for (var i = idx; i < lines.length; i++) {
-    var t = lines[i].trim();
-    if (t === "END") return { bytes: Buffer.from(out), next: i + 1 };
+    var t = _strTrim(lines[i]);
+    /** @internal The bytes a MULTILINE_OCTAL body decodes to are constructed with the capture. This is
+     *  the certificate DER itself, along with the CKA_ISSUER and CKA_SERIAL_NUMBER a pairing is decided
+     *  on, so a replaced construction substitutes an anchor rather than steering one check. */
+    if (t === "END") return { bytes: intrinsic.bufferFrom(out), next: i + 1 };
     if (t === "") throw E("trust/bad-octal", "MULTILINE_OCTAL body interrupted by a blank line before END");
     var chunks = _splitWhitespace(t);
     for (var c = 0; c < chunks.length; c++) {
       var chunk = chunks[c];
       for (var k = 0; k < chunk.length; k += 4) {
-        if (chunk.charCodeAt(k) !== 92 ) {
-          throw E("trust/bad-octal", "MULTILINE_OCTAL expects \\ooo escapes, got " + JSON.stringify(chunk.slice(k, k + 4)));
+        if (_charCodeAt(chunk, k) !== 92 ) {
+          throw E("trust/bad-octal", "MULTILINE_OCTAL expects \\ooo escapes, got " + intrinsic.stringify(_strSlice(chunk, k, k + 4)));
         }
-        var d = chunk.slice(k + 1, k + 4);
+        var d = _strSlice(chunk, k + 1, k + 4);
         if (!_isOctal3(d)) {
-          throw E("trust/bad-octal", "a MULTILINE_OCTAL escape is a backslash + exactly three octal digits, got " + JSON.stringify("\\" + d));
+          throw E("trust/bad-octal", "a MULTILINE_OCTAL escape is a backslash + exactly three octal digits, got " + intrinsic.stringify("\\" + d));
         }
-        if (d.charCodeAt(0) > 51 ) {
+        if (_charCodeAt(d, 0) > 51 ) {
           throw E("trust/bad-octal", "octal escape \\" + d + " exceeds \\377 (one byte)");
         }
         if (out.length >= cap) throw E("trust/bad-block", "MULTILINE_OCTAL blob exceeds LIMITS.TRUST_MAX_OCTAL_BYTES");
-        out.push(parseInt(d, 8));
+        guard.list.append(out, intrinsic.parseInt(d, 8));
       }
     }
   }
@@ -194,27 +217,27 @@ function _lexObjects(text) {
   var n = lines.length;
   var i = 0, sawBegin = false;
   for (; i < n; i++) {
-    if (lines[i].trim() === "BEGINDATA") { sawBegin = true; i++; break; }
+    if (_strTrim(lines[i]) === "BEGINDATA") { sawBegin = true; i++; break; }
   }
   if (!sawBegin) throw E("trust/bad-input", "not a certdata stream: no BEGINDATA line");
 
   var objects = [];
   var cur = null;
   while (i < n) {
-    var t = lines[i].trim();
+    var t = _strTrim(lines[i]);
     if (t === "") {
-      if (cur) { objects.push(cur); cur = null; }
+      if (cur) { guard.list.append(objects, cur); cur = null; }
       i++; continue;
     }
-    if (t.charAt(0) === "#") { i++; continue; }
+    if (_charAt(t, 0) === "#") { i++; continue; }
     var m = _parseAttrLine(t);
-    if (!m) throw E("trust/bad-block", "unexpected line in the certdata object stream: " + JSON.stringify(t.slice(0, 64)));
+    if (!m) throw E("trust/bad-block", "unexpected line in the certdata object stream: " + intrinsic.stringify(_strSlice(t, 0, 64)));
     var name = m[0], type = m[1];
-    var rawVal = m[2] !== undefined ? m[2].trim() : undefined;
+    var rawVal = m[2] !== undefined ? _strTrim(m[2]) : undefined;
     if (!type) throw E("trust/bad-block", "attribute line is missing its type token: " + name);
     if (!cur) {
       if (objects.length >= LIMITS.TRUST_MAX_OBJECTS) throw E("trust/bad-block", "certdata object count exceeds LIMITS.TRUST_MAX_OBJECTS");
-      cur = { attrs: Object.create(null) };
+      cur = { attrs: intrinsic.create(null) };
     }
     if (cur.attrs[name]) throw E("trust/bad-block", "duplicate attribute " + name + " within one object block");
 
@@ -235,18 +258,18 @@ function _lexObjects(text) {
       entry = { type: type, value: q };
     } else if (type === "CK_TRUST") {
       if (rawVal === undefined || _containsWs(rawVal)) throw E("trust/bad-block", name + " CK_TRUST must carry a single token value");
-      if (!CKT_RECOGNIZED[rawVal]) throw E("trust/bad-trust-value", "unrecognized CK_TRUST value " + JSON.stringify(rawVal) + " on " + name);
+      if (!CKT_RECOGNIZED[rawVal]) throw E("trust/bad-trust-value", "unrecognized CK_TRUST value " + intrinsic.stringify(rawVal) + " on " + name);
       entry = { type: type, value: rawVal };
     } else if (type === "CK_OBJECT_CLASS" || type === "CK_CERTIFICATE_TYPE") {
       if (rawVal === undefined || _containsWs(rawVal)) throw E("trust/bad-block", name + " " + type + " must carry a single token value");
       entry = { type: type, value: rawVal };
     } else {
-      throw E("trust/bad-block", "unrecognized attribute type " + JSON.stringify(type) + " on " + name);
+      throw E("trust/bad-block", "unrecognized attribute type " + intrinsic.stringify(type) + " on " + name);
     }
     cur.attrs[name] = entry;
     i++;
   }
-  if (cur) objects.push(cur);
+  if (cur) guard.list.append(objects, cur);
   return objects;
 }
 
@@ -259,10 +282,13 @@ function _requireOctal(obj, name, what) {
   return a.bytes;
 }
 
+/** @internal The TLV the time is decoded from is assembled with captured operations. A distrust date
+ *  decides from when an anchor is no longer trusted for a purpose, so an assembly answering with a
+ *  later date leaves a distrusted root in service. */
 function _strictTime(payload, code, label) {
   var tlv;
-  if (payload.length === 13) tlv = Buffer.concat([Buffer.from([0x17, 0x0d]), payload]);
-  else if (payload.length === 15) tlv = Buffer.concat([Buffer.from([0x18, 0x0f]), payload]);
+  if (payload.length === 13) tlv = intrinsic.bufferConcat([intrinsic.bufferFrom([0x17, 0x0d]), payload]);
+  else if (payload.length === 15) tlv = intrinsic.bufferConcat([intrinsic.bufferFrom([0x18, 0x0f]), payload]);
   else throw E(code, label + " must be a 13-byte UTCTime or a 15-byte GeneralizedTime payload, got " + payload.length + " bytes");
   try { return asn1.read.time(asn1.decode(tlv)); }
   catch (e) { throw E(code, label + " does not decode as a strict time", e); }
@@ -288,14 +314,17 @@ function _certEntry(obj) {
   var issuer = _requireOctal(obj, "CKA_ISSUER", "certificate");
   var serial = _requireOctal(obj, "CKA_SERIAL_NUMBER", "certificate");
 
-  if (!issuer.equals(cert.issuer.bytes)) {
+  /** @internal Each of the three pairing refusals below compares through a captured operation. They
+   *  decide that a certdata trust object describes THIS certificate, so one answering that two
+   *  different values are equal attaches another object's purposes to it. */
+  if (!intrinsic.bufferEquals(issuer, cert.issuer.bytes)) {
     throw E("trust/pairing-mismatch", "CKA_ISSUER disagrees with the certificate's issuer DER");
   }
   var serialContentHex;
   try {
     var sn = asn1.decode(serial);
     asn1.read.integer(sn);
-    serialContentHex = sn.content.toString("hex");
+    serialContentHex = intrinsic.bufToString(sn.content, "hex");
   } catch (e) {
     throw E("trust/pairing-mismatch", "CKA_SERIAL_NUMBER is not a DER INTEGER", e);
   }
@@ -303,7 +332,7 @@ function _certEntry(obj) {
     throw E("trust/pairing-mismatch", "CKA_SERIAL_NUMBER disagrees with the certificate's serial");
   }
   var subject = obj.attrs["CKA_SUBJECT"];
-  if (subject && (subject.type !== "MULTILINE_OCTAL" || !subject.bytes.equals(cert.subject.bytes))) {
+  if (subject && (subject.type !== "MULTILINE_OCTAL" || !intrinsic.bufferEquals(subject.bytes, cert.subject.bytes))) {
     throw E("trust/pairing-mismatch", "CKA_SUBJECT disagrees with the certificate's subject DER");
   }
 
@@ -312,14 +341,17 @@ function _certEntry(obj) {
   var policy = obj.attrs["CKA_NSS_MOZILLA_CA_POLICY"];
   if (policy && policy.type !== "CK_BBOOL") throw E("trust/bad-block", "CKA_NSS_MOZILLA_CA_POLICY must be CK_BBOOL");
 
-  var distrustAfter = {};
+  var distrustAfter = intrinsic.create(null);
   var server = _distrustDate(obj, "CKA_NSS_SERVER_DISTRUST_AFTER");
   if (server) distrustAfter.serverAuth = server;
   var email = _distrustDate(obj, "CKA_NSS_EMAIL_DISTRUST_AFTER");
   if (email) distrustAfter.emailProtection = email;
 
+  /** @internal The pairing key is built with the captured encoding. It is what a trust object and a
+   *  certificate are matched on, so an encoding answering with another certificate's issuer or serial
+   *  hands an otherwise orphaned object's delegator purposes to an unrelated certificate. */
   return {
-    key: issuer.toString("hex") + "/" + serial.toString("hex"),
+    key: intrinsic.bufToString(issuer, "hex") + "/" + intrinsic.bufToString(serial, "hex"),
     der: der,
     cert: cert,
     label: label ? label.value : null,
@@ -333,13 +365,13 @@ function _trustEntry(obj) {
   var issuer = _requireOctal(obj, "CKA_ISSUER", "trust");
   var serial = _requireOctal(obj, "CKA_SERIAL_NUMBER", "trust");
   var purposes = intrinsic.assign(intrinsic.create(null), { serverAuth: false, emailProtection: false, codeSigning: false });
-  PURPOSE_ATTRS.forEach(function (pair) {
+  intrinsic.forEach(PURPOSE_ATTRS, function (pair) {
     var a = obj.attrs[pair[0]];
     if (!a) return;
     if (a.type !== "CK_TRUST") throw E("trust/bad-block", pair[0] + " must be CK_TRUST");
     purposes[pair[1]] = a.value === CKT_DELEGATOR;
   });
-  return { key: issuer.toString("hex") + "/" + serial.toString("hex"), purposes: purposes };
+  return { key: intrinsic.bufToString(issuer, "hex") + "/" + intrinsic.bufToString(serial, "hex"), purposes: purposes };
 }
 
 
@@ -366,9 +398,9 @@ function _mkAnchor(cert, meta) {
   }
   var derived = {
     name: _copyName(cert.subject),
-    publicKey: Buffer.from(spki.bytes),
+    publicKey: intrinsic.bufferFrom(spki.bytes),
     algorithm: spki.algorithm.oid,
-    parameters: spki.algorithm.parameters == null ? spki.algorithm.parameters : Buffer.from(spki.algorithm.parameters),
+    parameters: spki.algorithm.parameters == null ? spki.algorithm.parameters : intrinsic.bufferFrom(spki.algorithm.parameters),
     purposes: _purposesOrNull(meta.purposes),
     distrustAfter: _copyDistrustAfter(meta.distrustAfter),
   };
@@ -379,7 +411,7 @@ function _mkAnchor(cert, meta) {
     dc.pathLenConstraint = certPathLen;
     derived.constraints = dc;
   }
-  _DERIVED_FROM.set(entry, derived);
+  intrinsic.weakSet(_DERIVED_FROM, entry, derived);
   return entry;
 }
 var _DERIVED_FROM = new WeakMap();
@@ -408,34 +440,44 @@ function _copyDistrustAfter(src) {
   if (!src || typeof src !== "object") return out;
   var names = guard.identifier.optionNames(src);
   for (var i = 0; i < names.length; i++) {
-    out[names[i]] = guard.time.isDate(src[names[i]]) ? new Date(guard.time.instantOf(src[names[i]])) : src[names[i]];
+    out[names[i]] = guard.time.isDate(src[names[i]]) ? new intrinsic.Date(guard.time.instantOf(src[names[i]])) : src[names[i]];
   }
   return out;
 }
 
+/** @internal The three classifications that decide whether a field is copied are captured. Each one
+ *  answering `false` returns the caller's own object or buffer in place of the copy, which leaves the
+ *  anchor's name mutable after it has been validated. */
 function _copyName(name) {
-  if (!name || !Array.isArray(name.rdns)) return name;
+  if (!name || !intrinsic.isArray(name.rdns)) return name;
   var out = guard.identifier.ownOptions(name);
   out.rdns = guard.list.copyMap(name.rdns, function (rdn) {
-    return Array.isArray(rdn) ? guard.list.copyMap(rdn, function (atv) { return guard.identifier.ownOptions(atv); }) : rdn;
+    return intrinsic.isArray(rdn) ? guard.list.copyMap(rdn, function (atv) { return guard.identifier.ownOptions(atv); }) : rdn;
   });
-  out.bytes = Buffer.isBuffer(name.bytes) ? Buffer.from(name.bytes) : name.bytes;
+  out.bytes = intrinsic.isBuffer(name.bytes) ? intrinsic.bufferFrom(name.bytes) : name.bytes;
   return out;
 }
 
+/** @internal The sort comes from the capture like the join and the test below it. Read off the live
+ * prototype it decides what the comparison SEES: a replacement answering with empty arrays makes the
+ * joins equal and the per-name test vacuous, so two rows for one root stop disagreeing without a
+ * single date being compared, and the pairing refusal is skipped while the later cutoff is kept. */
 function _datesEqual(x, y) {
-  var kx = guard.identifier.optionNames(x).sort(), ky = guard.identifier.optionNames(y).sort();
-  if (kx.join(",") !== ky.join(",")) return false;
-  return kx.every(function (k) { return guard.time.instantOf(x[k]) === guard.time.instantOf(y[k]); });
+  var kx = intrinsic.sort(guard.identifier.optionNames(x)), ky = intrinsic.sort(guard.identifier.optionNames(y));
+  if (_arrJoin(kx, ",") !== _arrJoin(ky, ",")) return false;
+  return _arrEvery(kx, function (k) { return guard.time.instantOf(x[k]) === guard.time.instantOf(y[k]); });
 }
 
+/** @internal The comparison that decides whether two rows for one root AGREE comes from the capture.
+ * A replacement answering `true` makes a conflicting pair compare equal, so the pairing refusal is
+ * skipped and the first row's grants are kept for both. */
 function _purposesEqual(x, y) {
-  return PURPOSES.every(function (p) { return x[p] === y[p]; });
+  return _arrEvery(PURPOSES, function (p) { return x[p] === y[p]; });
 }
 
 function _paramsEqual(x, y) {
   if (x === null || y === null) return x === y;
-  return Buffer.isBuffer(x) && Buffer.isBuffer(y) && x.equals(y);
+  return intrinsic.isBuffer(x) && intrinsic.isBuffer(y) && intrinsic.bufferEquals(x, y);
 }
 
 function _anchorsAgree(x, y) {
@@ -447,13 +489,17 @@ function _anchorsAgree(x, y) {
     _datesEqual(x.distrustAfter, y.distrustAfter);
 }
 
+/** @internal The dedup key identifies a root by its subject and its key, and the map that holds the
+ *  keys is constructed here. Both come from captures: an encoding that answers with another root's
+ *  bytes, or a map already holding this root's key, makes a second row for one root compare against
+ *  metadata it never carried, which is how a disagreeing pair passes the refusal below. */
 function _dedupAnchors(anchors) {
-  var seen = Object.create(null);
+  var seen = intrinsic.create(null);
   var out = [];
-  anchors.forEach(function (a) {
-    var key = a.subjectDer.toString("hex") + "/" + a.publicKey.toString("hex");
+  intrinsic.forEach(anchors, function (a) {
+    var key = intrinsic.bufToString(a.subjectDer, "hex") + "/" + intrinsic.bufToString(a.publicKey, "hex");
     var prev = seen[key];
-    if (!prev) { seen[key] = a; out.push(a); return; }
+    if (!prev) { seen[key] = a; guard.list.append(out, a); return; }
     if (!_anchorsAgree(prev, a)) {
       throw E("trust/pairing-mismatch", "two entries for one root (same subject + key) disagree on trust metadata");
     }
@@ -513,9 +559,12 @@ function parseCertdata(text) {
   var objects = _lexObjects(text);
 
   var certs = [];
-  var byKey = Object.create(null);
+  /** @internal The pairing map is constructed from the capture. A map that already holds an entry
+   *  under a key a trust object will present is the same bypass as a mis-encoded key: the lookup
+   *  below finds it and the object's purposes reach a certificate it does not describe. */
+  var byKey = intrinsic.create(null);
   var trusts = [];
-  objects.forEach(function (obj) {
+  intrinsic.forEach(objects, function (obj) {
     var cls = obj.attrs["CKA_CLASS"];
     if (!cls || cls.type !== "CK_OBJECT_CLASS") {
       throw E("trust/bad-block", "object block is missing CKA_CLASS CK_OBJECT_CLASS");
@@ -524,7 +573,7 @@ function parseCertdata(text) {
       var e = _certEntry(obj);
       var prev = byKey[e.key];
       if (prev) {
-        if (!prev.der.equals(e.der) || prev.label !== e.label ||
+        if (!intrinsic.bufferEquals(prev.der, e.der) || prev.label !== e.label ||
             prev.mozillaCaPolicy !== e.mozillaCaPolicy ||
             !_datesEqual(prev.distrustAfter, e.distrustAfter)) {
           throw E("trust/pairing-mismatch", "two certificate objects share an (issuer, serial) but disagree");
@@ -532,13 +581,13 @@ function parseCertdata(text) {
         return;
       }
       byKey[e.key] = e;
-      certs.push(e);
+      guard.list.append(certs, e);
     } else if (cls.value === "CKO_NSS_TRUST") {
-      trusts.push(_trustEntry(obj));
+      guard.list.append(trusts, _trustEntry(obj));
     }
   });
 
-  trusts.forEach(function (t) {
+  intrinsic.forEach(trusts, function (t) {
     var c = byKey[t.key];
     if (!c) return;
     if (c.purposes) {
@@ -551,7 +600,7 @@ function parseCertdata(text) {
   });
 
   return {
-    anchors: _dedupAnchors(certs.map(function (c) {
+    anchors: _dedupAnchors(intrinsic.mapList(certs, function (c) {
       return _mkAnchor(c.cert, {
         distrustAfter: c.distrustAfter,
         purposes: c.purposes || _copyPurposes(null),
@@ -580,19 +629,24 @@ function _csvRows(text) {
     if (field.length >= fieldCap) throw E("trust/bad-csv", "a CSV field exceeds LIMITS.TRUST_MAX_CSV_FIELD_BYTES");
     field += c;
   }
-  function endField() { row.push(field); field = ""; quoted = false; closed = false; }
+  function endField() { guard.list.append(row, field); field = ""; quoted = false; closed = false; }
   function endRow() {
     endField();
     if (rows.length >= LIMITS.TRUST_MAX_CSV_ROWS) throw E("trust/bad-csv", "CSV row count exceeds LIMITS.TRUST_MAX_CSV_ROWS");
-    rows.push(row); row = [];
+    guard.list.append(rows, row); row = [];
   }
 
+  /** @internal The lexer reads every character through the capture. It decides which characters
+   * reach the cell readers, so a replaced `charAt` changes the TOKEN those readers are handed even
+   * though they read it safely: measured, feeding the characters of `Email` at a `Bogus` token's
+   * offsets turned a refusal into an anchor carrying `emailProtection`. Converting the readers alone
+   * left this, which is why the module is converted rather than the sites that kept being found. */
   var i = 0, n = text.length;
   while (i < n) {
-    var ch = text.charAt(i);
+    var ch = _charAt(text, i);
     if (inQuotes) {
       if (ch === "\"") {
-        if (text.charAt(i + 1) === "\"") { appendChar("\""); i += 2; continue; }
+        if (_charAt(text, i + 1) === "\"") { appendChar("\""); i += 2; continue; }
         inQuotes = false; closed = true; i++; continue;
       }
       appendChar(ch); i++; continue;
@@ -602,7 +656,7 @@ function _csvRows(text) {
       inQuotes = true; quoted = true; i++; continue;
     }
     if (ch === ",") { endField(); i++; continue; }
-    if (ch === "\r" && text.charAt(i + 1) === "\n") { endRow(); i += 2; continue; }
+    if (ch === "\r" && _charAt(text, i + 1) === "\n") { endRow(); i += 2; continue; }
     if (ch === "\n" || ch === "\r") { endRow(); i++; continue; }
     if (closed) throw E("trust/bad-csv", "content after a closing quote (RFC 4180)");
     appendChar(ch); i++;
@@ -621,12 +675,20 @@ var _TRUST_BIT_TOKENS = intrinsic.assign(intrinsic.create(null), {
 });
 function _trustBits(cell) {
   var purposes = intrinsic.assign(intrinsic.create(null), { serverAuth: false, emailProtection: false, codeSigning: false });
-  String(cell).split(";").forEach(function (tok) {
-    var t = tok.trim();
+  /** @internal The string conversion is captured as well. A CSV field is already a string, so this
+   * guards the case where it is not; read off the live global it is one more operation that decides
+   * the TOKEN, and a `String` replacement mapping the cell `Email` to `Websites` reproduced the whole
+   * trust-widening bypass that the captured split, trim and fold had just closed. */
+  /** @internal The cell is scanned on the delimiter CHARACTER. A separator string carries a
+   * `Symbol.split` method the split operation is specified to look up and call, so capturing `split`
+   * leaves the separator's prototype chain in the operation; hard rule 11 bans `split` in lib/ for
+   * that reason. A hook answering `Websites` for a cell reading `Email` grants `serverAuth`. */
+  intrinsic.forEach(intrinsic.splitChar(intrinsic.String(cell), 59), function (tok) {
+    var t = _strTrim(tok);
     if (t === "") return;
-    var l = t.toLowerCase();
+    var l = intrinsic.toLowerCase(t);
     if (!_hasOwn(_TRUST_BIT_TOKENS, l)) {
-      throw E("trust/bad-csv", "unrecognized Trust Bits token " + JSON.stringify(t));
+      throw E("trust/bad-csv", "unrecognized Trust Bits token " + intrinsic.stringify(t));
     }
     var p = _TRUST_BIT_TOKENS[l];
     if (p) purposes[p] = true;
@@ -634,25 +696,30 @@ function _trustBits(cell) {
   return purposes;
 }
 
+/** @internal The trim comes from the capture: an empty cell means NO distrust date, so a replacement
+ * answering with the empty string for a cell the parser would have refused removes a distrust date
+ * rather than failing. Measured, `not-a-date` trimmed to `""` turned `trust/bad-csv` into `null`. */
 function _csvDate(cell, label) {
-  var s = String(cell).trim();
+  var s = _strTrim(intrinsic.String(cell));
   if (s === "") return null;
   var m = _parseYmd(s);
-  if (!m) throw E("trust/bad-csv", label + " must be a Y-M-D date, got " + JSON.stringify(s));
+  if (!m) throw E("trust/bad-csv", label + " must be a Y-M-D date, got " + intrinsic.stringify(s));
   var pad = function (x) { return x.length === 1 ? "0" + x : x; };
-  var payload = Buffer.from(m[0] + pad(m[1]) + pad(m[2]) + "235959Z", "latin1");
+  var payload = intrinsic.bufferFrom(m[0] + pad(m[1]) + pad(m[2]) + "235959Z", "latin1");
   try { return _strictTime(payload, "trust/bad-csv", label); }
   catch (e) {
     if (e && e.code === "trust/bad-csv") throw e;
-    throw E("trust/bad-csv", label + " is not a real calendar date: " + JSON.stringify(s), e);
+    throw E("trust/bad-csv", label + " is not a real calendar date: " + intrinsic.stringify(s), e);
   }
 }
 
+/** @internal The cell this reads holds the CERTIFICATE an anchor is built from, so the operations
+ * that unquote it come from the captures like the rest of the CSV path. */
 function _pemCell(cell) {
-  var s = String(cell).trim();
-  if (s.charAt(0) === "'") s = s.slice(1);
-  if (s.charAt(s.length - 1) === "'") s = s.slice(0, -1);
-  s = s.trim();
+  var s = _strTrim(intrinsic.String(cell));
+  if (_charCodeAt(s, 0) === 39) s = _strSlice(s, 1);
+  if (_charCodeAt(s, s.length - 1) === 39) s = _strSlice(s, 0, -1);
+  s = _strTrim(s);
   if (s === "") throw E("trust/bad-csv", "PEM Info cell is empty");
   try { return x509.parse(s); }
   catch (e) { throw E("trust/not-a-certificate", "PEM Info does not parse as an X.509 certificate", e); }
@@ -702,17 +769,28 @@ function parseCcadbCsv(text) {
   var rows = _csvRows(text);
   if (rows.length === 0) throw E("trust/bad-csv", "CSV input carries no header row");
 
-  var header = rows[0].map(function (h) { return h.trim(); });
-  var col = Object.create(null);
-  header.forEach(function (h, idx) {
+  /** @internal The header names decide WHICH column each field is read from, so the trim comes from
+   * the capture. Read off the live prototype, a replacement that renames the real Trust Bits header
+   * and answers `Trust Bits` for another column makes the purposes come from that column: measured, a
+   * row stating `Email` produced an anchor carrying `serverAuth` taken from a decoy cell. */
+  var header = intrinsic.mapList(rows[0], function (h) { return _strTrim(h); });
+  /** @internal The name-to-index map is constructed from the capture as well. A map handed back
+   *  already holding `Trust Bits` is the same result as a mis-trimmed header: the required-column
+   *  check below finds the name present and every field is read from the column it names. */
+  var col = intrinsic.create(null);
+  /** @internal The iteration that maps a header NAME to its column index, and the membership test
+   * that refuses a duplicated required column, both come from the captures. A replaced `forEach`
+   * supplied the decoy column's index for `Trust Bits` and swapped the two distrust-date columns, and
+   * a replaced `indexOf` answering -1 let a duplicated required column through. */
+  intrinsic.forEach(header, function (h, idx) {
     if (col[h] !== undefined) {
-      if (CSV_REQUIRED.indexOf(h) !== -1) throw E("trust/bad-csv", "duplicate required column " + JSON.stringify(h));
+      if (_arrIndexOf(CSV_REQUIRED, h) !== -1) throw E("trust/bad-csv", "duplicate required column " + intrinsic.stringify(h));
       return;
     }
     col[h] = idx;
   });
-  CSV_REQUIRED.forEach(function (r) {
-    if (col[r] === undefined) throw E("trust/bad-csv", "CSV is missing the required column " + JSON.stringify(r));
+  intrinsic.forEach(CSV_REQUIRED, function (r) {
+    if (col[r] === undefined) throw E("trust/bad-csv", "CSV is missing the required column " + intrinsic.stringify(r));
   });
 
   var anchors = [];
@@ -721,13 +799,13 @@ function parseCcadbCsv(text) {
     if (row.length !== header.length) {
       throw E("trust/bad-csv", "CSV row " + (i + 1) + " has " + row.length + " fields; the header has " + header.length);
     }
-    var distrustAfter = {};
+    var distrustAfter = intrinsic.create(null);
     var tls = _csvDate(row[col["Distrust for TLS After Date"]], "Distrust for TLS After Date");
     if (tls) distrustAfter.serverAuth = tls;
     var smime = _csvDate(row[col["Distrust for S/MIME After Date"]], "Distrust for S/MIME After Date");
     if (smime) distrustAfter.emailProtection = smime;
-    var label = row[col["Common Name or Certificate Name"]].trim();
-    anchors.push(_mkAnchor(_pemCell(row[col["PEM Info"]]), {
+    var label = _strTrim(row[col["Common Name or Certificate Name"]]);
+    guard.list.append(anchors, _mkAnchor(_pemCell(row[col["PEM Info"]]), {
       distrustAfter: distrustAfter,
       purposes: _trustBits(row[col["Trust Bits"]]),
       label: label === "" ? null : label,
@@ -948,15 +1026,18 @@ function anchor(entry, opts) {
   }
   opts = guard.identifier.optionsObject(opts, E, "trust/bad-input", "pki.trust.anchor options");
   guard.identifier.assertKnownKeys(opts, _ANCHOR_OPTS, E, "trust/bad-input", "unknown pki.trust.anchor option ");
-  var derived = _DERIVED_FROM.get(entry);
+  /** @internal The provenance lookup goes through the capture. A hit here is what says this entry is
+   *  one the store produced, so a replacement answering with metadata of its own both supplies the
+   *  purposes the gate below reads and waives the refusal that stops a rebuilt entry carrying them. */
+  var derived = intrinsic.weakGet(_DERIVED_FROM, entry);
   var meta = derived || entry;
-  if (!derived && (!Buffer.isBuffer(entry.publicKey) || typeof entry.algorithm !== "string" ||
-      !entry.name || !Array.isArray(entry.name.rdns))) {
+  if (!derived && (!intrinsic.isBuffer(entry.publicKey) || typeof entry.algorithm !== "string" ||
+      !entry.name || !intrinsic.isArray(entry.name.rdns))) {
     throw E("trust/bad-input", "anchor expects a trust-store entry ({ name, publicKey, algorithm, ... })");
   }
   if (opts.purpose !== undefined) {
-    if (PURPOSES.indexOf(opts.purpose) === -1) {
-      throw E("trust/bad-input", "anchor: opts.purpose must be one of " + PURPOSES.join(" | "));
+    if (_arrIndexOf(PURPOSES, opts.purpose) === -1) {
+      throw E("trust/bad-input", "anchor: opts.purpose must be one of " + _arrJoin(PURPOSES, " | "));
     }
     if (!meta.purposes || meta.purposes[opts.purpose] !== true) {
       throw E("trust/purpose-not-trusted", "this root is not a trusted delegator for " + opts.purpose);
@@ -968,9 +1049,9 @@ function anchor(entry, opts) {
   var nameConstraints = _copyNameConstraints(opts.nameConstraints);
   var out = {
     name: _copyName(meta.name),
-    publicKey: Buffer.isBuffer(meta.publicKey) ? Buffer.from(meta.publicKey) : meta.publicKey,
+    publicKey: intrinsic.isBuffer(meta.publicKey) ? intrinsic.bufferFrom(meta.publicKey) : meta.publicKey,
     algorithm: meta.algorithm,
-    parameters: Buffer.isBuffer(meta.parameters) ? Buffer.from(meta.parameters)
+    parameters: intrinsic.isBuffer(meta.parameters) ? intrinsic.bufferFrom(meta.parameters)
       : (meta.parameters !== undefined ? meta.parameters : null),
     distrustAfter: _copyDistrustAfter(meta.distrustAfter),
     purposes: _purposesOrNull(meta.purposes),
@@ -1001,7 +1082,7 @@ function _copyConstraints(c) {
       excluded: _copySubtrees(c.nameConstraints.excluded, "excluded"),
     };
   }
-  if (c.policySet) out.policySet = intrinsic.map(c.policySet, function (p) { return p; });
+  if (c.policySet) out.policySet = intrinsic.mapList(c.policySet, function (p) { return p; });
   if (c.policyFlags) {
     var f = intrinsic.create(null);
     intrinsic.forEach(trustanchorSchema.policyFlagBits, function (k) { f[k] = c.policyFlags[k] === true; });
@@ -1031,13 +1112,13 @@ function _anchorConstraintsOf(taInfo) {
   var any = false;
   if (cp.nameConstr !== null) {
     out.nameConstraints = {
-      permitted: intrinsic.map(cp.nameConstr.permittedSubtrees || [], _subtreeOf),
-      excluded: intrinsic.map(cp.nameConstr.excludedSubtrees || [], _subtreeOf),
+      permitted: intrinsic.mapList(cp.nameConstr.permittedSubtrees || [], _subtreeOf),
+      excluded: intrinsic.mapList(cp.nameConstr.excludedSubtrees || [], _subtreeOf),
     };
     any = true;
   }
   if (cp.policySet !== null) {
-    out.policySet = intrinsic.map(cp.policySet, function (p) { return p.policyIdentifier; });
+    out.policySet = intrinsic.mapList(cp.policySet, function (p) { return p.policyIdentifier; });
     any = true;
   }
   if (cp.policyFlags !== null) { out.policyFlags = cp.policyFlags; any = true; }
@@ -1116,7 +1197,7 @@ function _entryFromAnchor(a, i) {
    * obvious thing. Keeping the constraints out of reach of that call would hand them an
    * UNCONSTRAINED anchor and silently drop every restriction the list stated. */
   if (constraints) guard.verdict.set(entry, "constraints", constraints);
-  _DERIVED_FROM.set(entry, {
+  intrinsic.weakSet(_DERIVED_FROM, entry, {
     name: _copyName(info.certPath.taName),
     publicKey: intrinsic.bufferFrom(spki.bytes),
     algorithm: spki.algorithm.oid,
@@ -1194,26 +1275,26 @@ function discoversBundles(platform) {
 function _readBundleText(chosen, maxBytes) {
   var fd = null, raw, read;
   try {
-    fd = nodeFs.openSync(chosen, "r");
+    fd = _fsOpenSync(chosen, "r");
     var buf = intrinsic.bufferAlloc(maxBytes + 1);
     /** @internal readSync may return fewer bytes than asked for, so the prefix of one call is not
      * the file. Taking it as the whole bundle would drop the roots below the break with nothing
      * reported, and would let a file above the cap pass the check underneath it. */
     read = 0;
     for (;;) {
-      var got = nodeFs.readSync(fd, buf, read, (maxBytes + 1) - read, read);
+      var got = _fsReadSync(fd, buf, read, (maxBytes + 1) - read, read);
       if (got === 0) break;
       read += got;
       if (read >= maxBytes + 1) break;
     }
-    raw = buf.subarray(0, read);
+    raw = intrinsic.byteSlice(buf, 0, read);
   } catch (e) {
     throw E("trust/no-readable-store", "no CA bundle could be read at " + guard.text.showValue(chosen) +
       "; " + _exportHint() + ", or pass opts.allowNodeBundle to use the Mozilla set compiled into " +
       "Node, which is NOT what this host trusts", e);
   } finally {
     if (fd !== null) {
-      try { nodeFs.closeSync(fd); }
+      try { _fsCloseSync(fd); }
       // allow:swallow-unverified the descriptor is released on a best-effort basis
       catch (_e) { void 0; }
     }
@@ -1260,7 +1341,7 @@ function _readBundleText(chosen, maxBytes) {
  *   console.log(store.skipped.length >= 0); // -> true (entries named, never dropped silently)
  */
 function systemAnchors(opts) {
-  opts = opts || {};
+  opts = opts || intrinsic.create(null);
   guard.identifier.assertPlainRecord(opts, E, "trust/bad-input", "systemAnchors opts");
   guard.identifier.assertKnownKeys(opts, _SYSTEM_ANCHOR_OPTS, E, "trust/bad-input",
     "unknown systemAnchors option ");
@@ -1438,11 +1519,13 @@ function _systemResult(anchors, source, chosen, skipped) {
   return out;
 }
 
-module.exports = {
+/** @internal Frozen, so a consumer that reads one of these off this object at the call cannot be
+ *  handed a replacement in place of it. */
+module.exports = intrinsic.freeze({
   parseCertdata: parseCertdata,
   parseCcadbCsv: parseCcadbCsv,
   parseTrustAnchorList: parseTrustAnchorList,
   systemAnchors: systemAnchors,
   discoversBundles: discoversBundles,
   anchor: anchor,
-};
+});