repocairn 0.1.6 → 0.1.7

package/node_modules/jose/dist/webapi/jws/general/verify.js

@@ -1,41 +1,71 @@
-import { prepareVerify, verifySignature, verifyResult } from '../../lib/jws_verify.js';
+import { encodeJsonUnencodedPayload, parseProtectedHeader, prepareVerify, snapshotJws, verifySignature, verifyResult, } from '../../lib/jws_verify.js';
 import { JWSInvalid, JWSSignatureVerificationFailed } from '../../util/errors.js';
 import { isObject } from '../../lib/type_checks.js';
+function snapshotSignature(signature, payload) {
+    try {
+        const jws = snapshotJws(signature, [payload]);
+        const { protected: encodedProtected, header, signature: encodedSignature } = jws;
+        if (encodedProtected === undefined && header === undefined)
+            return undefined;
+        if (encodedProtected !== undefined && typeof encodedProtected !== 'string')
+            return undefined;
+        if (typeof encodedSignature !== 'string')
+            return undefined;
+        if (header !== undefined && !isObject(header))
+            return undefined;
+        const protectedHeader = parseProtectedHeader(encodedProtected);
+        const { b64, crit } = protectedHeader;
+        return [
+            jws,
+            protectedHeader,
+            Array.isArray(crit) && crit.includes('b64')
+                ? typeof b64 === 'boolean'
+                    ? b64
+                        ? 1
+                        : 2
+                    : 0
+                : 1,
+        ];
+    }
+    catch {
+        return undefined;
+    }
+}
 export async function generalVerify(jws, key, options) {
     if (!isObject(jws)) {
         throw new JWSInvalid('General JWS must be an object');
     }
-    const { signatures, payload } = jws;
-    if (!Array.isArray(signatures) || !signatures.every(isObject)) {
+    const { signatures, payload: inputPayload } = jws;
+    if (!Array.isArray(signatures)) {
+        throw new JWSInvalid('JWS Signatures missing or incorrect type');
+    }
+    const signatureEntries = Array.from(signatures);
+    if (!signatureEntries.every(isObject)) {
         throw new JWSInvalid('JWS Signatures missing or incorrect type');
     }
     let shared;
     try {
-        if (payload === undefined)
+        if (inputPayload === undefined)
             throw new Error();
         shared = prepareVerify(options);
     }
     catch {
         throw new JWSSignatureVerificationFailed();
     }
-    for (const signature of signatures) {
+    const payload = inputPayload instanceof Uint8Array ? new Uint8Array(inputPayload) : inputPayload;
+    const candidates = signatureEntries
+        .map((signature) => snapshotSignature(signature, payload))
+        .filter((candidate) => candidate !== undefined);
+    let modes = 0;
+    for (const [, , mode] of candidates) {
+        modes |= mode;
+        if (modes === 3) {
+            throw new JWSInvalid('inconsistent use of JWS Unencoded Payload (RFC7797)');
+        }
+    }
+    for (const candidate of candidates) {
         try {
-            const { protected: encodedProtected, header, signature: encodedSignature } = signature;
-            if (encodedProtected === undefined && header === undefined)
-                throw new Error();
-            if (encodedProtected !== undefined && typeof encodedProtected !== 'string') {
-                throw new Error();
-            }
-            if (typeof encodedSignature !== 'string')
-                throw new Error();
-            if (header !== undefined && !isObject(header))
-                throw new Error();
-            return verifyResult(signature, await verifySignature({
-                header,
-                payload,
-                protected: encodedProtected,
-                signature: encodedSignature,
-            }, shared, key));
+            return verifyResult(candidate[0], await verifySignature(candidate[0], shared, key, encodeJsonUnencodedPayload, candidate[1]));
         }
         catch {
         }

package/node_modules/jose/dist/webapi/jwt/decrypt.js

@@ -5,15 +5,13 @@ export async function jwtDecrypt(jwt, key, options) {
     const decrypted = await decryptCompact(jwt, prepareDecrypt(options), key);
     const protectedHeader = decrypted[1];
     const payload = validateClaimsSet(protectedHeader, decrypted[0], options);
-    if (protectedHeader.iss !== undefined && protectedHeader.iss !== payload.iss) {
-        throw new JWTClaimValidationFailed('replicated "iss" claim header parameter mismatch', payload, 'iss', 'mismatch');
-    }
-    if (protectedHeader.sub !== undefined && protectedHeader.sub !== payload.sub) {
-        throw new JWTClaimValidationFailed('replicated "sub" claim header parameter mismatch', payload, 'sub', 'mismatch');
-    }
-    if (protectedHeader.aud !== undefined &&
-        JSON.stringify(protectedHeader.aud) !== JSON.stringify(payload.aud)) {
-        throw new JWTClaimValidationFailed('replicated "aud" claim header parameter mismatch', payload, 'aud', 'mismatch');
+    for (const claim of ['iss', 'sub', 'aud']) {
+        if (protectedHeader[claim] !== undefined &&
+            (claim === 'aud'
+                ? JSON.stringify(protectedHeader.aud) !== JSON.stringify(payload.aud)
+                : protectedHeader[claim] !== payload[claim])) {
+            throw new JWTClaimValidationFailed(`replicated "${claim}" claim header parameter mismatch`, payload, claim, 'mismatch');
+        }
     }
     const result = { payload, protectedHeader };
     if (typeof key === 'function') {

package/node_modules/jose/dist/webapi/jwt/encrypt.js

@@ -1,7 +1,8 @@
-import { CompactEncrypt } from '../jwe/compact/encrypt.js';
-import { JWTClaimsBuilder } from '../lib/jwt_claims_set.js';
+import { createJWE } from '../lib/jwe_encrypt.js';
+import { JWTClaimsBuilder, jwtClaim, jwtData } from '../lib/jwt_claims_set.js';
 import { assertNotSet } from '../lib/helpers.js';
-export class EncryptJWT {
+const EncryptJWT_base = JWTClaimsBuilder;
+export class EncryptJWT extends EncryptJWT_base {
     #cek;
     #iv;
     #keyManagementParameters;
@@ -9,38 +10,6 @@ export class EncryptJWT {
     #replicateIssuerAsHeader;
     #replicateSubjectAsHeader;
     #replicateAudienceAsHeader;
-    #jwt;
-    constructor(payload = {}) {
-        this.#jwt = new JWTClaimsBuilder(payload);
-    }
-    setIssuer(issuer) {
-        this.#jwt.iss = issuer;
-        return this;
-    }
-    setSubject(subject) {
-        this.#jwt.sub = subject;
-        return this;
-    }
-    setAudience(audience) {
-        this.#jwt.aud = audience;
-        return this;
-    }
-    setJti(jwtId) {
-        this.#jwt.jti = jwtId;
-        return this;
-    }
-    setNotBefore(input) {
-        this.#jwt.nbf = input;
-        return this;
-    }
-    setExpirationTime(input) {
-        this.#jwt.exp = input;
-        return this;
-    }
-    setIssuedAt(input) {
-        this.#jwt.iat = input;
-        return this;
-    }
     setProtectedHeader(protectedHeader) {
         assertNotSet(this.#protectedHeader, 'setProtectedHeader');
         this.#protectedHeader = protectedHeader;
@@ -74,28 +43,30 @@ export class EncryptJWT {
         return this;
     }
     async encrypt(key, options) {
-        const enc = new CompactEncrypt(this.#jwt.data());
+        const plaintext = jwtData(this);
         if (this.#protectedHeader &&
             (this.#replicateIssuerAsHeader ||
                 this.#replicateSubjectAsHeader ||
                 this.#replicateAudienceAsHeader)) {
             this.#protectedHeader = {
                 ...this.#protectedHeader,
-                iss: this.#replicateIssuerAsHeader ? this.#jwt.iss : undefined,
-                sub: this.#replicateSubjectAsHeader ? this.#jwt.sub : undefined,
-                aud: this.#replicateAudienceAsHeader ? this.#jwt.aud : undefined,
+                iss: this.#replicateIssuerAsHeader ? jwtClaim(this, 'iss') : undefined,
+                sub: this.#replicateSubjectAsHeader ? jwtClaim(this, 'sub') : undefined,
+                aud: this.#replicateAudienceAsHeader ? jwtClaim(this, 'aud') : undefined,
             };
         }
-        enc.setProtectedHeader(this.#protectedHeader);
-        if (this.#iv) {
-            enc.setInitializationVector(this.#iv);
-        }
-        if (this.#cek) {
-            enc.setContentEncryptionKey(this.#cek);
-        }
-        if (this.#keyManagementParameters) {
-            enc.setKeyManagementParameters(this.#keyManagementParameters);
-        }
-        return enc.encrypt(key, options);
+        const jwe = await createJWE([
+            plaintext,
+            this.#protectedHeader,
+            undefined,
+            undefined,
+            undefined,
+            this.#cek,
+            this.#iv,
+            this.#keyManagementParameters,
+            undefined,
+            false,
+        ], key, options);
+        return [jwe.protected, jwe.encrypted_key, jwe.iv, jwe.ciphertext, jwe.tag].join('.');
     }
 }

package/node_modules/jose/dist/webapi/jwt/sign.js

@@ -1,51 +1,18 @@
-import { CompactSign } from '../jws/compact/sign.js';
-import { unencodedPayload } from '../lib/jws_sign.js';
+import { createCompactSignature } from '../lib/jws_sign.js';
 import { JWTInvalid } from '../util/errors.js';
-import { JWTClaimsBuilder } from '../lib/jwt_claims_set.js';
-export class SignJWT {
+import { JWTClaimsBuilder, jwtData } from '../lib/jwt_claims_set.js';
+import { assertNotSet } from '../lib/helpers.js';
+const SignJWT_base = JWTClaimsBuilder;
+export class SignJWT extends SignJWT_base {
     #protectedHeader;
-    #jwt;
-    constructor(payload = {}) {
-        this.#jwt = new JWTClaimsBuilder(payload);
-    }
-    setIssuer(issuer) {
-        this.#jwt.iss = issuer;
-        return this;
-    }
-    setSubject(subject) {
-        this.#jwt.sub = subject;
-        return this;
-    }
-    setAudience(audience) {
-        this.#jwt.aud = audience;
-        return this;
-    }
-    setJti(jwtId) {
-        this.#jwt.jti = jwtId;
-        return this;
-    }
-    setNotBefore(input) {
-        this.#jwt.nbf = input;
-        return this;
-    }
-    setExpirationTime(input) {
-        this.#jwt.exp = input;
-        return this;
-    }
-    setIssuedAt(input) {
-        this.#jwt.iat = input;
-        return this;
-    }
     setProtectedHeader(protectedHeader) {
+        assertNotSet(this.#protectedHeader, 'setProtectedHeader');
         this.#protectedHeader = protectedHeader;
         return this;
     }
     async sign(key, options) {
-        const sig = new CompactSign(this.#jwt.data());
-        sig.setProtectedHeader(this.#protectedHeader);
-        if (unencodedPayload(this.#protectedHeader)) {
+        return createCompactSignature(jwtData(this), this.#protectedHeader, options?.crit, key, () => {
             throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
-        }
-        return sig.sign(key, options);
+        });
     }
 }

package/node_modules/jose/dist/webapi/jwt/unsecured.js

@@ -1,46 +1,15 @@
 import * as b64u from '../util/base64url.js';
-import { strictDecoder } from '../lib/buffer_utils.js';
-import { decodeBase64url } from '../lib/helpers.js';
-import { JWTInvalid } from '../util/errors.js';
-import { validateClaimsSet, JWTClaimsBuilder } from '../lib/jwt_claims_set.js';
-export class UnsecuredJWT {
-    #jwt;
-    constructor(payload = {}) {
-        this.#jwt = new JWTClaimsBuilder(payload);
-    }
+import { decodeBase64url, parseJoseHeader } from '../lib/helpers.js';
+import { JWSInvalid, JWTInvalid } from '../util/errors.js';
+import { validateClaimsSet, JWTClaimsBuilder, jwtData } from '../lib/jwt_claims_set.js';
+import { JWS_RECOGNIZED, validateB64, validateCrit } from '../lib/options.js';
+const UnsecuredJWT_base = JWTClaimsBuilder;
+export class UnsecuredJWT extends UnsecuredJWT_base {
     encode() {
         const header = b64u.encode(JSON.stringify({ alg: 'none' }));
-        const payload = b64u.encode(this.#jwt.data());
+        const payload = b64u.encode(jwtData(this));
         return `${header}.${payload}.`;
     }
-    setIssuer(issuer) {
-        this.#jwt.iss = issuer;
-        return this;
-    }
-    setSubject(subject) {
-        this.#jwt.sub = subject;
-        return this;
-    }
-    setAudience(audience) {
-        this.#jwt.aud = audience;
-        return this;
-    }
-    setJti(jwtId) {
-        this.#jwt.jti = jwtId;
-        return this;
-    }
-    setNotBefore(input) {
-        this.#jwt.nbf = input;
-        return this;
-    }
-    setExpirationTime(input) {
-        this.#jwt.exp = input;
-        return this;
-    }
-    setIssuedAt(input) {
-        this.#jwt.iat = input;
-        return this;
-    }
     static decode(jwt, options) {
         if (typeof jwt !== 'string') {
             throw new JWTInvalid('Unsecured JWT must be a string');
@@ -50,14 +19,24 @@ export class UnsecuredJWT {
             throw new JWTInvalid('Invalid Unsecured JWT');
         }
         let header;
+        let b64;
         try {
-            header = JSON.parse(strictDecoder.decode(b64u.decode(encodedHeader)));
-            if (header.alg !== 'none')
-                throw new Error();
+            header = parseJoseHeader(encodedHeader, JWSInvalid, 'JWS Protected Header is invalid');
+            const extensions = validateCrit(JWSInvalid, JWS_RECOGNIZED, undefined, header, header);
+            b64 = validateB64(header, extensions);
         }
-        catch {
+        catch (cause) {
+            if (!(cause instanceof JWSInvalid)) {
+                throw cause;
+            }
+            throw new JWTInvalid('Invalid Unsecured JWT', { cause });
+        }
+        if (header.alg !== 'none') {
             throw new JWTInvalid('Invalid Unsecured JWT');
         }
+        if (!b64) {
+            throw new JWTInvalid('JWTs MUST NOT use unencoded payload');
+        }
         const payload = validateClaimsSet(header, decodeBase64url(encodedPayload, 'payload', JWTInvalid), options);
         return { payload, header };
     }

package/node_modules/jose/dist/webapi/key/generate_key_pair.js

@@ -1,13 +1,17 @@
 import { JOSENotSupported } from '../util/errors.js';
+import { validateExtractableOption } from '../lib/key_options.js';
 import { keyAlgorithm, unsupportedAlg, algArgument } from '../lib/key_algorithm.js';
 function getModulusLengthOption(options) {
     const modulusLength = options?.modulusLength ?? 2048;
-    if (typeof modulusLength !== 'number' || modulusLength < 2048) {
+    if (typeof modulusLength !== 'number' ||
+        !Number.isInteger(modulusLength) ||
+        modulusLength < 2048) {
         throw new JOSENotSupported('Invalid or unsupported modulusLength option provided, 2048 bits or larger keys must be used');
     }
     return modulusLength;
 }
 export async function generateKeyPair(alg, options) {
+    const extractable = validateExtractableOption(options?.extractable);
     const entry = keyAlgorithm(alg, algArgument);
     if (entry.secret) {
         unsupportedAlg(algArgument);
@@ -41,7 +45,7 @@ export async function generateKeyPair(alg, options) {
                 }
                 : entry.subtle;
     }
-    return crypto.subtle.generateKey(algorithm, options?.extractable ?? false, [
+    return crypto.subtle.generateKey(algorithm, extractable ?? false, [
         ...entry.usages[1],
         ...entry.usages[0],
     ]);

package/node_modules/jose/dist/webapi/key/generate_secret.js

@@ -1,5 +1,7 @@
 import { unsupportedAlg, algArgument } from '../lib/key_algorithm.js';
+import { validateExtractableOption } from '../lib/key_options.js';
 export async function generateSecret(alg, options) {
+    const extractable = validateExtractableOption(options?.extractable);
     let length;
     let algorithm;
     let keyUsages;
@@ -7,19 +9,18 @@ export async function generateSecret(alg, options) {
         case 'HS256':
         case 'HS384':
         case 'HS512':
-            length = parseInt(alg.slice(-3), 10);
+            length = +alg.slice(-3);
             algorithm = { name: 'HMAC', hash: `SHA-${length}`, length };
             keyUsages = ['sign', 'verify'];
             break;
         case 'A128CBC-HS256':
         case 'A192CBC-HS384':
         case 'A256CBC-HS512':
-            length = parseInt(alg.slice(-3), 10);
-            return crypto.getRandomValues(new Uint8Array(length >> 3));
+            return crypto.getRandomValues(new Uint8Array(+alg.slice(-3) >> 3));
         case 'A128KW':
         case 'A192KW':
         case 'A256KW':
-            length = parseInt(alg.slice(1, 4), 10);
+            length = +alg.slice(1, 4);
             algorithm = { name: 'AES-KW', length };
             keyUsages = ['wrapKey', 'unwrapKey'];
             break;
@@ -29,12 +30,12 @@ export async function generateSecret(alg, options) {
         case 'A128GCM':
         case 'A192GCM':
         case 'A256GCM':
-            length = parseInt(alg.slice(1, 4), 10);
+            length = +alg.slice(1, 4);
             algorithm = { name: 'AES-GCM', length };
             keyUsages = ['encrypt', 'decrypt'];
             break;
         default:
             unsupportedAlg(algArgument);
     }
-    return crypto.subtle.generateKey(algorithm, options?.extractable ?? false, keyUsages);
+    return crypto.subtle.generateKey(algorithm, extractable ?? false, keyUsages);
 }

package/node_modules/jose/dist/webapi/key/import.js

@@ -4,6 +4,8 @@ import { jwkToKey } from '../lib/jwk_to_key.js';
 import { keyAlgorithm } from '../lib/key_algorithm.js';
 import { JOSENotSupported } from '../util/errors.js';
 import { isObject } from '../lib/type_checks.js';
+import { validateExtractableOption } from '../lib/key_options.js';
+import { normalizeJwk } from '../lib/jwk_metadata.js';
 export async function importSPKI(spki, alg, options) {
     if (typeof spki !== 'string' || spki.indexOf('-----BEGIN PUBLIC KEY-----') !== 0) {
         throw new TypeError('"spki" must be SPKI formatted string');
@@ -26,31 +28,33 @@ export async function importJWK(jwk, alg, options) {
     if (!isObject(jwk)) {
         throw new TypeError('JWK must be an object');
     }
-    alg ??= jwk.alg;
-    const ext = options?.extractable ?? jwk.ext;
-    if (jwk.kty !== 'oct' && !alg) {
+    const normalized = normalizeJwk(jwk);
+    const extractable = validateExtractableOption(options?.extractable);
+    const { alg: jwkAlg } = normalized;
+    alg ??= jwkAlg;
+    const ext = extractable ?? normalized.ext;
+    if (normalized.kty !== 'oct' && !alg) {
         throw new TypeError('"alg" argument is required when "jwk.alg" is not present');
     }
-    switch (jwk.kty) {
+    switch (normalized.kty) {
         case 'oct':
-            if (typeof jwk.k !== 'string' || !jwk.k) {
+            if (typeof normalized.k !== 'string') {
                 throw new TypeError('missing "k" (Key Value) Parameter value');
             }
-            return decodeBase64URL(jwk.k);
-        case 'RSA':
-            return jwkToKey(keyAlgorithm(alg), { ...jwk, alg, ext });
+            return decodeBase64URL(normalized.k);
         case 'AKP': {
-            if (typeof jwk.alg !== 'string' || !jwk.alg) {
+            if (typeof jwkAlg !== 'string' || !jwkAlg) {
                 throw new TypeError('missing "alg" (Algorithm) Parameter value');
             }
-            if (alg !== undefined && alg !== jwk.alg) {
+            if (alg !== jwkAlg) {
                 throw new TypeError('JWK alg and alg option value mismatch');
             }
-            return jwkToKey(keyAlgorithm(jwk.alg), { ...jwk, ext });
+            return jwkToKey(keyAlgorithm(alg), { ...normalized, ext });
         }
+        case 'RSA':
         case 'EC':
         case 'OKP':
-            return jwkToKey(keyAlgorithm(alg), { ...jwk, alg, ext });
+            return jwkToKey(keyAlgorithm(alg), { ...normalized, alg, ext });
         default:
             throw new JOSENotSupported('Unsupported "kty" (Key Type) Parameter value');
     }

package/node_modules/jose/dist/webapi/lib/asn1.js

@@ -3,6 +3,7 @@ import { encodeBase64, decodeBase64 } from '../lib/base64.js';
 import { JOSENotSupported } from '../util/errors.js';
 import { keyAlgorithm, unsupportedAlg, algArgument } from './key_algorithm.js';
 import { isCryptoKey, isKeyObject } from './is_key_like.js';
+import { validateExtractableOption } from './key_options.js';
 const formatPEM = (b64, descriptor) => {
     const newlined = (b64.match(/.{1,64}/g) || []).join('\n');
     return `-----BEGIN ${descriptor}-----\n${newlined}\n-----END ${descriptor}-----`;
@@ -112,6 +113,7 @@ const parseECAlgorithmIdentifier = (state) => {
     throw new Error('Unsupported named curve');
 };
 const genericImport = async (keyFormat, keyData, alg, options) => {
+    const extractable = validateExtractableOption(options?.extractable);
     const entry = keyAlgorithm(alg, algArgument);
     if (entry.secret) {
         unsupportedAlg(algArgument);
@@ -131,7 +133,7 @@ const genericImport = async (keyFormat, keyData, alg, options) => {
     else {
         algorithm = entry.subtle;
     }
-    return crypto.subtle.importKey(keyFormat, keyData, algorithm, options?.extractable ?? isPublic, entry.usages[isPublic ? 0 : 1]);
+    return crypto.subtle.importKey(keyFormat, keyData, algorithm, extractable ?? isPublic, entry.usages[isPublic ? 0 : 1]);
 };
 const processPEMData = (pem, pattern) => {
     return decodeBase64(pem.replace(pattern, ''));
@@ -147,7 +149,10 @@ export const fromSPKI = (pem, alg, options) => {
 function spkiFromX509(buf) {
     const state = createASN1State(buf);
     expectTag(state, 0x30, 'Invalid certificate structure');
-    parseLength(state);
+    const certificateLength = parseLength(state);
+    if (certificateLength < 0 || state.pos + certificateLength > state.data.length) {
+        throw new Error('Unexpected end of ASN.1 input');
+    }
     expectTag(state, 0x30, 'Invalid tbsCertificate structure');
     parseLength(state);
     if (buf[state.pos] === 0xa0) {

package/node_modules/jose/dist/webapi/lib/content_encryption.js

@@ -51,25 +51,14 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     const [encKey, macKey, keySize] = await cbcKeySetup(enc, cek, 'decrypt');
     const macData = concat(aad, iv, ciphertext, uint64be(aad.length * 8));
     const expectedTag = await cbcHmacTag(macKey, macData, keySize);
-    let macCheckPassed;
     try {
-        macCheckPassed = await timingSafeEqual(tag, expectedTag);
+        if (await timingSafeEqual(tag, expectedTag)) {
+            return new Uint8Array(await crypto.subtle.decrypt({ iv: iv, name: 'AES-CBC' }, encKey, ciphertext));
+        }
     }
     catch {
     }
-    if (!macCheckPassed) {
-        throw new JWEDecryptionFailed();
-    }
-    let plaintext;
-    try {
-        plaintext = new Uint8Array(await crypto.subtle.decrypt({ iv: iv, name: 'AES-CBC' }, encKey, ciphertext));
-    }
-    catch {
-    }
-    if (!plaintext) {
-        throw new JWEDecryptionFailed();
-    }
-    return plaintext;
+    throw new JWEDecryptionFailed();
 }
 async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
     const encKey = cek instanceof Uint8Array
@@ -132,6 +121,9 @@ export async function decrypt(enc, cek, ciphertext, iv, tag, aad) {
     if (!tag) {
         throw new JWEInvalid('JWE Authentication Tag missing');
     }
+    if (!enc.cbc && tag.length !== 16) {
+        throw new JWEInvalid('Invalid Authentication Tag length');
+    }
     checkIvLength(enc, iv);
     if (cek instanceof Uint8Array) {
         checkCekLength(cek, enc.cekBits);

package/node_modules/jose/dist/webapi/lib/deflate.js

@@ -1,5 +1,13 @@
 import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
 import { concat } from './buffer_utils.js';
+export function validateZip(joseHeader, protectedHeader) {
+    if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
+        throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
+    }
+    if (joseHeader.zip !== undefined && !protectedHeader?.zip) {
+        throw new JWEInvalid('JWE "zip" (Compression Algorithm) Header Parameter MUST be in a protected header.');
+    }
+}
 function supported(name) {
     if (typeof globalThis[name] === 'undefined') {
         throw new JOSENotSupported(`JWE "zip" (Compression Algorithm) Header Parameter requires the ${name} API.`);

package/node_modules/jose/dist/webapi/lib/helpers.js

@@ -3,7 +3,7 @@ import { encode, strictDecoder } from './buffer_utils.js';
 import { isObject } from './type_checks.js';
 export const unprotected = Symbol();
 export function assertNotSet(value, name) {
-    if (value) {
+    if (value !== undefined) {
         throw new TypeError(`${name} can only be called once`);
     }
 }