@blamejs/pki 0.5.22 → 0.5.24

package/lib/attrcert-sign.js

@@ -33,6 +33,11 @@ var attrcert = require("./schema-attrcert");
 var x509 = require("./schema-x509");
 var signScheme = require("./sign-scheme");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Membership is asked through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and either answering true admits a name the table
+// never carried -- here, an unrecognized critical extension counted as one this profile supports.
+var _hasOwn = intrinsic.hasOwn;
 var pkix = require("./schema-pkix");
 var schema = require("./schema-engine");
 require("./path-validate");   // side-effect: path-validate injects its signature engine into attrcert-verify at load
@@ -373,10 +378,10 @@ function _buildAttributes(attrSpec) {
 // carrying, so BOTH extension forms meet it -- the object form and the pre-encoded array form, which
 // is the one that can name a pointer at all. `seen` is the OID-keyed set each branch already builds.
 function _assertRevocationSchemesExclusive(seen) {
-  if (!Object.prototype.hasOwnProperty.call(seen, O("noRevAvail"))) return;
+  if (!_hasOwn(seen, O("noRevAvail"))) return;
   var names = Object.keys(REVOCATION_POINTERS);
   for (var i = 0; i < names.length; i++) {
-    if (Object.prototype.hasOwnProperty.call(seen, names[i])) {
+    if (_hasOwn(seen, names[i])) {
       throw _err("attrcert/bad-input", "an attribute certificate must not carry both noRevAvail and a " +
         REVOCATION_POINTERS[names[i]] + " revocation pointer (RFC 5755 sec. 6)");
     }
@@ -762,7 +767,7 @@ function _unsupportedCritical(ac) {
     if (e.critical !== true) continue;
     // Own-property membership, so an extension OID that happens to name something on Object.prototype
     // cannot read as supported.
-    if (!Object.prototype.hasOwnProperty.call(SUPPORTED_CRITICAL, e.oid)) return e.oid;
+    if (!_hasOwn(SUPPORTED_CRITICAL, e.oid)) return e.oid;
     // A supported OID whose value this build could not interpret is still unusable.
     if (e.decoded === null || e.decoded === undefined || e.decoded.opaque === true) return e.oid;
   }
@@ -887,7 +892,7 @@ function _fixVerifyOptions(opts) {
   var revocationStatus = null;
   if (o.revocationStatus !== undefined) {
     if (typeof o.revocationStatus !== "string" ||
-      !Object.prototype.hasOwnProperty.call(REVOCATION_STATUS, o.revocationStatus)) {
+      !_hasOwn(REVOCATION_STATUS, o.revocationStatus)) {
       throw _err("attrcert/bad-input", 'pki.attrcert.verify opts.revocationStatus must be "notRevoked" or "revoked"');
     }
     revocationStatus = o.revocationStatus;
@@ -916,7 +921,7 @@ function _revocationScheme(ac) {
     var e = ac.extensions[i];
     if (e.name === "noRevAvail") out.noRevAvail = true;
     var p = REVOCATION_POINTERS[e.oid];
-    if (p !== undefined && Object.prototype.hasOwnProperty.call(REVOCATION_POINTERS, e.oid)) out.pointer = p;
+    if (p !== undefined && _hasOwn(REVOCATION_POINTERS, e.oid)) out.pointer = p;
   }
   return out;
 }

package/lib/cmc-build.js

@@ -33,6 +33,10 @@ var cmcFmt = require("./schema-cmc");  // to read the assembled message back bef
 var oid = require("./oid");
 var cmsSign = require("./cms-sign");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which controls a request carries.
+var _hasOwn = intrinsic.hasOwn;
 var frameworkError = require("./framework-error");
 
 var CmcError = frameworkError.CmcError;
@@ -710,7 +714,7 @@ function _copySigners(signer, owned) {
     if (!s || typeof s !== "object") return s;
     var out = {}, k;
     for (k in s) {
-      if (!Object.prototype.hasOwnProperty.call(s, k)) continue;
+      if (!_hasOwn(s, k)) continue;
       out[k] = copyValue(s[k], k === "key");
     }
     return out;
@@ -725,7 +729,7 @@ function _copySigners(signer, owned) {
     if (!v || typeof v !== "object" || typeof v.type === "string") return v;   // CryptoKey / scalar
     var c = {}, ck;
     for (ck in v) {
-      if (!Object.prototype.hasOwnProperty.call(v, ck)) continue;
+      if (!_hasOwn(v, ck)) continue;
       var cv = v[ck];
       c[ck] = (Buffer.isBuffer(cv) || cv instanceof Uint8Array) ? _own(Buffer.from(cv), isSecret) : cv;
     }

package/lib/cmc-verify.js

@@ -25,6 +25,10 @@ var cmc = require("./schema-cmc");
 var cmsVerify = require("./cms-verify");   // PD14: the carrier's signature MUST be verified
 var cmsDecrypt = require("./cms-decrypt"); // ... and an AuthenticatedData carrier by its MAC
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which controls a response carries.
+var _hasOwn = intrinsic.hasOwn;
 var frameworkError = require("./framework-error");
 
 var CmcError = frameworkError.CmcError;
@@ -428,7 +432,7 @@ function _copyAnyBytes(v) {
 
 function _snapshotSent(sent) {
   var out = {}, k;
-  for (k in sent) { if (Object.prototype.hasOwnProperty.call(sent, k)) out[k] = sent[k]; }
+  for (k in sent) { if (_hasOwn(sent, k)) out[k] = sent[k]; }
   // Normalized through the SAME authoring guard pki.cmc.build puts an authored
   // integer through. A Transaction Identifier is an unbounded INTEGER on the wire,
   // so one above Number.MAX_SAFE_INTEGER has already been rounded by the time it
@@ -458,7 +462,7 @@ function _snapshotSent(sent) {
   if (out.recipient && typeof out.recipient === "object") {
     var r = {}, rk;
     for (rk in out.recipient) {
-      if (!Object.prototype.hasOwnProperty.call(out.recipient, rk)) continue;
+      if (!_hasOwn(out.recipient, rk)) continue;
       r[rk] = _copyAnyBytes(out.recipient[rk]);
     }
     out.recipient = r;

package/lib/cmp-verify.js

@@ -339,14 +339,9 @@ function _rfc822Equal(a, b) {
 // SIGN lowercases to "k", so a host carrying it would compare EQUAL to the ASCII spelling
 // and two distinct domains would read as one identity. Fold only A-Z and leave every other
 // octet alone, so a non-ASCII host can differ from an ASCII one but never collide with it.
-function _lowerAsciiDomain(h) {
-  var out = "";
-  for (var i = 0; i < h.length; i++) {
-    var c = _charCodeAt(h, i);
-    out += (c >= 0x41 && c <= 0x5a) ? _fromCharCode(c + 32) : _charAt(h, i);
-  }
-  return out;
-}
+// Through the toolkit's one definition of that fold, so no two name comparisons can disagree
+// about which characters case-fold.
+var _lowerAsciiDomain = guard.name.lowerAscii;
 
 // RFC 5280 sec. 4.2.1.6 / RFC 3986 sec. 6.2.2.1 URI comparison: the scheme and the authority host are
 // case-insensitive; every other component (userinfo, port, path, query, fragment) is byte-exact. Return
@@ -935,9 +930,9 @@ function _fixTime(v) {
 }
 function _fixVerifyOptions(opts, made) {
   if (opts == null) opts = {};   // ONLY null / undefined -> the default empty opts (a falsy false/0/"" is a bad config, not a default)
-  // Through the toolkit's own options door, which this verb used to skip in favor of its own two
-  // checks. The door does the thing those could not: it REFUSES an options bag whose fields are
-  // accessors, and refuses one that changes which fields it carries while they are read.
+  // Through the toolkit's own options door rather than a pair of local field checks. The door
+  // REFUSES an options bag whose fields are accessors, and refuses one that changes which fields it
+  // carries while they are read; a local check on each field it needs can do neither.
   //
   // That is what closes this whole class rather than one member of it. An accessor is caller code
   // running inside the call, before the verb has done anything, and from there it can rewrite the

package/lib/cms-verify.js

@@ -829,7 +829,7 @@ function _cloneAnchorValue(v, depth) {
   if (Array.isArray(v)) return v.map(function (e) { return _cloneAnchorValue(e, depth + 1); });
   var out = {}, k;
   for (k in v) {
-    if (!Object.prototype.hasOwnProperty.call(v, k)) continue;
+    if (!intrinsic.hasOwn(v, k)) continue;
     out[k] = _cloneAnchorValue(v[k], depth + 1);
   }
   return out;

package/lib/crl-sign.js

@@ -29,6 +29,11 @@ var crlSchema = require("./schema-crl");
 var x509Schema = require("./schema-x509");
 var signScheme = require("./sign-scheme");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Membership is asked through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and either of them answering true admits a name the
+// table never carried -- here, a reason code the CRL profile does not define.
+var _hasOwn = intrinsic.hasOwn;
 var frameworkError = require("./framework-error");
 var pkix = require("./schema-pkix");
 var schema = require("./schema-engine");
@@ -164,10 +169,10 @@ function _resolveReason(reason, isDelta) {
   var codeNum;
   if (typeof reason === "number") codeNum = reason;
   else if (typeof reason === "string") {
-    if (!Object.prototype.hasOwnProperty.call(REASON_BY_NAME, reason)) throw _err("crl/bad-reason-code", "unknown CRLReason " + JSON.stringify(reason));
+    if (!_hasOwn(REASON_BY_NAME, reason)) throw _err("crl/bad-reason-code", "unknown CRLReason " + JSON.stringify(reason));
     codeNum = REASON_BY_NAME[reason];
   } else throw _err("crl/bad-reason-code", "reason must be a CRLReason name or number");
-  if (!Object.prototype.hasOwnProperty.call(CRL_REASON, String(codeNum))) throw _err("crl/bad-reason-code", "undefined or reserved CRLReason " + codeNum + " (RFC 5280 sec. 5.3.1)");
+  if (!_hasOwn(CRL_REASON, String(codeNum))) throw _err("crl/bad-reason-code", "undefined or reserved CRLReason " + codeNum + " (RFC 5280 sec. 5.3.1)");
   if (codeNum === 8 && !isDelta) throw _err("crl/bad-reason-code", "removeFromCRL(8) may appear only in a delta CRL (RFC 5280 sec. 5.3.1)");
   return codeNum;
 }
@@ -284,7 +289,7 @@ function _buildCrlExtensions(spec, ctx) {
       // fixed criticality (assertValidExtension rejects an explicit critical=FALSE, so 3 children == critical,
       // 2 == non-critical) AND a well-formed value of the right type (INTEGER for cRLNumber/deltaCRLIndicator,
       // else a SEQUENCE), never emitted opaque.
-      if (Object.prototype.hasOwnProperty.call(REQUIRED_CRITICALITY, extnId)) {
+      if (_hasOwn(REQUIRED_CRITICALITY, extnId)) {
         if ((node.children.length === 3) !== REQUIRED_CRITICALITY[extnId]) {
           throw _err("crl/bad-input", "pre-encoded " + (oid.name(extnId) || extnId) + " extension has the wrong criticality (RFC 5280 sec. 5.2 requires it " + (REQUIRED_CRITICALITY[extnId] ? "critical" : "non-critical") + ")");
         }
@@ -387,13 +392,13 @@ function _buildRevoked(entryList, isDelta) {
         // RFC 5280 sec. 5.3 -- a recognized entry extension is held to the profile even via the escape hatch:
         // its fixed criticality AND a well-formed value of the right type (reasonCode an ENUMERATED in the
         // legal set, invalidityDate a GeneralizedTime).
-        if (Object.prototype.hasOwnProperty.call(REQUIRED_ENTRY_CRITICALITY, extnId)) {
+        if (_hasOwn(REQUIRED_ENTRY_CRITICALITY, extnId)) {
           if ((xnode.children.length === 3) !== REQUIRED_ENTRY_CRITICALITY[extnId]) throw _err("crl/bad-input", "pre-encoded entry extension " + (oid.name(extnId) || extnId) + " has the wrong criticality (RFC 5280 sec. 5.3 requires it " + (REQUIRED_ENTRY_CRITICALITY[extnId] ? "critical" : "non-critical") + ")");
           var einner = _extInner(xnode, oid.name(extnId) || extnId);
           if (extnId === O("reasonCode")) {
             if (einner.tagClass !== "universal" || einner.tagNumber !== TAGS.ENUMERATED) throw _err("crl/bad-reason-code", "pre-encoded reasonCode value must be an ENUMERATED (RFC 5280 sec. 5.3.1)");
             var rc = asn1.read.enumerated(einner);
-            if (!Object.prototype.hasOwnProperty.call(CRL_REASON, rc.toString())) throw _err("crl/bad-reason-code", "pre-encoded reasonCode " + rc + " is undefined or reserved (RFC 5280 sec. 5.3.1)");
+            if (!_hasOwn(CRL_REASON, rc.toString())) throw _err("crl/bad-reason-code", "pre-encoded reasonCode " + rc + " is undefined or reserved (RFC 5280 sec. 5.3.1)");
             if (rc === 8n && !isDelta) throw _err("crl/bad-reason-code", "removeFromCRL(8) may appear only in a delta CRL (RFC 5280 sec. 5.3.1)");
           } else if (extnId === O("invalidityDate")) {
             if (einner.tagClass !== "universal" || einner.tagNumber !== TAGS.GENERALIZED_TIME) throw _err("crl/bad-input", "pre-encoded invalidityDate value must be a GeneralizedTime (RFC 5280 sec. 5.3.2)");

package/lib/ct.js

@@ -44,6 +44,11 @@ var asn1 = require("./asn1-der.js");
 var constants = require("./constants.js");
 var frameworkError = require("./framework-error.js");
 var guard = require("./guard-all.js");
+var intrinsic = require("./guard-intrinsic.js");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides whether a log state is one this
+// toolkit trusts -- answering true for a name the table never carried trusts an untrusted log.
+var _hasOwn = intrinsic.hasOwn;
 var ByteReader = require("./byte-reader.js");
 var ByteWriter = require("./byte-writer.js");
 var oid = require("./oid.js");
@@ -650,7 +655,7 @@ var LOG_STATE_TRUST = { pending: "no", qualified: "yes", usable: "yes", readonly
 function _parseLogState(state) {
   if (state == null || typeof state !== "object") throw _ctErr("ct/bad-state", "a CT log entry is missing its state");
   var keys = Object.keys(state);
-  if (keys.length !== 1 || !Object.prototype.hasOwnProperty.call(LOG_STATE_TRUST, keys[0])) {
+  if (keys.length !== 1 || !_hasOwn(LOG_STATE_TRUST, keys[0])) {
     throw _ctErr("ct/bad-state", "a CT log state must carry exactly one recognized member (pending/qualified/usable/readonly/retired/rejected)");
   }
   var name = keys[0], member = state[name];

package/lib/est.js

@@ -72,6 +72,10 @@ var OID_CMC_DATA_RETURN = oid.byName("id-cmc-dataReturn");
 var crmfFmt = require("./schema-crmf");
 var frameworkError = require("./framework-error");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load: written out it reads two replaceable
+// properties to answer one question, and here it decides which fields of a response are copied.
+var _hasOwn = intrinsic.hasOwn;
 var httpTransport = require("./http-transport");
 var httpDigest = require("./http-digest");
 var retryAfter = require("./http-retry-after");
@@ -1592,7 +1596,7 @@ function _assertAgrees(name, supplied, carried) {
 function _copyRecipient(r) {
   if (!r || typeof r !== "object") return r;
   var out = {}, k;
-  for (k in r) { if (Object.prototype.hasOwnProperty.call(r, k)) out[k] = _copyBytes(r[k]); }
+  for (k in r) { if (_hasOwn(r, k)) out[k] = _copyBytes(r[k]); }
   return out;
 }
 
@@ -1606,10 +1610,10 @@ function _copyRecipient(r) {
 // transport function, a tls config).
 function _shallowCopy(o) {
   var out = {}, k;
-  for (k in o) { if (Object.prototype.hasOwnProperty.call(o, k)) out[k] = o[k]; }
+  for (k in o) { if (_hasOwn(o, k)) out[k] = o[k]; }
   if (out.auth && typeof out.auth === "object") {
     var a = {}, ak;
-    for (ak in out.auth) { if (Object.prototype.hasOwnProperty.call(out.auth, ak)) a[ak] = out.auth[ak]; }
+    for (ak in out.auth) { if (_hasOwn(out.auth, ak)) a[ak] = out.auth[ak]; }
     out.auth = a;
   }
   return out;

package/lib/guard-all.js

@@ -51,6 +51,7 @@
 // its guard module, so a new boundary cannot re-inline the shape and forget the
 // defense.
 
+var _freeze = require("./guard-intrinsic").freeze;
 var bytes  = require("./guard-bytes");
 var text   = require("./guard-text");
 var limits = require("./guard-limits");
@@ -74,7 +75,11 @@ var async_ = require("./guard-async");
 // live reads were never named. With one spelling, a module's own require IS the fact, and the check
 // reads it off the loaded module graph rather than guessing at the text.
 
-module.exports = {
+// Frozen, like every module it gathers. A boundary reaches its guard as `guard.<family>.<fn>(...)`
+// at the call, and the registry hands every module this same object, so one property assignment
+// would replace a fail-closed check everywhere at once -- which is the substitution the family
+// exists to refuse. Nothing writes to it after load.
+module.exports = _freeze({
   bytes:  bytes,
   text:   text,
   limits: limits,
@@ -92,4 +97,4 @@ module.exports = {
   secret: secret,
   parsed: parsed,
   async:  async_,
-};
+});

package/lib/guard-async.js

@@ -46,4 +46,6 @@ function deferred(body) {
   catch (e) { return _reject(_Promise, e); }
 }
 
-module.exports = { deferred: deferred };
+// 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({ deferred: deferred });

package/lib/guard-bytes.js

@@ -1032,8 +1032,10 @@ function fixedCall(ErrorClass, code, args, body) {
   }), function () { if (handle) handle.release(); });
 }
 
-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({
   view: view, source: source, snapshot: snapshot, snapshotSource: snapshotSource,
   isByteSource: isByteSource, lengthOf: lengthOf, outputView: outputView,
   snapshotDeep: snapshotDeep, fixArguments: fixArguments, fixedCall: fixedCall,
-};
+});

package/lib/guard-compress.js

@@ -181,4 +181,6 @@ function bounded(algorithm, stream, cap, E, codes, label) {
 // and a consumer offering an algorithm this list omits fails closed at `bounded`.
 function algorithms() { return _objectKeys(SAFE); }
 
-module.exports = { bounded: bounded, algorithms: algorithms };
+// 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({ bounded: bounded, algorithms: algorithms });

package/lib/guard-crypto.js

@@ -28,6 +28,7 @@
 // with unusedBits !== 0 fails closed before its bytes reach a verifier.
 
 var nodeCrypto = require("node:crypto");
+var _freeze = require("./guard-intrinsic").freeze;
 
 // constantTimeEqual(a, b) -> boolean. Length-checked, then constant-time over
 // equal lengths. a and b are Buffers.
@@ -61,4 +62,6 @@ function assertOctetAligned(bitString, E, code, label) {
   return bitString;
 }
 
-module.exports = { constantTimeEqual: constantTimeEqual, isOctetAligned: isOctetAligned, assertOctetAligned: assertOctetAligned };
+// 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({ constantTimeEqual: constantTimeEqual, isOctetAligned: isOctetAligned, assertOctetAligned: assertOctetAligned });

package/lib/guard-der.js

@@ -33,6 +33,7 @@
 // The byte comparison SET-OF ordering is decided by, taken at load. A replacement chooses which
 // encodings this guard calls correctly ordered. See guard-intrinsic for the whole captured set.
 var _compare = require("./guard-intrinsic").compare;
+var _freeze = require("./guard-intrinsic").freeze;
 var _forEach = require("./guard-intrinsic").forEach;
 // The emptiness gate below decides whether bytes reach the decoder at all, and on a byte view
 // `length` is a replaceable accessor: one answering non-zero for an empty buffer sends nothing to
@@ -172,4 +173,6 @@ function tlv(content, E, code, label) {
   return content;
 }
 
-module.exports = { element: element, tlv: tlv };
+// 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({ element: element, tlv: tlv });

package/lib/guard-encoding.js

@@ -132,4 +132,6 @@ function hex(text, maxBytes, E, code, label) {
   return buf;
 }
 
-module.exports = { base64url: base64url, base64: base64, hex: hex };
+// 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({ base64url: base64url, base64: base64, hex: hex });

package/lib/guard-header.js

@@ -21,6 +21,7 @@ var C = require("./constants");
 // Taken at load. `byteLength` is what the RFC 5322 line limit is measured with, so a replacement
 // decides whether an over-long header line is refused. See guard-intrinsic for the whole set.
 var _byteLength = require("./guard-intrinsic").byteLength;
+var _freeze = require("./guard-intrinsic").freeze;
 // The character-code read the RFC 5322 ftext and CR/LF/NUL checks are built on. One that never
 // reports a control byte is a header-injection defense that inspects nothing.
 var _charCodeAt = require("./guard-intrinsic").uncurry(String.prototype.charCodeAt);
@@ -60,4 +61,6 @@ function assertField(name, value, E, code) {
   return v;
 }
 
-module.exports = { assertField: assertField };
+// 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({ assertField: assertField });

package/lib/guard-identifier.js

@@ -851,7 +851,9 @@ function _settle(opts, E, code, label) {
   return opts;
 }
 
-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({
   assertCanonicalOid: assertCanonicalOid,
   assertKnownKeys: assertKnownKeys,
   optionsObject: optionsObject,
@@ -864,4 +866,4 @@ module.exports = {
   // Exported for the same reason as its sibling: a caller copying an array has to reach the
   // elements a read reaches, and the own keys are not that set.
   readableIndices: readableIndices
-};
+});

package/lib/guard-intrinsic.js

@@ -260,7 +260,12 @@ function sizeOf(value) {
     (value === null ? "null" : typeof value));
 }
 
-module.exports = {
+// Frozen, and that is what makes the capture worth taking. A consumer binds these at load, but it
+// also reads several of them as `intrinsic.<name>(...)` at the call itself, and the module registry
+// hands every caller this same object: assigning one property would redirect that call in every
+// module at once, which is the substitution the captures exist to refuse. Freezing costs nothing
+// here because nothing writes to it after load.
+module.exports = Object.freeze({
   uncurry: uncurry,
   getter: getter,
   sizeOf: sizeOf,
@@ -347,4 +352,4 @@ module.exports = {
   Set: _Set,
   Map: _Map,
   WeakMap: _WeakMap,
-};
+});

package/lib/guard-json.js

@@ -27,6 +27,7 @@ var text = require("./guard-text");
 // setter, and `fromCharCode` is how an escape becomes the character it names; a replacement for
 // either decides what this parser produces. See guard-intrinsic for the whole captured set.
 var _defineProperty = require("./guard-intrinsic").defineProperty;
+var _freeze = require("./guard-intrinsic").freeze;
 var _fromCharCode = require("./guard-intrinsic").fromCharCode;
 // The character-code read the whole scanner is built on: whitespace, escapes and the control-byte
 // reject all consult it, so one that lies decides what this parser sees in the input.
@@ -209,4 +210,6 @@ function parse(input, ErrorClass, spec) {
   return result;
 }
 
-module.exports = { parse: parse };
+// 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({ parse: parse });

package/lib/guard-limits.js

@@ -27,6 +27,7 @@ var constants = require("./constants");
 // one returning true admits a NaN or fractional cap, which makes the comparison it guards always
 // false. See guard-intrinsic for the whole captured set.
 var _isInteger = require("./guard-intrinsic").isInteger;
+var _freeze = require("./guard-intrinsic").freeze;
 // And the size measurement, for the same reason one step further in: a cap compares against a
 // length, and on a byte view `length` is a replaceable accessor. One reporting a small number for a
 // large buffer leaves every byteCap below always-false, which is the size defense silently dead.
@@ -137,4 +138,6 @@ function byteCap(buf, max, E, code, label) {
   return buf;
 }
 
-module.exports = { cap: cap, depthCap: depthCap, counter: counter, byteCap: byteCap };
+// 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({ cap: cap, depthCap: depthCap, counter: counter, byteCap: byteCap });

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/hpke.js

@@ -27,6 +27,10 @@
 var nodeCrypto = require("crypto");
 var frameworkError = require("./framework-error");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+// Own-key membership through an operation taken at load. Written out, the question reads two
+// replaceable properties to answer one thing, and here it decides which suite parameters are read.
+var _hasOwn = intrinsic.hasOwn;
 
 var HpkeError = frameworkError.HpkeError;
 function _err(code, message, cause) { return new HpkeError(code, message, cause); }
@@ -423,7 +427,7 @@ function _mode(opts, keys, who) {
   guard.identifier.assertKnownKeys(opts, keys, _err, "hpke/bad-input", function (k) {
     var other = (keys === _SETUP_S_KEYS ? _SETUP_R_KEYS : _SETUP_S_KEYS);
     return "unknown HPKE " + who + " option " + JSON.stringify(k) +
-      (Object.prototype.hasOwnProperty.call(other, k)
+      (_hasOwn(other, k)
         ? " -- that option belongs to the other end of the exchange, where it would authenticate or seed; here it would do nothing"
         : "") + " -- accepted: " + Object.keys(keys).sort().join(", ");
   });