jose 4.1.2 → 4.2.0

package/README.md

@@ -37,7 +37,7 @@ If you or your business use `jose`, please consider becoming a [sponsor][support
   - [Public Key Import (X.509 Certificate)](docs/functions/key_import.importX509.md#readme)
   - [Private Key Import (PKCS #8)](docs/functions/key_import.importPKCS8.md#readme)
 - JSON Web Encryption (JWE)
-  - Encryption - [Compact](docs/classes/jwe_compact_encrypt.CompactEncrypt.md#readme), [Flattened](docs/classes/jwe_flattened_encrypt.FlattenedEncrypt.md#readme)
+  - Encryption - [Compact](docs/classes/jwe_compact_encrypt.CompactEncrypt.md#readme), [Flattened](docs/classes/jwe_flattened_encrypt.FlattenedEncrypt.md#readme), [General](docs/classes/jwe_general_encrypt.GeneralEncrypt.md#readme)
   - Decryption - [Compact](docs/functions/jwe_compact_decrypt.compactDecrypt.md#readme), [Flattened](docs/functions/jwe_flattened_decrypt.flattenedDecrypt.md#readme), [General](docs/functions/jwe_general_decrypt.generalDecrypt.md#readme)
 - JSON Web Signature (JWS)
   - Signing - [Compact](docs/classes/jws_compact_sign.CompactSign.md#readme), [Flattened](docs/classes/jws_flattened_sign.FlattenedSign.md#readme), [General](docs/classes/jws_general_sign.GeneralSign.md#readme)
@@ -65,6 +65,7 @@ If you or your business use `jose`, please consider becoming a [sponsor][support
 - [Cloudflare Workers Support][]
 - [Deno Support][]
 - [Electron Support][]
+- [Next.js Middleware / Vercel Edge Functions Support][]
 - [Node.js Support][]
 
 ## FAQ
@@ -133,8 +134,10 @@ install size should not be a cause for concern.
 [webcrypto]: https://www.w3.org/TR/WebCryptoAPI/
 [nodewebcrypto]: https://nodejs.org/docs/latest-v15.x/api/webcrypto.html
 [deno.land/x/jose]: https://deno.land/x/jose
+
 [Browser Support]: https://github.com/panva/jose/issues/263
 [Cloudflare Workers Support]: https://github.com/panva/jose/issues/265
 [Deno Support]: https://github.com/panva/jose/issues/266
 [Electron Support]: https://github.com/panva/jose/issues/264
+[Next.js Middleware / Vercel Edge Functions Support]: https://github.com/panva/jose/issues/301
 [Node.js Support]: https://github.com/panva/jose/issues/262

package/dist/browser/index.js

@@ -1,6 +1,7 @@
 export { compactDecrypt } from './jwe/compact/decrypt.js';
 export { flattenedDecrypt } from './jwe/flattened/decrypt.js';
 export { generalDecrypt } from './jwe/general/decrypt.js';
+export { GeneralEncrypt } from './jwe/general/encrypt.js';
 export { compactVerify } from './jws/compact/verify.js';
 export { flattenedVerify } from './jws/flattened/verify.js';
 export { generalVerify } from './jws/general/verify.js';

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

@@ -7,6 +7,7 @@ import { JOSENotSupported, JWEInvalid } from '../../util/errors.js';
 import isDisjoint from '../../lib/is_disjoint.js';
 import { encoder, decoder, concat } from '../../lib/buffer_utils.js';
 import validateCrit from '../../lib/validate_crit.js';
+export const unprotected = Symbol();
 export class FlattenedEncrypt {
     constructor(plaintext) {
         if (!(plaintext instanceof Uint8Array)) {
@@ -65,7 +66,7 @@ export class FlattenedEncrypt {
             throw new JWEInvalid('either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()');
         }
         if (!isDisjoint(this._protectedHeader, this._unprotectedHeader, this._sharedUnprotectedHeader)) {
-            throw new JWEInvalid('JWE Shared Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
+            throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
         }
         const joseHeader = {
             ...this._protectedHeader,
@@ -104,11 +105,21 @@ export class FlattenedEncrypt {
             let parameters;
             ({ cek, encryptedKey, parameters } = await encryptKeyManagement(alg, enc, key, this._cek, this._keyManagementParameters));
             if (parameters) {
-                if (!this._protectedHeader) {
-                    this.setProtectedHeader(parameters);
+                if (options && unprotected in options) {
+                    if (!this._unprotectedHeader) {
+                        this.setUnprotectedHeader(parameters);
+                    }
+                    else {
+                        this._unprotectedHeader = { ...this._unprotectedHeader, ...parameters };
+                    }
                 }
                 else {
-                    this._protectedHeader = { ...this._protectedHeader, ...parameters };
+                    if (!this._protectedHeader) {
+                        this.setProtectedHeader(parameters);
+                    }
+                    else {
+                        this._protectedHeader = { ...this._protectedHeader, ...parameters };
+                    }
                 }
             }
         }

package/dist/browser/jwe/general/decrypt.js

@@ -8,6 +8,9 @@ export async function generalDecrypt(jwe, key, options) {
     if (!Array.isArray(jwe.recipients) || !jwe.recipients.every(isObject)) {
         throw new JWEInvalid('JWE Recipients missing or incorrect type');
     }
+    if (!jwe.recipients.length) {
+        throw new JWEInvalid('JWE Recipients has no members');
+    }
     for (const recipient of jwe.recipients) {
         try {
             return await flattenedDecrypt({

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

@@ -0,0 +1,161 @@
+import { FlattenedEncrypt, unprotected } from '../flattened/encrypt.js';
+import { JWEInvalid } from '../../util/errors.js';
+import generateCek from '../../lib/cek.js';
+import isDisjoint from '../../lib/is_disjoint.js';
+import encryptKeyManagement from '../../lib/encrypt_key_management.js';
+import { encode as base64url } from '../../runtime/base64url.js';
+import validateCrit from '../../lib/validate_crit.js';
+const recipientRef = new WeakMap();
+class IndividualRecipient {
+    setUnprotectedHeader(unprotectedHeader) {
+        if (this._unprotectedHeader) {
+            throw new TypeError('setUnprotectedHeader can only be called once');
+        }
+        this._unprotectedHeader = unprotectedHeader;
+        return this;
+    }
+    set _unprotectedHeader(value) {
+        recipientRef.get(this).unprotectedHeader = value;
+    }
+    get _unprotectedHeader() {
+        return recipientRef.get(this).unprotectedHeader;
+    }
+}
+export class GeneralEncrypt {
+    constructor(plaintext) {
+        this._recipients = [];
+        this._plaintext = plaintext;
+    }
+    addRecipient(key, options) {
+        const recipient = new IndividualRecipient();
+        recipientRef.set(recipient, { key, options: { crit: options === null || options === void 0 ? void 0 : options.crit } });
+        this._recipients.push(recipient);
+        return recipient;
+    }
+    setProtectedHeader(protectedHeader) {
+        if (this._protectedHeader) {
+            throw new TypeError('setProtectedHeader can only be called once');
+        }
+        this._protectedHeader = protectedHeader;
+        return this;
+    }
+    setSharedUnprotectedHeader(sharedUnprotectedHeader) {
+        if (this._unprotectedHeader) {
+            throw new TypeError('setSharedUnprotectedHeader can only be called once');
+        }
+        this._unprotectedHeader = sharedUnprotectedHeader;
+        return this;
+    }
+    setAdditionalAuthenticatedData(aad) {
+        this._aad = aad;
+        return this;
+    }
+    async encrypt(options) {
+        var _a, _b;
+        if (!this._recipients.length) {
+            throw new JWEInvalid('at least one recipient must be added');
+        }
+        options = { deflateRaw: options === null || options === void 0 ? void 0 : options.deflateRaw };
+        if (this._recipients.length === 1) {
+            const { unprotectedHeader, options: recipientOpts, key, } = recipientRef.get(this._recipients[0]);
+            const flattened = await new FlattenedEncrypt(this._plaintext)
+                .setAdditionalAuthenticatedData(this._aad)
+                .setProtectedHeader(this._protectedHeader)
+                .setSharedUnprotectedHeader(this._unprotectedHeader)
+                .setUnprotectedHeader(unprotectedHeader)
+                .encrypt(key, { ...recipientOpts, ...options });
+            let jwe = {
+                ciphertext: flattened.ciphertext,
+                iv: flattened.iv,
+                recipients: [{}],
+                tag: flattened.tag,
+            };
+            if (flattened.aad)
+                jwe.aad = flattened.aad;
+            if (flattened.protected)
+                jwe.protected = flattened.protected;
+            if (flattened.unprotected)
+                jwe.unprotected = flattened.unprotected;
+            if (flattened.encrypted_key)
+                jwe.recipients[0].encrypted_key = flattened.encrypted_key;
+            if (flattened.header)
+                jwe.recipients[0].header = flattened.header;
+            return jwe;
+        }
+        let enc;
+        for (let i = 0; i < this._recipients.length; i++) {
+            const recipient = this._recipients[i];
+            const { unprotectedHeader, options: recipientOpts } = recipientRef.get(recipient);
+            if (!isDisjoint(this._protectedHeader, this._unprotectedHeader, unprotectedHeader)) {
+                throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
+            }
+            const joseHeader = {
+                ...this._protectedHeader,
+                ...this._unprotectedHeader,
+                ...unprotectedHeader,
+            };
+            const { alg } = joseHeader;
+            if (typeof alg !== 'string' || !alg) {
+                throw new JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid');
+            }
+            if (alg === 'dir' || alg === 'ECDH-ES') {
+                throw new JWEInvalid('"dir" and "ECDH-ES" alg may only be used with a single recipient');
+            }
+            if (typeof joseHeader.enc !== 'string' || !joseHeader.enc) {
+                throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');
+            }
+            if (!enc) {
+                enc = joseHeader.enc;
+            }
+            else if (enc !== joseHeader.enc) {
+                throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must be the same for all recipients');
+            }
+            validateCrit(JWEInvalid, new Map(), recipientOpts === null || recipientOpts === void 0 ? void 0 : recipientOpts.crit, this._protectedHeader, joseHeader);
+            if (joseHeader.zip !== undefined) {
+                if (!this._protectedHeader || !this._protectedHeader.zip) {
+                    throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');
+                }
+            }
+        }
+        const cek = generateCek(enc);
+        let jwe = {
+            ciphertext: '',
+            iv: '',
+            recipients: [],
+            tag: '',
+        };
+        for (let i = 0; i < this._recipients.length; i++) {
+            const recipient = this._recipients[i];
+            const target = {};
+            jwe.recipients.push(target);
+            const { unprotectedHeader, options: recipientOpts, key } = recipientRef.get(recipient);
+            if (i === 0) {
+                const flattened = await new FlattenedEncrypt(this._plaintext)
+                    .setAdditionalAuthenticatedData(this._aad)
+                    .setContentEncryptionKey(cek)
+                    .setProtectedHeader(this._protectedHeader)
+                    .setSharedUnprotectedHeader(this._unprotectedHeader)
+                    .setUnprotectedHeader(unprotectedHeader)
+                    .encrypt(key, { ...recipientOpts, ...options, [unprotected]: true });
+                jwe.ciphertext = flattened.ciphertext;
+                jwe.iv = flattened.iv;
+                jwe.tag = flattened.tag;
+                if (flattened.aad)
+                    jwe.aad = flattened.aad;
+                if (flattened.protected)
+                    jwe.protected = flattened.protected;
+                if (flattened.unprotected)
+                    jwe.unprotected = flattened.unprotected;
+                target.encrypted_key = flattened.encrypted_key;
+                if (flattened.header)
+                    target.header = flattened.header;
+                continue;
+            }
+            const { encryptedKey, parameters } = await encryptKeyManagement((unprotectedHeader === null || unprotectedHeader === void 0 ? void 0 : unprotectedHeader.alg) || ((_a = this._protectedHeader) === null || _a === void 0 ? void 0 : _a.alg) || ((_b = this._unprotectedHeader) === null || _b === void 0 ? void 0 : _b.alg), enc, key, cek);
+            target.encrypted_key = base64url(encryptedKey);
+            if (unprotectedHeader || parameters)
+                target.header = { ...unprotectedHeader, ...parameters };
+        }
+        return jwe;
+    }
+}

package/dist/browser/key/import.js

@@ -62,7 +62,8 @@ function parseElement(bytes) {
     };
 }
 function spkiFromX509(buf) {
-    return encodeBase64(getElement(getElement(parseElement(buf).contents)[0].contents)[6].raw);
+    const tbsCertificate = getElement(getElement(parseElement(buf).contents)[0].contents);
+    return encodeBase64(tbsCertificate[tbsCertificate[0].raw[0] === 0xa0 ? 6 : 5].raw);
 }
 function getSPKI(x509) {
     const pem = x509.replace(/(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g, '');

package/dist/browser/lib/crypto_key.js

@@ -1,4 +1,4 @@
-import { isCloudflareWorkers, isNodeJs } from '../runtime/global.js';
+import { isCloudflareWorkers, isNodeJs } from '../runtime/env.js';
 function unusable(name, prop = 'algorithm.name') {
     return new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
 }

package/dist/browser/runtime/asn1.js

@@ -1,4 +1,4 @@
-import globalThis, { isCloudflareWorkers, isNodeJs } from './global.js';
+import { isCloudflareWorkers, isNodeJs } from './env.js';
 import crypto, { isCryptoKey } from './webcrypto.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
 import { encodeBase64 } from './base64url.js';
@@ -54,8 +54,7 @@ const genericImport = async (replace, keyFormat, pem, alg, options) => {
     var _a;
     let algorithm;
     let keyUsages;
-    const keyData = new Uint8Array(globalThis
-        .atob(pem.replace(replace, ''))
+    const keyData = new Uint8Array(atob(pem.replace(replace, ''))
         .split('')
         .map((c) => c.charCodeAt(0)));
     const isPublic = keyFormat === 'spki';

package/dist/browser/runtime/base64url.js

@@ -1,5 +1,4 @@
 import { encoder, decoder } from '../lib/buffer_utils.js';
-import globalThis from './global.js';
 export const encodeBase64 = (input) => {
     let unencoded = input;
     if (typeof unencoded === 'string') {
@@ -10,14 +9,13 @@ export const encodeBase64 = (input) => {
     for (let i = 0; i < unencoded.length; i += CHUNK_SIZE) {
         arr.push(String.fromCharCode.apply(null, unencoded.subarray(i, i + CHUNK_SIZE)));
     }
-    return globalThis.btoa(arr.join(''));
+    return btoa(arr.join(''));
 };
 export const encode = (input) => {
     return encodeBase64(input).replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
 };
 export const decodeBase64 = (encoded) => {
-    return new Uint8Array(globalThis
-        .atob(encoded)
+    return new Uint8Array(atob(encoded)
         .split('')
         .map((c) => c.charCodeAt(0)));
 };

package/dist/browser/runtime/check_key_length.js

@@ -1,11 +1,4 @@
 export default (alg, key) => {
-    if (alg.startsWith('HS')) {
-        const bitlen = parseInt(alg.substr(-3), 10);
-        const { length } = key.algorithm;
-        if (typeof length !== 'number' || length < bitlen) {
-            throw new TypeError(`${alg} requires symmetric keys to be ${bitlen} bits or larger`);
-        }
-    }
     if (alg.startsWith('RS') || alg.startsWith('PS')) {
         const { modulusLength } = key.algorithm;
         if (typeof modulusLength !== 'number' || modulusLength < 2048) {

package/dist/browser/runtime/env.js

@@ -0,0 +1,11 @@
+export function isCloudflareWorkers() {
+    return typeof WebSocketPair === 'function';
+}
+export function isNodeJs() {
+    try {
+        return process.versions.node !== undefined;
+    }
+    catch (_a) {
+        return false;
+    }
+}

package/dist/browser/runtime/fetch_jwks.js

@@ -1,5 +1,5 @@
 import { JOSEError, JWKSTimeout } from '../util/errors.js';
-import globalThis, { isCloudflareWorkers } from './global.js';
+import { isCloudflareWorkers } from './env.js';
 const fetchJwks = async (url, timeout) => {
     let controller;
     let id;
@@ -11,8 +11,7 @@ const fetchJwks = async (url, timeout) => {
             controller.abort();
         }, timeout);
     }
-    const response = await globalThis
-        .fetch(url.href, {
+    const response = await fetch(url.href, {
         signal: controller ? controller.signal : undefined,
         redirect: 'manual',
         method: 'GET',
@@ -23,8 +22,7 @@ const fetchJwks = async (url, timeout) => {
                 mode: 'cors',
             }
             : undefined),
-    })
-        .catch((err) => {
+    }).catch((err) => {
         if (timedOut)
             throw new JWKSTimeout();
         throw err;

package/dist/browser/runtime/generate.js

@@ -1,4 +1,4 @@
-import { isCloudflareWorkers, isNodeJs } from './global.js';
+import { isCloudflareWorkers, isNodeJs } from './env.js';
 import crypto from './webcrypto.js';
 import { JOSENotSupported } from '../util/errors.js';
 import random from './random.js';

package/dist/browser/runtime/jwk_to_key.js

@@ -1,4 +1,4 @@
-import { isCloudflareWorkers, isNodeJs } from './global.js';
+import { isCloudflareWorkers, isNodeJs } from './env.js';
 import crypto from './webcrypto.js';
 import { JOSENotSupported } from '../util/errors.js';
 import { decode as base64url } from './base64url.js';

package/dist/browser/runtime/subtle_dsa.js

@@ -1,4 +1,4 @@
-import { isCloudflareWorkers, isNodeJs } from './global.js';
+import { isCloudflareWorkers, isNodeJs } from './env.js';
 import { JOSENotSupported } from '../util/errors.js';
 export default function subtleDsa(alg, namedCurve) {
     const length = parseInt(alg.substr(-3), 10);

package/dist/browser/runtime/webcrypto.js

@@ -1,8 +1,12 @@
-import globalThis from './global.js';
-export default globalThis.crypto;
+export default crypto;
 export function isCryptoKey(key) {
-    if (typeof globalThis.CryptoKey === 'undefined') {
+    try {
+        return (key != null &&
+            typeof key.extractable === 'boolean' &&
+            typeof key.algorithm.name === 'string' &&
+            typeof key.type === 'string');
+    }
+    catch (_a) {
         return false;
     }
-    return key != null && key instanceof globalThis.CryptoKey;
 }

package/dist/node/cjs/index.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.base64url = exports.generateSecret = exports.generateKeyPair = exports.errors = exports.decodeProtectedHeader = exports.importJWK = exports.importX509 = exports.importPKCS8 = exports.importSPKI = exports.exportJWK = exports.exportSPKI = exports.exportPKCS8 = exports.UnsecuredJWT = exports.createRemoteJWKSet = exports.EmbeddedJWK = exports.calculateJwkThumbprint = exports.EncryptJWT = exports.SignJWT = exports.GeneralSign = exports.FlattenedSign = exports.CompactSign = exports.FlattenedEncrypt = exports.CompactEncrypt = exports.jwtDecrypt = exports.jwtVerify = exports.generalVerify = exports.flattenedVerify = exports.compactVerify = exports.generalDecrypt = exports.flattenedDecrypt = exports.compactDecrypt = void 0;
+exports.base64url = exports.generateSecret = exports.generateKeyPair = exports.errors = exports.decodeProtectedHeader = exports.importJWK = exports.importX509 = exports.importPKCS8 = exports.importSPKI = exports.exportJWK = exports.exportSPKI = exports.exportPKCS8 = exports.UnsecuredJWT = exports.createRemoteJWKSet = exports.EmbeddedJWK = exports.calculateJwkThumbprint = exports.EncryptJWT = exports.SignJWT = exports.GeneralSign = exports.FlattenedSign = exports.CompactSign = exports.FlattenedEncrypt = exports.CompactEncrypt = exports.jwtDecrypt = exports.jwtVerify = exports.generalVerify = exports.flattenedVerify = exports.compactVerify = exports.GeneralEncrypt = exports.generalDecrypt = exports.flattenedDecrypt = exports.compactDecrypt = void 0;
 var decrypt_js_1 = require("./jwe/compact/decrypt.js");
 Object.defineProperty(exports, "compactDecrypt", { enumerable: true, get: function () { return decrypt_js_1.compactDecrypt; } });
 var decrypt_js_2 = require("./jwe/flattened/decrypt.js");
 Object.defineProperty(exports, "flattenedDecrypt", { enumerable: true, get: function () { return decrypt_js_2.flattenedDecrypt; } });
 var decrypt_js_3 = require("./jwe/general/decrypt.js");
 Object.defineProperty(exports, "generalDecrypt", { enumerable: true, get: function () { return decrypt_js_3.generalDecrypt; } });
+var encrypt_js_1 = require("./jwe/general/encrypt.js");
+Object.defineProperty(exports, "GeneralEncrypt", { enumerable: true, get: function () { return encrypt_js_1.GeneralEncrypt; } });
 var verify_js_1 = require("./jws/compact/verify.js");
 Object.defineProperty(exports, "compactVerify", { enumerable: true, get: function () { return verify_js_1.compactVerify; } });
 var verify_js_2 = require("./jws/flattened/verify.js");
@@ -17,10 +19,10 @@ var verify_js_4 = require("./jwt/verify.js");
 Object.defineProperty(exports, "jwtVerify", { enumerable: true, get: function () { return verify_js_4.jwtVerify; } });
 var decrypt_js_4 = require("./jwt/decrypt.js");
 Object.defineProperty(exports, "jwtDecrypt", { enumerable: true, get: function () { return decrypt_js_4.jwtDecrypt; } });
-var encrypt_js_1 = require("./jwe/compact/encrypt.js");
-Object.defineProperty(exports, "CompactEncrypt", { enumerable: true, get: function () { return encrypt_js_1.CompactEncrypt; } });
-var encrypt_js_2 = require("./jwe/flattened/encrypt.js");
-Object.defineProperty(exports, "FlattenedEncrypt", { enumerable: true, get: function () { return encrypt_js_2.FlattenedEncrypt; } });
+var encrypt_js_2 = require("./jwe/compact/encrypt.js");
+Object.defineProperty(exports, "CompactEncrypt", { enumerable: true, get: function () { return encrypt_js_2.CompactEncrypt; } });
+var encrypt_js_3 = require("./jwe/flattened/encrypt.js");
+Object.defineProperty(exports, "FlattenedEncrypt", { enumerable: true, get: function () { return encrypt_js_3.FlattenedEncrypt; } });
 var sign_js_1 = require("./jws/compact/sign.js");
 Object.defineProperty(exports, "CompactSign", { enumerable: true, get: function () { return sign_js_1.CompactSign; } });
 var sign_js_2 = require("./jws/flattened/sign.js");
@@ -29,8 +31,8 @@ var sign_js_3 = require("./jws/general/sign.js");
 Object.defineProperty(exports, "GeneralSign", { enumerable: true, get: function () { return sign_js_3.GeneralSign; } });
 var sign_js_4 = require("./jwt/sign.js");
 Object.defineProperty(exports, "SignJWT", { enumerable: true, get: function () { return sign_js_4.SignJWT; } });
-var encrypt_js_3 = require("./jwt/encrypt.js");
-Object.defineProperty(exports, "EncryptJWT", { enumerable: true, get: function () { return encrypt_js_3.EncryptJWT; } });
+var encrypt_js_4 = require("./jwt/encrypt.js");
+Object.defineProperty(exports, "EncryptJWT", { enumerable: true, get: function () { return encrypt_js_4.EncryptJWT; } });
 var thumbprint_js_1 = require("./jwk/thumbprint.js");
 Object.defineProperty(exports, "calculateJwkThumbprint", { enumerable: true, get: function () { return thumbprint_js_1.calculateJwkThumbprint; } });
 var embedded_js_1 = require("./jwk/embedded.js");

package/dist/node/cjs/jwe/flattened/encrypt.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlattenedEncrypt = void 0;
+exports.FlattenedEncrypt = exports.unprotected = void 0;
 const base64url_js_1 = require("../../runtime/base64url.js");
 const encrypt_js_1 = require("../../runtime/encrypt.js");
 const zlib_js_1 = require("../../runtime/zlib.js");
@@ -10,6 +10,7 @@ const errors_js_1 = require("../../util/errors.js");
 const is_disjoint_js_1 = require("../../lib/is_disjoint.js");
 const buffer_utils_js_1 = require("../../lib/buffer_utils.js");
 const validate_crit_js_1 = require("../../lib/validate_crit.js");
+exports.unprotected = Symbol();
 class FlattenedEncrypt {
     constructor(plaintext) {
         if (!(plaintext instanceof Uint8Array)) {
@@ -68,7 +69,7 @@ class FlattenedEncrypt {
             throw new errors_js_1.JWEInvalid('either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()');
         }
         if (!(0, is_disjoint_js_1.default)(this._protectedHeader, this._unprotectedHeader, this._sharedUnprotectedHeader)) {
-            throw new errors_js_1.JWEInvalid('JWE Shared Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
+            throw new errors_js_1.JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
         }
         const joseHeader = {
             ...this._protectedHeader,
@@ -107,11 +108,21 @@ class FlattenedEncrypt {
             let parameters;
             ({ cek, encryptedKey, parameters } = await (0, encrypt_key_management_js_1.default)(alg, enc, key, this._cek, this._keyManagementParameters));
             if (parameters) {
-                if (!this._protectedHeader) {
-                    this.setProtectedHeader(parameters);
+                if (options && exports.unprotected in options) {
+                    if (!this._unprotectedHeader) {
+                        this.setUnprotectedHeader(parameters);
+                    }
+                    else {
+                        this._unprotectedHeader = { ...this._unprotectedHeader, ...parameters };
+                    }
                 }
                 else {
-                    this._protectedHeader = { ...this._protectedHeader, ...parameters };
+                    if (!this._protectedHeader) {
+                        this.setProtectedHeader(parameters);
+                    }
+                    else {
+                        this._protectedHeader = { ...this._protectedHeader, ...parameters };
+                    }
                 }
             }
         }

package/dist/node/cjs/jwe/general/decrypt.js

@@ -11,6 +11,9 @@ async function generalDecrypt(jwe, key, options) {
     if (!Array.isArray(jwe.recipients) || !jwe.recipients.every(is_object_js_1.default)) {
         throw new errors_js_1.JWEInvalid('JWE Recipients missing or incorrect type');
     }
+    if (!jwe.recipients.length) {
+        throw new errors_js_1.JWEInvalid('JWE Recipients has no members');
+    }
     for (const recipient of jwe.recipients) {
         try {
             return await (0, decrypt_js_1.flattenedDecrypt)({

package/dist/node/cjs/jwe/general/encrypt.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneralEncrypt = void 0;
+const encrypt_js_1 = require("../flattened/encrypt.js");
+const errors_js_1 = require("../../util/errors.js");
+const cek_js_1 = require("../../lib/cek.js");
+const is_disjoint_js_1 = require("../../lib/is_disjoint.js");
+const encrypt_key_management_js_1 = require("../../lib/encrypt_key_management.js");
+const base64url_js_1 = require("../../runtime/base64url.js");
+const validate_crit_js_1 = require("../../lib/validate_crit.js");
+const recipientRef = new WeakMap();
+class IndividualRecipient {
+    setUnprotectedHeader(unprotectedHeader) {
+        if (this._unprotectedHeader) {
+            throw new TypeError('setUnprotectedHeader can only be called once');
+        }
+        this._unprotectedHeader = unprotectedHeader;
+        return this;
+    }
+    set _unprotectedHeader(value) {
+        recipientRef.get(this).unprotectedHeader = value;
+    }
+    get _unprotectedHeader() {
+        return recipientRef.get(this).unprotectedHeader;
+    }
+}
+class GeneralEncrypt {
+    constructor(plaintext) {
+        this._recipients = [];
+        this._plaintext = plaintext;
+    }
+    addRecipient(key, options) {
+        const recipient = new IndividualRecipient();
+        recipientRef.set(recipient, { key, options: { crit: options === null || options === void 0 ? void 0 : options.crit } });
+        this._recipients.push(recipient);
+        return recipient;
+    }
+    setProtectedHeader(protectedHeader) {
+        if (this._protectedHeader) {
+            throw new TypeError('setProtectedHeader can only be called once');
+        }
+        this._protectedHeader = protectedHeader;
+        return this;
+    }
+    setSharedUnprotectedHeader(sharedUnprotectedHeader) {
+        if (this._unprotectedHeader) {
+            throw new TypeError('setSharedUnprotectedHeader can only be called once');
+        }
+        this._unprotectedHeader = sharedUnprotectedHeader;
+        return this;
+    }
+    setAdditionalAuthenticatedData(aad) {
+        this._aad = aad;
+        return this;
+    }
+    async encrypt(options) {
+        var _a, _b;
+        if (!this._recipients.length) {
+            throw new errors_js_1.JWEInvalid('at least one recipient must be added');
+        }
+        options = { deflateRaw: options === null || options === void 0 ? void 0 : options.deflateRaw };
+        if (this._recipients.length === 1) {
+            const { unprotectedHeader, options: recipientOpts, key, } = recipientRef.get(this._recipients[0]);
+            const flattened = await new encrypt_js_1.FlattenedEncrypt(this._plaintext)
+                .setAdditionalAuthenticatedData(this._aad)
+                .setProtectedHeader(this._protectedHeader)
+                .setSharedUnprotectedHeader(this._unprotectedHeader)
+                .setUnprotectedHeader(unprotectedHeader)
+                .encrypt(key, { ...recipientOpts, ...options });
+            let jwe = {
+                ciphertext: flattened.ciphertext,
+                iv: flattened.iv,
+                recipients: [{}],
+                tag: flattened.tag,
+            };
+            if (flattened.aad)
+                jwe.aad = flattened.aad;
+            if (flattened.protected)
+                jwe.protected = flattened.protected;
+            if (flattened.unprotected)
+                jwe.unprotected = flattened.unprotected;
+            if (flattened.encrypted_key)
+                jwe.recipients[0].encrypted_key = flattened.encrypted_key;
+            if (flattened.header)
+                jwe.recipients[0].header = flattened.header;
+            return jwe;
+        }
+        let enc;
+        for (let i = 0; i < this._recipients.length; i++) {
+            const recipient = this._recipients[i];
+            const { unprotectedHeader, options: recipientOpts } = recipientRef.get(recipient);
+            if (!(0, is_disjoint_js_1.default)(this._protectedHeader, this._unprotectedHeader, unprotectedHeader)) {
+                throw new errors_js_1.JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
+            }
+            const joseHeader = {
+                ...this._protectedHeader,
+                ...this._unprotectedHeader,
+                ...unprotectedHeader,
+            };
+            const { alg } = joseHeader;
+            if (typeof alg !== 'string' || !alg) {
+                throw new errors_js_1.JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid');
+            }
+            if (alg === 'dir' || alg === 'ECDH-ES') {
+                throw new errors_js_1.JWEInvalid('"dir" and "ECDH-ES" alg may only be used with a single recipient');
+            }
+            if (typeof joseHeader.enc !== 'string' || !joseHeader.enc) {
+                throw new errors_js_1.JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');
+            }
+            if (!enc) {
+                enc = joseHeader.enc;
+            }
+            else if (enc !== joseHeader.enc) {
+                throw new errors_js_1.JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must be the same for all recipients');
+            }
+            (0, validate_crit_js_1.default)(errors_js_1.JWEInvalid, new Map(), recipientOpts === null || recipientOpts === void 0 ? void 0 : recipientOpts.crit, this._protectedHeader, joseHeader);
+            if (joseHeader.zip !== undefined) {
+                if (!this._protectedHeader || !this._protectedHeader.zip) {
+                    throw new errors_js_1.JWEInvalid('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');
+                }
+            }
+        }
+        const cek = (0, cek_js_1.default)(enc);
+        let jwe = {
+            ciphertext: '',
+            iv: '',
+            recipients: [],
+            tag: '',
+        };
+        for (let i = 0; i < this._recipients.length; i++) {
+            const recipient = this._recipients[i];
+            const target = {};
+            jwe.recipients.push(target);
+            const { unprotectedHeader, options: recipientOpts, key } = recipientRef.get(recipient);
+            if (i === 0) {
+                const flattened = await new encrypt_js_1.FlattenedEncrypt(this._plaintext)
+                    .setAdditionalAuthenticatedData(this._aad)
+                    .setContentEncryptionKey(cek)
+                    .setProtectedHeader(this._protectedHeader)
+                    .setSharedUnprotectedHeader(this._unprotectedHeader)
+                    .setUnprotectedHeader(unprotectedHeader)
+                    .encrypt(key, { ...recipientOpts, ...options, [encrypt_js_1.unprotected]: true });
+                jwe.ciphertext = flattened.ciphertext;
+                jwe.iv = flattened.iv;
+                jwe.tag = flattened.tag;
+                if (flattened.aad)
+                    jwe.aad = flattened.aad;
+                if (flattened.protected)
+                    jwe.protected = flattened.protected;
+                if (flattened.unprotected)
+                    jwe.unprotected = flattened.unprotected;
+                target.encrypted_key = flattened.encrypted_key;
+                if (flattened.header)
+                    target.header = flattened.header;
+                continue;
+            }
+            const { encryptedKey, parameters } = await (0, encrypt_key_management_js_1.default)((unprotectedHeader === null || unprotectedHeader === void 0 ? void 0 : unprotectedHeader.alg) || ((_a = this._protectedHeader) === null || _a === void 0 ? void 0 : _a.alg) || ((_b = this._unprotectedHeader) === null || _b === void 0 ? void 0 : _b.alg), enc, key, cek);
+            target.encrypted_key = (0, base64url_js_1.encode)(encryptedKey);
+            if (unprotectedHeader || parameters)
+                target.header = { ...unprotectedHeader, ...parameters };
+        }
+        return jwe;
+    }
+}
+exports.GeneralEncrypt = GeneralEncrypt;

package/dist/node/cjs/key/import.js

@@ -65,7 +65,8 @@ function parseElement(bytes) {
     };
 }
 function spkiFromX509(buf) {
-    return (0, base64url_js_1.encodeBase64)(getElement(getElement(parseElement(buf).contents)[0].contents)[6].raw);
+    const tbsCertificate = getElement(getElement(parseElement(buf).contents)[0].contents);
+    return (0, base64url_js_1.encodeBase64)(tbsCertificate[tbsCertificate[0].raw[0] === 0xa0 ? 6 : 5].raw);
 }
 function getSPKI(x509) {
     const pem = x509.replace(/(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g, '');

package/dist/node/cjs/lib/crypto_key.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkEncCryptoKey = exports.checkSigCryptoKey = void 0;
-const global_js_1 = require("../runtime/global.js");
+const env_js_1 = require("../runtime/env.js");
 function unusable(name, prop = 'algorithm.name') {
     return new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
 }
@@ -74,12 +74,12 @@ function checkSigCryptoKey(key, alg, ...usages) {
                 throw unusable(`SHA-${expected}`, 'algorithm.hash');
             break;
         }
-        case (0, global_js_1.isNodeJs)() && 'EdDSA': {
+        case (0, env_js_1.isNodeJs)() && 'EdDSA': {
             if (key.algorithm.name !== 'NODE-ED25519' && key.algorithm.name !== 'NODE-ED448')
                 throw unusable('NODE-ED25519 or NODE-ED448');
             break;
         }
-        case (0, global_js_1.isCloudflareWorkers)() && 'EdDSA': {
+        case (0, env_js_1.isCloudflareWorkers)() && 'EdDSA': {
             if (!isAlgorithm(key.algorithm, 'NODE-ED25519'))
                 throw unusable('NODE-ED25519');
             break;

package/dist/node/cjs/runtime/decrypt.js

@@ -36,8 +36,8 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     }
     let plaintext;
     try {
-        const cipher = (0, crypto_1.createDecipheriv)(algorithm, encKey, iv);
-        plaintext = (0, buffer_utils_js_1.concat)(cipher.update(ciphertext), cipher.final());
+        const decipher = (0, crypto_1.createDecipheriv)(algorithm, encKey, iv);
+        plaintext = (0, buffer_utils_js_1.concat)(decipher.update(ciphertext), decipher.final());
     }
     catch {
     }
@@ -53,12 +53,14 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
         throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
     }
     try {
-        const cipher = (0, crypto_1.createDecipheriv)(algorithm, cek, iv, { authTagLength: 16 });
-        cipher.setAuthTag(tag);
+        const decipher = (0, crypto_1.createDecipheriv)(algorithm, cek, iv, { authTagLength: 16 });
+        decipher.setAuthTag(tag);
         if (aad.byteLength) {
-            cipher.setAAD(aad, { plaintextLength: ciphertext.length });
+            decipher.setAAD(aad, { plaintextLength: ciphertext.length });
         }
-        return (0, buffer_utils_js_1.concat)(cipher.update(ciphertext), cipher.final());
+        const plaintext = decipher.update(ciphertext);
+        decipher.final();
+        return plaintext;
     }
     catch {
         throw new errors_js_1.JWEDecryptionFailed();

package/dist/node/cjs/runtime/encrypt.js

@@ -38,7 +38,8 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
     if (aad.byteLength) {
         cipher.setAAD(aad, { plaintextLength: plaintext.length });
     }
-    const ciphertext = (0, buffer_utils_js_1.concat)(cipher.update(plaintext), cipher.final());
+    const ciphertext = cipher.update(plaintext);
+    cipher.final();
     const tag = cipher.getAuthTag();
     return { ciphertext, tag };
 }

package/dist/node/cjs/runtime/sign.js

@@ -16,10 +16,6 @@ else {
 const sign = async (alg, key, data) => {
     const keyObject = (0, get_sign_verify_key_js_1.default)(alg, key, 'sign');
     if (alg.startsWith('HS')) {
-        const bitlen = parseInt(alg.substr(-3), 10);
-        if (!keyObject.symmetricKeySize || keyObject.symmetricKeySize << 3 < bitlen) {
-            throw new TypeError(`${alg} requires symmetric keys to be ${bitlen} bits or larger`);
-        }
         const hmac = crypto.createHmac((0, hmac_digest_js_1.default)(alg), keyObject);
         hmac.update(data);
         return hmac.digest();

package/dist/node/esm/index.js

@@ -1,6 +1,7 @@
 export { compactDecrypt } from './jwe/compact/decrypt.js';
 export { flattenedDecrypt } from './jwe/flattened/decrypt.js';
 export { generalDecrypt } from './jwe/general/decrypt.js';
+export { GeneralEncrypt } from './jwe/general/encrypt.js';
 export { compactVerify } from './jws/compact/verify.js';
 export { flattenedVerify } from './jws/flattened/verify.js';
 export { generalVerify } from './jws/general/verify.js';

package/dist/node/esm/jwe/flattened/encrypt.js

@@ -7,6 +7,7 @@ import { JOSENotSupported, JWEInvalid } from '../../util/errors.js';
 import isDisjoint from '../../lib/is_disjoint.js';
 import { encoder, decoder, concat } from '../../lib/buffer_utils.js';
 import validateCrit from '../../lib/validate_crit.js';
+export const unprotected = Symbol();
 export class FlattenedEncrypt {
     constructor(plaintext) {
         if (!(plaintext instanceof Uint8Array)) {
@@ -65,7 +66,7 @@ export class FlattenedEncrypt {
             throw new JWEInvalid('either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()');
         }
         if (!isDisjoint(this._protectedHeader, this._unprotectedHeader, this._sharedUnprotectedHeader)) {
-            throw new JWEInvalid('JWE Shared Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
+            throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
         }
         const joseHeader = {
             ...this._protectedHeader,
@@ -104,11 +105,21 @@ export class FlattenedEncrypt {
             let parameters;
             ({ cek, encryptedKey, parameters } = await encryptKeyManagement(alg, enc, key, this._cek, this._keyManagementParameters));
             if (parameters) {
-                if (!this._protectedHeader) {
-                    this.setProtectedHeader(parameters);
+                if (options && unprotected in options) {
+                    if (!this._unprotectedHeader) {
+                        this.setUnprotectedHeader(parameters);
+                    }
+                    else {
+                        this._unprotectedHeader = { ...this._unprotectedHeader, ...parameters };
+                    }
                 }
                 else {
-                    this._protectedHeader = { ...this._protectedHeader, ...parameters };
+                    if (!this._protectedHeader) {
+                        this.setProtectedHeader(parameters);
+                    }
+                    else {
+                        this._protectedHeader = { ...this._protectedHeader, ...parameters };
+                    }
                 }
             }
         }

package/dist/node/esm/jwe/general/decrypt.js

@@ -8,6 +8,9 @@ export async function generalDecrypt(jwe, key, options) {
     if (!Array.isArray(jwe.recipients) || !jwe.recipients.every(isObject)) {
         throw new JWEInvalid('JWE Recipients missing or incorrect type');
     }
+    if (!jwe.recipients.length) {
+        throw new JWEInvalid('JWE Recipients has no members');
+    }
     for (const recipient of jwe.recipients) {
         try {
             return await flattenedDecrypt({

package/dist/node/esm/jwe/general/encrypt.js

@@ -0,0 +1,161 @@
+import { FlattenedEncrypt, unprotected } from '../flattened/encrypt.js';
+import { JWEInvalid } from '../../util/errors.js';
+import generateCek from '../../lib/cek.js';
+import isDisjoint from '../../lib/is_disjoint.js';
+import encryptKeyManagement from '../../lib/encrypt_key_management.js';
+import { encode as base64url } from '../../runtime/base64url.js';
+import validateCrit from '../../lib/validate_crit.js';
+const recipientRef = new WeakMap();
+class IndividualRecipient {
+    setUnprotectedHeader(unprotectedHeader) {
+        if (this._unprotectedHeader) {
+            throw new TypeError('setUnprotectedHeader can only be called once');
+        }
+        this._unprotectedHeader = unprotectedHeader;
+        return this;
+    }
+    set _unprotectedHeader(value) {
+        recipientRef.get(this).unprotectedHeader = value;
+    }
+    get _unprotectedHeader() {
+        return recipientRef.get(this).unprotectedHeader;
+    }
+}
+export class GeneralEncrypt {
+    constructor(plaintext) {
+        this._recipients = [];
+        this._plaintext = plaintext;
+    }
+    addRecipient(key, options) {
+        const recipient = new IndividualRecipient();
+        recipientRef.set(recipient, { key, options: { crit: options === null || options === void 0 ? void 0 : options.crit } });
+        this._recipients.push(recipient);
+        return recipient;
+    }
+    setProtectedHeader(protectedHeader) {
+        if (this._protectedHeader) {
+            throw new TypeError('setProtectedHeader can only be called once');
+        }
+        this._protectedHeader = protectedHeader;
+        return this;
+    }
+    setSharedUnprotectedHeader(sharedUnprotectedHeader) {
+        if (this._unprotectedHeader) {
+            throw new TypeError('setSharedUnprotectedHeader can only be called once');
+        }
+        this._unprotectedHeader = sharedUnprotectedHeader;
+        return this;
+    }
+    setAdditionalAuthenticatedData(aad) {
+        this._aad = aad;
+        return this;
+    }
+    async encrypt(options) {
+        var _a, _b;
+        if (!this._recipients.length) {
+            throw new JWEInvalid('at least one recipient must be added');
+        }
+        options = { deflateRaw: options === null || options === void 0 ? void 0 : options.deflateRaw };
+        if (this._recipients.length === 1) {
+            const { unprotectedHeader, options: recipientOpts, key, } = recipientRef.get(this._recipients[0]);
+            const flattened = await new FlattenedEncrypt(this._plaintext)
+                .setAdditionalAuthenticatedData(this._aad)
+                .setProtectedHeader(this._protectedHeader)
+                .setSharedUnprotectedHeader(this._unprotectedHeader)
+                .setUnprotectedHeader(unprotectedHeader)
+                .encrypt(key, { ...recipientOpts, ...options });
+            let jwe = {
+                ciphertext: flattened.ciphertext,
+                iv: flattened.iv,
+                recipients: [{}],
+                tag: flattened.tag,
+            };
+            if (flattened.aad)
+                jwe.aad = flattened.aad;
+            if (flattened.protected)
+                jwe.protected = flattened.protected;
+            if (flattened.unprotected)
+                jwe.unprotected = flattened.unprotected;
+            if (flattened.encrypted_key)
+                jwe.recipients[0].encrypted_key = flattened.encrypted_key;
+            if (flattened.header)
+                jwe.recipients[0].header = flattened.header;
+            return jwe;
+        }
+        let enc;
+        for (let i = 0; i < this._recipients.length; i++) {
+            const recipient = this._recipients[i];
+            const { unprotectedHeader, options: recipientOpts } = recipientRef.get(recipient);
+            if (!isDisjoint(this._protectedHeader, this._unprotectedHeader, unprotectedHeader)) {
+                throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
+            }
+            const joseHeader = {
+                ...this._protectedHeader,
+                ...this._unprotectedHeader,
+                ...unprotectedHeader,
+            };
+            const { alg } = joseHeader;
+            if (typeof alg !== 'string' || !alg) {
+                throw new JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid');
+            }
+            if (alg === 'dir' || alg === 'ECDH-ES') {
+                throw new JWEInvalid('"dir" and "ECDH-ES" alg may only be used with a single recipient');
+            }
+            if (typeof joseHeader.enc !== 'string' || !joseHeader.enc) {
+                throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');
+            }
+            if (!enc) {
+                enc = joseHeader.enc;
+            }
+            else if (enc !== joseHeader.enc) {
+                throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must be the same for all recipients');
+            }
+            validateCrit(JWEInvalid, new Map(), recipientOpts === null || recipientOpts === void 0 ? void 0 : recipientOpts.crit, this._protectedHeader, joseHeader);
+            if (joseHeader.zip !== undefined) {
+                if (!this._protectedHeader || !this._protectedHeader.zip) {
+                    throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');
+                }
+            }
+        }
+        const cek = generateCek(enc);
+        let jwe = {
+            ciphertext: '',
+            iv: '',
+            recipients: [],
+            tag: '',
+        };
+        for (let i = 0; i < this._recipients.length; i++) {
+            const recipient = this._recipients[i];
+            const target = {};
+            jwe.recipients.push(target);
+            const { unprotectedHeader, options: recipientOpts, key } = recipientRef.get(recipient);
+            if (i === 0) {
+                const flattened = await new FlattenedEncrypt(this._plaintext)
+                    .setAdditionalAuthenticatedData(this._aad)
+                    .setContentEncryptionKey(cek)
+                    .setProtectedHeader(this._protectedHeader)
+                    .setSharedUnprotectedHeader(this._unprotectedHeader)
+                    .setUnprotectedHeader(unprotectedHeader)
+                    .encrypt(key, { ...recipientOpts, ...options, [unprotected]: true });
+                jwe.ciphertext = flattened.ciphertext;
+                jwe.iv = flattened.iv;
+                jwe.tag = flattened.tag;
+                if (flattened.aad)
+                    jwe.aad = flattened.aad;
+                if (flattened.protected)
+                    jwe.protected = flattened.protected;
+                if (flattened.unprotected)
+                    jwe.unprotected = flattened.unprotected;
+                target.encrypted_key = flattened.encrypted_key;
+                if (flattened.header)
+                    target.header = flattened.header;
+                continue;
+            }
+            const { encryptedKey, parameters } = await encryptKeyManagement((unprotectedHeader === null || unprotectedHeader === void 0 ? void 0 : unprotectedHeader.alg) || ((_a = this._protectedHeader) === null || _a === void 0 ? void 0 : _a.alg) || ((_b = this._unprotectedHeader) === null || _b === void 0 ? void 0 : _b.alg), enc, key, cek);
+            target.encrypted_key = base64url(encryptedKey);
+            if (unprotectedHeader || parameters)
+                target.header = { ...unprotectedHeader, ...parameters };
+        }
+        return jwe;
+    }
+}

package/dist/node/esm/key/import.js

@@ -62,7 +62,8 @@ function parseElement(bytes) {
     };
 }
 function spkiFromX509(buf) {
-    return encodeBase64(getElement(getElement(parseElement(buf).contents)[0].contents)[6].raw);
+    const tbsCertificate = getElement(getElement(parseElement(buf).contents)[0].contents);
+    return encodeBase64(tbsCertificate[tbsCertificate[0].raw[0] === 0xa0 ? 6 : 5].raw);
 }
 function getSPKI(x509) {
     const pem = x509.replace(/(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g, '');

package/dist/node/esm/lib/crypto_key.js

@@ -1,4 +1,4 @@
-import { isCloudflareWorkers, isNodeJs } from '../runtime/global.js';
+import { isCloudflareWorkers, isNodeJs } from '../runtime/env.js';
 function unusable(name, prop = 'algorithm.name') {
     return new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
 }

package/dist/node/esm/runtime/decrypt.js

@@ -34,8 +34,8 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     }
     let plaintext;
     try {
-        const cipher = createDecipheriv(algorithm, encKey, iv);
-        plaintext = concat(cipher.update(ciphertext), cipher.final());
+        const decipher = createDecipheriv(algorithm, encKey, iv);
+        plaintext = concat(decipher.update(ciphertext), decipher.final());
     }
     catch {
     }
@@ -51,12 +51,14 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
         throw new JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
     }
     try {
-        const cipher = createDecipheriv(algorithm, cek, iv, { authTagLength: 16 });
-        cipher.setAuthTag(tag);
+        const decipher = createDecipheriv(algorithm, cek, iv, { authTagLength: 16 });
+        decipher.setAuthTag(tag);
         if (aad.byteLength) {
-            cipher.setAAD(aad, { plaintextLength: ciphertext.length });
+            decipher.setAAD(aad, { plaintextLength: ciphertext.length });
         }
-        return concat(cipher.update(ciphertext), cipher.final());
+        const plaintext = decipher.update(ciphertext);
+        decipher.final();
+        return plaintext;
     }
     catch {
         throw new JWEDecryptionFailed();

package/dist/node/esm/runtime/encrypt.js

@@ -36,7 +36,8 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
     if (aad.byteLength) {
         cipher.setAAD(aad, { plaintextLength: plaintext.length });
     }
-    const ciphertext = concat(cipher.update(plaintext), cipher.final());
+    const ciphertext = cipher.update(plaintext);
+    cipher.final();
     const tag = cipher.getAuthTag();
     return { ciphertext, tag };
 }

package/dist/node/esm/runtime/sign.js

@@ -14,10 +14,6 @@ else {
 const sign = async (alg, key, data) => {
     const keyObject = getSignKey(alg, key, 'sign');
     if (alg.startsWith('HS')) {
-        const bitlen = parseInt(alg.substr(-3), 10);
-        if (!keyObject.symmetricKeySize || keyObject.symmetricKeySize << 3 < bitlen) {
-            throw new TypeError(`${alg} requires symmetric keys to be ${bitlen} bits or larger`);
-        }
         const hmac = crypto.createHmac(hmacDigest(alg), keyObject);
         hmac.update(data);
         return hmac.digest();

package/dist/types/index.d.ts

@@ -4,6 +4,8 @@ export { flattenedDecrypt } from './jwe/flattened/decrypt';
 export type { FlattenedDecryptGetKey } from './jwe/flattened/decrypt';
 export { generalDecrypt } from './jwe/general/decrypt';
 export type { GeneralDecryptGetKey } from './jwe/general/decrypt';
+export { GeneralEncrypt } from './jwe/general/encrypt';
+export type { Recipient } from './jwe/general/encrypt';
 export { compactVerify } from './jws/compact/verify';
 export type { CompactVerifyGetKey } from './jws/compact/verify';
 export { flattenedVerify } from './jws/flattened/verify';
@@ -40,4 +42,4 @@ export type { GenerateKeyPairResult, GenerateKeyPairOptions } from './key/genera
 export { generateSecret } from './key/generate_secret';
 export type { GenerateSecretOptions } from './key/generate_secret';
 export * as base64url from './util/base64url';
-export type { KeyLike, JWK, FlattenedJWSInput, GeneralJWSInput, FlattenedJWS, GeneralJWS, JoseHeaderParameters, JWSHeaderParameters, JWEKeyManagementHeaderParameters, FlattenedJWE, GeneralJWE, JWEHeaderParameters, CritOption, DecryptOptions, EncryptOptions, JWTClaimVerificationOptions, VerifyOptions, SignOptions, JWTPayload, DeflateFunction, InflateFunction, FlattenedDecryptResult, GeneralDecryptResult, CompactDecryptResult, FlattenedVerifyResult, GeneralVerifyResult, CompactVerifyResult, JWTVerifyResult, JWTDecryptResult, ResolvedKey, } from './types';
+export type { KeyLike, JWK, FlattenedJWSInput, GeneralJWSInput, FlattenedJWS, GeneralJWS, JoseHeaderParameters, JWSHeaderParameters, JWEKeyManagementHeaderParameters, FlattenedJWE, GeneralJWE, JWEHeaderParameters, CritOption, DeflateOption, DecryptOptions, EncryptOptions, JWTClaimVerificationOptions, VerifyOptions, SignOptions, JWTPayload, DeflateFunction, InflateFunction, FlattenedDecryptResult, GeneralDecryptResult, CompactDecryptResult, FlattenedVerifyResult, GeneralVerifyResult, CompactVerifyResult, JWTVerifyResult, JWTDecryptResult, ResolvedKey, } from './types';

package/dist/types/jwe/flattened/encrypt.d.ts

@@ -1,4 +1,5 @@
 import type { KeyLike, FlattenedJWE, JWEHeaderParameters, JWEKeyManagementHeaderParameters, EncryptOptions } from '../../types';
+export declare const unprotected: unique symbol;
 export declare class FlattenedEncrypt {
     private _plaintext;
     private _protectedHeader;

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

@@ -0,0 +1,17 @@
+import type { KeyLike, GeneralJWE, JWEHeaderParameters, CritOption, DeflateOption } from '../../types';
+export interface Recipient {
+    setUnprotectedHeader(unprotectedHeader: JWEHeaderParameters): Recipient;
+}
+export declare class GeneralEncrypt {
+    private _plaintext;
+    private _recipients;
+    private _protectedHeader;
+    private _unprotectedHeader;
+    private _aad;
+    constructor(plaintext: Uint8Array);
+    addRecipient(key: KeyLike | Uint8Array, options?: CritOption): Recipient;
+    setProtectedHeader(protectedHeader: JWEHeaderParameters): this;
+    setSharedUnprotectedHeader(sharedUnprotectedHeader: JWEHeaderParameters): this;
+    setAdditionalAuthenticatedData(aad: Uint8Array): this;
+    encrypt(options?: DeflateOption): Promise<GeneralJWE>;
+}

package/dist/types/types.d.ts

@@ -200,9 +200,10 @@ export interface DecryptOptions extends CritOption {
   contentEncryptionAlgorithms?: string[]
   inflateRaw?: InflateFunction
 }
-export interface EncryptOptions extends CritOption {
+export interface DeflateOption {
   deflateRaw?: DeflateFunction
 }
+export interface EncryptOptions extends CritOption, DeflateOption {}
 export interface JWTClaimVerificationOptions {
   audience?: string | string[]
   clockTolerance?: string | number

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jose",
-  "version": "4.1.2",
+  "version": "4.2.0",
   "description": "'JSON Web Almost Everything' - JWA, JWS, JWE, JWT, JWK, JWKS with no dependencies using runtime's native crypto",
   "keywords": [
     "browser",

package/dist/browser/runtime/global.js

@@ -1,27 +0,0 @@
-function getGlobal() {
-    if (typeof globalThis !== 'undefined')
-        return globalThis;
-    if (typeof self !== 'undefined')
-        return self;
-    if (typeof window !== 'undefined')
-        return window;
-    throw new Error('unable to locate global object');
-}
-export default getGlobal();
-export function isCloudflareWorkers() {
-    try {
-        return getGlobal().WebSocketPair !== undefined;
-    }
-    catch (_a) {
-        return false;
-    }
-}
-export function isNodeJs() {
-    var _a, _b;
-    try {
-        return ((_b = (_a = getGlobal().process) === null || _a === void 0 ? void 0 : _a.versions) === null || _b === void 0 ? void 0 : _b.node) !== undefined;
-    }
-    catch (_c) {
-        return false;
-    }
-}