@blamejs/pki 0.8.30 → 0.8.48

package/lib/sleep.js

@@ -3,10 +3,17 @@
 "use strict";
 // @internal
 
+var intrinsic = require("./guard-intrinsic");
+/** @internal The constructor is captured at load like every operation the toolkit decides with. A
+ *  replacement reached here settles the wait itself, so a backoff a caller asked for does not happen.
+ *  `setTimeout` is deliberately NOT captured: the delay this splits is observed through the global, and
+ *  capturing it would make the split unobservable. */
+var _Promise = intrinsic.Promise;
+
 var SETTIMEOUT_MAX_MS = 2147483647;
 
 function sleep(ms) {
-  return new Promise(function (resolve) {
+  return new _Promise(function (resolve) {
     (function step(remaining) {
       if (remaining <= SETTIMEOUT_MAX_MS) { setTimeout(resolve, remaining); return; }
       setTimeout(function () { step(remaining - SETTIMEOUT_MAX_MS); }, SETTIMEOUT_MAX_MS);

package/lib/smime.js

@@ -62,7 +62,7 @@ var ENCRYPT_OPTS = Object.assign(Object.create(null), {
   entity: 1, contentType: 1, protectHeaders: 1, headers: 1, hcp: 1,
   contentEncryptionAlgorithm: 1, oaepHash: 1, keyIdentifier: 1, ukm: 1,
 });
-var DECRYPT_OPTS = Object.assign(Object.create(null), { recipientIndex: 1, maxIterations: 1, strictSmimeType: 1, legacyHeaderProtection: 1 });
+var DECRYPT_OPTS = Object.assign(Object.create(null), { recipientIndex: 1, maxIterations: 1, strictSmimeType: 1, legacyHeaderProtection: 1, allowUnauthenticatedRsa15: 1 });
 var COMPRESS_OPTS = Object.assign(Object.create(null), { entity: 1, contentType: 1, level: 1 });
 var DECOMPRESS_OPTS = Object.assign(Object.create(null), { maxOutputBytes: 1 });
 
@@ -84,6 +84,19 @@ function _isPkcs7(type, kind) {
 
 var MICALG = Object.assign(Object.create(null), { sha1: "sha-1", sha224: "sha-224", sha256: "sha-256", sha384: "sha-384", sha512: "sha-512", md5: "md5", shake128: "shake128", shake256: "shake256" });
 
+/** @internal The content, copied before the caller's options are read. Every verb that builds an entity
+ *  settles its options first, and settling them COPIES them, which reads the caller's own object: a
+ *  property there is caller code that runs before the content would otherwise have been read, and over a
+ *  view of the content it would replace what the verb goes on to sign, encrypt or compress, after the
+ *  verb had accepted the content it was handed. So the copy has to come before the option copy, not at
+ *  the entity builders below, which run too late.
+ *  The test is the one the byte readers themselves apply, so a value they would refuse is still refused
+ *  where they refuse it and no diagnostic moves ahead of the option check. */
+function _fixedContent(content) {
+  if (!nodeUtil.types.isUint8Array(content)) return content;
+  return guard.bytes.snapshot(content, SmimeError, "smime/bad-input", "content");
+}
+
 function _entityBytes(content, opts) {
   var raw = guard.bytes.view(content, SmimeError, "smime/bad-input", "content");
   if (opts.entity) return mime.canonicalize(raw, SmimeError, "smime/bad-mime");
@@ -637,6 +650,7 @@ function _base64Body(der) {
  *   var msg = await pki.smime.sign(Buffer.from("hello"), [{ cert: signerCertDer, key: signerKeyPkcs8 }]);
  */
 async function sign(content, signers, opts) {
+  content = _fixedContent(content);
   opts = opts || {};
   opts = _knownOpts(opts, SIGN_OPTS, "sign");
   signers = _snapshotSignersFitForMail(signers);
@@ -859,6 +873,7 @@ function _cmsEncryptOpts(opts) {
  *   var enc = await pki.smime.encrypt(Buffer.from("secret"), [{ cert: recipientCertDer }]);
  */
 async function encrypt(content, recipients, opts) {
+  content = _fixedContent(content);
   opts = opts || {};
   opts = _knownOpts(opts, ENCRYPT_OPTS, "encrypt");
   var hp = opts.protectHeaders === true;
@@ -902,6 +917,7 @@ async function encrypt(content, recipients, opts) {
  * @opts recipientIndex  forwarded to cms.decrypt: explicitly select the recipient by index.
  * @opts maxIterations   forwarded to cms.decrypt: lower the PBKDF2 iteration cap (downward only).
  * @opts strictSmimeType reject a header `smime-type` that disagrees with the CMS body (`smime/smime-type-mismatch`).
+ * @opts allowUnauthenticatedRsa15  forwarded to cms.decrypt: read a body that uses RSAES-PKCS1-v1_5 key transport over a content with no integrity tag, refused by default with `cms/unauthenticated-rsa-v15`. An `openssl smime -encrypt` message is exactly that combination when no algorithm is named.
  * @opts legacyHeaderProtection  opt in to detecting a LEGACY RFC 8551 header-protected message (RFC 9788 sec. 4.10): an encrypted Cryptographic Payload that is a bare `message/rfc822` wrap with no `hp=` parameter. When set, a precisely-identified legacy message surfaces the inner headers under `headerProtection.legacy = { headers, mode: "cipher", fromMismatch, confidential }`, with `headers` an ordered `[{ name, value }]` array (retaining repeated fields) and the `confidential` set derived from the actual visible outer Header Section. They are not placed under `protectedHeaders`, and `present` stays `false`, since a legacy message is structurally indistinguishable from a forwarded `message/rfc822` (a heuristic; cross-check `legacy.fromMismatch`). Anything not precisely identified reports `legacy: null`. Off by default.
  * @example
  *   var rsa = { name: "RSA-OAEP", modulusLength: 2048, publicExponent: new Uint8Array([1, 0, 1]), hash: "SHA-256" };
@@ -929,6 +945,10 @@ async function decrypt(message, keyMaterial, opts) {
   var cmsOpts = {};
   if (opts.recipientIndex !== undefined) cmsOpts.recipientIndex = opts.recipientIndex;
   if (opts.maxIterations !== undefined) cmsOpts.maxIterations = opts.maxIterations;
+  /** @internal Forwarded rather than re-decided here: an S/MIME body is a CMS structure and the rule about
+   *  RSAES-PKCS1-v1_5 over an unauthenticated content belongs to the verb that opens it. An
+   *  `openssl smime -encrypt` or `openssl cms -encrypt` message is exactly that combination by default. */
+  if (opts.allowUnauthenticatedRsa15 !== undefined) cmsOpts.allowUnauthenticatedRsa15 = opts.allowUnauthenticatedRsa15;
   var res = await cms.decrypt(der, keyMaterial, cmsOpts);
   return Object.assign({
     content: res.content, smimeType: smimeType, authenticated: res.authenticated,
@@ -960,6 +980,7 @@ async function decrypt(message, keyMaterial, opts) {
  *   var z = await pki.smime.compress(Buffer.from("compress this message"));
  */
 async function compress(content, opts) {
+  content = _fixedContent(content);
   opts = opts || {};
   opts = _knownOpts(opts, COMPRESS_OPTS, "compress");
   var entity = _entityBytes(content, opts);