@blamejs/pki 0.8.58 → 0.8.60

package/lib/crl-sign.js

@@ -24,6 +24,9 @@ var x509Schema = require("./schema-x509");
 var signScheme = require("./sign-scheme");
 var guard = require("./guard-all");
 var intrinsic = require("./guard-intrinsic");
+/** @internal The append every list here is built with: `push` stores at the index and a store
+ *  consults a setter inherited there, and these lists become the bytes that get signed. */
+var _push = intrinsic.append;
 var _hasOwn = intrinsic.hasOwn, _bufferEquals = intrinsic.bufferEquals;
 var _arrSlice = intrinsic.arraySlice, _promiseResolve = intrinsic.uncurry(intrinsic.promiseResolve);
 /** @internal The RECEIVER for the captured `Promise.resolve`, captured too. `resolve` builds through
@@ -108,8 +111,8 @@ var KNOWN_REVOKED_KEYS = intrinsic.assign(intrinsic.create(null), {
 });
 
 var REQUIRED_CRITICALITY = intrinsic.create(null);
-[["cRLNumber", false], ["authorityKeyIdentifier", false], ["freshestCRL", false], ["authorityInfoAccess", false],
-  ["issuingDistributionPoint", true], ["deltaCRLIndicator", true]].forEach(function (r) { REQUIRED_CRITICALITY[O(r[0])] = r[1]; });
+intrinsic.forEach([["cRLNumber", false], ["authorityKeyIdentifier", false], ["freshestCRL", false], ["authorityInfoAccess", false],
+  ["issuingDistributionPoint", true], ["deltaCRLIndicator", true]], function (r) { REQUIRED_CRITICALITY[O(r[0])] = r[1]; });
 
 var REQUIRED_ENTRY_CRITICALITY = intrinsic.create(null);
 (function () {
@@ -184,11 +187,11 @@ function _idpValue(idp) {
   if (idp.fullName != null) {
     var entries = Array.isArray(idp.fullName) ? pkiBuild.reqDenseArray(idp.fullName, "issuingDistributionPoint.fullName", _err, "crl/bad-idp") : [idp.fullName];
     if (!entries.length) throw _err("crl/bad-idp", "issuingDistributionPoint fullName must carry at least one GeneralName");
-    children.push(b.contextConstructed(0, b.contextConstructed(0, Buffer.concat(entries.map(_encodeGeneralName)))));
+    _push(children,b.contextConstructed(0, b.contextConstructed(0, Buffer.concat(entries.map(_encodeGeneralName)))));
   }
   var scopeTrue = 0;
-  if (idp.onlyContainsUserCerts === true) { children.push(b.contextPrimitive(1, Buffer.from([0xff]))); scopeTrue++; }
-  if (idp.onlyContainsCACerts === true) { children.push(b.contextPrimitive(2, Buffer.from([0xff]))); scopeTrue++; }
+  if (idp.onlyContainsUserCerts === true) { _push(children,b.contextPrimitive(1, Buffer.from([0xff]))); scopeTrue++; }
+  if (idp.onlyContainsCACerts === true) { _push(children,b.contextPrimitive(2, Buffer.from([0xff]))); scopeTrue++; }
   if (idp.indirectCRL === true) throw _err("crl/bad-idp", _INDIRECT_IDP_DEFERRED);
   if (scopeTrue > 1) throw _err("crl/bad-idp", "at most one of onlyContainsUserCerts / onlyContainsCACerts may be TRUE (RFC 5280 sec. 5.2.5)");
   if (!children.length) throw _err("crl/bad-idp", "issuingDistributionPoint MUST NOT be empty (RFC 5280 sec. 5.2.5)");
@@ -199,7 +202,7 @@ var _PRE_ENCODED_IDP_SCHEMA = pkix.issuingDistributionPoint("crl/bad-idp");
 function _validatePreEncodedIdp(inner) {
   if (!inner.children || !inner.children.length) throw _err("crl/bad-idp", "pre-encoded issuingDistributionPoint MUST NOT be empty (RFC 5280 sec. 5.2.5)");
   var f = schema.walk(_PRE_ENCODED_IDP_SCHEMA, inner, NS).fields;
-  ["onlyContainsUserCerts", "onlyContainsCACerts", "onlyContainsAttributeCerts"].forEach(function (name) {
+  intrinsic.forEach(["onlyContainsUserCerts", "onlyContainsCACerts", "onlyContainsAttributeCerts"], function (name) {
     if (f[name].present && f[name].value !== true) throw _err("crl/bad-idp", "pre-encoded issuingDistributionPoint " + name + " encodes its DEFAULT FALSE, which DER omits (X.690 sec. 11.5)");
   });
   if (f.indirectCRL.present) throw _err("crl/bad-idp", _INDIRECT_IDP_DEFERRED);
@@ -232,7 +235,7 @@ function _buildCrlExtensions(spec, ctx) {
     var id = O(oidName);
     if (seen[id]) throw _err("crl/bad-input", "duplicate CRL extension " + oidName + " (RFC 5280 sec. 5.2 -- at most one instance)");
     seen[id] = true;
-    out.push(_ext(id, critical, valueDer));
+    _push(out,_ext(id, critical, valueDer));
   }
   var crlNumberVal = null;
   if (spec.crlNumber != null) { var cn = _boundedInteger(spec.crlNumber, "cRLNumber"); crlNumberVal = cn.value; push("cRLNumber", false, cn.tlv); }
@@ -264,7 +267,7 @@ function _buildCrlExtensions(spec, ctx) {
       }
       _assertExtensionValueDecodes(node, extnId, "extension");
       if (extnId === O("deltaCRLIndicator")) isDelta = true;
-      out.push(b.raw(der));
+      _push(out,b.raw(der));
     });
     if (isDelta) {
       if (seen[O("freshestCRL")]) throw _err("crl/bad-input", "freshestCRL MUST NOT appear in a delta CRL (RFC 5280 sec. 5.2.6)");
@@ -323,7 +326,7 @@ function _buildRevoked(entryList, isDelta) {
       var id = O(oidName);
       if (seen[id]) throw _err("crl/bad-input", "duplicate entry extension " + oidName + " in revoked entry [" + idx + "]");
       seen[id] = true;
-      entryExts.push(_ext(id, critical, valueDer));
+      _push(entryExts,_ext(id, critical, valueDer));
     }
     if (e.reason != null) {
       var codeNum = _resolveReason(e.reason, isDelta);
@@ -360,10 +363,10 @@ function _buildRevoked(entryList, isDelta) {
           }
         }
         _assertExtensionValueDecodes(xnode, extnId, "entry extension");
-        entryExts.push(b.raw(der));
+        _push(entryExts,b.raw(der));
       });
     }
-    if (entryExts.length) { anyExt = true; children.push(b.sequence(entryExts)); }
+    if (entryExts.length) { anyExt = true; _push(children,b.sequence(entryExts)); }
     return b.sequence(children);
   });
   return { entries: entries, anyExt: anyExt };
@@ -375,7 +378,11 @@ function _parseIssuerCert(cert) {
 }
 
 function _assertIssuerCanSignCrl(issuerCert) {
-  var kuExt = (issuerCert.extensions || []).filter(function (e) { return e.oid === O("keyUsage"); })[0];
+  /** @internal The selection returns the first matching row or null. `filter(...)[0]` indexes a
+   *  result that is EMPTY when the certificate carries no keyUsage, and index 0 of an empty array
+   *  answers from the array prototype, so a value installed there would be decoded as the issuer's
+   *  key usage and decide whether it may sign this CRL. */
+  var kuExt = guard.list.firstMatch(issuerCert.extensions || [], function (e) { return e.oid === O("keyUsage"); });
   if (!kuExt) return;
   var ku;
   try { ku = EXT_DECODERS[O("keyUsage")](kuExt.value); }
