@blamejs/pki 0.8.60 → 0.9.0

package/lib/smime.js

@@ -33,6 +33,10 @@
  *   algorithm-agnostic.
  */
 
+/** @internal The record constructor, captured at load, for the reason the same capture in
+ * `lib/inspect.js` gives: requiring the guard-intrinsic captures arms the module whole, which counts
+ * 176 live runtime reads here. */
+var _create = Object.create;
 var frameworkError = require("./framework-error.js");
 var mime = require("./mime.js");
 var cms = require("./cms-verify.js");
@@ -48,7 +52,6 @@ var _push = guard.list.append;
 var pkiBuild = require("./pki-build.js");
 var C = require("./constants.js");
 var nodeUtil = require("util");
-var nodeCrypto = require("crypto");
 
 var SmimeError = frameworkError.SmimeError;
 
@@ -591,7 +594,7 @@ function _micalgOf(p7Der) {
   return out.length ? out.sort().join(",") : null;
 }
 
-function _boundary() { return "----=_pki_smime_" + nodeCrypto.randomBytes(18).toString("hex"); }
+function _boundary() { return "----=_pki_smime_" + guard.crypto.randomBytes(18).toString("hex"); }
 
 function _wrap64Crlf(s) {
   var out = "";
@@ -655,7 +658,7 @@ function _base64Body(der) {
  */
 async function sign(content, signers, opts) {
   content = _fixedContent(content);
-  opts = opts || {};
+  opts = opts || _create(null);
   opts = _knownOpts(opts, SIGN_OPTS, "sign");
   signers = _snapshotSignersFitForMail(signers);
   var hp = opts.protectHeaders === true;
@@ -768,7 +771,7 @@ function _capped(msg) {
  *   if (res.valid) { res.content; res.signers[0].sid; }
  */
 async function verify(message, opts) {
-  opts = opts || {};
+  opts = opts || _create(null);
   opts = _knownOpts(opts, VERIFY_OPTS, "verify");
   var ent = mime.parse(message, SmimeError, "smime/bad-mime");
   var ct = ent.contentType;
@@ -878,7 +881,7 @@ function _cmsEncryptOpts(opts) {
  */
 async function encrypt(content, recipients, opts) {
   content = _fixedContent(content);
-  opts = opts || {};
+  opts = opts || _create(null);
   opts = _knownOpts(opts, ENCRYPT_OPTS, "encrypt");
   var hp = opts.protectHeaders === true;
   var hpList = hp ? _hpHeaderList(opts.headers) : null;
@@ -935,7 +938,7 @@ async function encrypt(content, recipients, opts) {
  *   res.authenticated;  // true here (an AEAD content cipher); false for an enveloped-only CBC message, which carries no integrity
  */
 async function decrypt(message, keyMaterial, opts) {
-  opts = opts || {};
+  opts = opts || _create(null);
   opts = _knownOpts(opts, DECRYPT_OPTS, "decrypt");
   var ent = mime.parse(message, SmimeError, "smime/bad-mime");
   var ct = ent.contentType;
@@ -985,7 +988,7 @@ async function decrypt(message, keyMaterial, opts) {
  */
 async function compress(content, opts) {
   content = _fixedContent(content);
-  opts = opts || {};
+  opts = opts || _create(null);
   opts = _knownOpts(opts, COMPRESS_OPTS, "compress");
   var entity = _entityBytes(content, opts);
   var cOpts = {};
@@ -1019,7 +1022,7 @@ async function compress(content, opts) {
  *   res.content;   // the recovered inner MIME entity
  */
 async function decompress(message, opts) {
-  opts = opts || {};
+  opts = opts || _create(null);
   opts = _knownOpts(opts, DECOMPRESS_OPTS, "decompress");
   var ent = mime.parse(message, SmimeError, "smime/bad-mime");
   var ct = ent.contentType;
@@ -1065,7 +1068,7 @@ var CERTS_ONLY_OPTS = Object.assign(Object.create(null), { crls: 1 });
  *   var p7c = pki.smime.buildCertsOnly([leafDer]);
  */
 function buildCertsOnly(certs, opts) {
-  opts = opts || {};
+  opts = opts || _create(null);
   opts = _knownOpts(opts, CERTS_ONLY_OPTS, "buildCertsOnly");
   var der = _toBuf(cms.certsOnly(certs, { crls: opts.crls }));
   return _capped(Buffer.concat([_pkcs7MimeHead("certs-only", "smime.p7c"), _base64Body(der), mime.CRLF]));

package/lib/tlog.js

@@ -299,12 +299,13 @@ function _resolveKey(keyName, publicKey) {
     throw _err("tlog/bad-input", "publicKey must be the raw " + ED25519_RAW_BYTES +
       " Ed25519 bytes or a SubjectPublicKeyInfo, got " + bytes.length + " bytes", e);
   }
-  var type = key.asymmetricKeyType;
+  var type = guard.crypto.keyType(key);
   if (type === "ed25519") {
     return _edKey(name, bytes, _subarray(bytes, bytes.length - ED25519_RAW_BYTES));
   }
   if (type === "ec") {
-    var curve = key.asymmetricKeyDetails && key.asymmetricKeyDetails.namedCurve;
+    var keyDetails = guard.crypto.keyDetails(key);
+    var curve = keyDetails && keyDetails.namedCurve;
     if (EC_CURVES[curve] !== 1) {
       throw _err("tlog/bad-input", "a signed note names no key-ID derivation for the elliptic curve " +
         guard.text.showValue(_stringOf(curve)));
@@ -670,7 +671,7 @@ function parseCheckpoint(input) {
  */
 var _CHECKPOINT_OPTS = _assign(_create(null), { origin: 1 });
 async function verifyCheckpoint(input, keys, opts) {
-  opts = opts || {};
+  opts = opts || _create(null);
   guard.identifier.assertKnownKeys(opts, _CHECKPOINT_OPTS, _err,
     "tlog/bad-input", "unknown verifyCheckpoint option ");
   /** @internal ONE read of the caller's input, shared by the decode and the verification below. Reading
@@ -1208,7 +1209,7 @@ async function _tilePath(lo, hi, m, size, unitAt) {
  */
 var _INCLUSION_PROOF_KEYS = _assign(_create(null), { index: 1, size: 1, read: 1 });
 async function inclusionProof(opts) {
-  opts = opts || {};
+  opts = opts || _create(null);
   guard.identifier.assertKnownKeys(opts, _INCLUSION_PROOF_KEYS, _err,
     "tlog/bad-input", "unknown inclusionProof option ");
   var size = guard.range.uint64(opts.size, _err, "tlog/bad-input", "size");

package/lib/tls-cert-compress.js

@@ -167,7 +167,7 @@ function _resolveAllowed(opts) {
  *   pki.schema.x509.parse(out.certificate.entries[0].certData).subject;
  */
 function decompressCertificate(bytes, opts) {
-  opts = opts || {};
+  opts = opts || intrinsic.create(null);
   /** @internal Viewed, CAPPED, then COPIED, and only then are the options read. A view stays a window
    *  onto the caller's buffer, and `_resolveCap` reads `opts`, which is caller code when it is an
    *  accessor: a `maxOutputBytes` getter that wrote another valid message of the same length over the
@@ -262,7 +262,7 @@ function decompressCertificate(bytes, opts) {
  *   pki.schema.x509.parse(msg.entries[0].certData).subject;
  */
 function parseCertificateMessage(bytes, opts) {
-  opts = opts || {};
+  opts = opts || intrinsic.create(null);
   var type = opts.certificateType === undefined ? "X509" : opts.certificateType;
   if (type !== "X509" && type !== "RawPublicKey") {
     throw _err("tls/bad-input", "opts.certificateType must be \"X509\" or \"RawPublicKey\"");
@@ -315,7 +315,7 @@ function parseCertificateMessage(bytes, opts) {
  *   wire.length < message.length;                       // true
  */
 function compressCertificate(certificateMessage, opts) {
-  opts = opts || {};
+  opts = opts || intrinsic.create(null);
   /** @internal Copied, not viewed. `opts.algorithm` is read below, and reading an option is caller code
    *  when it is an accessor, so over a view it would run between the message being looked at and being
    *  compressed and replace what this verb compresses, after it had accepted the message it was handed.

package/lib/tsp-sign.js

@@ -155,7 +155,7 @@ var _SIGN_OPTS = intrinsic.assign(intrinsic.create(null), {
 });
 
 function _sign(messageImprint, tsa, opts) {
-  opts = opts || {};
+  opts = opts || intrinsic.create(null);
   if (messageImprint && typeof messageImprint === "object" && !Buffer.isBuffer(messageImprint)) {
     guard.identifier.assertKnownKeys(messageImprint, _IMPRINT_KEYS, _err, "tsp/bad-input", function (k) {
       return "unknown messageImprint field " + JSON.stringify(k) + " (the imprint is { hashAlgorithm, hashedMessage })";
@@ -169,7 +169,7 @@ function _sign(messageImprint, tsa, opts) {
         " (the TSA is { cert, key }; a signing option belongs in the third argument)";
     });
   }
-  var mi = messageImprint || {};
+  var mi = messageImprint || intrinsic.create(null);
   if (!mi.hashAlgorithm || !NODE_DIGEST[guard.text.keyOf(mi.hashAlgorithm)]) throw _err("tsp/unsupported-algorithm", "messageImprint.hashAlgorithm must be a supported hash name");
   if (!guard.bytes.isByteSource(mi.hashedMessage)) throw _err("tsp/bad-input", "messageImprint.hashedMessage must be a BufferSource");
   var _signHmLen = guard.bytes.source(mi.hashedMessage, TspError, "tsp/bad-input", "messageImprint.hashedMessage").length;
@@ -292,10 +292,10 @@ function _assertImprint(mi) {
 var _REQUEST_OPTS = intrinsic.assign(intrinsic.create(null), { reqPolicy: 1, nonce: 1, certReq: 1, extensions: 1, pem: 1 });
 
 function request(messageImprint, opts) {
-  opts = opts || {};
+  opts = opts || intrinsic.create(null);
   if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw _err("tsp/bad-input", "pki.tsp.request options must be an object");
   guard.identifier.assertKnownKeys(opts, _REQUEST_OPTS, _err, "tsp/bad-input", "pki.tsp.request has an unknown option ");
-  var mi = messageImprint || {};
+  var mi = messageImprint || intrinsic.create(null);
   if (mi && typeof mi === "object" && !Buffer.isBuffer(mi)) {
     guard.identifier.assertKnownKeys(mi, _IMPRINT_KEYS, _err, "tsp/bad-input", function (k) {
       return "unknown messageImprint field " + JSON.stringify(k) +
@@ -379,7 +379,7 @@ function parseRequest(input) { return schemaTsp.parseRequest(input); }
 var _RESPONSE_OPTS = intrinsic.assign(intrinsic.create(null), { status: 1, statusString: 1, failInfo: 1, pem: 1 });
 
 function response(token, opts) {
-  opts = opts || {};
+  opts = opts || intrinsic.create(null);
   if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw _err("tsp/bad-input", "pki.tsp.response options must be an object");
   guard.identifier.assertKnownKeys(opts, _RESPONSE_OPTS, _err, "tsp/bad-input", "pki.tsp.response has an unknown option ");
   var st = opts.status;
@@ -664,7 +664,7 @@ function _anyCritical(extensions) {
 }
 
 async function verify(token, data, opts) {
-  opts = opts || {};
+  opts = opts || intrinsic.create(null);
   if (typeof opts !== "object" || Buffer.isBuffer(opts)) throw _err("tsp/bad-input", "pki.tsp.verify options must be an object");
   guard.identifier.assertKnownKeys(opts, _VERIFY_OPTS, _err, "tsp/bad-input",
     "pki.tsp.verify has an unknown option (the anchor option is `trustAnchors`) ");

package/lib/tuf.js

@@ -798,12 +798,13 @@ function _declarationOf(key) {
 function _checkedPublicKey(key, d) {
   if (d.nodeType === "ed25519") return null;
   var imported = _publicFromPem(key.keyval.public, "a " + key.keytype + " public key");
-  if (imported.asymmetricKeyType !== d.nodeType) {
+  var importedType = guard.crypto.keyType(imported);
+  if (importedType !== d.nodeType) {
     throw _err("tuf/bad-key", "the key declared as " + key.keytype + " holds a " +
-      guard.text.showValue(imported.asymmetricKeyType) + " public key, so the signature would be checked " +
+      guard.text.showValue(importedType) + " public key, so the signature would be checked " +
       "under an algorithm the metadata does not name");
   }
-  var details = imported.asymmetricKeyDetails || {};
+  var details = guard.crypto.keyDetails(imported) || _create(null);
   if (d.curve !== null && details.namedCurve !== d.curve) {
     throw _err("tuf/bad-key", "the scheme " + key.scheme + " names the " + d.curve +
       " curve; the key is on " + guard.text.showValue(details.namedCurve));
@@ -888,7 +889,7 @@ function _publicFromPem(pem, label) {
  */
 var _VERIFY_KEYS = intrinsic.assign(_create(null), { metadata: 1, keys: 1, role: 1 });
 async function verifySignatures(opts) {
-  opts = opts || {};
+  opts = opts || _create(null);
   guard.identifier.assertKnownKeys(opts, _VERIFY_KEYS, _err, "tuf/bad-input", "unknown verifySignatures option ");
   /** @internal Every caller-owned input is taken ONCE, at the top, and everything below reads the copy.
    *  Validating the caller's object and then reading it again is two reads, and a member reached through an
@@ -1296,7 +1297,7 @@ function _asRoot(input, label) {
  */
 var _UPDATE_KEYS = intrinsic.assign(_create(null), { trustedRoot: 1, candidates: 1, now: 1 });
 async function updateRoot(opts) {
-  opts = opts || {};
+  opts = opts || _create(null);
   guard.identifier.assertKnownKeys(opts, _UPDATE_KEYS, _err, "tuf/bad-input", "unknown updateRoot option ");
   /** @internal The instant is CAPTURED here, at the call, into a Date this function owns. A Date is
    *  mutable and the caller keeps theirs, and the freeze-attack check runs at the END, after a signature

package/lib/validator-cose.js

@@ -7,7 +7,7 @@ var cbor = require("./cbor-det");
 var asn1 = require("./asn1-der");
 var oid = require("./oid");
 var edwardsPoint = require("./edwards-point");
-var nodeCrypto = require("crypto");
+var guard = require("./guard-all.js");
 
 var EC2_CRV_LEN = Object.assign(Object.create(null), { 1: 32, 2: 48, 3: 66 });
 var EC2_CRV_OID = Object.assign(Object.create(null), { 1: "prime256v1", 2: "secp384r1", 3: "secp521r1" });
@@ -114,7 +114,7 @@ function assertKeyMaterial(key, E, code, unsupportedCode) {
   if (!prof) throw new E(unsupportedCode || code, "unsupported credential key algorithm " + key.alg);
   if (prof.kty !== key.kty) throw bad("credential key algorithm " + key.alg + " is inconsistent with key type " + key.kty);
   if (prof.crv != null && prof.crv !== key.crv) throw bad("credential key algorithm " + key.alg + " requires a different curve");
-  try { nodeCrypto.createPublicKey({ key: toSpki(key, E, code), format: "der", type: "spki" }); }
+  try { guard.crypto.publicKey({ key: toSpki(key, E, code), format: "der", type: "spki" }); }
   catch (e) { throw bad("the credential public key point is not valid for its curve", e); }
   if (Number(key.kty) === 1 && !edwardsPoint.validate(key.x, key.crv)) throw bad("the OKP credential public key is not a valid, full-order Edwards point");
   return key;

package/lib/webauthn-mds.js

@@ -26,12 +26,6 @@ var _charAt = intrinsic.uncurry(String.prototype.charAt);
 var _strToLowerCase = intrinsic.toLowerCase;
 var _strSlice = intrinsic.uncurry(String.prototype.slice);
 var _strSplit = intrinsic.uncurry(String.prototype.split);
-/** @internal The hash constructor and the methods of the object it returns. What a digest here
- *  produces is a metadata lookup key and the identity two certificates are told apart by, so a
- *  replaced constructor, update or digest decides which entry governs an attestation. */
-var _createHash = _nodeCrypto.createHash;
-var _hashUpdate = intrinsic.uncurry(_nodeCrypto.createHash("sha256").update);
-var _hashDigest = intrinsic.uncurry(_nodeCrypto.createHash("sha256").digest);
 var jose = require("./jose");
 var rfc3339 = require("./rfc3339");
 var constants = require("./constants");
@@ -324,7 +318,7 @@ function _verifyMetadataBlob(blob, opts) {
   });
   var leaf = chain[0];
   _assertLeafSigns(leaf);
-  var leafAlg = (leaf.subjectPublicKeyInfo.algorithm || {}).name;
+  var leafAlg = (leaf.subjectPublicKeyInfo.algorithm || intrinsic.create(null)).name;
   var leafSchemes = typeof leafAlg === "string" ? LEAF_SCHEMES_BY_SPKI_ALG[leafAlg] : undefined;
   if (!leafSchemes || !leafSchemes[algRow.scheme]) {
     throw _err("webauthn/unsupported-algorithm", "the metadata BLOB alg " + header.alg + " does not match the x5c leaf key type " + intrinsic.stringify(leafAlg));
@@ -702,7 +696,9 @@ function certKeyIdentifier(cert) {
   if (!pk || !intrinsic.isBuffer(pk.bytes)) {
     throw _err("webauthn/bad-input", "certKeyIdentifier expects a parsed certificate carrying a subject public key");
   }
-  return _hashDigest(_hashUpdate(_createHash("sha1"), pk.bytes), "hex");
+  /** @internal A metadata lookup key, and the identity two certificates are told apart by, so
+   *  whatever computes it decides which entry governs an attestation. */
+  return guard.crypto.digest("sha1", pk.bytes, { output: "hex" });
 }
 
 function metadataForKeyIdentifier(metadata, keyId) {

package/lib/webauthn.js

@@ -54,7 +54,6 @@ var _promiseResolve = intrinsic.uncurry(intrinsic.promiseResolve);
 var _promiseReject = intrinsic.uncurry(intrinsic.promiseReject);
 var jose = require("./jose");
 var mds = require("./webauthn-mds");
-var nodeCrypto = require("crypto");
 
 var WebauthnError = frameworkError.WebauthnError;
 function _err(code, message, cause) { return new WebauthnError(code, message, cause); }
@@ -76,16 +75,10 @@ var _subtleVerify = intrinsic.uncurry(subtle.verify);
  * while the bytes handed in were never the credential's. */
 var _subtleImportKey = intrinsic.uncurry(subtle.importKey);
 
-/** @internal The hash constructor is captured, and so are the methods of the object it returns. Every
- * attestation comparison in this module rests on a digest, so a replaced `createHash`, or a replaced
- * `update` or `digest` on the object it hands back, chooses what the comparison sees. */
-var _createHash = nodeCrypto.createHash;
-function _sha(name, buf) {
-  var h = _createHash(name);
-  return _hashDigest(_hashUpdate(h, buf));
-}
-var _hashUpdate = intrinsic.uncurry(nodeCrypto.createHash("sha256").update);
-var _hashDigest = intrinsic.uncurry(nodeCrypto.createHash("sha256").digest);
+/** @internal Every attestation comparison in this module rests on a digest, so whatever computes one
+ * chooses what the comparison sees. The guard owns the hash construction and the methods of the
+ * object it returns. */
+function _sha(name, buf) { return guard.crypto.digest(name, buf); }
 /** @internal The comparison goes through the captured operation. This is what decides that an
  *  attestation statement's key is the credential's key, so a replacement answering zero makes a
  *  different key match. */
@@ -275,7 +268,7 @@ function _certKeyAlgNames(cose) {
   return [];
 }
 function _assertCertKeyAlgorithm(cert, cose, E) {
-  var alg = (cert.subjectPublicKeyInfo && cert.subjectPublicKeyInfo.algorithm) || {};
+  var alg = (cert.subjectPublicKeyInfo && cert.subjectPublicKeyInfo.algorithm) || intrinsic.create(null);
   var want = _certKeyAlgNames(cose);
   if (!want.length || intrinsic.indexOf(want, alg.name) < 0) {
     throw E("webauthn/key-mismatch", "the attestation certificate carries a " + intrinsic.stringify(alg.name) +