@blamejs/pki 0.8.59 → 0.8.60

package/lib/est.js

@@ -73,6 +73,9 @@ 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);
@@ -423,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);
@@ -439,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);
@@ -758,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)]);
@@ -780,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;
 }
@@ -1217,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;
@@ -1240,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;
       }
@@ -1251,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) {
@@ -1299,7 +1302,7 @@ function _requestBinding(der) {
   var paths = [];
   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);
@@ -1344,7 +1347,7 @@ function _collectNestedPaths(list, prefix, out, depth) {
     if (!inner || inner.kind !== "pkiData") return;
     var path = prefix.concat([el.bodyPartID]);
     intrinsic.forEach([inner.requests, inner.controls, inner.cmsSequence, inner.otherMsgs], function (l) {
-      (l || []).forEach(function (e2) { if (e2 && e2.bodyPartID != null) out.push(path.concat([e2.bodyPartID])); });
+      (l || []).forEach(function (e2) { if (e2 && e2.bodyPartID != null) _push(out,path.concat([e2.bodyPartID])); });
     });
     _collectNestedPaths(inner.cmsSequence, path, out, depth + 1);
   });

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-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,

package/lib/guard-list.js

@@ -8,6 +8,7 @@ var _defineProperty = require("./guard-intrinsic").defineProperty;
 var _isArray = require("./guard-intrinsic").isArray;
 var _arrSort = require("./guard-intrinsic").sort;
 var _isSafeInteger = require("./guard-intrinsic").isSafeInteger;
+var _hasOwn = require("./guard-intrinsic").hasOwn;
 
 var MAX_ARRAY_LENGTH = 4294967295;
 
@@ -76,6 +77,67 @@ function allMatch(list, predicate) {
   return true;
 }
 
