jose 6.1.3 → 6.2.0

package/dist/types/jwe/general/decrypt.d.ts

@@ -16,6 +16,13 @@ export interface GeneralDecryptGetKey extends types.GetKeyFunction<types.JWEHead
  * This function is exported (as a named export) from the main `'jose'` module entry point as well
  * as from its subpath export `'jose/jwe/general/decrypt'`.
  *
+ * > [!NOTE]\
+ * > The function iterates over the `recipients` array in the General JWE and returns the decryption
+ * > result of the first recipient entry that can be successfully decrypted. The result only contains
+ * > the plaintext and headers of that successfully decrypted recipient entry. Other recipient entries
+ * > in the General JWE are not validated, and their headers are not included in the returned result.
+ * > Recipients of a General JWE should only rely on the returned (decrypted) data.
+ *
  * @param jwe General JWE.
  * @param key Private Key or Secret to decrypt the JWE with. See
  *   {@link https://github.com/panva/jose/issues/210#jwe-alg Algorithm Key Requirements}.

package/dist/types/jws/general/verify.d.ts

@@ -18,6 +18,14 @@ export interface GeneralVerifyGetKey extends types.GenericGetKeyFunction<types.J
  * This function is exported (as a named export) from the main `'jose'` module entry point as well
  * as from its subpath export `'jose/jws/general/verify'`.
  *
+ * > [!NOTE]\
+ * > The function iterates over the `signatures` array in the General JWS and returns the verification
+ * > result of the first signature entry that can be successfully verified. The result only contains
+ * > the payload, protected header, and unprotected header of that successfully verified signature
+ * > entry. Other signature entries in the General JWS are not validated, and their headers are not
+ * > included in the returned result. Recipients of a General JWS should only rely on the returned
+ * > (verified) data.
+ *
  * @param jws General JWS.
  * @param key Key to verify the JWS with. See
  *   {@link https://github.com/panva/jose/issues/210#jws-alg Algorithm Key Requirements}.

package/dist/types/types.d.ts

@@ -415,12 +415,12 @@ export interface JWEHeaderParameters extends JoseHeaderParameters {
   crit?: string[]
 
   /**
-   * JWE "zip" (Compression Algorithm) Header Parameter. This parameter is not supported anymore.
+   * JWE "zip" (Compression Algorithm) Header Parameter.
    *
-   * @deprecated Compression of data SHOULD NOT be done before encryption, because such compressed
-   *   data often reveals information about the plaintext.
+   * The only supported value is `"DEF"` (DEFLATE). Requires the `CompressionStream` /
+   * `DecompressionStream` APIs to be available in the runtime.
    *
-   * @see {@link https://www.rfc-editor.org/rfc/rfc8725#name-avoid-compression-of-encryp Avoid Compression of Encryption Inputs}
+   * @see {@link https://www.rfc-editor.org/rfc/rfc7516#section-4.1.3 JWE "zip" Header Parameter}
    */
   zip?: string
 
@@ -474,6 +474,17 @@ export interface DecryptOptions extends CritOption {
    * this value is set to 10000.
    */
   maxPBES2Count?: number
+
+  /**
+   * Maximum allowed size (in bytes) of the decompressed plaintext when the JWE `"zip"` (Compression
+   * Algorithm) Header Parameter is present. By default this value is set to 250000 (250 KB). The
+   * value must be `0`, a positive safe integer, or `Infinity`.
+   *
+   * Set to `0` to reject all compressed JWEs during decryption.
+   *
+   * Set to `Infinity` to disable the decompressed size limit.
+   */
+  maxDecompressedLength?: number
 }
 
 /** JWE Encryption options. */

package/dist/webapi/jwe/flattened/decrypt.js

@@ -10,6 +10,7 @@ import { validateCrit } from '../../lib/validate_crit.js';
 import { validateAlgorithms } from '../../lib/validate_algorithms.js';
 import { normalizeKey } from '../../lib/normalize_key.js';
 import { checkKeyType } from '../../lib/check_key_type.js';
+import { decompress } from '../../lib/deflate.js';
 export async function flattenedDecrypt(jwe, key, options) {
     if (!isObject(jwe)) {
         throw new JWEInvalid('Flattened JWE must be an object');
@@ -60,8 +61,11 @@ export async function flattenedDecrypt(jwe, key, options) {
         ...jwe.unprotected,
     };
     validateCrit(JWEInvalid, new Map(), options?.crit, parsedProt, joseHeader);
-    if (joseHeader.zip !== undefined) {
-        throw new JOSENotSupported('JWE "zip" (Compression Algorithm) Header Parameter is not supported.');
+    if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
+        throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
+    }
+    if (joseHeader.zip !== undefined && !parsedProt?.zip) {
+        throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
     }
     const { alg, enc } = joseHeader;
     if (typeof alg !== 'string' || !alg) {
@@ -141,6 +145,17 @@ export async function flattenedDecrypt(jwe, key, options) {
     }
     const plaintext = await decrypt(enc, cek, ciphertext, iv, tag, additionalData);
     const result = { plaintext };
+    if (joseHeader.zip === 'DEF') {
+        const maxDecompressedLength = options?.maxDecompressedLength ?? 250_000;
+        if (maxDecompressedLength === 0) {
+            throw new JOSENotSupported('JWE "zip" (Compression Algorithm) Header Parameter is not supported.');
+        }
+        if (maxDecompressedLength !== Infinity &&
+            (!Number.isSafeInteger(maxDecompressedLength) || maxDecompressedLength < 1)) {
+            throw new TypeError('maxDecompressedLength must be 0, a positive safe integer, or Infinity');
+        }
+        result.plaintext = await decompress(plaintext, maxDecompressedLength);
+    }
     if (jwe.protected !== undefined) {
         result.protectedHeader = parsedProt;
     }

package/dist/webapi/jwe/flattened/encrypt.js

@@ -8,6 +8,7 @@ import { concat, encode } from '../../lib/buffer_utils.js';
 import { validateCrit } from '../../lib/validate_crit.js';
 import { normalizeKey } from '../../lib/normalize_key.js';
 import { checkKeyType } from '../../lib/check_key_type.js';
+import { compress } from '../../lib/deflate.js';
 export class FlattenedEncrypt {
     #plaintext;
     #protectedHeader;
@@ -82,8 +83,11 @@ export class FlattenedEncrypt {
             ...this.#sharedUnprotectedHeader,
         };
         validateCrit(JWEInvalid, new Map(), options?.crit, this.#protectedHeader, joseHeader);
-        if (joseHeader.zip !== undefined) {
-            throw new JOSENotSupported('JWE "zip" (Compression Algorithm) Header Parameter is not supported.');
+        if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
+            throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
+        }
+        if (joseHeader.zip !== undefined && !this.#protectedHeader?.zip) {
+            throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
         }
         const { alg, enc } = joseHeader;
         if (typeof alg !== 'string' || !alg) {
@@ -139,7 +143,11 @@ export class FlattenedEncrypt {
         else {
             additionalData = protectedHeaderB;
         }
-        const { ciphertext, tag, iv } = await encrypt(enc, this.#plaintext, cek, this.#iv, additionalData);
+        let plaintext = this.#plaintext;
+        if (joseHeader.zip === 'DEF') {
+            plaintext = await compress(plaintext);
+        }
+        const { ciphertext, tag, iv } = await encrypt(enc, plaintext, cek, this.#iv, additionalData);
         const jwe = {
             ciphertext: b64u(ciphertext),
         };

package/dist/webapi/jwe/general/encrypt.js

@@ -133,8 +133,11 @@ export class GeneralEncrypt {
                 throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must be the same for all recipients');
             }
             validateCrit(JWEInvalid, new Map(), recipient.options.crit, this.#protectedHeader, joseHeader);
-            if (joseHeader.zip !== undefined) {
-                throw new JOSENotSupported('JWE "zip" (Compression Algorithm) Header Parameter is not supported.');
+            if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
+                throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
+            }
+            if (joseHeader.zip !== undefined && !this.#protectedHeader?.zip) {
+                throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
             }
         }
         const cek = generateCek(enc);

package/dist/webapi/jwks/remote.js

@@ -9,7 +9,7 @@ function isCloudflareWorkers() {
 let USER_AGENT;
 if (typeof navigator === 'undefined' || !navigator.userAgent?.startsWith?.('Mozilla/5.0 ')) {
     const NAME = 'jose';
-    const VERSION = 'v6.1.3';
+    const VERSION = 'v6.2.0';
     USER_AGENT = `${NAME}/${VERSION}`;
 }
 export const customFetch = Symbol();

package/dist/webapi/lib/deflate.js

@@ -0,0 +1,44 @@
+import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
+import { concat } from './buffer_utils.js';
+function supported(name) {
+    if (typeof globalThis[name] === 'undefined') {
+        throw new JOSENotSupported(`JWE "zip" (Compression Algorithm) Header Parameter requires the ${name} API.`);
+    }
+}
+export async function compress(input) {
+    supported('CompressionStream');
+    const cs = new CompressionStream('deflate-raw');
+    const writer = cs.writable.getWriter();
+    writer.write(input);
+    writer.close();
+    const chunks = [];
+    const reader = cs.readable.getReader();
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        chunks.push(value);
+    }
+    return concat(...chunks);
+}
+export async function decompress(input, maxLength) {
+    supported('DecompressionStream');
+    const ds = new DecompressionStream('deflate-raw');
+    const writer = ds.writable.getWriter();
+    writer.write(input);
+    writer.close();
+    const chunks = [];
+    let length = 0;
+    const reader = ds.readable.getReader();
+    for (;;) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        chunks.push(value);
+        length += value.byteLength;
+        if (maxLength !== Infinity && length > maxLength) {
+            throw new JWEInvalid('Decompressed plaintext exceeded the configured limit');
+        }
+    }
+    return concat(...chunks);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jose",
-  "version": "6.1.3",
+  "version": "6.2.0",
   "description": "JWA, JWS, JWE, JWT, JWK, JWKS for Node.js, Browser, Cloudflare Workers, Deno, Bun, and other Web-interoperable runtimes",
   "keywords": [
     "akp",