jose 4.0.3 → 4.1.2

package/dist/browser/{runtime → lib}/aesgcmkw.js

@@ -1,14 +1,14 @@
-import encrypt from './encrypt.js';
-import decrypt from './decrypt.js';
-import generateIv from '../lib/iv.js';
-import { encode as base64url } from './base64url.js';
-export const wrap = async (alg, key, cek, iv) => {
+import encrypt from '../runtime/encrypt.js';
+import decrypt from '../runtime/decrypt.js';
+import generateIv from './iv.js';
+import { encode as base64url } from '../runtime/base64url.js';
+export async function wrap(alg, key, cek, iv) {
     const jweAlgorithm = alg.substr(0, 7);
     iv || (iv = generateIv(jweAlgorithm));
     const { ciphertext: encryptedKey, tag } = await encrypt(jweAlgorithm, cek, key, iv, new Uint8Array(0));
     return { encryptedKey, iv: base64url(iv), tag: base64url(tag) };
-};
-export const unwrap = async (alg, key, encryptedKey, iv, tag) => {
+}
+export async function unwrap(alg, key, encryptedKey, iv, tag) {
     const jweAlgorithm = alg.substr(0, 7);
     return decrypt(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array(0));
-};
+}

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/check_key_type.js

@@ -1,4 +1,4 @@
-import invalidKeyInput from '../runtime/invalid_key_input.js';
+import invalidKeyInput from './invalid_key_input.js';
 import isKeyLike, { types } from '../runtime/is_key_like.js';
 const symmetricTypeCheck = (key) => {
     if (key instanceof Uint8Array)

package/dist/browser/lib/crypto_key.js

@@ -0,0 +1,150 @@
+import { isCloudflareWorkers, isNodeJs } from '../runtime/global.js';
+function unusable(name, prop = 'algorithm.name') {
+    return new TypeError(`CryptoKey does not support this operation, its ${prop} must be ${name}`);
+}
+function isAlgorithm(algorithm, name) {
+    return algorithm.name === name;
+}
+function getHashLength(hash) {
+    return parseInt(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';
+        default:
+            throw new Error('unreachable');
+    }
+}
+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 (!isAlgorithm(key.algorithm, 'HMAC'))
+                throw unusable('HMAC');
+            const expected = parseInt(alg.substr(2), 10);
+            const actual = getHashLength(key.algorithm.hash);
+            if (actual !== expected)
+                throw unusable(`SHA-${expected}`, 'algorithm.hash');
+            break;
+        }
+        case 'RS256':
+        case 'RS384':
+        case 'RS512': {
+            if (!isAlgorithm(key.algorithm, 'RSASSA-PKCS1-v1_5'))
+                throw unusable('RSASSA-PKCS1-v1_5');
+            const expected = parseInt(alg.substr(2), 10);
+            const actual = getHashLength(key.algorithm.hash);
+            if (actual !== expected)
+                throw unusable(`SHA-${expected}`, 'algorithm.hash');
+            break;
+        }
+        case 'PS256':
+        case 'PS384':
+        case 'PS512': {
+            if (!isAlgorithm(key.algorithm, 'RSA-PSS'))
+                throw unusable('RSA-PSS');
+            const expected = parseInt(alg.substr(2), 10);
+            const actual = getHashLength(key.algorithm.hash);
+            if (actual !== expected)
+                throw unusable(`SHA-${expected}`, 'algorithm.hash');
+            break;
+        }
+        case isNodeJs() && 'EdDSA': {
+            if (key.algorithm.name !== 'NODE-ED25519' && key.algorithm.name !== 'NODE-ED448')
+                throw unusable('NODE-ED25519 or NODE-ED448');
+            break;
+        }
+        case isCloudflareWorkers() && 'EdDSA': {
+            if (!isAlgorithm(key.algorithm, 'NODE-ED25519'))
+                throw unusable('NODE-ED25519');
+            break;
+        }
+        case 'ES256':
+        case 'ES384':
+        case 'ES512': {
+            if (!isAlgorithm(key.algorithm, 'ECDSA'))
+                throw unusable('ECDSA');
+            const expected = getNamedCurve(alg);
+            const actual = key.algorithm.namedCurve;
+            if (actual !== expected)
+                throw unusable(expected, 'algorithm.namedCurve');
+            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 (!isAlgorithm(key.algorithm, 'AES-GCM'))
+                throw unusable('AES-GCM');
+            const expected = parseInt(alg.substr(1, 3), 10);
+            const actual = key.algorithm.length;
+            if (actual !== expected)
+                throw unusable(expected, 'algorithm.length');
+            break;
+        }
+        case 'A128KW':
+        case 'A192KW':
+        case 'A256KW': {
+            if (!isAlgorithm(key.algorithm, 'AES-KW'))
+                throw unusable('AES-KW');
+            const expected = parseInt(alg.substr(1, 3), 10);
+            const actual = key.algorithm.length;
+            if (actual !== expected)
+                throw unusable(expected, 'algorithm.length');
+            break;
+        }
+        case 'ECDH-ES':
+            if (!isAlgorithm(key.algorithm, 'ECDH'))
+                throw unusable('ECDH');
+            break;
+        case 'PBES2-HS256+A128KW':
+        case 'PBES2-HS384+A192KW':
+        case 'PBES2-HS512+A256KW':
+            if (!isAlgorithm(key.algorithm, 'PBKDF2'))
+                throw unusable('PBKDF2');
+            break;
+        case 'RSA-OAEP':
+        case 'RSA-OAEP-256':
+        case 'RSA-OAEP-384':
+        case 'RSA-OAEP-512': {
+            if (!isAlgorithm(key.algorithm, 'RSA-OAEP'))
+                throw unusable('RSA-OAEP');
+            const expected = parseInt(alg.substr(9), 10) || 1;
+            const actual = getHashLength(key.algorithm.hash);
+            if (actual !== expected)
+                throw unusable(`SHA-${expected}`, 'algorithm.hash');
+            break;
+        }
+        default:
+            throw new TypeError('CryptoKey does not support this operation');
+    }
+    checkUsage(key, usages);
+}