+/** @internal The first element a predicate selects, or null. Written as `list.filter(p)[0]`, the
+ * selection is a fresh array that is empty when nothing matched, and reading index 0 of an empty
+ * array answers from the array prototype: an accessor there becomes the selected element in a
+ * selection that selected nothing, which reads at every call site as "found one". `filter` also
+ * builds its result through the receiver's `Symbol.species`, so the array indexed is not necessarily
+ * one this toolkit made. This walks the own indexes and returns null when nothing matched, so a
+ * caller's `if (!found)` test answers for the list rather than for the prototype.
+ *
+ * @enforced-by behavioral -- `filter(...)[0]` has no rename-proof shape of its own beyond the method
+ * name, which the captured-operation budget already counts; the RED vectors are the empty-selection
+ * ones each consumer carries (a signedAttrs with no message-digest attribute, a certificate with no
+ * subject key identifier).
+ */
+function firstMatch(list, predicate) {
+  if (!list) return null;
+  for (var i = 0, n = _count(list, "firstMatch"); i < n; i++) {
+    if (!_hasOwn(list, i)) continue;
+    /** @internal One read of the element, tested and returned. Read again after the predicate, an
+     * own accessor at the index answers the test with one value and the caller with another, and a
+     * getter that deletes its own slot leaves the second read falling through to the prototype. */
+    var element = list[i];
+    if (predicate(element, i)) return element;
+  }
+  return null;
+}
+
+/** @internal Remove the element at `index`, shifting the ones after it down by defining each slot
+ * and then truncating through the array's own `length`. `splice` is the ordinary way to write this
+ * and it is not usable here: it returns the removed elements, so it builds that result through
+ * `ArraySpeciesCreate`, which reads the receiver's `constructor` and then its `Symbol.species`. A
+ * getter installed on `Array.prototype.constructor` receives the real array as its `this`, which
+ * hands caller code a reference to the list being edited and to every record in it, in the middle of
+ * the edit. Nothing is returned here, so nothing is constructed.
+ *
+ * @enforced-by behavioral -- `splice(i, 1)` has no rename-proof shape beyond the method name, which
+ * the captured-operation budget counts; the RED vector is the policy-node removal driven with a
+ * `constructor` getter installed.
+ */
+function removeAt(list, index) {
+  if (!_isArray(list)) throw new TypeError("guard.list.removeAt: the receiver must be an array");
+  var n = _count(list, "removeAt");
+  if (!_isSafeInteger(index) || index < 0 || index >= n) {
+    throw new RangeError("guard.list.removeAt: the index must be a position the array holds");
+  }
+  /** @internal A hole stays a hole, and is never read through. `splice` leaves an absent element
+   * absent, so a shift that defined every slot would turn one into an own `undefined`; and reading
+   * `list[i + 1]` at a hole answers from the prototype, which is the value this family exists to
+   * keep out. Each source slot is tested for own-ness once and read once. */
+  for (var i = index; i < n - 1; i++) {
+    if (_hasOwn(list, i + 1)) {
+      _defineProperty(list, i, { value: list[i + 1], writable: true, enumerable: true, configurable: true });
+    } else if (_hasOwn(list, i)) {
+      delete list[i];
+    }
+  }
+  /** @internal `length` is an array's own writable property, so assigning it consults no prototype
+   * and the assignment deletes the tail slot the shift left behind. */
+  list.length = n - 1;
+  return list;
+}
+
 // @enforced-by caller-array-copied-live
 function snapshot(list) {
   if (!_isArray(list)) throw new TypeError("guard.list.snapshot: the receiver must be an array");
@@ -132,6 +194,8 @@ module.exports = _freeze({
   containsAll: containsAll,
   anyMatches: anyMatches,
   allMatch: allMatch,
+  firstMatch: firstMatch,
+  removeAt: removeAt,
   snapshot: snapshot,
   copyMap: copyMap,
 });

package/lib/guard-name.js

@@ -177,7 +177,7 @@ function _reduceDpn(d, E, code, label) {
   for (var i = 0; i < len; i++) {
     var n = ownValue(names, i);
     if (!_isBuffer(n)) throw refuse("every fullName GeneralName must be its encoded bytes");
-    taken[i] = n;
+    _append(taken, n);
   }
   return { kind: kind, names: taken };
 }

package/lib/hpke.js

@@ -47,7 +47,10 @@ var oid = require("./oid");
 var _hasOwn = intrinsic.hasOwn;
 var _isBuffer = intrinsic.isBuffer, _bufferFrom = intrinsic.bufferFrom, _bufferAlloc = intrinsic.bufferAlloc;
 var _bufferConcat = intrinsic.bufferConcat, _bufferEquals = intrinsic.bufferEquals, _compare = intrinsic.compare;
-var _push = intrinsic.push;
+/** @internal `append`, not a captured `push`: a store at an index walks the prototype chain for a
+ *  setter, so an accessor there takes the element being appended. The lists here become the byte
+ *  strings a KEM's key schedule is computed over. `append` defines the index. */
+var _push = intrinsic.append;
 var _subarray = intrinsic.subarray;
 
 var HpkeError = frameworkError.HpkeError;
@@ -76,7 +79,10 @@ function _pushPrefixed(parts, b, what) {
     throw _err("hpke/input-length", what + " is " + b.length + " bytes; a single-stage KDF accepts at " +
       "most " + MAX_PREFIXED + " (draft-ietf-hpke-hpke-05 sec. 7.2.1)");
   }
-  _push(parts, i2osp(b.length, 2), b);
+  /** @internal Two appends, because `append` takes one value where `push` took many: the length
+   *  prefix and the value it measures are both part of the byte string a KDF reads. */
+  _push(parts, i2osp(b.length, 2));
+  _push(parts, b);
   return parts;
 }
 /** @internal Through the capture, which is the whole point of this helper existing: every
@@ -346,7 +352,8 @@ function _derive(xof, input, outLen) {
 function _labeledDerive(xof, suiteId, ikm, label, context, outLen) {
   var lab = _bufferFrom(label, "latin1");
   var parts = _pushPrefixed([ikm, HPKE_V1, suiteId], lab, "a derive label");
-  _push(parts, i2osp(outLen, 2), context);
+  _push(parts, i2osp(outLen, 2));
+  _push(parts, context);
   var labeledIkm = concat(parts);
   try { return _derive(xof, labeledIkm, outLen); }
   finally { guard.secret.zeroize(labeledIkm, HpkeError, "hpke/bad-input", "the labeled derive input"); }

package/lib/http-transport.js

@@ -128,7 +128,10 @@ var _toLowerCase = intrinsic.toLowerCase;
 var _fromCharCode = intrinsic.fromCharCode;
 var _isArray = intrinsic.isArray;
 var _arrIndexOf = intrinsic.indexOf;
-var _arrPush = intrinsic.push;
+/** @internal `append`, not a captured `push`: a store at an index walks the prototype chain for a
+ *  setter, so an accessor there takes the element being appended, and this list is the peer chain a
+ *  caller reads. `append` defines the index. */
+var _arrPush = intrinsic.append;
 var _arrForEach = intrinsic.forEach;
 var _isBuffer = intrinsic.isBuffer;
 var _bufferFrom = intrinsic.bufferFrom;