@@ -453,13 +460,13 @@ function _sign(spec, issuer, opts) {
    *  into the PreTBSCertList the alternative signature covers. */
   function tbsOver(extList, omitSignatureAlg) {
     var tbsChildren = [];
-    if (version === 2) tbsChildren.push(b.integer(1n));
-    if (omitSignatureAlg !== true) tbsChildren.push(scheme.sigAlgId);
-    tbsChildren.push(issuerDer);
-    tbsChildren.push(thisU);
-    if (nextU) tbsChildren.push(nextU);
-    if (revoked.entries.length) tbsChildren.push(b.sequence(revoked.entries));
-    if (extList.length) tbsChildren.push(b.explicit(0, b.sequence(extList)));
+    if (version === 2) _push(tbsChildren,b.integer(1n));
+    if (omitSignatureAlg !== true) _push(tbsChildren,scheme.sigAlgId);
+    _push(tbsChildren,issuerDer);
+    _push(tbsChildren,thisU);
+    if (nextU) _push(tbsChildren,nextU);
+    if (revoked.entries.length) _push(tbsChildren,b.sequence(revoked.entries));
+    if (extList.length) _push(tbsChildren,b.explicit(0, b.sequence(extList)));
     return b.sequence(tbsChildren);
   }
 
@@ -813,7 +820,7 @@ function isRevoked(crl, serialNumber, opts) {
 
 function _findExtOid(list, name) {
   var want = O(name);
-  return (list || []).filter(function (e) { return e.oid === want; })[0] || null;
+  return guard.list.firstMatch(list || [], function (e) { return e.oid === want; });
 }
 
 var _IDP_SCHEMA = pkix.issuingDistributionPoint("crl/scope-not-authoritative");

package/lib/csr-sign.js

@@ -26,6 +26,9 @@ var pkiBuild = require("./pki-build");
 var frameworkError = require("./framework-error");
 var guard = require("./guard-all");
 var intrinsic = require("./guard-intrinsic");
+/** @internal The append every list here is built with: `push` stores at the index and a store
+ *  consults a setter inherited there, and these lists become the bytes that get signed. */
+var _push = intrinsic.append;
 /** @internal The promise a self-check is awaited through, built from the constructor captured at load.
  *  `Promise.resolve` builds from its RECEIVER, so reading the global binding at the call hands the
  *  construction to whatever that binding holds, and a constructor settling without awaiting its
@@ -224,7 +227,7 @@ function _sign(spec, key, opts) {
   function addAttr(attrType, valueTlv) {
     if (seenAttr[attrType]) throw _err("csr/bad-input", "duplicate " + (oid.name(attrType) || attrType) + " attribute");
     seenAttr[attrType] = true;
-    attrs.push(b.sequence([b.oid(attrType), b.set([valueTlv])]));
+    _push(attrs,b.sequence([b.oid(attrType), b.set([valueTlv])]));
   }
   if (spec.extensionRequest != null) addAttr(O("extensionRequest"), _buildRequestedExtensions(spec.extensionRequest, subjectSpki));
   if (spec.challengePassword != null) addAttr(O("challengePassword"), _challengePassword(spec.challengePassword));
@@ -259,7 +262,7 @@ function _sign(spec, key, opts) {
       if (!n.children[1].children || n.children[1].children.length === 0) throw _err("csr/bad-input", "pre-encoded attribute [" + i + "] value SET must contain at least one value (RFC 2986 SET SIZE(1..MAX))");
       if (seenAttr[at]) throw _err("csr/bad-input", "duplicate " + (oid.name(at) || at) + " attribute");
       seenAttr[at] = true;
-      attrs.push(b.raw(der));
+      _push(attrs,b.raw(der));
     });
   }
 

package/lib/ct.js

@@ -63,6 +63,8 @@ var _bufToString = intrinsic.bufToString;
 var _bufferCompare = intrinsic.compare;
 var _subarray = intrinsic.subarray;
 var _toLowerCase = intrinsic.toLowerCase;
+var _ctTrim = intrinsic.uncurry(String.prototype.trim);
+var _writeBigUInt64BE = intrinsic.uncurry(Buffer.prototype.writeBigUInt64BE);
 var _bufCopy = intrinsic.uncurry(Buffer.prototype.copy);
 var _writeU64BE = intrinsic.uncurry(Buffer.prototype.writeBigUInt64BE);
 var _searchSet = intrinsic.uncurry(URLSearchParams.prototype.set);
@@ -292,8 +294,11 @@ function parseSctList(extValue) {
     }
     sctCount.tick();
     var one = _parseSct(outer.subReader(sctLen, "ct/list-trailing-bytes"), sctLen);
-    if (one.unknown) { var u = { version: one.version, rawSct: one.rawSct }; unknownScts.push(u); all.push(u); }
-    else { scts.push(one); all.push(one); }
+    /** @internal The parsed timestamps are appended by defining their indexes: the lists a caller
+     *  reads its verdict from, and the `all` list a policy counts, are what a numeric setter on the
+     *  array prototype would otherwise take an entry out of. */
+    if (one.unknown) { var u = { version: one.version, rawSct: one.rawSct }; intrinsic.append(unknownScts, u); intrinsic.append(all, u); }
+    else { intrinsic.append(scts, one); intrinsic.append(all, one); }
   }
   return guard.verdict.of({ scts: scts, unknownScts: unknownScts, all: all });
 }
