jose 6.2.11 → 6.2.13

package/dist/webapi/lib/buffer_utils.js

@@ -1,4 +1,4 @@
-const encoder = new TextEncoder(), decoder = new TextDecoder(), strictDecoder = new TextDecoder("utf-8", { fatal: !0 }), MAX_INT32 = 2 ** 32;
+const encoder = new TextEncoder(), decoder = new TextDecoder(), strictDecoder = new TextDecoder("utf-8", { fatal: !0 }), UINT32_RANGE = 2 ** 32;
 function concat(...buffers) {
   const size = buffers.reduce((acc, { length }) => acc + length, 0), buf = new Uint8Array(size);
   let i = 0;
@@ -7,19 +7,25 @@ function concat(...buffers) {
   return buf;
 }
 function writeUInt32BE(buf, value, offset) {
-  if (value < 0 || value >= MAX_INT32)
-    throw new RangeError(`value must be >= 0 and <= ${MAX_INT32 - 1}. Received ${value}`);
+  if (value < 0 || value >= UINT32_RANGE)
+    throw new RangeError(`value must be >= 0 and <= ${UINT32_RANGE - 1}. Received ${value}`);
   buf.set([value >>> 24, value >>> 16, value >>> 8, value & 255], offset);
 }
 function uint64be(value) {
-  const high = Math.floor(value / MAX_INT32), low = value % MAX_INT32, buf = new Uint8Array(8);
+  const high = Math.floor(value / UINT32_RANGE), low = value % UINT32_RANGE, buf = new Uint8Array(8);
   return writeUInt32BE(buf, high, 0), writeUInt32BE(buf, low, 4), buf;
 }
 function uint32be(value) {
   const buf = new Uint8Array(4);
   return writeUInt32BE(buf, value), buf;
 }
+const NON_ASCII = /[^\x00-\x7f]/;
 function encode(string) {
+  if (typeof string == "string" && string.length >= 128) {
+    if (NON_ASCII.test(string))
+      throw new TypeError("non-ASCII string encountered in encode()");
+    return encoder.encode(string);
+  }
   const bytes = new Uint8Array(string.length);
   for (let i = 0; i < string.length; i++) {
     const code = string.charCodeAt(i);
@@ -29,10 +35,39 @@ function encode(string) {
   }
   return bytes;
 }
+function encodeBase64(input, url = !1) {
+  if (Uint8Array.prototype.toBase64)
+    return input.toBase64({ alphabet: url ? "base64url" : "base64", omitPadding: url });
+  const CHUNK_SIZE = 32768, arr = [];
+  for (let i = 0; i < input.length; i += CHUNK_SIZE)
+    arr.push(String.fromCharCode.apply(null, input.subarray(i, i + CHUNK_SIZE)));
+  const encoded = btoa(arr.join(""));
+  return url ? encoded.replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_") : encoded;
+}
+function decodeBase64(encoded, url = !1) {
+  if (Uint8Array.fromBase64)
+    return Uint8Array.fromBase64(encoded, { alphabet: url ? "base64url" : "base64" });
+  if (url) {
+    if (encoded.includes("+") || encoded.includes("/"))
+      throw new TypeError("Invalid base64url");
+    encoded = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  }
+  const binary = atob(encoded), bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++)
+    bytes[i] = binary.charCodeAt(i);
+  return bytes;
+}
+async function digest(algorithm, data) {
+  const subtleDigest = `SHA-${algorithm.slice(-3)}`;
+  return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
+}
 export {
   concat,
+  decodeBase64,
   decoder,
+  digest,
   encode,
+  encodeBase64,
   encoder,
   strictDecoder,
   uint32be,

package/dist/webapi/lib/content_encryption.js

@@ -1,8 +1,6 @@
 import { concat, uint64be } from "./buffer_utils.js";
-import { checkCryptoKey } from "./crypto_key.js";
-import { invalidKeyInput } from "./invalid_key_input.js";
+import { rawKey, invalidKeyInput, isCryptoKey } from "./key.js";
 import { JWEDecryptionFailed, JWEInvalid } from "../util/errors.js";
-import { isCryptoKey } from "./is_key_like.js";
 const generateCek = (enc) => crypto.getRandomValues(new Uint8Array(enc.cekBits >> 3));
 function checkCekLength(cek, expected) {
   const actual = cek.byteLength << 3;
@@ -17,20 +15,20 @@ function checkIvLength(enc, iv) {
 async function cbcKeySetup(enc, cek, usage) {
   if (!(cek instanceof Uint8Array))
     throw new TypeError(invalidKeyInput(cek, "Uint8Array"));
-  const keySize = enc.cekBits >> 1, encKey = await crypto.subtle.importKey("raw", cek.subarray(keySize >> 3), "AES-CBC", !1, [usage]), macKey = await crypto.subtle.importKey("raw", cek.subarray(0, keySize >> 3), {
-    hash: `SHA-${keySize << 1}`,
+  const keyLengthBits = enc.cekBits >> 1, encKey = await crypto.subtle.importKey("raw", cek.subarray(keyLengthBits >> 3), "AES-CBC", !1, [usage]), macKey = await crypto.subtle.importKey("raw", cek.subarray(0, keyLengthBits >> 3), {
+    hash: `SHA-${keyLengthBits << 1}`,
     name: "HMAC"
   }, !1, ["sign"]);
-  return [encKey, macKey, keySize];
+  return [encKey, macKey, keyLengthBits];
 }
-async function cbcHmacTag(macKey, macData, keySize) {
-  return new Uint8Array((await crypto.subtle.sign("HMAC", macKey, macData)).slice(0, keySize >> 3));
+async function cbcHmacTag(macKey, macData, keyLengthBits) {
+  return new Uint8Array((await crypto.subtle.sign("HMAC", macKey, macData)).slice(0, keyLengthBits >> 3));
 }
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
-  const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, "encrypt"), ciphertext = new Uint8Array(await crypto.subtle.encrypt({
+  const [encKey, macKey, keyLengthBits] = await cbcKeySetup(enc, cek, "encrypt"), ciphertext = new Uint8Array(await crypto.subtle.encrypt({
     iv,
     name: "AES-CBC"
-  }, encKey, plaintext)), macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8)), tag = await cbcHmacTag(macKey, macData, keySize);
+  }, encKey, plaintext)), al = uint64be(aad.length * 8), macData = concat(aad, iv, ciphertext, al), tag = await cbcHmacTag(macKey, macData, keyLengthBits);
   return { ciphertext, tag, iv };
 }
 async function timingSafeEqual(a, b) {
@@ -38,7 +36,7 @@ async function timingSafeEqual(a, b) {
   return crypto.subtle.verify(algorithm, key, aHmac, b);
 }
 async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-  const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, "decrypt"), macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8)), expectedTag = await cbcHmacTag(macKey, macData, keySize);
+  const [encKey, macKey, keyLengthBits] = await cbcKeySetup(enc, cek, "decrypt"), al = uint64be(aad.length * 8), macData = concat(aad, iv, ciphertext, al), expectedTag = await cbcHmacTag(macKey, macData, keyLengthBits);
   try {
     if (await timingSafeEqual(tag, expectedTag))
       return new Uint8Array(await crypto.subtle.decrypt({ iv, name: "AES-CBC" }, encKey, ciphertext));
@@ -46,21 +44,31 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
   }
   throw new JWEDecryptionFailed();
 }
