@blamejs/pki 0.5.23 → 0.5.25

package/lib/guard-list.js

@@ -28,6 +28,8 @@
 // over `===` has nothing to replace, so it holds whatever the prototype says, in a module that has
 // been swept and in one that has not.
 
+var _freeze = require("./guard-intrinsic").freeze;
+
 // contains(list, value) -> boolean. Strict-equality membership, the `indexOf(v) !== -1` rule.
 // A null / undefined list is honestly empty, never a throw: these run on verdict paths.
 // @enforced-by behavioral -- `.indexOf(x) !== -1` has no rename-proof form that separates a
@@ -77,9 +79,11 @@ function allMatch(list, predicate) {
   return true;
 }
 
-module.exports = {
+// Frozen for the reason the family header gives: a boundary reads its guard off this object at the
+// call, so a writable export would let a caller replace the check rather than pass it.
+module.exports = _freeze({
   contains: contains,
   containsAll: containsAll,
   anyMatches: anyMatches,
   allMatch: allMatch,
-};
+});

package/lib/guard-name.js

@@ -273,7 +273,7 @@ function emailEqual(a, b) {
   var aHost = _strSlice(a, ai + 1), bHost = _strSlice(b, bi + 1);
   if (!_asciiHost(aHost) || !_asciiHost(bHost)) return "not-comparable";
   if (aLocal !== bLocal) return "no-match";
-  return _lowerAscii(aHost) === _lowerAscii(bHost) ? "match" : "no-match";
+  return lowerAscii(aHost) === lowerAscii(bHost) ? "match" : "no-match";
 }
 
 // A host-part this comparison can decide: ASCII, and carrying no A-label. Anything else
@@ -292,11 +292,18 @@ function _asciiHost(h) {
   return true;
 }
 
+// lowerAscii(s) -> string
 // ASCII-only lowercase. String.toLowerCase() is Unicode-aware and would fold characters
