@blamejs/pki 0.7.28 → 0.7.29

package/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to `@blamejs/pki` are documented here. The format
 follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); this
 project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## v0.7.29 — 2026-09-12
+
+Every decision pki.key makes is taken with operations bound when the module loads.
+
+### Changed
+
+- pki.key.import, pki.key.generate, pki.key.decrypt, pki.key.encrypt, pki.key.export, pki.key.publicFromPrivate and the key-pair correspondence check read Array.isArray, Math.floor, isFinite, String, String.prototype.toUpperCase and String.prototype.indexOf, Buffer.from, Object.assign, Object.create and Object.prototype.hasOwnProperty as bound at module load. Replacing any of them afterwards changes nothing the module decides: a non-array usages is still refused, a fractional or infinite maxIterations is still refused, an Ed25519 import still receives signing usages, and an unrestricted RSASSA-PSS pair still corresponds when an inherited saltLength is planted on Object.prototype. Behavior on an untouched runtime is unchanged.
+
 ## v0.7.28 — 2026-09-12
 
 pki.cmp.verify names a MAC algorithm it does not compute as what it is, not as a failed signature.

package/lib/key.js

@@ -29,6 +29,16 @@ var webcrypto = require("./webcrypto");
 var compositeKem = require("./composite-kem");
 var frameworkError = require("./framework-error");
 var guard = require("./guard-all");
+var intrinsic = require("./guard-intrinsic");
+var _assign = intrinsic.assign;
+var _create = intrinsic.create;
+var _isArray = intrinsic.isArray;
+var _bufferFrom = intrinsic.bufferFrom;
+var _floor = intrinsic.floor;
+var _isFinite = intrinsic.isFinite;
+var _String = intrinsic.String;
+var _toUpperCase = intrinsic.toUpperCase;
+var _strIndexOf = intrinsic.stringIndexOf;
 
 var b = asn1.build;
 var subtle = webcrypto.webcrypto.subtle;
@@ -37,16 +47,16 @@ var PemError = frameworkError.PemError;
 function O(n) { return oid.byName(n); }
 function _err(code, msg, cause) { return new KeyError(code, msg, cause); }
 
-var CIPHER_NAME = Object.assign(Object.create(null), { "aes-128-cbc": "aes128-CBC", "aes-192-cbc": "aes192-CBC", "aes-256-cbc": "aes256-CBC" });
+var CIPHER_NAME = _assign(_create(null), { "aes-128-cbc": "aes128-CBC", "aes-192-cbc": "aes192-CBC", "aes-256-cbc": "aes256-CBC" });
 
-var INFER_ALG = Object.create(null);
+var INFER_ALG = _create(null);
 ["Ed25519", "Ed448", "X25519", "X448"].forEach(function (n) { INFER_ALG[O(n)] = { name: n }; });
 [["id-ml-dsa-44", "ML-DSA-44"], ["id-ml-dsa-65", "ML-DSA-65"], ["id-ml-dsa-87", "ML-DSA-87"],
  ["id-ml-kem-512", "ML-KEM-512"], ["id-ml-kem-768", "ML-KEM-768"], ["id-ml-kem-1024", "ML-KEM-1024"]
 ].forEach(function (r) { INFER_ALG[O(r[0])] = { name: r[1] }; });
 ["sha2-128s", "sha2-128f", "sha2-192s", "sha2-192f", "sha2-256s", "sha2-256f",
  "shake-128s", "shake-128f", "shake-192s", "shake-192f", "shake-256s", "shake-256f"
-].forEach(function (s) { INFER_ALG[O("id-slh-dsa-" + s)] = { name: ("SLH-DSA-" + s).toUpperCase() }; });
+].forEach(function (s) { INFER_ALG[O("id-slh-dsa-" + s)] = { name: _toUpperCase("SLH-DSA-" + s) }; });
 
 function _isCryptoKey(x) { return webcrypto.isCryptoKeyLike(x); }
 function _algName(a) { return typeof a === "string" ? a : (a && a.name); }