-async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
-  const encKey = cek instanceof Uint8Array ? await crypto.subtle.importKey("raw", cek, "AES-GCM", !1, [
-    "encrypt"
-  ]) : (checkCryptoKey(cek, enc.subtle, "encrypt"), cek), encrypted = new Uint8Array(await crypto.subtle.encrypt({
+async function encrypt(enc, plaintext, cek, iv, aad) {
+  if (!isCryptoKey(cek) && !(cek instanceof Uint8Array))
+    throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
+  if (iv ? checkIvLength(enc, iv) : iv = generateIv(enc), cek instanceof Uint8Array && checkCekLength(cek, enc.cekBits), enc.cbc)
+    return cbcEncrypt(enc, plaintext, cek, iv, aad);
+  const encKey = await rawKey(cek, enc.subtle, "encrypt"), encrypted = new Uint8Array(await crypto.subtle.encrypt({
     additionalData: aad,
     iv,
     name: "AES-GCM",
     tagLength: 128
-  }, encKey, plaintext)), tag = encrypted.slice(-16);
-  return { ciphertext: encrypted.slice(0, -16), tag, iv };
+  }, encKey, plaintext));
+  return { ciphertext: encrypted.subarray(0, -16), tag: encrypted.subarray(-16), iv };
 }
-async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-  const encKey = cek instanceof Uint8Array ? await crypto.subtle.importKey("raw", cek, "AES-GCM", !1, [
-    "decrypt"
-  ]) : (checkCryptoKey(cek, enc.subtle, "decrypt"), cek);
+async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
+  if (!isCryptoKey(cek) && !(cek instanceof Uint8Array))
+    throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
+  if (!iv)
+    throw new JWEInvalid("JWE Initialization Vector missing");
+  if (!tag)
+    throw new JWEInvalid("JWE Authentication Tag missing");
+  if (!enc.cbc && tag.length !== 16)
+    throw new JWEInvalid("Invalid Authentication Tag length");
+  if (checkIvLength(enc, iv), cek instanceof Uint8Array && checkCekLength(cek, enc.cekBits), enc.cbc)
+    return cbcDecrypt(enc, cek, ciphertext, iv, tag, aad);
+  const encKey = await rawKey(cek, enc.subtle, "decrypt");
   try {
     return new Uint8Array(await crypto.subtle.decrypt({
       additionalData: aad,
@@ -72,22 +80,6 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     throw new JWEDecryptionFailed();
   }
 }
-async function encrypt(enc, plaintext, cek, iv, aad) {
-  if (!isCryptoKey(cek) && !(cek instanceof Uint8Array))
-    throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
-  return iv ? checkIvLength(enc, iv) : iv = generateIv(enc), cek instanceof Uint8Array && checkCekLength(cek, enc.cekBits), enc.cbc ? cbcEncrypt(enc, plaintext, cek, iv, aad) : gcmEncrypt(enc, plaintext, cek, iv, aad);
-}
-async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
-  if (!isCryptoKey(cek) && !(cek instanceof Uint8Array))
-    throw new TypeError(invalidKeyInput(cek, "CryptoKey", "KeyObject", "Uint8Array", "JSON Web Key"));
-  if (!iv)
-    throw new JWEInvalid("JWE Initialization Vector missing");
-  if (!tag)
-    throw new JWEInvalid("JWE Authentication Tag missing");
-  if (!enc.cbc && tag.length !== 16)
-    throw new JWEInvalid("Invalid Authentication Tag length");
-  return checkIvLength(enc, iv), cek instanceof Uint8Array && checkCekLength(cek, enc.cekBits), enc.cbc ? cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) : gcmDecrypt(enc, cek, ciphertext, iv, tag, aad);
-}
 export {
   checkCekLength,
   checkIvLength,

package/dist/webapi/lib/deflate.js

@@ -10,30 +10,14 @@ function supported(name) {
   if (typeof globalThis[name] > "u")
     throw new JOSENotSupported(`JWE "zip" (Compression Algorithm) Header Parameter requires the ${name} API.`);
 }
-async function compress(input) {
-  supported("CompressionStream");
-  const cs = new CompressionStream("deflate-raw"), writer = cs.writable.getWriter();
-  writer.write(input).catch(() => {
-  }), writer.close().catch(() => {
-  });
-  const chunks = [], reader = cs.readable.getReader();
-  for (; ; ) {
-    const { value, done } = await reader.read();
-    if (done)
-      break;
-    chunks.push(value);
-  }
-  return concat(...chunks);
-}
-async function decompress(input, maxLength) {
-  supported("DecompressionStream");
-  const ds = new DecompressionStream("deflate-raw"), writer = ds.writable.getWriter();
+async function transform(stream, input, maxLength = 1 / 0) {
+  const writer = stream.writable.getWriter();
   writer.write(input).catch(() => {
   }), writer.close().catch(() => {
   });
   const chunks = [];
   let length = 0;
-  const reader = ds.readable.getReader();
+  const reader = stream.readable.getReader();
   for (; ; ) {
     const { value, done } = await reader.read();
     if (done)
@@ -43,6 +27,12 @@ async function decompress(input, maxLength) {
   }
   return concat(...chunks);
 }
+async function compress(input) {
+  return supported("CompressionStream"), transform(new CompressionStream("deflate-raw"), input);
+}
+async function decompress(input, maxLength) {
+  return supported("DecompressionStream"), transform(new DecompressionStream("deflate-raw"), input, maxLength);
+}
 export {
   compress,
   decompress,

package/dist/webapi/lib/jwe_algorithms.js

@@ -105,15 +105,11 @@ function jweAlgorithm(alg) {
 function isJWECEKTransport(algorithm) {
   return algorithm.mode === "key-wrapping" || algorithm.mode === "key-encryption" || algorithm.mode === "key-agreement-with-key-wrapping";
 }
-function invalidJWEKeyManagementMode(_mode) {
-  throw new TypeError("Invalid JWE key management mode");
-}
 function jweEncryption(enc) {
   return (typeof enc == "string" ? ENC[enc] : void 0) ?? unsupported("enc", "Encryption Algorithm");
 }
 export {
   JWE,
-  invalidJWEKeyManagementMode,
   isJWECEKTransport,
   jweAlgorithm,
   jweEncryption

package/dist/webapi/lib/jwe_decrypt.js

@@ -1,12 +1,10 @@
 import { decrypt, generateCek } from "./content_encryption.js";
-import { decodeBase64url, encodeBase64url, parseJoseHeader } from "./helpers.js";
+import { decodeBase64url, encodeAsciiMember, parseJoseHeader, isDisjoint, isObject, validateCrit, validateAlgorithms, JWE_RECOGNIZED } from "./validate.js";
 import { JOSEAlgNotAllowed, JOSENotSupported, JWEInvalid } from "../util/errors.js";
-import { isDisjoint, isObject } from "./type_checks.js";
 import { decryptKeyManagement } from "./key_management.js";
-import { concat, decoder, encode } from "./buffer_utils.js";
-import { validateCrit, validateAlgorithms, JWE_RECOGNIZED } from "./options.js";
+import { decoder } from "./buffer_utils.js";
 import { prepareKey } from "./key.js";
-import { JWE, invalidJWEKeyManagementMode, isJWECEKTransport, jweAlgorithm, jweEncryption } from "./jwe_algorithms.js";
+import { JWE, isJWECEKTransport, jweAlgorithm, jweEncryption } from "./jwe_algorithms.js";
 import { decompress, validateZip } from "./deflate.js";
 function snapshotSharedJWE(jwe) {
   const { aad, ciphertext, iv, protected: encodedProtected, tag, unprotected } = jwe;
@@ -44,10 +42,6 @@ function snapshotRecipientJWE(recipient) {
       ]));
     } else
       header = inputHeader;
-  } catch (error) {
-    return [void 0, headerAlg, error];
-  }
-  try {
     const { encrypted_key: encryptedKey } = recipient;
     return [{ encrypted_key: encryptedKey, header }, headerAlg];
   } catch (error) {
@@ -65,21 +59,15 @@ function checkRecipient(jwe) {
 }
 function shareJWE(jwe) {
   const { protected: encodedProtected, ciphertext, iv, tag, aad } = jwe;
-  let parsedProt;
-  encodedProtected !== void 0 && (parsedProt = parseJoseHeader(encodedProtected, JWEInvalid, "JWE Protected Header is invalid"));
-  const protectedHeader = encodedProtected !== void 0 ? encode(encodedProtected) : new Uint8Array();
-  return [
-    parsedProt,
+  let protectedHeader;
+  return encodedProtected !== void 0 && (protectedHeader = parseJoseHeader(encodedProtected, JWEInvalid, "JWE Protected Header is invalid")), [
+    protectedHeader,
     decodeBase64url(ciphertext, "ciphertext", JWEInvalid),
     iv !== void 0 ? decodeBase64url(iv, "iv", JWEInvalid) : void 0,
     tag !== void 0 ? decodeBase64url(tag, "tag", JWEInvalid) : void 0,
-    aad !== void 0 ? concat(protectedHeader, encode("."), encodeBase64url(aad, "aad", JWEInvalid)) : protectedHeader
+    encodeAsciiMember((encodedProtected ?? "") + (aad !== void 0 ? `.${aad}` : ""), "aad", JWEInvalid)
   ];
 }
-function decryptResult(jwe, decrypted) {
-  const [plaintext, parsedProt, key, resolvedKey] = decrypted, { protected: encodedProtected, aad, unprotected, header } = jwe, result = { plaintext };
-  return encodedProtected !== void 0 && (result.protectedHeader = parsedProt), aad !== void 0 && (result.additionalAuthenticatedData = decodeBase64url(aad, "aad", JWEInvalid)), unprotected !== void 0 && (result.sharedUnprotectedHeader = unprotected), header !== void 0 && (result.unprotectedHeader = header), resolvedKey ? { ...result, key } : result;
-}
 function prepareDecrypt(options) {
   return [
     options && validateAlgorithms("keyManagementAlgorithms", options.keyManagementAlgorithms),
@@ -89,20 +77,17 @@ function prepareDecrypt(options) {
     options?.maxDecompressedLength
   ];
 }
-async function decryptRecipient(jwe, token, shared, key) {
-  const [parsedProt] = token, { header, unprotected } = jwe;
+async function decryptJWE(jwe, shared, key, token = shareJWE(jwe)) {
+  const [protectedHeader, ciphertext, iv, tag, additionalAuthenticatedData] = token, { header, unprotected, aad } = jwe;
   let joseHeader;
   if (header !== void 0 || unprotected !== void 0) {
-    if (!isDisjoint(parsedProt, header, unprotected))
+    if (!isDisjoint(protectedHeader, header, unprotected))
       throw new JWEInvalid("JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint");
-    joseHeader = { ...parsedProt, ...header, ...unprotected };
+    joseHeader = { ...protectedHeader, ...header, ...unprotected };
   } else
-    joseHeader = parsedProt ?? {};
-  return decryptRecipientCore(jwe, token, shared, key, joseHeader);
-}
-async function decryptRecipientCore(jwe, token, shared, key, joseHeader) {
-  const [keyManagementAlgorithms, contentEncryptionAlgorithms, crit, maxPBES2Count, maxDecompressedLength] = shared, [parsedProt, ciphertext, iv, tag, additionalData] = token, { encrypted_key: encodedKey } = jwe;
-  validateCrit(JWEInvalid, JWE_RECOGNIZED, crit, parsedProt, joseHeader), validateZip(joseHeader, parsedProt);
+    joseHeader = protectedHeader ?? {};
+  const [keyManagementAlgorithms, contentEncryptionAlgorithms, crit, maxPBES2Count, maxDecompressedLength] = shared, { encrypted_key: encodedKey } = jwe;
+  validateCrit(JWEInvalid, JWE_RECOGNIZED, crit, protectedHeader, joseHeader), validateZip(joseHeader, protectedHeader);
   const { alg, enc } = joseHeader;
   if (typeof alg != "string" || !alg)
     throw new JWEInvalid("missing JWE Algorithm (alg) in JWE Header");
@@ -137,28 +122,13 @@ async function decryptRecipientCore(jwe, token, shared, key, joseHeader) {
       encryptedKey = new Uint8Array();
     }
   let resolvedKey = !1;
-  typeof key == "function" && (key = await key(parsedProt, jwe), resolvedKey = !0);
+  typeof key == "function" && (key = await key(protectedHeader, jwe), resolvedKey = !0);
   const algEntry = selected ?? jweAlgorithm(alg);
   isJWECEKTransport(algEntry) && encryptedKey === void 0 && (encryptedKey = new Uint8Array());
-  let k;
-  const mode = algEntry.mode;
-  switch (mode) {
-    case "direct-encryption":
-      k = await prepareKey(encEntry, key, "decrypt");
-      break;
-    case "direct-key-agreement":
-    case "key-wrapping":
-    case "key-encryption":
-    case "key-agreement-with-key-wrapping":
-    case "integrated-encryption":
-      k = await prepareKey(algEntry, key, "decrypt");
-      break;
-    default:
-      invalidJWEKeyManagementMode(mode);
-  }
+  const k = await prepareKey(algEntry.mode === "direct-encryption" ? encEntry : algEntry, key, "decrypt");
   let plaintext;
   if (algEntry.mode === "integrated-encryption")
-    plaintext = await algEntry.decrypt(k, encryptedKey, ciphertext, additionalData, parsedProt, joseHeader);
+    plaintext = await algEntry.decrypt(k, encryptedKey, ciphertext, additionalAuthenticatedData, protectedHeader, joseHeader);
   else {
     const encryption = encEntry;
     let cek;
@@ -169,7 +139,7 @@ async function decryptRecipientCore(jwe, token, shared, key, joseHeader) {
         throw err;
       cek = generateCek(encryption);
     }
-    plaintext = await decrypt(encryption, cek, ciphertext, iv, tag, additionalData);
+    plaintext = await decrypt(encryption, cek, ciphertext, iv, tag, additionalAuthenticatedData);
   }
   if (joseHeader.zip === "DEF") {
     const decompressionLimit = maxDecompressedLength ?? 25e4;
@@ -181,10 +151,16 @@ async function decryptRecipientCore(jwe, token, shared, key, joseHeader) {
       throw cause instanceof JWEInvalid ? cause : new JWEInvalid("Failed to decompress plaintext", { cause });
     });
   }
-  return [plaintext, parsedProt, k, resolvedKey];
-}
-async function decryptJWE(jwe, shared, key) {
-  return decryptRecipient(jwe, shareJWE(jwe), shared, key);
+  return {
+    plaintext,
+    ...protectedHeader && { protectedHeader },
+    ...aad !== void 0 && {
+      additionalAuthenticatedData: decodeBase64url(aad, "aad", JWEInvalid)
+    },
+    ...unprotected && { sharedUnprotectedHeader: unprotected },
+    ...header && { unprotectedHeader: header },
+    ...resolvedKey && { key: k }
+  };
 }
 async function decryptCompact(jwe, shared, key) {
   if (jwe instanceof Uint8Array && (jwe = decoder.decode(jwe)), typeof jwe != "string")
@@ -192,27 +168,18 @@ async function decryptCompact(jwe, shared, key) {
   const { 0: protectedHeader, 1: encryptedKey, 2: iv, 3: ciphertext, 4: tag, length } = jwe.split(".");
   if (length !== 5)
     throw new JWEInvalid("Invalid Compact JWE");
-  const flattened = {
+  return decryptJWE({
     ciphertext,
     iv: iv || void 0,
     protected: protectedHeader,
     tag: tag || void 0,
     encrypted_key: encryptedKey || void 0
-  }, parsedProt = parseJoseHeader(protectedHeader, JWEInvalid, "JWE Protected Header is invalid"), protectedBytes = encode(protectedHeader), token = [
-    parsedProt,
-    decodeBase64url(ciphertext, "ciphertext", JWEInvalid),
-    iv ? decodeBase64url(iv, "iv", JWEInvalid) : void 0,
-    tag ? decodeBase64url(tag, "tag", JWEInvalid) : void 0,
-    protectedBytes
-  ];
-  return decryptRecipientCore(flattened, token, shared, key, parsedProt);
+  }, shared, key);
 }
 export {
   checkRecipient,
   decryptCompact,
   decryptJWE,
-  decryptRecipient,
-  decryptResult,
   prepareDecrypt,
   shareJWE,
   snapshotRecipientJWE,

package/dist/webapi/lib/jwe_encrypt.js

@@ -1,21 +1,22 @@
 import { encode as b64u } from "../util/base64url.js";
-import { checkCekLength, encrypt, generateCek } from "./content_encryption.js";
+import { encrypt } from "./content_encryption.js";
 import { encryptKeyManagement } from "./key_management.js";
 import { JWEInvalid } from "../util/errors.js";
-import { assertUint8Array, isDisjoint, isObject } from "./type_checks.js";
-import { concat, encode } from "./buffer_utils.js";
-import { serializeJoseHeader, validateCrit, validateCritDuplicates, JWE_RECOGNIZED } from "./options.js";
+import { assertUint8Array, isDisjoint, isObject, serializeJoseHeader, validateCrit, validateCritDuplicates, JWE_RECOGNIZED } from "./validate.js";
+import { encode } from "./buffer_utils.js";
 import { prepareKey } from "./key.js";
-import { JWE, invalidJWEKeyManagementMode, isJWECEKTransport, jweAlgorithm, jweEncryption } from "./jwe_algorithms.js";
+import { JWE, jweAlgorithm, jweEncryption } from "./jwe_algorithms.js";
 import { compress, validateZip } from "./deflate.js";
-import { unprotected } from "./helpers.js";
 function checkDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader) {
   if (!isDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader))
     throw new JWEInvalid("JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint");
 }
-function checkEncryptHeaders(input) {
+function checkEncryptHeaders(input, options, sharedHeadersNormalized = !1) {
+  if (!input[1] && !input[2] && !input[3])
+    throw new JWEInvalid("either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()");
+  options !== void 0 && (input[8] = options?.crit);
   let [, protectedHeader, unprotectedHeader, sharedUnprotectedHeader, aad, cek, iv, keyManagementParameters, crit] = input;
-  if (aad !== void 0 && assertUint8Array(aad, "JWE Additional Authenticated Data"), cek !== void 0 && assertUint8Array(cek, "JWE Content Encryption Key"), iv !== void 0 && assertUint8Array(iv, "JWE Initialization Vector"), protectedHeader !== void 0 && (protectedHeader = serializeJoseHeader(JWEInvalid, protectedHeader)[0], input[1] = protectedHeader), unprotectedHeader !== void 0 && (unprotectedHeader = serializeJoseHeader(JWEInvalid, unprotectedHeader)[0], input[2] = unprotectedHeader), sharedUnprotectedHeader !== void 0 && (sharedUnprotectedHeader = serializeJoseHeader(JWEInvalid, sharedUnprotectedHeader)[0], input[3] = sharedUnprotectedHeader), keyManagementParameters !== void 0 && !isObject(keyManagementParameters))
+  if (aad !== void 0 && assertUint8Array(aad, "JWE Additional Authenticated Data"), cek !== void 0 && assertUint8Array(cek, "JWE Content Encryption Key"), iv !== void 0 && assertUint8Array(iv, "JWE Initialization Vector"), !sharedHeadersNormalized && protectedHeader !== void 0 && (protectedHeader = serializeJoseHeader(JWEInvalid, protectedHeader)[0], input[1] = protectedHeader), unprotectedHeader !== void 0 && (unprotectedHeader = serializeJoseHeader(JWEInvalid, unprotectedHeader)[0], input[2] = unprotectedHeader), !sharedHeadersNormalized && sharedUnprotectedHeader !== void 0 && (sharedUnprotectedHeader = serializeJoseHeader(JWEInvalid, sharedUnprotectedHeader)[0], input[3] = sharedUnprotectedHeader), keyManagementParameters !== void 0 && !isObject(keyManagementParameters))
     throw new TypeError("JWE Key Management Parameters must be an object");
   checkDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader);
   const joseHeader = {
@@ -27,82 +28,48 @@ function checkEncryptHeaders(input) {
   const { alg, enc } = joseHeader;
   if (typeof alg != "string" || !alg)
     throw new JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid');
-  if (JWE[alg]?.mode === "integrated-encryption") {
+  const algEntry = JWE[alg];
+  if (algEntry?.mode === "integrated-encryption") {
     if (enc !== void 0)
       throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must not be present for integrated encryption');
     if (cek !== void 0)
       throw new TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${alg}`);
     if (iv !== void 0)
       throw new TypeError(`setInitializationVector cannot be called with JWE "alg" (Algorithm) Header ${alg}`);
-    return [joseHeader, alg, void 0, void 0];
+    return [joseHeader, void 0, algEntry];
   }
   if (typeof enc != "string" || !enc)
     throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');
-  return [joseHeader, alg, enc, jweEncryption(enc)];
-}
-function checkProducedEncryptedKey(encryptedKey) {
-  if (!(encryptedKey instanceof Uint8Array) || !encryptedKey.byteLength)
-    throw new TypeError("JWE key management algorithm did not produce an Encrypted Key");
-}
-async function transportCek(algEntry, encEntry, key, providedCek, joseHeader, providedParameters) {
-  const preparedKey = await prepareKey(algEntry, key, "encrypt"), cek = providedCek ?? generateCek(encEntry);
-  checkCekLength(cek, encEntry.cekBits);
-  const [, encryptedKey, parameters] = await encryptKeyManagement(algEntry, encEntry, preparedKey, joseHeader, cek, providedParameters);
-  return checkProducedEncryptedKey(encryptedKey), [cek, encryptedKey, parameters];
+  return [joseHeader, jweEncryption(enc), algEntry];
 }
-async function encryptJWE(input, checked, key, resolvedAlgEntry) {
-  const [joseHeader, alg, , encEntry] = checked, [inputPlaintext, inputProtectedHeader, inputUnprotectedHeader, sharedUnprotectedHeader, aad, providedCek, inputIv, keyManagementParameters, , unprotectedParameters] = input;
+async function encryptJWE(input, checked, key) {
+  const [joseHeader, encEntry, selected] = checked, [inputPlaintext, inputProtectedHeader, inputUnprotectedHeader, sharedUnprotectedHeader, aad, providedCek, inputIv, keyManagementParameters, , unprotectedParameters] = input;
   let protectedHeader = inputProtectedHeader, unprotectedHeader = inputUnprotectedHeader;
-  const algEntry = resolvedAlgEntry ?? jweAlgorithm(alg);
-  if (providedCek !== void 0 && !isJWECEKTransport(algEntry))
-    throw new TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${alg}`);
-  let encryptedKey, parameters, cek, integratedKey;
-  const mode = algEntry.mode;
-  switch (mode) {
-    case "direct-encryption":
-      cek = await prepareKey(encEntry, key, "encrypt");
-      break;
-    case "direct-key-agreement": {
-      const preparedKey = await prepareKey(algEntry, key, "encrypt");
-      [cek, , parameters] = await encryptKeyManagement(algEntry, encEntry, preparedKey, joseHeader, void 0, keyManagementParameters);
-      break;
-    }
-    case "key-wrapping":
-    case "key-encryption":
-    case "key-agreement-with-key-wrapping":
-      [cek, encryptedKey, parameters] = await transportCek(algEntry, encEntry, key, providedCek, joseHeader, keyManagementParameters);
-      break;
-    case "integrated-encryption":
-      integratedKey = await prepareKey(algEntry, key, "encrypt");
-      break;
-    default:
-      invalidJWEKeyManagementMode(mode);
-  }
-  parameters && (unprotectedParameters ? unprotectedHeader = unprotectedHeader ? { ...unprotectedHeader, ...parameters } : parameters : protectedHeader = protectedHeader ? { ...protectedHeader, ...parameters } : parameters, checkDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader));
-  let protectedHeaderS, protectedHeaderB;
-  protectedHeader ? (protectedHeaderS = b64u(JSON.stringify(protectedHeader)), protectedHeaderB = encode(protectedHeaderS)) : (protectedHeaderS = "", protectedHeaderB = new Uint8Array());
-  let additionalData, aadMember;
-  aad?.byteLength ? (aadMember = b64u(aad), additionalData = concat(protectedHeaderB, encode("."), encode(aadMember))) : additionalData = protectedHeaderB;
+  const algEntry = selected ?? jweAlgorithm(joseHeader.alg);
+  let encryptedKey, parameters, cek;
+  algEntry.mode === "integrated-encryption" ? cek = await prepareKey(algEntry, key, "encrypt") : [cek, encryptedKey, parameters] = await encryptKeyManagement(algEntry, encEntry, key, joseHeader, providedCek, keyManagementParameters), parameters && (unprotectedParameters ? unprotectedHeader = unprotectedHeader ? { ...unprotectedHeader, ...parameters } : parameters : protectedHeader = protectedHeader ? { ...protectedHeader, ...parameters } : parameters, checkDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader));
+  const encodedProtectedHeader = protectedHeader ? b64u(JSON.stringify(protectedHeader)) : "", encodedAad = aad?.byteLength ? b64u(aad) : void 0, additionalAuthenticatedData = encode(encodedAad ? `${encodedProtectedHeader}.${encodedAad}` : encodedProtectedHeader);
   let plaintext = inputPlaintext;
   joseHeader.zip === "DEF" && (plaintext = await compress(plaintext).catch((cause) => {
     throw new JWEInvalid("Failed to compress plaintext", { cause });
   }));
   let ciphertext, tag, iv;
-  algEntry.mode === "integrated-encryption" ? [encryptedKey, ciphertext] = await algEntry.encrypt(integratedKey, plaintext, additionalData, protectedHeader, joseHeader, keyManagementParameters) : { ciphertext, tag, iv } = await encrypt(encEntry, plaintext, cek, inputIv, additionalData);
+  algEntry.mode === "integrated-encryption" ? [encryptedKey, ciphertext] = await algEntry.encrypt(cek, plaintext, additionalAuthenticatedData, protectedHeader, joseHeader, keyManagementParameters) : { ciphertext, tag, iv } = await encrypt(encEntry, plaintext, cek, inputIv, additionalAuthenticatedData);
   const jwe = {
     ciphertext: b64u(ciphertext)
   };
-  return iv && (jwe.iv = b64u(iv)), tag && (jwe.tag = b64u(tag)), encryptedKey?.byteLength && (jwe.encrypted_key = b64u(encryptedKey)), aadMember && (jwe.aad = aadMember), protectedHeader && (jwe.protected = protectedHeaderS), sharedUnprotectedHeader && (jwe.unprotected = sharedUnprotectedHeader), unprotectedHeader && (jwe.header = unprotectedHeader), jwe;
+  return iv && (jwe.iv = b64u(iv)), tag && (jwe.tag = b64u(tag)), encryptedKey?.byteLength && (jwe.encrypted_key = b64u(encryptedKey)), encodedAad && (jwe.aad = encodedAad), protectedHeader && (jwe.protected = encodedProtectedHeader), sharedUnprotectedHeader && (jwe.unprotected = sharedUnprotectedHeader), unprotectedHeader && (jwe.header = unprotectedHeader), jwe;
 }
 async function createJWE(input, key, options) {
-  if (!input[1] && !input[2] && !input[3])
-    throw new JWEInvalid("either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()");
-  return options !== void 0 && (input[8] = options?.crit, input[9] = options ? unprotected in options : !1), encryptJWE(input, checkEncryptHeaders(input), key);
+  return encryptJWE(input, checkEncryptHeaders(input, options), key);
+}
+function compactJWE(jwe) {
+  return [jwe.protected, jwe.encrypted_key, jwe.iv, jwe.ciphertext, jwe.tag].join(".");
 }
 export {
   checkDisjoint,
   checkEncryptHeaders,
+  compactJWE,
   createJWE,
-  encryptJWE,
-  transportCek
+  encryptJWE
 };

package/dist/webapi/lib/jws_algorithms.js

@@ -34,8 +34,8 @@ function eddsa() {
     usages: sig
   };
 }
-function mldsa(bits) {
-  const subtle = { name: `ML-DSA-${bits}` };
+function mldsa(parameterSet) {
+  const subtle = { name: `ML-DSA-${parameterSet}` };
   return {
     kty: ["AKP"],
     subtle,