@@ -365,29 +370,36 @@ function reconstructSignedData(entry, sct) {
     throw new CtError("ct/bad-input", "reconstructSignedData expects a decoded v1 SCT from parseSctList().scts[]");
   }
   var tsVal = guard.range.uint64(sct.timestamp, _ctErr, "ct/bad-input", "sct.timestamp (RFC 6962 3.2)");
+  /** @internal EVERY component of this preimage is appended by defining its index, and the
+   *  concatenation is the captured one. These bytes are what a log's signature is verified over, so a
+   *  numeric setter inherited from the array prototype replacing any one of them, the version, the
+   *  signature type, the timestamp, the entry type, the certificate or the extensions, puts the
+   *  verification on bytes the log never signed. Converting only the timestamp left the rest open,
+   *  which is the whole class: the rule belongs to the function, not to the line it was found on. */
   var parts = [];
-  parts.push(_bufferFrom([sct.version & 0xff]));
-  parts.push(_bufferFrom([0]));
-  var ts = _bufferAlloc(8); ts.writeBigUInt64BE(tsVal); parts.push(ts);
-  parts.push(_bufferFrom([(entryType >> 8) & 0xff, entryType & 0xff]));
+  intrinsic.append(parts, _bufferFrom([sct.version & 0xff]));
+  intrinsic.append(parts, _bufferFrom([0]));
+  var ts = _bufferAlloc(8); _writeBigUInt64BE(ts, tsVal); intrinsic.append(parts, ts);
+  intrinsic.append(parts, _bufferFrom([(entryType >> 8) & 0xff, entryType & 0xff]));
   if (entryType === 0) {
     var cert = _toBuffer(entry.leafCert, "leafCert", undefined, undefined, 0xffffff, "ct/bad-tbs-length");
-    parts.push(_u24Bytes(cert.length)); parts.push(cert);
+    intrinsic.append(parts, _u24Bytes(cert.length)); intrinsic.append(parts, cert);
   } else {
     var ikh = _toBuffer(entry.issuerKeyHash, "issuerKeyHash");
     if (ikh.length !== 32) {
       throw new CtError("ct/bad-issuer-key-hash", "issuer_key_hash must be exactly 32 bytes (SHA-256 of the issuer SPKI), got " + ikh.length + " (RFC 6962 sec. 3.2)");
     }
     var tbs = _toBuffer(entry.tbsCertificate, "tbsCertificate", undefined, undefined, 0xffffff, "ct/bad-tbs-length");
-    parts.push(ikh);
-    parts.push(_u24Bytes(tbs.length)); parts.push(tbs);
+    intrinsic.append(parts, ikh);
+    intrinsic.append(parts, _u24Bytes(tbs.length)); intrinsic.append(parts, tbs);
   }
   var ext = _toBuffer(sct.extensions, "sct.extensions", undefined, undefined, 0xffff, "ct/bad-extensions");
   if (ext.length > 0xffff) {
     throw new CtError("ct/bad-extensions", "CtExtensions must be 0..65535 bytes, got " + ext.length + " (RFC 6962 3.2)");
   }