package/dist/browser/lib/decrypt_key_management.js

@@ -2,13 +2,13 @@ import { unwrap as aesKw } from '../runtime/aeskw.js';
 import * as ECDH from '../runtime/ecdhes.js';
 import { decrypt as pbes2Kw } from '../runtime/pbes2kw.js';
 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';
+import { unwrap as aesGcmKw } from './aesgcmkw.js';
 async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
     checkKeyType(alg, key, 'decrypt');
     switch (alg) {
@@ -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

@@ -2,12 +2,12 @@ import { wrap as aesKw } from '../runtime/aeskw.js';
 import * as ECDH from '../runtime/ecdhes.js';
 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';
+import { wrap as aesGcmKw } from './aesgcmkw.js';
 async function encryptKeyManagement(alg, enc, key, providedCek, providedParameters = {}) {
     let encryptedKey;
     let parameters;
@@ -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,6 +1,7 @@
 import bogusWebCrypto from './bogus.js';
-import crypto, { checkCryptoKey, isCryptoKey } from './webcrypto.js';
-import invalidKeyInput from './invalid_key_input.js';
+import crypto, { isCryptoKey } from './webcrypto.js';
+import { checkEncCryptoKey } from '../lib/crypto_key.js';
+import invalidKeyInput from '../lib/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}`);
@@ -8,7 +9,7 @@ function checkKeySize(key, alg) {
 }
 function getCryptoKey(key, alg, usage) {
     if (isCryptoKey(key)) {
-        checkCryptoKey(key, alg, usage);
+        checkEncCryptoKey(key, alg, usage);
         return key;
     }
     if (key instanceof Uint8Array) {

package/dist/browser/runtime/asn1.js

@@ -1,6 +1,6 @@
 import globalThis, { isCloudflareWorkers, isNodeJs } from './global.js';
 import crypto, { isCryptoKey } from './webcrypto.js';
-import invalidKeyInput from './invalid_key_input.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 import { encodeBase64 } from './base64url.js';
 import formatPEM from '../lib/format_pem.js';
 import { JOSENotSupported } from '../util/errors.js';
@@ -63,13 +63,13 @@ const genericImport = async (replace, keyFormat, pem, alg, options) => {
         case 'PS256':
         case 'PS384':
         case 'PS512':
-            algorithm = { name: 'RSA-PSS', hash: { name: `SHA-${alg.substr(-3)}` } };
+            algorithm = { name: 'RSA-PSS', hash: `SHA-${alg.substr(-3)}` };
             keyUsages = isPublic ? ['verify'] : ['sign'];
             break;
         case 'RS256':
         case 'RS384':
         case 'RS512':
-            algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: { name: `SHA-${alg.substr(-3)}` } };
+            algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: `SHA-${alg.substr(-3)}` };
             keyUsages = isPublic ? ['verify'] : ['sign'];
             break;
         case 'RSA-OAEP':
@@ -78,7 +78,7 @@ const genericImport = async (replace, keyFormat, pem, alg, options) => {
         case 'RSA-OAEP-512':
             algorithm = {
                 name: 'RSA-OAEP',
-                hash: { name: `SHA-${parseInt(alg.substr(-3), 10) || 1}` },
+                hash: `SHA-${parseInt(alg.substr(-3), 10) || 1}`,
             };
             keyUsages = isPublic ? ['encrypt', 'wrapKey'] : ['decrypt', 'unwrapKey'];
             break;

package/dist/browser/runtime/bogus.js

@@ -1,5 +1,5 @@
 const bogusWebCrypto = [
-    { hash: { name: 'SHA-256' }, name: 'HMAC' },
+    { hash: 'SHA-256', name: 'HMAC' },
     true,
     ['sign'],
 ];

package/dist/browser/runtime/check_cek_length.js

@@ -0,0 +1,7 @@
+import { JWEInvalid } from '../util/errors.js';
+const checkCekLength = (cek, expected) => {
+    if (cek.length << 3 !== expected) {
+        throw new JWEInvalid('Invalid Content Encryption Key length');
+    }
+};
+export default checkCekLength;

package/dist/browser/runtime/decrypt.js

@@ -1,9 +1,11 @@
 import { concat, uint64be } from '../lib/buffer_utils.js';
 import checkIvLength from '../lib/check_iv_length.js';
+import checkCekLength from './check_cek_length.js';
 import timingSafeEqual from './timing_safe_equal.js';
 import { JOSENotSupported, JWEDecryptionFailed } from '../util/errors.js';
-import crypto, { checkCryptoKey, isCryptoKey } from './webcrypto.js';
-import invalidKeyInput from './invalid_key_input.js';
+import crypto, { isCryptoKey } from './webcrypto.js';
+import { checkEncCryptoKey } from '../lib/crypto_key.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     if (!(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
@@ -11,7 +13,7 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     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), {
-        hash: { name: `SHA-${keySize << 1}` },
+        hash: `SHA-${keySize << 1}`,
         name: 'HMAC',
     }, false, ['sign']);
     const macData = concat(aad, iv, ciphertext, uint64be(aad.length << 3));
@@ -42,7 +44,7 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
         encKey = await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, ['decrypt']);
     }
     else {
-        checkCryptoKey(cek, enc, 'decrypt');
+        checkEncCryptoKey(cek, enc, 'decrypt');
         encKey = cek;
     }
     try {
@@ -66,10 +68,14 @@ const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
         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':
+            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,16 +1,17 @@
 import { encoder, concat, uint32be, lengthAndInput, concatKdf } from '../lib/buffer_utils.js';
-import crypto, { checkCryptoKey, isCryptoKey } from './webcrypto.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';
+import invalidKeyInput from '../lib/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'));
     }