@@ -89,7 +99,7 @@ async function _toPrivateKeyDer(input) {
  *   var enc = await pki.key.encrypt(der, "s3cr3t", { pem: true });
  *   var back = await pki.key.decrypt(enc, "s3cr3t");
  */
-var _ENCRYPT_OPTS = Object.assign(Object.create(null), { cipher: 1, iterations: 1, pem: 1, prf: 1, salt: 1 });
+var _ENCRYPT_OPTS = _assign(_create(null), { cipher: 1, iterations: 1, pem: 1, prf: 1, salt: 1 });
 
 async function encrypt(privateKey, password, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.encrypt options");
@@ -148,14 +158,14 @@ async function encrypt(privateKey, password, opts) {
  *   var enc = await pki.key.encrypt(await pki.key.export(pair.privateKey), "s3cr3t", { pem: true });
  *   var der = await pki.key.decrypt(enc, "s3cr3t");
  */
-var _DECRYPT_OPTS = Object.assign(Object.create(null), { maxIterations: 1, pem: 1 });
+var _DECRYPT_OPTS = _assign(_create(null), { maxIterations: 1, pem: 1 });
 
 async function decrypt(encrypted, password, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.decrypt options");
   guard.identifier.assertKnownKeys(opts, _DECRYPT_OPTS, _err, "key/bad-input",
     "pki.key.decrypt has an unknown option (the PBKDF2 cap here is `maxIterations`; " +
     "`iterations` is the encrypt-side count): ");
-  if (opts.maxIterations != null && (typeof opts.maxIterations !== "number" || !isFinite(opts.maxIterations) || opts.maxIterations < 1 || Math.floor(opts.maxIterations) !== opts.maxIterations)) {
+  if (opts.maxIterations != null && (typeof opts.maxIterations !== "number" || !_isFinite(opts.maxIterations) || opts.maxIterations < 1 || _floor(opts.maxIterations) !== opts.maxIterations)) {
     throw _err("key/bad-input", "maxIterations must be a positive integer");
   }
   var input = pkix.coerceToDer(encrypted, { pemLabel: "ENCRYPTED PRIVATE KEY", PemError: PemError, ErrorClass: KeyError, prefix: "key" });
@@ -204,7 +214,7 @@ function _decryptPbes2(encAlg, ciphertext, password, opts) {
  *   var pair = await pki.key.generate("Ed25519");
  *   var spkiPem = await pki.key.export(pair.publicKey, { format: "pem" });
  */
-var _EXPORT_OPTS = Object.assign(Object.create(null), { format: 1, label: 1 });
+var _EXPORT_OPTS = _assign(_create(null), { format: 1, label: 1 });
 
 async function export_(key, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.export options");
@@ -247,7 +257,7 @@ async function export_(key, opts) {
  *   var spki = await pki.key.export(pair.publicKey);
  *   var pub = await pki.key.import(spki);                       // Ed25519 -- algorithm inferred
  */
-var _IMPORT_OPTS = Object.assign(Object.create(null), { algorithm: 1, extractable: 1, password: 1, usages: 1 });
+var _IMPORT_OPTS = _assign(_create(null), { algorithm: 1, extractable: 1, password: 1, usages: 1 });
 
 async function import_(input, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.import options");
@@ -260,7 +270,7 @@ async function import_(input, opts) {
   }
   var algorithm = opts.algorithm != null ? opts.algorithm : _inferAlgorithm(detected);
   var isPublic = detected.format === "spki";
-  if (opts.usages != null && !Array.isArray(opts.usages)) throw _err("key/bad-input", "opts.usages must be an array of key-usage strings");
+  if (opts.usages != null && !_isArray(opts.usages)) throw _err("key/bad-input", "opts.usages must be an array of key-usage strings");
   var usages = opts.usages || _importUsages(_algName(algorithm), isPublic);
   var extractable = opts.extractable != null ? opts.extractable : false;
   try {
@@ -291,14 +301,14 @@ async function import_(input, opts) {
  *   var pair = await pki.key.generate("Ed25519");
  *   var pkcs8 = await pki.key.export(pair.privateKey);
  */
-var _GENERATE_OPTS = Object.assign(Object.create(null), { extractable: 1, usages: 1 });
+var _GENERATE_OPTS = _assign(_create(null), { extractable: 1, usages: 1 });
 
 async function generate(algorithm, opts) {
   opts = guard.identifier.optionsObject(opts, _err, "key/bad-input", "pki.key.generate options");
   guard.identifier.assertKnownKeys(opts, _GENERATE_OPTS, _err, "key/bad-input",
     "pki.key.generate has an unknown option (the WebCrypto spelling is `extractable`): ");
   var extractable = opts.extractable != null ? opts.extractable : true;
-  if (opts.usages != null && !Array.isArray(opts.usages)) throw _err("key/bad-input", "opts.usages must be an array of key-usage strings");
+  if (opts.usages != null && !_isArray(opts.usages)) throw _err("key/bad-input", "opts.usages must be an array of key-usage strings");
   var usages = opts.usages || _generateUsages(_algName(algorithm));
   var pair;
   try { pair = await subtle.generateKey(algorithm, extractable, usages); }
@@ -333,7 +343,7 @@ async function generate(algorithm, opts) {
  *   var pair = await pki.key.generate("Ed25519");
  *   var spki = await pki.key.publicFromPrivate(await pki.key.export(pair.privateKey));
  */
-var _PUBLIC_FROM_PRIVATE_OPTS = Object.assign(Object.create(null), { pem: 1 });
+var _PUBLIC_FROM_PRIVATE_OPTS = _assign(_create(null), { pem: 1 });
 
 /** @internal The composite ML-KEM OID a private key names, or null when it names anything else. Read
  * from the AlgorithmIdentifier alone: a key that is not well formed enough to state one is left to the
@@ -399,17 +409,17 @@ async function publicFromPrivate(privateKey, opts) {
  * correspondence that succeeds, and does not stop the key from being usable with the certificate.
  * A caller needing structural consistency has a different question, and this is not it.
  */
-var _PAIR_DIGEST = Object.assign(Object.create(null), { rsa: "sha256", ec: "sha256" });
-var _PAIR_AGREE = Object.assign(Object.create(null), { x25519: 1, x448: 1 });
-var _PAIR_KEM = Object.assign(Object.create(null),
+var _PAIR_DIGEST = _assign(_create(null), { rsa: "sha256", ec: "sha256" });
+var _PAIR_AGREE = _assign(_create(null), { x25519: 1, x448: 1 });
+var _PAIR_KEM = _assign(_create(null),
   { "ml-kem-512": 1, "ml-kem-768": 1, "ml-kem-1024": 1 });
 /** @internal RFC 4055 sec. 1.2: ONE RSA key pair may be identified either by `rsaEncryption` or by
  * `id-RSASSA-PSS`, and a delivered private key and the certificate that certifies it need not have
  * chosen the same one. The key engine reports those two encodings as different types, so comparing
  * types alone would call a usable pair no pair at all. They name one algorithm and are exercised
  * together, under PSS, which is the padding the restricted encoding permits. */
-var _PAIR_RSA = Object.assign(Object.create(null), { rsa: 1, "rsa-pss": 1 });
-var _PAIR_PROBE = Buffer.from("pki.js key pair correspondence", "utf8");
+var _PAIR_RSA = _assign(_create(null), { rsa: 1, "rsa-pss": 1 });
+var _PAIR_PROBE = _bufferFrom("pki.js key pair correspondence", "utf8");
 
 function _sameKeyFamily(priv, pub) {
   if (priv.asymmetricKeyType === pub.asymmetricKeyType) return true;
@@ -443,7 +453,7 @@ function _pairSignOptions(priv, pub) {
   var salt = _pssSalt(privDetails.saltLength, pubDetails.saltLength);
   /** @internal Null-prototype, because the engine READS this object by name. A plain object would
    * let an inherited `saltLength` reach the signature as a restriction neither half stated. */
-  var options = Object.create(null);
+  var options = _create(null);
   options.padding = nodeCrypto.constants.RSA_PKCS1_PSS_PADDING;
   if (salt != null) options.saltLength = salt;
   return { digest: digest, options: options };
@@ -457,12 +467,12 @@ var _PSS_PINS = ["hashAlgorithm", "mgf1HashAlgorithm", "saltLength"];
  * object would let an inherited `saltLength` or `hashAlgorithm` answer as a restriction the key never
  * carried, and refuse a genuine pair. */
 function _pssRestrictionOf(key, isPss) {
-  var out = Object.create(null);
+  var out = _create(null);
   var details = isPss ? key.asymmetricKeyDetails : null;
   if (details == null) return out;
   for (var i = 0; i < _PSS_PINS.length; i++) {
     var name = _PSS_PINS[i];
-    if (Object.prototype.hasOwnProperty.call(details, name) && details[name] != null) out[name] = details[name];
+    if (intrinsic.hasOwn(details, name) && details[name] != null) out[name] = details[name];
   }
   return out;
 }
@@ -492,7 +502,7 @@ async function correspondsTo(privateKey, spkiDer) {
   var priv, pub;
   try { priv = nodeCrypto.createPrivateKey({ key: privDer, format: "der", type: "pkcs8" }); }
   catch (e) { throw _err("key/bad-input", "the private key could not be read", e); }
-  try { pub = nodeCrypto.createPublicKey({ key: Buffer.from(spkiDer), format: "der", type: "spki" }); }
+  try { pub = nodeCrypto.createPublicKey({ key: _bufferFrom(spkiDer), format: "der", type: "spki" }); }
   catch (e) { throw _err("key/bad-input", "the public key could not be read", e); }
   if (!_sameKeyFamily(priv, pub)) return false;
   var kind = guard.text.keyOf(priv.asymmetricKeyType);
@@ -521,8 +531,8 @@ async function correspondsTo(privateKey, spkiDer) {
     if (how === null) {
       throw _err("key/unsupported-algorithm", "the two halves pin incompatible RSASSA-PSS parameters, so no operation exercises them together and whether they are a pair cannot be decided");
     }
-    var signKey = how.options ? Object.assign(Object.create(null), { key: priv }, how.options) : priv;
-    var verifyKey = how.options ? Object.assign(Object.create(null), { key: pub }, how.options) : pub;
+    var signKey = how.options ? _assign(_create(null), { key: priv }, how.options) : priv;
+    var verifyKey = how.options ? _assign(_create(null), { key: pub }, how.options) : pub;
     return nodeCrypto.verify(how.digest, _PAIR_PROBE, verifyKey,
       nodeCrypto.sign(how.digest, _PAIR_PROBE, signKey)) === true;
   } catch (e) {
@@ -569,17 +579,17 @@ function _inferAlgorithm(detected) {
 }
 
 function _importUsages(name, isPublic) {
-  var n = String(name == null ? "" : name).toUpperCase();
+  var n = _toUpperCase(_String(name == null ? "" : name));
   if (n === "X25519" || n === "X448" || n === "ECDH") return isPublic ? [] : ["deriveBits", "deriveKey"];
-  if (n.indexOf("ML-KEM") === 0) return isPublic ? ["encapsulateBits"] : ["decapsulateBits"];
+  if (_strIndexOf(n, "ML-KEM") === 0) return isPublic ? ["encapsulateBits"] : ["decapsulateBits"];
   if (n === "RSA-OAEP") return isPublic ? ["encrypt"] : ["decrypt"];
   return isPublic ? ["verify"] : ["sign"];
 }
 
 function _generateUsages(name) {
-  var n = String(name == null ? "" : name).toUpperCase();
+  var n = _toUpperCase(_String(name == null ? "" : name));
   if (n === "X25519" || n === "X448" || n === "ECDH") return ["deriveBits", "deriveKey"];
-  if (n.indexOf("ML-KEM") === 0) return ["encapsulateBits", "decapsulateBits"];
+  if (_strIndexOf(n, "ML-KEM") === 0) return ["encapsulateBits", "decapsulateBits"];
   if (n === "RSA-OAEP") return ["encrypt", "decrypt"];
   return ["sign", "verify"];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/pki",
-  "version": "0.7.28",
+  "version": "0.7.29",
   "description": "Pure-JavaScript PKI toolkit that owns its stack — X.509, ASN.1/DER, CMS, PQC-first.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",
@@ -84,6 +84,6 @@
   "devDependencies": {
     "c8": "12.0.0",
     "esbuild": "0.28.2",
-    "eslint": "10.9.1"
+    "eslint": "10.10.0"
   }
 }

package/sbom.cdx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:369c5f21-643b-4e6e-9bbe-caa64491393d",
+  "serialNumber": "urn:uuid:3c9a8588-ff6f-477c-92fd-33c03ea2c98b",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-09-12T04:58:41.118Z",
+    "timestamp": "2026-09-12T05:32:15.338Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/pki@0.7.28",
+      "bom-ref": "@blamejs/pki@0.7.29",
       "type": "application",
       "name": "pki",
-      "version": "0.7.28",
+      "version": "0.7.29",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "Pure-JavaScript PKI toolkit that owns its stack — X.509, ASN.1/DER, CMS, PQC-first.",
-      "purl": "pkg:npm/%40blamejs/pki@0.7.28",
+      "purl": "pkg:npm/%40blamejs/pki@0.7.29",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/pki@0.7.28",
+      "ref": "@blamejs/pki@0.7.29",
       "dependsOn": []
     }
   ]