@@ -348,7 +351,10 @@ function _makeGuardedLookup(lookupFn) {
           var entry = address[i];
           var one = { address: entry && entry.address, family: entry && entry.family };
           if (_isBlockedIp(one.address)) return callback(_blockedAddrErr(hostname, one.address));
-          checked[i] = one;
+          /** @internal Appended by defining the index. Stored at, the store walks the prototype chain
+           *  for a setter, so an accessor there took the checked entry and node read the address it
+           *  connects to back from the getter instead: an address this check never saw. */
+          _arrPush(checked, one);
         }
         return callback(null, checked);
       }
@@ -448,7 +454,10 @@ function snapshotProxy(p) {
       var a = p.tls.anchors;
       if (_copyableArray(a)) {
         var copied = [];
-        for (var i = 0; i < a.length; i++) copied[i] = _copyAnchor(a[i]);
+        /** @internal Appended by defining the index, for the reason the address list above is: these
+         *  are the trust anchors the handshake runs under, and a store consults a setter inherited at
+         *  the index. */
+        for (var i = 0; i < a.length; i++) _arrPush(copied, _copyAnchor(a[i]));
         out.tls.anchors = copied;
       } else if (typeof a === "string") out.tls.anchors = a;
       else if (a !== null && typeof a === "object" && !nodeUtil.types.isProxy(a) && _isBuffer(a)) out.tls.anchors = _bufferFrom(a);

package/lib/inspect.js

@@ -1158,7 +1158,11 @@ function _joinAnd(list) {
  *  door can validate to arbitrary depth, so a report must not fault on any shape it is handed. */
 function _list(v) { return Array.isArray(v) ? v : []; }
 /** @internal The same for a member a loop body dereferences. */
-function _obj(v) { return (v !== null && typeof v === "object") ? v : {}; }
+/** @internal The stand-in for a value that is not a record has NO PROTOTYPE. Written as `{}`, it
+ *  inherits `Object.prototype`, so a field read off it answers with whatever a name planted there
+ *  holds and a report prints a value its subject does not carry. */
+var _EMPTY_RECORD = Object.create(null);
+function _obj(v) { return (v !== null && typeof v === "object") ? v : _EMPTY_RECORD; }
 
 /** @internal A serial reads the same wherever a report carries one, through the certificate report's own
  *  presentation: small values as decimal with the hex beside them, long ones as wrapped colon-hex. Printed
@@ -1327,7 +1331,11 @@ function _someSignerUnmatched(signed) {
 }
 function _certMatchesSid(cert, sid) {
   if (Buffer.isBuffer(sid.subjectKeyIdentifier)) {
-    var ski = _list(cert.extensions).filter(function (e) { return _obj(e).oid === OID_SUBJECT_KEY_ID; })[0];
+    /** @internal The selection returns the first matching row or null. `filter(...)[0]` indexes a
+     *  result that is EMPTY when the certificate carries no key identifier, and index 0 of an empty
+     *  array answers from the array prototype, which would report a signer match for a certificate
+     *  that carries nothing to match on. */
+    var ski = guard.list.firstMatch(_list(cert.extensions), function (e) { return _obj(e).oid === OID_SUBJECT_KEY_ID; });
     if (!ski) return false;
     // allow:swallow-unverified drop-silent display fallback: an unreadable key id matches nothing
     try { return asn1.read.octetString(asn1.decode(_obj(ski).value)).equals(sid.subjectKeyIdentifier); }

package/lib/jose.js

@@ -54,7 +54,9 @@ var _isBuffer = intrinsic.isBuffer;
 var _bufferFrom = intrinsic.bufferFrom;
 var _stringify = intrinsic.stringify;
 var _ObjectProto = intrinsic.ObjectProto;
-var _push = intrinsic.uncurry(Array.prototype.push);
+/** @internal `append`, not a captured `push`: a store at an index walks the prototype chain for a
+ *  setter, so an accessor there takes the element being appended. `append` defines it. */
+var _push = intrinsic.append;
 var _join = intrinsic.join;
 var _map = intrinsic.map;
 var _bufToString = intrinsic.uncurry(Buffer.prototype.toString);