jose 4.0.0 → 4.0.4

package/dist/browser/lib/cek.js

@@ -1,19 +1,21 @@
 import { JOSENotSupported } from '../util/errors.js';
 import random from '../runtime/random.js';
-const bitLengths = new Map([
-    ['A128CBC-HS256', 256],
-    ['A128GCM', 128],
-    ['A192CBC-HS384', 384],
-    ['A192GCM', 192],
-    ['A256CBC-HS512', 512],
-    ['A256GCM', 256],
-]);
-const generateCek = (alg) => {
-    const bitLength = bitLengths.get(alg);
-    if (!bitLength) {
-        throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
+export function bitLength(alg) {
+    switch (alg) {
+        case 'A128CBC-HS256':
+            return 256;
+        case 'A192CBC-HS384':
+            return 384;
+        case 'A256CBC-HS512':
+            return 512;
+        case 'A128GCM':
+            return 128;
+        case 'A192GCM':
+            return 192;
+        case 'A256GCM':
+            return 256;
+        default:
+            throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }
-    return random(new Uint8Array(bitLength >> 3));
-};
-export default generateCek;
-export { bitLengths };
+}
+export default (alg) => random(new Uint8Array(bitLength(alg) >> 3));

package/dist/browser/lib/check_iv_length.js

@@ -1,7 +1,7 @@
 import { JWEInvalid } from '../util/errors.js';
-import { bitLengths } from './iv.js';
+import { bitLength } from './iv.js';
 const checkIvLength = (enc, iv) => {
-    if (iv.length << 3 !== bitLengths.get(enc)) {
+    if (iv.length << 3 !== bitLength(enc)) {
         throw new JWEInvalid('Invalid Initialization Vector length');
     }
 };

package/dist/browser/lib/crypto_key.js

@@ -0,0 +1,160 @@
+import { isCloudflareWorkers, isNodeJs } from '../runtime/global.js';
+function getHashLength(hash) {
+    return parseInt(hash === null || hash === void 0 ? void 0 : hash.name.substr(4), 10);
+}
+function getNamedCurve(alg) {
+    switch (alg) {
+        case 'ES256':
+            return 'P-256';
+        case 'ES384':
+            return 'P-384';
+        case 'ES512':
+            return 'P-521';
+    }
+}
+function checkUsage(key, usages) {
+    if (usages.length && !usages.some((expected) => key.usages.includes(expected))) {
+        let msg = 'CryptoKey does not support this operation, its usages must include ';
+        if (usages.length > 2) {
+            const last = usages.pop();
+            msg += `one of ${usages.join(', ')}, or ${last}.`;
+        }
+        else if (usages.length === 2) {
+            msg += `one of ${usages[0]} or ${usages[1]}.`;
+        }
+        else {
+            msg += `${usages[0]}.`;
+        }
+        throw new TypeError(msg);
+    }
+}
+export function checkSigCryptoKey(key, alg, ...usages) {
+    switch (alg) {
+        case 'HS256':
+        case 'HS384':
+        case 'HS512': {
+            if (key.algorithm.name !== 'HMAC') {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be HMAC.`);
+            }
+            const expected = parseInt(alg.substr(2), 10);
+            const actual = getHashLength(key.algorithm.hash);
+            if (actual !== expected) {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.hash must be SHA-${expected}.`);
+            }
+            break;
+        }
+        case 'RS256':
+        case 'RS384':
+        case 'RS512': {
+            if (key.algorithm.name !== 'RSASSA-PKCS1-v1_5') {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be RSASSA-PKCS1-v1_5.`);
+            }
+            const expected = parseInt(alg.substr(2), 10);
+            const actual = getHashLength(key.algorithm.hash);
+            if (actual !== expected) {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.hash must be SHA-${expected}.`);
+            }
+            break;
+        }
+        case 'PS256':
+        case 'PS384':
+        case 'PS512': {
+            if (key.algorithm.name !== 'RSA-PSS') {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be RSA-PSS.`);
+            }
+            const expected = parseInt(alg.substr(2), 10);
+            const actual = getHashLength(key.algorithm.hash);
+            if (actual !== expected) {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.hash must be SHA-${expected}.`);
+            }
+            break;
+        }
+        case isNodeJs() && 'EdDSA': {
+            if (key.algorithm.name !== 'NODE-ED25519' && key.algorithm.name !== 'NODE-ED448') {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be NODE-ED25519 or NODE-ED448.`);
+            }
+            break;
+        }
+        case isCloudflareWorkers() && 'EdDSA': {
+            if (key.algorithm.name !== 'NODE-ED25519') {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be NODE-ED25519.`);
+            }
+            break;
+        }
+        case 'ES256':
+        case 'ES384':
+        case 'ES512': {
+            if (key.algorithm.name !== 'ECDSA') {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be ECDSA.`);
+            }
+            const expected = getNamedCurve(alg);
+            const actual = key.algorithm.namedCurve;
+            if (actual !== expected) {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.namedCurve must be ${expected}.`);
+            }
+            break;
+        }
+        default:
+            throw new TypeError('CryptoKey does not support this operation');
+    }
+    checkUsage(key, usages);
+}
+export function checkEncCryptoKey(key, alg, ...usages) {
+    switch (alg) {
+        case 'A128GCM':
+        case 'A192GCM':
+        case 'A256GCM': {
+            if (key.algorithm.name !== 'AES-GCM') {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be AES-GCM.`);
+            }
+            const expected = parseInt(alg.substr(1, 3), 10);
+            const actual = key.algorithm.length;
+            if (actual !== expected) {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.length must be ${expected}.`);
+            }
+            break;
+        }
+        case 'A128KW':
+        case 'A192KW':
+        case 'A256KW': {
+            if (key.algorithm.name !== 'AES-KW') {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be AES-KW.`);
+            }
+            const expected = parseInt(alg.substr(1, 3), 10);
+            const actual = key.algorithm.length;
+            if (actual !== expected) {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.length must be ${expected}.`);
+            }
+            break;
+        }
+        case 'ECDH-ES':
+            if (key.algorithm.name !== 'ECDH') {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be ECDH.`);
+            }
+            break;
+        case 'PBES2-HS256+A128KW':
+        case 'PBES2-HS384+A192KW':
+        case 'PBES2-HS512+A256KW':
+            if (key.algorithm.name !== 'PBKDF2') {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be PBKDF2.`);
+            }
+            break;
+        case 'RSA-OAEP':
+        case 'RSA-OAEP-256':
+        case 'RSA-OAEP-384':
+        case 'RSA-OAEP-512': {
+            if (key.algorithm.name !== 'RSA-OAEP') {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.name must be RSA-OAEP.`);
+            }
+            const expected = parseInt(alg.substr(9), 10) || 1;
+            const actual = getHashLength(key.algorithm.hash);
+            if (actual !== expected) {
+                throw new TypeError(`CryptoKey does not support this operation, its algorithm.hash must be SHA-${expected}.`);
+            }
+            break;
+        }
+        default:
+            throw new TypeError('CryptoKey does not support this operation');
+    }
+    checkUsage(key, usages);
+}

package/dist/browser/lib/decrypt_key_management.js

@@ -5,7 +5,7 @@ import { decrypt as rsaEs } from '../runtime/rsaes.js';
 import { unwrap as aesGcmKw } from '../runtime/aesgcmkw.js';
 import { decode as base64url } from '../runtime/base64url.js';
 import { JOSENotSupported, JWEInvalid } from '../util/errors.js';
-import { bitLengths as cekLengths } from '../lib/cek.js';
+import { bitLength as cekLength } from '../lib/cek.js';
 import { importJWK } from '../key/import.js';
 import checkKeyType from './check_key_type.js';
 import isObject from './is_object.js';
@@ -40,7 +40,7 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
                     throw new JWEInvalid(`JOSE Header "apv" (Agreement PartyVInfo) invalid`);
                 partyVInfo = base64url(joseHeader.apv);
             }
-            const sharedSecret = await ECDH.deriveKey(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, parseInt(alg.substr(-5, 3), 10) || cekLengths.get(joseHeader.enc), partyUInfo, partyVInfo);
+            const sharedSecret = await ECDH.deriveKey(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, parseInt(alg.substr(-5, 3), 10) || cekLength(joseHeader.enc), partyUInfo, partyVInfo);
             if (alg === 'ECDH-ES')
                 return sharedSecret;
             if (encryptedKey === undefined)

package/dist/browser/lib/encrypt_key_management.js

@@ -4,7 +4,7 @@ import { encrypt as pbes2Kw } from '../runtime/pbes2kw.js';
 import { encrypt as rsaEs } from '../runtime/rsaes.js';
 import { wrap as aesGcmKw } from '../runtime/aesgcmkw.js';
 import { encode as base64url } from '../runtime/base64url.js';
-import generateCek, { bitLengths as cekLengths } from '../lib/cek.js';
+import generateCek, { bitLength as cekLength } from '../lib/cek.js';
 import { JOSENotSupported } from '../util/errors.js';
 import { exportJWK } from '../key/export.js';
 import checkKeyType from './check_key_type.js';
@@ -29,7 +29,7 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
             let { epk: ephemeralKey } = providedParameters;
             ephemeralKey || (ephemeralKey = await ECDH.generateEpk(key));
             const { x, y, crv, kty } = await exportJWK(ephemeralKey);
-            const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, parseInt(alg.substr(-5, 3), 10) || cekLengths.get(enc), apu, apv);
+            const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, parseInt(alg.substr(-5, 3), 10) || cekLength(enc), apu, apv);
             parameters = { epk: { x, y, crv, kty } };
             if (apu)
                 parameters.apu = base64url(apu);

package/dist/browser/lib/iv.js

@@ -1,22 +1,27 @@
 import { JOSENotSupported } from '../util/errors.js';
 import random from '../runtime/random.js';
-const bitLengths = new Map([
-    ['A128CBC-HS256', 128],
-    ['A128GCM', 96],
-    ['A128GCMKW', 96],
-    ['A192CBC-HS384', 128],
-    ['A192GCM', 96],
-    ['A192GCMKW', 96],
-    ['A256CBC-HS512', 128],
-    ['A256GCM', 96],
-    ['A256GCMKW', 96],
-]);
-const generateIv = (alg) => {
-    const bitLength = bitLengths.get(alg);
-    if (!bitLength) {
-        throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
+export function bitLength(alg) {
+    switch (alg) {
+        case 'A128CBC-HS256':
+            return 128;
+        case 'A128GCM':
+            return 96;
+        case 'A128GCMKW':
+            return 96;
+        case 'A192CBC-HS384':
+            return 128;
+        case 'A192GCM':
+            return 96;
+        case 'A192GCMKW':
+            return 96;
+        case 'A256CBC-HS512':
+            return 128;
+        case 'A256GCM':
+            return 96;
+        case 'A256GCMKW':
+            return 96;
+        default:
+            throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }
-    return random(new Uint8Array(bitLength >> 3));
-};
-export default generateIv;
-export { bitLengths };
+}
+export default (alg) => random(new Uint8Array(bitLength(alg) >> 3));

package/dist/browser/runtime/aeskw.js

@@ -1,13 +1,15 @@
 import bogusWebCrypto from './bogus.js';
 import crypto, { isCryptoKey } from './webcrypto.js';
+import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import invalidKeyInput from './invalid_key_input.js';
 function checkKeySize(key, alg) {
     if (key.algorithm.length !== parseInt(alg.substr(1, 3), 10)) {
         throw new TypeError(`Invalid key size for alg: ${alg}`);
     }
 }
-function getCryptoKey(key, usage) {
+function getCryptoKey(key, alg, usage) {
     if (isCryptoKey(key)) {
+        checkEncCryptoKey(key, alg, usage);
         return key;
     }
     if (key instanceof Uint8Array) {
@@ -16,13 +18,13 @@ function getCryptoKey(key, usage) {
     throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'Uint8Array'));
 }
 export const wrap = async (alg, key, cek) => {
-    const cryptoKey = await getCryptoKey(key, 'wrapKey');
+    const cryptoKey = await getCryptoKey(key, alg, 'wrapKey');
     checkKeySize(cryptoKey, alg);
     const cryptoKeyCek = await crypto.subtle.importKey('raw', cek, ...bogusWebCrypto);
     return new Uint8Array(await crypto.subtle.wrapKey('raw', cryptoKeyCek, cryptoKey, 'AES-KW'));
 };
 export const unwrap = async (alg, key, encryptedKey) => {
-    const cryptoKey = await getCryptoKey(key, 'unwrapKey');
+    const cryptoKey = await getCryptoKey(key, alg, 'unwrapKey');
     checkKeySize(cryptoKey, alg);
     const cryptoKeyCek = await crypto.subtle.unwrapKey('raw', encryptedKey, cryptoKey, 'AES-KW', ...bogusWebCrypto);
     return new Uint8Array(await crypto.subtle.exportKey('raw', cryptoKeyCek));

package/dist/browser/runtime/check_cek_length.js

@@ -1,37 +1,7 @@
-import { JWEInvalid, JOSENotSupported } from '../util/errors.js';
-import { isCryptoKey } from './webcrypto.js';
-const checkCekLength = (enc, cek) => {
-    let expected;
-    switch (enc) {
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            expected = parseInt(enc.substr(-3), 10);
-            if (!(cek instanceof Uint8Array)) {
-                throw new TypeError(`${enc} content encryption requires Uint8Array as key input`);
-            }
-            break;
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM':
-            expected = parseInt(enc.substr(1, 3), 10);
-            break;
-        default:
-            throw new JOSENotSupported(`Content Encryption Algorithm ${enc} is not supported either by JOSE or your javascript runtime`);
+import { JWEInvalid } from '../util/errors.js';
+const checkCekLength = (cek, expected) => {
+    if (cek.length << 3 !== expected) {
+        throw new JWEInvalid('Invalid Content Encryption Key length');
     }
-    if (cek instanceof Uint8Array) {
-        if (cek.length << 3 !== expected) {
-            throw new JWEInvalid('Invalid Content Encryption Key length');
-        }
-        return;
-    }
-    if (isCryptoKey(cek)) {
-        const { length } = cek.algorithm;
-        if (length !== expected) {
-            throw new JWEInvalid('Invalid Content Encryption Key length');
-        }
-        return;
-    }
-    throw new TypeError('Invalid Content Encryption Key type');
 };
 export default checkCekLength;

package/dist/browser/runtime/decrypt.js

@@ -4,8 +4,12 @@ import checkCekLength from './check_cek_length.js';
 import timingSafeEqual from './timing_safe_equal.js';
 import { JOSENotSupported, JWEDecryptionFailed } from '../util/errors.js';
 import crypto, { isCryptoKey } from './webcrypto.js';
+import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import invalidKeyInput from './invalid_key_input.js';
 async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
+    if (!(cek instanceof Uint8Array)) {
+        throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
+    }
     const keySize = parseInt(enc.substr(1, 3), 10);
     const encKey = await crypto.subtle.importKey('raw', cek.subarray(keySize >> 3), 'AES-CBC', false, ['decrypt']);
     const macKey = await crypto.subtle.importKey('raw', cek.subarray(0, keySize >> 3), {
@@ -34,10 +38,15 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     }
     return plaintext;
 }
-async function gcmDecrypt(cek, ciphertext, iv, tag, aad) {
-    const encKey = cek instanceof Uint8Array
-        ? await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, ['decrypt'])
-        : cek;
+async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
+    let encKey;
+    if (cek instanceof Uint8Array) {
+        encKey = await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, ['decrypt']);
+    }
+    else {
+        checkEncCryptoKey(cek, enc, 'decrypt');
+        encKey = cek;
+    }
     try {
         return new Uint8Array(await crypto.subtle.decrypt({
             additionalData: aad,
@@ -54,17 +63,20 @@ const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'Uint8Array'));
     }
-    checkCekLength(enc, cek);
     checkIvLength(enc, iv);
     switch (enc) {
         case 'A128CBC-HS256':
         case 'A192CBC-HS384':
         case 'A256CBC-HS512':
+            if (cek instanceof Uint8Array)
+                checkCekLength(cek, parseInt(enc.substr(-3), 10));
             return cbcDecrypt(enc, cek, ciphertext, iv, tag, aad);
         case 'A128GCM':
         case 'A192GCM':
         case 'A256GCM':
-            return gcmDecrypt(cek, ciphertext, iv, tag, aad);
+            if (cek instanceof Uint8Array)
+                checkCekLength(cek, parseInt(enc.substr(1, 3), 10));
+            return gcmDecrypt(enc, cek, ciphertext, iv, tag, aad);
         default:
             throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
     }

package/dist/browser/runtime/ecdhes.js

@@ -1,14 +1,17 @@
 import { encoder, concat, uint32be, lengthAndInput, concatKdf } from '../lib/buffer_utils.js';
 import crypto, { isCryptoKey } from './webcrypto.js';
+import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import digest from './digest.js';
 import invalidKeyInput from './invalid_key_input.js';
 export const deriveKey = async (publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) => {
     if (!isCryptoKey(publicKey)) {
         throw new TypeError(invalidKeyInput(publicKey, 'CryptoKey'));
     }
+    checkEncCryptoKey(publicKey, 'ECDH-ES');
     if (!isCryptoKey(privateKey)) {
         throw new TypeError(invalidKeyInput(privateKey, 'CryptoKey'));
     }
+    checkEncCryptoKey(privateKey, 'ECDH-ES', 'deriveBits', 'deriveKey');
     const value = concat(lengthAndInput(encoder.encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength));
     if (!privateKey.usages.includes('deriveBits')) {
         throw new TypeError('ECDH-ES private key "usages" must include "deriveBits"');

package/dist/browser/runtime/encrypt.js

@@ -2,9 +2,13 @@ import { concat, uint64be } from '../lib/buffer_utils.js';
 import checkIvLength from '../lib/check_iv_length.js';
 import checkCekLength from './check_cek_length.js';
 import crypto, { isCryptoKey } from './webcrypto.js';
+import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import invalidKeyInput from './invalid_key_input.js';
 import { JOSENotSupported } from '../util/errors.js';
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
+    if (!(cek instanceof Uint8Array)) {
+        throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
+    }
     const keySize = parseInt(enc.substr(1, 3), 10);
     const encKey = await crypto.subtle.importKey('raw', cek.subarray(keySize >> 3), 'AES-CBC', false, ['encrypt']);
     const macKey = await crypto.subtle.importKey('raw', cek.subarray(0, keySize >> 3), {
@@ -19,10 +23,15 @@ async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     const tag = new Uint8Array((await crypto.subtle.sign('HMAC', macKey, macData)).slice(0, keySize >> 3));
     return { ciphertext, tag };
 }
-async function gcmEncrypt(plaintext, cek, iv, aad) {
-    const encKey = cek instanceof Uint8Array
-        ? await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, ['encrypt'])
-        : cek;
+async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
+    let encKey;
+    if (cek instanceof Uint8Array) {
+        encKey = await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, ['encrypt']);
+    }
+    else {
+        checkEncCryptoKey(cek, enc, 'encrypt');
+        encKey = cek;
+    }
     const encrypted = new Uint8Array(await crypto.subtle.encrypt({
         additionalData: aad,
         iv,
@@ -37,17 +46,20 @@ const encrypt = async (enc, plaintext, cek, iv, aad) => {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'Uint8Array'));
     }
-    checkCekLength(enc, cek);
     checkIvLength(enc, iv);
     switch (enc) {
         case 'A128CBC-HS256':
         case 'A192CBC-HS384':
         case 'A256CBC-HS512':
+            if (cek instanceof Uint8Array)
+                checkCekLength(cek, parseInt(enc.substr(-3), 10));
             return cbcEncrypt(enc, plaintext, cek, iv, aad);
         case 'A128GCM':
         case 'A192GCM':
         case 'A256GCM':
-            return gcmEncrypt(plaintext, cek, iv, aad);
+            if (cek instanceof Uint8Array)
+                checkCekLength(cek, parseInt(enc.substr(1, 3), 10));
+            return gcmEncrypt(enc, plaintext, cek, iv, aad);
         default:
             throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
     }

package/dist/browser/runtime/get_sign_verify_key.js

@@ -1,7 +1,9 @@
 import crypto, { isCryptoKey } from './webcrypto.js';
+import { checkSigCryptoKey } from '../lib/crypto_key.js';
 import invalidKeyInput from './invalid_key_input.js';
 export default function getCryptoKey(alg, key, usage) {
     if (isCryptoKey(key)) {
+        checkSigCryptoKey(key, alg, usage);
         return key;
     }
     if (key instanceof Uint8Array) {

package/dist/browser/runtime/pbes2kw.js

@@ -4,12 +4,14 @@ import { encode as base64url } from './base64url.js';
 import { wrap, unwrap } from './aeskw.js';
 import checkP2s from '../lib/check_p2s.js';
 import crypto, { isCryptoKey } from './webcrypto.js';
+import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import invalidKeyInput from './invalid_key_input.js';
-function getCryptoKey(key) {
+function getCryptoKey(key, alg) {
     if (key instanceof Uint8Array) {
         return crypto.subtle.importKey('raw', key, 'PBKDF2', false, ['deriveBits']);
     }
     if (isCryptoKey(key)) {
+        checkEncCryptoKey(key, alg, 'deriveBits', 'deriveKey');
         return key;
     }
     throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'Uint8Array'));
@@ -28,7 +30,7 @@ export const encrypt = async (alg, key, cek, p2c = Math.floor(Math.random() * 20
         length: keylen,
         name: 'AES-KW',
     };
-    const cryptoKey = await getCryptoKey(key);
+    const cryptoKey = await getCryptoKey(key, alg);
     let derived;
     if (cryptoKey.usages.includes('deriveBits')) {
         derived = new Uint8Array(await crypto.subtle.deriveBits(subtleAlg, cryptoKey, keylen));
@@ -56,7 +58,7 @@ export const decrypt = async (alg, key, encryptedKey, p2c, p2s) => {
         length: keylen,
         name: 'AES-KW',
     };
-    const cryptoKey = await getCryptoKey(key);
+    const cryptoKey = await getCryptoKey(key, alg);
     let derived;
     if (cryptoKey.usages.includes('deriveBits')) {
         derived = new Uint8Array(await crypto.subtle.deriveBits(subtleAlg, cryptoKey, keylen));

package/dist/browser/runtime/rsaes.js

@@ -1,12 +1,14 @@
 import subtleAlgorithm from './subtle_rsaes.js';
 import bogusWebCrypto from './bogus.js';
 import crypto, { isCryptoKey } from './webcrypto.js';
+import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import checkKeyLength from './check_key_length.js';
 import invalidKeyInput from './invalid_key_input.js';
 export const encrypt = async (alg, key, cek) => {
     if (!isCryptoKey(key)) {
         throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
     }
+    checkEncCryptoKey(key, alg, 'encrypt', 'wrapKey');
     checkKeyLength(alg, key);
     if (key.usages.includes('encrypt')) {
         return new Uint8Array(await crypto.subtle.encrypt(subtleAlgorithm(alg), key, cek));
@@ -21,6 +23,7 @@ export const decrypt = async (alg, key, encryptedKey) => {
     if (!isCryptoKey(key)) {
         throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
     }
+    checkEncCryptoKey(key, alg, 'decrypt', 'unwrapKey');
     checkKeyLength(alg, key);
     if (key.usages.includes('decrypt')) {
         return new Uint8Array(await crypto.subtle.decrypt(subtleAlgorithm(alg), key, encryptedKey));

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

@@ -1,22 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bitLengths = void 0;
+exports.bitLength = void 0;
 const errors_js_1 = require("../util/errors.js");
 const random_js_1 = require("../runtime/random.js");
-const bitLengths = new Map([
-    ['A128CBC-HS256', 256],
-    ['A128GCM', 128],
-    ['A192CBC-HS384', 384],
-    ['A192GCM', 192],
-    ['A256CBC-HS512', 512],
-    ['A256GCM', 256],
-]);
-exports.bitLengths = bitLengths;
-const generateCek = (alg) => {
-    const bitLength = bitLengths.get(alg);
-    if (!bitLength) {
-        throw new errors_js_1.JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
+function bitLength(alg) {
+    switch (alg) {
+        case 'A128CBC-HS256':
+            return 256;
+        case 'A192CBC-HS384':
+            return 384;
+        case 'A256CBC-HS512':
+            return 512;
+        case 'A128GCM':
+            return 128;
+        case 'A192GCM':
+            return 192;
+        case 'A256GCM':
+            return 256;
+        default:
+            throw new errors_js_1.JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }
-    return (0, random_js_1.default)(new Uint8Array(bitLength >> 3));
-};
-exports.default = generateCek;
+}
+exports.bitLength = bitLength;
+exports.default = (alg) => (0, random_js_1.default)(new Uint8Array(bitLength(alg) >> 3));

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const errors_js_1 = require("../util/errors.js");
 const iv_js_1 = require("./iv.js");
 const checkIvLength = (enc, iv) => {
-    if (iv.length << 3 !== iv_js_1.bitLengths.get(enc)) {
+    if (iv.length << 3 !== (0, iv_js_1.bitLength)(enc)) {
         throw new errors_js_1.JWEInvalid('Invalid Initialization Vector length');
     }
 };