-    checkCryptoKey(publicKey, 'ECDH-ES');
+    checkEncCryptoKey(publicKey, 'ECDH-ES');
     if (!isCryptoKey(privateKey)) {
         throw new TypeError(invalidKeyInput(privateKey, 'CryptoKey'));
     }
-    checkCryptoKey(privateKey, 'ECDH-ES', 'deriveBits', 'deriveKey');
+    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

@@ -1,7 +1,9 @@
 import { concat, uint64be } from '../lib/buffer_utils.js';
 import checkIvLength from '../lib/check_iv_length.js';
-import crypto, { checkCryptoKey, isCryptoKey } from './webcrypto.js';
-import invalidKeyInput from './invalid_key_input.js';
+import checkCekLength from './check_cek_length.js';
+import crypto, { isCryptoKey } from './webcrypto.js';
+import { checkEncCryptoKey } from '../lib/crypto_key.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 import { JOSENotSupported } from '../util/errors.js';
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     if (!(cek instanceof Uint8Array)) {
@@ -10,7 +12,7 @@ async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     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), {
-        hash: { name: `SHA-${keySize << 1}` },
+        hash: `SHA-${keySize << 1}`,
         name: 'HMAC',
     }, false, ['sign']);
     const ciphertext = new Uint8Array(await crypto.subtle.encrypt({
@@ -27,7 +29,7 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
         encKey = await crypto.subtle.importKey('raw', cek, 'AES-GCM', false, ['encrypt']);
     }
     else {
-        checkCryptoKey(cek, enc, 'encrypt');
+        checkEncCryptoKey(cek, enc, 'encrypt');
         encKey = cek;
     }
     const encrypted = new Uint8Array(await crypto.subtle.encrypt({
@@ -49,10 +51,14 @@ const encrypt = async (enc, plaintext, cek, iv, aad) => {
         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':
+            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/generate.js

@@ -12,7 +12,7 @@ export async function generateSecret(alg, options) {
         case 'HS384':
         case 'HS512':
             length = parseInt(alg.substr(-3), 10);
-            algorithm = { name: 'HMAC', hash: { name: `SHA-${length}` }, length };
+            algorithm = { name: 'HMAC', hash: `SHA-${length}`, length };
             keyUsages = ['sign', 'verify'];
             break;
         case 'A128CBC-HS256':
@@ -60,7 +60,7 @@ export async function generateKeyPair(alg, options) {
         case 'PS512':
             algorithm = {
                 name: 'RSA-PSS',
-                hash: { name: `SHA-${alg.substr(-3)}` },
+                hash: `SHA-${alg.substr(-3)}`,
                 publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                 modulusLength: getModulusLengthOption(options),
             };
@@ -71,7 +71,7 @@ export async function generateKeyPair(alg, options) {
         case 'RS512':
             algorithm = {
                 name: 'RSASSA-PKCS1-v1_5',
-                hash: { name: `SHA-${alg.substr(-3)}` },
+                hash: `SHA-${alg.substr(-3)}`,
                 publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                 modulusLength: getModulusLengthOption(options),
             };
@@ -83,7 +83,7 @@ export async function generateKeyPair(alg, options) {
         case 'RSA-OAEP-512':
             algorithm = {
                 name: 'RSA-OAEP',
-                hash: { name: `SHA-${parseInt(alg.substr(-3), 10) || 1}` },
+                hash: `SHA-${parseInt(alg.substr(-3), 10) || 1}`,
                 publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                 modulusLength: getModulusLengthOption(options),
             };

package/dist/browser/runtime/get_sign_verify_key.js

@@ -1,15 +1,16 @@
-import crypto, { checkCryptoKey, isCryptoKey } from './webcrypto.js';
-import invalidKeyInput from './invalid_key_input.js';
+import crypto, { isCryptoKey } from './webcrypto.js';
+import { checkSigCryptoKey } from '../lib/crypto_key.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 export default function getCryptoKey(alg, key, usage) {
     if (isCryptoKey(key)) {
-        checkCryptoKey(key, alg, usage);
+        checkSigCryptoKey(key, alg, usage);
         return key;
     }
     if (key instanceof Uint8Array) {
         if (!alg.startsWith('HS')) {
             throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
         }
-        return crypto.subtle.importKey('raw', key, { hash: { name: `SHA-${alg.substr(-3)}` }, name: 'HMAC' }, false, [usage]);
+        return crypto.subtle.importKey('raw', key, { hash: `SHA-${alg.substr(-3)}`, name: 'HMAC' }, false, [usage]);
     }
     throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'Uint8Array'));
 }

package/dist/browser/runtime/jwk_to_key.js

@@ -11,7 +11,7 @@ function subtleMapping(jwk) {
                 case 'HS256':
                 case 'HS384':
                 case 'HS512':
-                    algorithm = { name: 'HMAC', hash: { name: `SHA-${jwk.alg.substr(-3)}` } };
+                    algorithm = { name: 'HMAC', hash: `SHA-${jwk.alg.substr(-3)}` };
                     keyUsages = ['sign', 'verify'];
                     break;
                 case 'A128CBC-HS256':
@@ -49,13 +49,13 @@ function subtleMapping(jwk) {
                 case 'PS256':
                 case 'PS384':
                 case 'PS512':
-                    algorithm = { name: 'RSA-PSS', hash: { name: `SHA-${jwk.alg.substr(-3)}` } };
+                    algorithm = { name: 'RSA-PSS', hash: `SHA-${jwk.alg.substr(-3)}` };
                     keyUsages = jwk.d ? ['sign'] : ['verify'];
                     break;
                 case 'RS256':
                 case 'RS384':
                 case 'RS512':
-                    algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: { name: `SHA-${jwk.alg.substr(-3)}` } };
+                    algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: `SHA-${jwk.alg.substr(-3)}` };
                     keyUsages = jwk.d ? ['sign'] : ['verify'];
                     break;
                 case 'RSA-OAEP':
@@ -64,7 +64,7 @@ function subtleMapping(jwk) {
                 case 'RSA-OAEP-512':
                     algorithm = {
                         name: 'RSA-OAEP',
-                        hash: { name: `SHA-${parseInt(jwk.alg.substr(-3), 10) || 1}` },
+                        hash: `SHA-${parseInt(jwk.alg.substr(-3), 10) || 1}`,
                     };
                     keyUsages = jwk.d ? ['decrypt', 'unwrapKey'] : ['encrypt', 'wrapKey'];
                     break;

package/dist/browser/runtime/key_to_jwk.js

@@ -1,5 +1,5 @@
 import crypto, { isCryptoKey } from './webcrypto.js';
-import invalidKeyInput from './invalid_key_input.js';
+import invalidKeyInput from '../lib/invalid_key_input.js';
 import { encode as base64url } from './base64url.js';
 const keyToJWK = async (key) => {
     if (key instanceof Uint8Array) {