-// outside ASCII (the Kelvin sign lowercases to "k"), which is precisely the mapping the
-// host-part rule does not authorize; _asciiHost has already excluded those inputs, so this
-// stays a plain A-Z shift rather than inheriting a locale-sensitive transform.
-function _lowerAscii(s) {
+// outside ASCII (the Kelvin sign lowercases to "k"), which is precisely the mapping a
+// name comparison does not authorize: a name folded that way is one the certificate or
+// message does not carry, and comparing it equal to a name that was asked for is the
+// defect. Every case-insensitive name comparison in the toolkit -- a host part, a CMP
+// domain, an ACME identifier set -- folds through this one definition, so none of them can
+// disagree about which characters case-fold.
+//
+// @enforced-by guard-shape-reinlined
+// @guard-shape 0x41\s*&&\s*[A-Za-z_$][\w$]*\s*<=\s*0x5[aA]\s*\)\s*\?[^:]*\+\s*(?:32|0x20)\s*\)
+function lowerAscii(s) {
   var out = "";
   for (var i = 0; i < s.length; i++) {
     var c = _charCodeAt(s, i);
@@ -305,8 +312,11 @@ function _lowerAscii(s) {
   return out;
 }
 
-module.exports = {
+// Frozen for the reason the family header gives: a boundary reads its guard off this object at the
+// call, so a writable export would let a caller replace the check rather than pass it.
+module.exports = intrinsic.freeze({
   assertNoControlBytes: assertNoControlBytes, assertPrintableIa5: assertPrintableIa5,
   dnEqual: dnEqual, rdnEqual: rdnEqual, emailEqual: emailEqual,
   escapeControlBytes: escapeControlBytes, escapeDnValue: escapeDnValue,
-};
+  lowerAscii: lowerAscii,
+});

package/lib/guard-parsed.js

@@ -44,6 +44,7 @@ var time = require("./guard-time");
 // one answering `false` makes each of those checks reject a well-formed parsed structure -- the
 // fail-closed direction, and still a caller deciding what this guard recognizes.
 var _isArray = require("./guard-intrinsic").isArray;
+var _freezeExports = require("./guard-intrinsic").freeze;
 // The copy that becomes the recorded provenance bytes. A replacement returning a buffer over the
 // caller's own memory would let those bytes change after they were recorded, which is the one
 // thing provenance exists to prevent.
@@ -598,10 +599,12 @@ function acceptDerived(input, kind, parse, E, code, label) {
     ".parse result: " + _WHY[kind]);
 }
 
-module.exports = {
+// Frozen for the reason the family header gives: a boundary reads its guard off this object at the
+// call, so a writable export would let a caller replace the check rather than pass it.
+module.exports = _freezeExports({
   accept: accept, acceptDerived: acceptDerived,
   fromTrustedSource: fromTrustedSource, recordingParser: recordingParser,
   recordingWalker: recordingWalker,
   isCert: certShape, isCrl: crlShape, isRecorded: isRecorded,
   isRecordedAsProduced: isRecordedAsProduced,
-};
+});

package/lib/guard-range.js

@@ -25,6 +25,7 @@
 // Number at all, so one answering true for an unsafe magnitude reopens the precision loss this
 // guard exists to prevent. See guard-intrinsic for the whole captured set.
 var _isSafeInteger = require("./guard-intrinsic").isSafeInteger;
+var _freeze = require("./guard-intrinsic").freeze;
 // The narrow itself. This module exists to turn a bounded BigInt into a Number without losing the
 // bound, and `Number` is a writable property of globalThis, so a replacement returns whatever it
 // likes from a value this function has just certified as in range.
@@ -131,7 +132,9 @@ function authoredInteger(value, E, code, label) {
   throw E(code, label + " must be an integer (a safe-integer number, or a bigint for a large value)");
 }
 
-module.exports = {
+// Frozen for the reason the family header gives: a boundary reads its guard off this object at the
+// call, so a writable export would let a caller replace the check rather than pass it.
+module.exports = _freeze({
   int: int, uint31: uint31, positiveInt31: positiveInt31, uint64: uint64,
   authoredInteger: authoredInteger,
-};
+});

package/lib/guard-secret.js

@@ -138,4 +138,6 @@ function cipherFinish(transform, input, ErrorClass, code, label) {
   }
 }
 
-module.exports = { zeroize: zeroize, zeroizeAll: zeroizeAll, cipherFinish: cipherFinish };
+// Frozen for the reason the family header gives: a boundary reads its guard off this object at the
+// call, so a writable export would let a caller replace the check rather than pass it.
+module.exports = intrinsic.freeze({ zeroize: zeroize, zeroizeAll: zeroizeAll, cipherFinish: cipherFinish });

package/lib/guard-text.js

@@ -99,4 +99,6 @@ function decode(input, maxBytes, ErrorClass, spec) {
   throw new ErrorClass(spec.badInput, spec.label + " expects a string or Buffer");
 }
 
-module.exports = { decode: decode };
+// Frozen for the reason the family header gives: a boundary reads its guard off this object at the
+// call, so a writable export would let a caller replace the check rather than pass it.
+module.exports = intrinsic.freeze({ decode: decode });

package/lib/guard-time.js

@@ -32,6 +32,7 @@
 // the global `isNaN` is writable, and one returning false makes an invalid Date pass the check
 // below, which is the fail-open direction.
 var util = { types: require("./guard-intrinsic").types };
+var _freeze = require("./guard-intrinsic").freeze;
 var _isNaN = Number.isNaN;
 
 // assertValid(value, E, code, label) -> the same Date, once proven valid.
@@ -130,9 +131,11 @@ function isDate(value) {
   return util.types.isDate(value);
 }
 
-module.exports = {
+// Frozen for the reason the family header gives: a boundary reads its guard off this object at the
+// call, so a writable export would let a caller replace the check rather than pass it.
+module.exports = _freeze({
   assertValid: assertValid,
   instantOf: instantOf,
   isDate: isDate,
   within: within,
-};
+});

package/lib/pki-build.js

@@ -18,9 +18,16 @@ var intrinsic = require("./guard-intrinsic");
 // Each of these doors refuses a caller argument that is not a list. Read live, a replacement
 // answering true lets a non-list through the check written to stop it.
 var _isArray = intrinsic.isArray;
+// Taken at load for the reason every capture here is: the question "do these two encodings name the
+// same key" decides whether a proof of possession is accepted, and a caller who replaces the copy or
+// the comparison afterwards decides it instead.
+var _bufferFrom = intrinsic.bufferFrom;
+var _bufferEquals = intrinsic.bufferEquals;
 var oid = require("./oid");
 var ipUtils = require("./ip-utils");
 var nodeCrypto = require("crypto");
+// The key-material comparison, taken at load like every other operation a decision here rests on.
+var _keyEquals = intrinsic.uncurry(nodeCrypto.KeyObject.prototype.equals);
 
 var b = asn1.build;
 
@@ -402,6 +409,27 @@ function makeBuilder(ctx) {
     if (!ok) throw E("bad-input", "the signing key does not correspond to the public key -- the signature would not verify");
   }
 
+  // Do two SubjectPublicKeyInfo encodings name the same key? Bytes first, because that is the answer
+  // almost always and it costs nothing. When they differ the question is still open, since one key has
+  // more than one legal SPKI: an EC point may be carried compressed or uncompressed, so a P-256 key
+  // written the compressed way is byte-unequal to the same key written the other. Comparing the DER
+  // alone would refuse a proof of possession over a key the requester genuinely holds, while the
+  // sibling arms of the same verb accept that template. The fallback asks the key layer, which
+  // compares key material and still answers false for a different key, a different curve, or a
+  // different algorithm. A key neither side can import is equal to nothing, so the refusal stands.
+  function samePublicKey(spkiA, spkiB) {
+    var a = _bufferFrom(spkiA), bb = _bufferFrom(spkiB);
+    if (_bufferEquals(a, bb)) return true;
+    var ka, kb;
+    // allow:swallow-unverified an SPKI the key layer cannot import matches nothing, which is the
+    // refusal the caller wants; the caller raises its own typed error on the false.
+    try {
+      ka = nodeCrypto.createPublicKey({ key: a, format: "der", type: "spki" });
+      kb = nodeCrypto.createPublicKey({ key: bb, format: "der", type: "spki" });
+    } catch (_e) { return false; }
+    return _keyEquals(ka, kb) === true;
+  }
+
   return {
     E: E, code: code, KU_BIT: KU_BIT,
     encodeName: encodeName, isEmptyName: isEmptyName, encodeGeneralName: encodeGeneralName,
@@ -413,6 +441,7 @@ function makeBuilder(ctx) {
     spkiKeyId: spkiKeyId, skiKeyId: skiKeyId,
     reqDer: reqDer, assertValidSpki: assertValidSpki, assertValidExtension: assertValidExtension,
     certLikeFromSpki: certLikeFromSpki, assertSignatureVerifies: assertSignatureVerifies,
+    samePublicKey: samePublicKey,
   };
 }