-  parts.push(_bufferFrom([(ext.length >> 8) & 0xff, ext.length & 0xff])); parts.push(ext);
-  return Buffer.concat(parts);
+  intrinsic.append(parts, _bufferFrom([(ext.length >> 8) & 0xff, ext.length & 0xff]));
+  intrinsic.append(parts, ext);
+  return intrinsic.bufferConcat(parts);
 }
 
 var CT_HASH = intrinsic.assign(intrinsic.create(null), { sha256: "SHA-256" });
@@ -583,7 +595,7 @@ function encodeSctList(scts) {
     var el = ew.build();
     total += el.length;
     if (total > 0xffff) throw new CtError("ct/too-large", "the SCT list body exceeds the 65535-byte maximum (RFC 6962 sec. 3.3)");
-    elements.push(el);
+    intrinsic.append(elements, el);
   }
   var lw = new TlsWriter();
   lw.vector(2, 1, 0xffff, Buffer.concat(elements, total), "ct/too-large");
@@ -802,7 +814,7 @@ function parseLogList(json, opts) {
           continue;
         }
         byLogId[rec.logIdHex] = rec;
-        logs.push(rec);
+        intrinsic.append(logs, rec);
       }
     }
   }
@@ -1091,13 +1103,13 @@ function x509CertEntry(cert, issuer) {
   for (var j = 0; j < extsSeq.children.length; j++) {
     var ext = extsSeq.children[j];
     if (ext.children[0] && intrinsic.bufferEquals(ext.children[0].bytes, sctOid)) { removed++; continue; }
-    intrinsic.push(kept, ext.bytes);
+    intrinsic.append(kept, ext.bytes);
   }
   if (removed === 0) throw _ctErr("ct/no-sct-extension", "the certificate carries no signedCertificateTimestampList extension (RFC 6962 sec. 3.2)");
   var tbsChildren = [];
   for (var k = 0; k < tbs.children.length; k++) {
-    if (k !== wrapIdx) { intrinsic.push(tbsChildren, tbs.children[k].bytes); continue; }
-    if (kept.length > 0) intrinsic.push(tbsChildren, asn1.build.explicit(3, asn1.build.sequence(kept)));
+    if (k !== wrapIdx) { intrinsic.append(tbsChildren, tbs.children[k].bytes); continue; }
+    if (kept.length > 0) intrinsic.append(tbsChildren, asn1.build.explicit(3, asn1.build.sequence(kept)));
   }
   var issuerKeyHash = nodeCrypto.createHash("sha256").update(issSpki).digest();
   return { entryType: 1, tbsCertificate: asn1.build.sequence(tbsChildren), issuerKeyHash: issuerKeyHash };
@@ -1230,7 +1242,15 @@ function _assertTransport(opts) {
     "(request) => Promise<{ status, headers, body }>");
 }
 
-function _fetchCtypeToken(headers) { return String((headers || {})["content-type"] || "").split(";")[0].trim().toLowerCase(); }
+/** @internal The media type is read through the captured operations, and on the delimiter CHARACTER
+ *  rather than through `split`, which hard rule 11 bans in lib/ because the separator's own
+ *  `Symbol.split` is part of that operation. The token decides which parser a log's response body is
+ *  handed to. */
+function _fetchCtypeToken(headers) {
+  var raw = intrinsic.String((headers || {})["content-type"] || "");
+  var parts = intrinsic.splitChar(raw, 59);
+  return _toLowerCase(_ctTrim(parts.length ? parts[0] : ""));
+}
 
 function _parseHttpsUrl(u, label) {
   var parsed;

package/lib/est.js

@@ -73,9 +73,15 @@ var crmfFmt = require("./schema-crmf");
 var frameworkError = require("./framework-error");
 var guard = require("./guard-all");
 var intrinsic = require("./guard-intrinsic");
+/** @internal The append every list here is built with: `push` stores at the index and a store
+ *  consults a setter inherited there, which takes the element being appended. */
+var _push = intrinsic.append;
 var _charCodeAt = intrinsic.uncurry(String.prototype.charCodeAt);
 var _strSlice = intrinsic.uncurry(String.prototype.slice);
 var _toLowerCase = intrinsic.uncurry(String.prototype.toLowerCase);
+var _estTrim = intrinsic.uncurry(String.prototype.trim);
+var _estCharAt = intrinsic.uncurry(String.prototype.charAt);
+var _estIndexOf = intrinsic.stringIndexOf;
 /** @internal Each verb gates its body on a resolved promise and returns its refusals as rejected ones,
  *  and both build from the RECEIVER, so reading the global binding at the call decides whether the body
  *  runs and whether a refusal stays a refusal. Taken at load. */
@@ -250,7 +256,7 @@ function _isMultipartMixedPrefix(ct) {
 }
 
 function _multipartBoundary(contentType) {
-  var ct = String(contentType || "");
+  var ct = _stringOf(contentType || "");
   if (!_isMultipartMixedPrefix(ct)) return null;
   var bp = _ctParam(ct, "boundary");
   if (bp.duplicated) {
@@ -356,12 +362,16 @@ function splitMultipartMixed(body, contentType) {
     var lines = _splitCrlf(_unfoldHeaders(rawHeaders));
     for (var li = 0; li < lines.length; li++) {
       var line = lines[li];
-      var col = line.indexOf(":");
-      if (col > 0) headers[line.slice(0, col).trim().toLowerCase()] = line.slice(col + 1).trim();
+      /** @internal A part's header name and value are cut, trimmed and folded through the captured
+       *  operations. One of those headers is the part's own content type, which selects the reader
+       *  its body goes to: measured, a part stating `application/pkcs8` was read as
+       *  `application/pkcs7-mime` with a `smime-type` of `certs-only`. */
+      var col = _estIndexOf(line, ":");
+      if (col > 0) headers[_toLowerCase(_estTrim(_strSlice(line, 0, col)))] = _estTrim(_strSlice(line, col + 1));
     }
     var partCt = headers["content-type"] || "";
     if (_ciStartsWith(partCt, "MULTIPART/")) throw E("est/bad-multipart", "a nested multipart part is not permitted");
-    parts.push({ headers: headers, contentType: partCt, body: partBody });
+    intrinsic.append(parts, { headers: headers, contentType: partCt, body: partBody });
   }
   return parts;
 }
@@ -416,7 +426,7 @@ function findIssuedCert(certs, target) {
 
 function _recipientKeyIds(recipientInfos, kind) {
   var ids = [];
-  function push(v) { if (Buffer.isBuffer(v)) ids.push(v); }
+  function push(v) { if (Buffer.isBuffer(v)) _push(ids,v); }
   (recipientInfos || []).forEach(function (r) {
     if (kind !== "symmetric") {
       if (r.rid) push(r.rid.subjectKeyIdentifier);
@@ -432,7 +442,7 @@ function _recipientKeyIds(recipientInfos, kind) {
 
 function _recipientIssuerSerials(recipientInfos) {
   var out = [];
-  function push(rid) { if (rid && rid.issuer && Buffer.isBuffer(rid.issuer.bytes) && rid.serialNumber != null) out.push({ issuer: rid.issuer.bytes, serialNumber: rid.serialNumber }); }
+  function push(rid) { if (rid && rid.issuer && Buffer.isBuffer(rid.issuer.bytes) && rid.serialNumber != null) _push(out,{ issuer: rid.issuer.bytes, serialNumber: rid.serialNumber }); }
   (recipientInfos || []).forEach(function (r) {
     push(r.rid);
     if (r.kemri) push(r.kemri.rid);
@@ -457,29 +467,37 @@ function _recipientMatches(recipientInfos, opts) {
   return false;
 }
 
+/** @internal The segments are collected through the captured append. Read off the prototype, a
+ *  replacement decides which segments a parameter is then looked for in, and one of those parameters
+ *  is the multipart boundary a response body is divided on: measured, a `boundary=wire` header
+ *  yielded `forged`. */
 function _splitContentTypeParams(s) {
   var segs = [], cur = "", inQuote = false;
   for (var i = 0; i < s.length; i++) {
-    var ch = s[i];
+    var ch = _estCharAt(s, i);
     if (ch === '"') { inQuote = !inQuote; cur += ch; }
-    else if (ch === ";" && !inQuote) { segs.push(cur); cur = ""; }
+    else if (ch === ";" && !inQuote) { intrinsic.append(segs, cur); cur = ""; }
     else cur += ch;
   }
-  segs.push(cur);
+  intrinsic.append(segs, cur);
   return segs;
 }
 
 function _ctParam(contentType, name) {
-  var segs = _splitContentTypeParams(String(contentType || ""));
+  var segs = _splitContentTypeParams(_stringOf(contentType || ""));
   var value = null, count = 0;
+  /** @internal Each parameter is read through the captured operations. The name decides which
+   *  parameter this is, and the value it returns is the one a caller acts on: for the RFC 7030
+   *  multipart boundary, it is where a response body is split. */
   for (var i = 1; i < segs.length; i++) {
-    var eq = segs[i].indexOf("=");
+    var seg = segs[i];
+    var eq = _estIndexOf(seg, "=");
     if (eq === -1) continue;
-    if (segs[i].slice(0, eq).trim().toLowerCase() !== name) continue;
+    if (_toLowerCase(_estTrim(_strSlice(seg, 0, eq))) !== name) continue;
     count++;
     if (count > 1) continue;
-    var val = segs[i].slice(eq + 1).trim();
-    if (val.length >= 2 && val.charAt(0) === '"' && val.charAt(val.length - 1) === '"') val = val.slice(1, -1);
+    var val = _estTrim(_strSlice(seg, eq + 1));
+    if (val.length >= 2 && _estCharAt(val, 0) === '"' && _estCharAt(val, val.length - 1) === '"') val = _strSlice(val, 1, -1);
     value = val;
   }
   return { value: value, duplicated: count > 1 };
@@ -501,12 +519,15 @@ function _mediaType(seg) {
   return _toLowerCase(_strSlice(seg, a, b));
 }
 
+/** @internal The media type and the S/MIME type are produced through the captured conversions. The
+ *  media type selects which reader a part's body goes to, and read through the live global `String`
+ *  a replacement chose it: measured, `text/plain` arrived as `application/pkcs8`. */
 function _partMediaType(contentType) {
-  var segs = _splitContentTypeParams(String(contentType || ""));
+  var segs = _splitContentTypeParams(_stringOf(contentType || ""));
   var st = _ctParam(contentType, "smime-type");
   return {
     media: _mediaType(segs[0]),
-    smimeType: st.value === null ? null : st.value.toLowerCase(),
+    smimeType: st.value === null ? null : _toLowerCase(st.value),
     ambiguous: st.duplicated,
   };
 }
@@ -740,7 +761,7 @@ function smimeCapabilitiesAttr(capabilities) {
   if (!Array.isArray(capabilities) || capabilities.length === 0) throw E("est/bad-input", "smimeCapabilitiesAttr requires a non-empty capability list");
   var caps = capabilities.map(function (c) {
     var seq = [asn1.build.oid(c.capabilityID)];
-    if (c.parameters !== undefined && c.parameters !== null) seq.push(Buffer.isBuffer(c.parameters) ? c.parameters : asn1.build.oid(c.parameters));
+    if (c.parameters !== undefined && c.parameters !== null) _push(seq,Buffer.isBuffer(c.parameters) ? c.parameters : asn1.build.oid(c.parameters));
     return asn1.build.sequence(seq);
   });
   return _attr(OID_SMIME_CAPABILITIES, [asn1.build.sequence(caps)]);
@@ -762,7 +783,7 @@ function buildEnrollAttributes(csrattrsParsed) {
       if (plan.keyType) throw E("est/ambiguous-key-type", "a non-template CsrAttrs response must carry exactly one key-type attribute (RFC 9908 sec. 3.2)");
       plan.keyType = { type: it.name, curve: it.curve || null, keySize: it.keySize || null, values: it.values || [] };
     }
-    else plan.unhandled.push({ kind: it.kind, oid: it.oid, name: it.name });
+    else _push(plan.unhandled,{ kind: it.kind, oid: it.oid, name: it.name });
   }
   return plan;
 }
@@ -1199,7 +1220,7 @@ function _correlateIssued(bag, wanted, arm) {
 function _allMatching(bag, key) {
   var rest = bag.slice(), out = [], hit;
   while ((hit = findIssuedCert(rest, key)) !== null) {
-    out.push(hit);
+    _push(out,hit);
     rest = rest.filter(function (c) { return c !== hit; });
   }
   return out;
@@ -1222,7 +1243,7 @@ function _requestedPublicKeys(der) {
     try {
       if (r.certificationRequestBytes) {
         var spki = csr.parse(r.certificationRequestBytes).subjectPublicKeyInfo;
-        if (spki && Buffer.isBuffer(spki.bytes)) out.push(spki.bytes);
+        if (spki && Buffer.isBuffer(spki.bytes)) _push(out,spki.bytes);
         if (out.length === before) _unreadableArm();
         return;
       }
@@ -1233,7 +1254,7 @@ function _requestedPublicKeys(der) {
         var pk = (tmpl && tmpl.publicKey) ||
           (msg0 && msg0.popo && msg0.popo.poposkInput && msg0.popo.poposkInput.publicKey);
         var pkBytes = Buffer.isBuffer(pk) ? pk : (pk && pk.bytes);
-        if (Buffer.isBuffer(pkBytes)) out.push(pkBytes);
+        if (Buffer.isBuffer(pkBytes)) _push(out,pkBytes);
         if (out.length === before) _unreadableArm();
       }
     } catch (e) {
@@ -1279,9 +1300,9 @@ function _requestBinding(der) {
   var body = cmcFmt.parse(der);
   var ids = [];
   var paths = [];
-  [body.requests, body.controls, body.cmsSequence, body.otherMsgs].forEach(function (list) {
+  intrinsic.forEach([body.requests, body.controls, body.cmsSequence, body.otherMsgs], function (list) {
     (list || []).forEach(function (el) {
-      if (el && el.bodyPartID != null) { ids.push(el.bodyPartID); paths.push([el.bodyPartID]); }
+      if (el && el.bodyPartID != null) { _push(ids,el.bodyPartID); _push(paths,[el.bodyPartID]); }
     });
   });
   _collectNestedPaths(body.cmsSequence, [], paths, 0);
@@ -1325,8 +1346,8 @@ function _collectNestedPaths(list, prefix, out, depth) {
     catch (_e) { /* allow:swallow-unverified the outer request must itself parse for this to run, which already rejects a malformed nested ContentInfo; a payload that survives that and still fails to read back lands on the same no-path refusal the non-pkiData route below takes, which the vectors drive */ return; }
     if (!inner || inner.kind !== "pkiData") return;
     var path = prefix.concat([el.bodyPartID]);
-    [inner.requests, inner.controls, inner.cmsSequence, inner.otherMsgs].forEach(function (l) {
-      (l || []).forEach(function (e2) { if (e2 && e2.bodyPartID != null) out.push(path.concat([e2.bodyPartID])); });
+    intrinsic.forEach([inner.requests, inner.controls, inner.cmsSequence, inner.otherMsgs], function (l) {
+      (l || []).forEach(function (e2) { if (e2 && e2.bodyPartID != null) _push(out,path.concat([e2.bodyPartID])); });
     });
     _collectNestedPaths(inner.cmsSequence, path, out, depth + 1);
   });
@@ -1405,7 +1426,7 @@ function _fullcmcResult(res, opts, wanted, sent) {
   }
   var smimeType = pt200.smimeType;
   if (smimeType === "certs-only") {
-    var unecho = ["transactionId", "senderNonce", "dataReturn"].filter(function (k) {
+    var unecho = intrinsic.selectList(["transactionId", "senderNonce", "dataReturn"], function (k) {
       return sent[k] != null;
     });
     if (unecho.length) {
@@ -1731,21 +1752,23 @@ function _assertConfidentialCipher(res) {
 
 function _ciHeaderList(headers, name) {
   headers = headers || {};
-  var lname = name.toLowerCase(), keys = guard.identifier.optionNames(headers), parts = [];
+  /** @internal The header NAME a value is selected under is folded through the captured conversion on
+   *  both sides of the comparison: the match decides which header this response is read from. */
+  var lname = _toLowerCase(name), keys = guard.identifier.optionNames(headers), parts = [];
   for (var i = 0; i < keys.length; i++) {
-    if (keys[i].toLowerCase() !== lname) continue;
+    if (_toLowerCase(keys[i]) !== lname) continue;
     var v = headers[keys[i]];
     if (v == null) continue;
-    parts.push(Array.isArray(v) ? v.join(", ") : String(v));
+    intrinsic.append(parts, intrinsic.isArray(v) ? intrinsic.join(v, ", ") : _stringOf(v));
   }
-  return parts.length ? parts.join(", ") : null;
+  return parts.length ? intrinsic.join(parts, ", ") : null;
 }
 
 function _ciHeader(headers, name) {
   headers = headers || {};
-  var lname = name.toLowerCase(), keys = guard.identifier.optionNames(headers), found = null, n = 0;
+  var lname = _toLowerCase(name), keys = guard.identifier.optionNames(headers), found = null, n = 0;
   for (var i = 0; i < keys.length; i++) {
-    if (keys[i].toLowerCase() !== lname) continue;
+    if (_toLowerCase(keys[i]) !== lname) continue;
     n += 1;
     if (n === 1) found = headers[keys[i]];
   }

package/lib/guard-bytes.js

@@ -446,7 +446,11 @@ function _deep(v, ErrorClass, code, label, cap, depth, collect, work) {
       var element;
       try { element = v[k]; }
       catch (e) { throw _raise(ErrorClass, code, label + ": reading element " + k + " threw", e); }
-      arr[k] = _deep(element, ErrorClass, code, label, cap, depth + 1, collect, work);
+      /** @internal The copy's slot is DEFINED, not stored at. The indices walked here are the ones
+       *  the source holds of its own, so they can skip: a store at an index this copy has no own
+       *  property at walks the prototype chain for a setter, which would take the copied element at
+       *  the toolkit's own door for caller byte structures. */
+      _defineProperty(arr, k, { value: _deep(element, ErrorClass, code, label, cap, depth + 1, collect, work), writable: true, enumerable: true, configurable: true });
     });
     arr.length = vCount;
     _copyNamed(v, arr, ErrorClass, code, label, cap, depth, collect, work);

package/lib/guard-der.js

@@ -9,6 +9,7 @@ var _sizeOf = require("./guard-intrinsic").sizeOf;
 var _create = require("./guard-intrinsic").create;
 var _isBuffer = require("./guard-intrinsic").isBuffer;
 var _isArray = require("./guard-intrinsic").isArray;
+var _append = require("./guard-intrinsic").append;
 
 var asn1 = null;
 function _asn1() { if (asn1 === null) asn1 = require("./asn1-der"); return asn1; }
@@ -117,7 +118,11 @@ function _element(node, E, code, label) {
       throw E(code, label + " of universal constructed type " + tag + " has no strict DER structure validator here");
     }
     var n = kids.length, members = [];
-    for (var i = 0; i < n; i++) members[i] = _element(kids[i], E, code, label);
+    /** @internal Appended by defining the index. A store at an index the list has no own property at
+     *  consults a setter inherited from the array prototype, and the SET ordering below is checked
+     *  over this list, so a member read back through such a hole is one the canonical-order check
+     *  never saw. */
+    for (var i = 0; i < n; i++) _append(members, _element(kids[i], E, code, label));
     if (cls === "universal" && tag === C.SET && !setOrderOk(members)) {
       throw E(code, label + " has a SET whose members are in no canonical DER order (X.690 sec. 11.6 / X.680 sec. 8.6)");
     }

package/lib/guard-identifier.js

@@ -257,7 +257,7 @@ var _CONCRETE_TYPED_MEMBERS = ["BYTES_PER_ELEMENT"];
 var _BUFFER_PROTO_MEMBERS = ["parent", "offset"];
 
 var _ARRAY_MEMBERS = _ARRAY_PROTO_MEMBERS;
-var _REGEXP_MEMBERS = ["lastIndex"].concat(_REGEXP_PROTO_MEMBERS);
+var _REGEXP_MEMBERS = intrinsic.concatList(["lastIndex"], _REGEXP_PROTO_MEMBERS);
 var _VIEW_MEMBERS = _TYPED_PROTO_MEMBERS.concat(_CONCRETE_TYPED_MEMBERS);
 var _BUFFER_KIND_MEMBERS = _VIEW_MEMBERS.concat(_BUFFER_PROTO_MEMBERS);
 var _DATAVIEW_MEMBERS = _DATAVIEW_PROTO_MEMBERS;

package/lib/guard-intrinsic.js

@@ -528,14 +528,24 @@ var _arrSort = uncurry(Array.prototype.sort);
 var _arrConcat = uncurry(Array.prototype.concat);
 var _arrSlice = uncurry(Array.prototype.slice);
 var _arrJoin = uncurry(Array.prototype.join);
-var _arrPush = uncurry(Array.prototype.push);
+/** @internal `push` is NOT captured and NOT offered. Capturing it closes who `push` is, not what
+ *  `push` DOES: it STORES at the index, and a store walks the prototype chain for a setter, so an
+ *  accessor installed at an array index receives each element as it is appended and can define
+ *  something else in its place. Measured through `pki.asn1.read.oid`: the content octets of `1.2.3`
+ *  rendered `0.1.3` through a captured push. `append` below defines the index on the array itself,
+ *  and `concatList` / `copyList` / `selectList` / `mapList` build their results the same way. With
+ *  nothing to reach for, no module in lib/ can take the storing form. */
 /** @internal The mutators. A list is what a rule is enforced over, so an operation that drops or moves
  *  an element decides whether the rule reaches it: a replaced `pop` that popped twice took a signed
  *  note's last signature line away with the empty tail element, and the forged signature on that line
  *  was never checked. */
+/** @internal `unshift` is absent for the reason `push` is: it GROWS the list, so it stores at an
+ *  index the array has no own property at, and a store walks the prototype chain for a setter. The
+ *  mutators kept below move or drop elements that already have own slots, which reaches no accessor
+ *  on a list this toolkit built by defining. A module prepending to a list counts its elements and
+ *  appends them in order instead; `encodeLength` and `intToDer` in lib/asn1-der.js are the pattern. */
 var _arrPop = uncurry(Array.prototype.pop);
 var _arrShift = uncurry(Array.prototype.shift);
-var _arrUnshift = uncurry(Array.prototype.unshift);
 var _arrSplice = uncurry(Array.prototype.splice);
 var _arrReverse = uncurry(Array.prototype.reverse);
 
@@ -706,10 +716,8 @@ module.exports = Object.freeze({
   min: _mathMin,
   max: _mathMax,
   parseInt: _parseInt,
-  push: _arrPush,
   pop: _arrPop,
   shift: _arrShift,
-  unshift: _arrUnshift,
   splice: _arrSplice,
   reverse: _arrReverse,
   toUpperCase: _strToUpperCase,