jose 5.10.0 → 6.0.0

package/dist/{browser → webapi}/lib/buffer_utils.js

@@ -1,8 +1,11 @@
-import digest from '../runtime/digest.js';
 export const encoder = new TextEncoder();
 export const decoder = new TextDecoder();
 const MAX_INT32 = 2 ** 32;
+const Buffer = globalThis.process?.getBuiltinModule?.('node:buffer')?.Buffer;
+export { Buffer };
 export function concat(...buffers) {
+    if (Buffer)
+        return Buffer.concat(buffers);
     const size = buffers.reduce((acc, { length }) => acc + length, 0);
     const buf = new Uint8Array(size);
     let i = 0;
@@ -12,9 +15,6 @@ export function concat(...buffers) {
     }
     return buf;
 }
-export function p2s(alg, p2sInput) {
-    return concat(encoder.encode(alg), new Uint8Array([0]), p2sInput);
-}
 function writeUInt32BE(buf, value, offset) {
     if (value < 0 || value >= MAX_INT32) {
         throw new RangeError(`value must be >= 0 and <= ${MAX_INT32 - 1}. Received ${value}`);
@@ -34,18 +34,3 @@ export function uint32be(value) {
     writeUInt32BE(buf, value);
     return buf;
 }
-export function lengthAndInput(input) {
-    return concat(uint32be(input.length), input);
-}
-export async function concatKdf(secret, bits, value) {
-    const iterations = Math.ceil((bits >> 3) / 32);
-    const res = new Uint8Array(iterations * 32);
-    for (let iter = 0; iter < iterations; iter++) {
-        const buf = new Uint8Array(4 + secret.length + value.length);
-        buf.set(uint32be(iter + 1));
-        buf.set(secret, 4);
-        buf.set(value, 4 + secret.length);
-        res.set(await digest('sha256', buf), iter * 32);
-    }
-    return res.slice(0, bits >> 3);
-}

package/dist/{browser → webapi}/lib/cek.js

@@ -1,5 +1,4 @@
 import { JOSENotSupported } from '../util/errors.js';
-import random from '../runtime/random.js';
 export function bitLength(alg) {
     switch (alg) {
         case 'A128GCM':
@@ -17,4 +16,4 @@ export function bitLength(alg) {
             throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }
 }
-export default (alg) => random(new Uint8Array(bitLength(alg) >> 3));
+export default (alg) => crypto.getRandomValues(new Uint8Array(bitLength(alg) >> 3));

package/dist/{browser/runtime → webapi/lib}/check_cek_length.js

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

package/dist/{browser → webapi}/lib/check_iv_length.js

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

package/dist/webapi/lib/check_key_type.js

@@ -0,0 +1,126 @@
+import { withAlg as invalidKeyInput } from './invalid_key_input.js';
+import isKeyLike from './is_key_like.js';
+import * as jwk from './is_jwk.js';
+const tag = (key) => key?.[Symbol.toStringTag];
+const jwkMatchesOp = (alg, key, usage) => {
+    if (key.use !== undefined) {
+        let expected;
+        switch (usage) {
+            case 'sign':
+            case 'verify':
+                expected = 'sig';
+                break;
+            case 'encrypt':
+            case 'decrypt':
+                expected = 'enc';
+                break;
+        }
+        if (key.use !== expected) {
+            throw new TypeError(`Invalid key for this operation, its "use" must be "${expected}" when present`);
+        }
+    }
+    if (key.alg !== undefined && key.alg !== alg) {
+        throw new TypeError(`Invalid key for this operation, its "alg" must be "${alg}" when present`);
+    }
+    if (Array.isArray(key.key_ops)) {
+        let expectedKeyOp;
+        switch (true) {
+            case usage === 'sign' || usage === 'verify':
+            case alg === 'dir':
+            case alg.includes('CBC-HS'):
+                expectedKeyOp = usage;
+                break;
+            case alg.startsWith('PBES2'):
+                expectedKeyOp = 'deriveBits';
+                break;
+            case /^A\d{3}(?:GCM)?(?:KW)?$/.test(alg):
+                if (!alg.includes('GCM') && alg.endsWith('KW')) {
+                    expectedKeyOp = usage === 'encrypt' ? 'wrapKey' : 'unwrapKey';
+                }
+                else {
+                    expectedKeyOp = usage;
+                }
+                break;
+            case usage === 'encrypt' && alg.startsWith('RSA'):
+                expectedKeyOp = 'wrapKey';
+                break;
+            case usage === 'decrypt':
+                expectedKeyOp = alg.startsWith('RSA') ? 'unwrapKey' : 'deriveBits';
+                break;
+        }
+        if (expectedKeyOp && key.key_ops?.includes?.(expectedKeyOp) === false) {
+            throw new TypeError(`Invalid key for this operation, its "key_ops" must include "${expectedKeyOp}" when present`);
+        }
+    }
+    return true;
+};
+const symmetricTypeCheck = (alg, key, usage) => {
+    if (key instanceof Uint8Array)
+        return;
+    if (jwk.isJWK(key)) {
+        if (jwk.isSecretJWK(key) && jwkMatchesOp(alg, key, usage))
+            return;
+        throw new TypeError(`JSON Web Key for symmetric algorithms must have JWK "kty" (Key Type) equal to "oct" and the JWK "k" (Key Value) present`);
+    }
+    if (!isKeyLike(key)) {
+        throw new TypeError(invalidKeyInput(alg, key, 'CryptoKey', 'KeyObject', 'JSON Web Key', 'Uint8Array'));
+    }
+    if (key.type !== 'secret') {
+        throw new TypeError(`${tag(key)} instances for symmetric algorithms must be of type "secret"`);
+    }
+};
+const asymmetricTypeCheck = (alg, key, usage) => {
+    if (jwk.isJWK(key)) {
+        switch (usage) {
+            case 'decrypt':
+            case 'sign':
+                if (jwk.isPrivateJWK(key) && jwkMatchesOp(alg, key, usage))
+                    return;
+                throw new TypeError(`JSON Web Key for this operation be a private JWK`);
+            case 'encrypt':
+            case 'verify':
+                if (jwk.isPublicJWK(key) && jwkMatchesOp(alg, key, usage))
+                    return;
+                throw new TypeError(`JSON Web Key for this operation be a public JWK`);
+        }
+    }
+    if (!isKeyLike(key)) {
+        throw new TypeError(invalidKeyInput(alg, key, 'CryptoKey', 'KeyObject', 'JSON Web Key'));
+    }
+    if (key.type === 'secret') {
+        throw new TypeError(`${tag(key)} instances for asymmetric algorithms must not be of type "secret"`);
+    }
+    if (key.type === 'public') {
+        switch (usage) {
+            case 'sign':
+                throw new TypeError(`${tag(key)} instances for asymmetric algorithm signing must be of type "private"`);
+            case 'decrypt':
+                throw new TypeError(`${tag(key)} instances for asymmetric algorithm decryption must be of type "private"`);
+            default:
+                break;
+        }
+    }
+    if (key.type === 'private') {
+        switch (usage) {
+            case 'verify':
+                throw new TypeError(`${tag(key)} instances for asymmetric algorithm verifying must be of type "public"`);
+            case 'encrypt':
+                throw new TypeError(`${tag(key)} instances for asymmetric algorithm encryption must be of type "public"`);
+            default:
+                break;
+        }
+    }
+};
+export default (alg, key, usage) => {
+    const symmetric = alg.startsWith('HS') ||
+        alg === 'dir' ||
+        alg.startsWith('PBES2') ||
+        /^A(?:128|192|256)(?:GCM)?(?:KW)?$/.test(alg) ||
+        /^A(?:128|192|256)CBC-HS(?:256|384|512)$/.test(alg);
+    if (symmetric) {
+        symmetricTypeCheck(alg, key, usage);
+    }
+    else {
+        asymmetricTypeCheck(alg, key, usage);
+    }
+};

package/dist/{node/esm → webapi}/lib/crypto_key.js

@@ -19,23 +19,12 @@ function getNamedCurve(alg) {
             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);
+function checkUsage(key, usage) {
+    if (usage && !key.usages.includes(usage)) {
+        throw new TypeError(`CryptoKey does not support this operation, its usages must include ${usage}.`);
     }
 }
-export function checkSigCryptoKey(key, alg, ...usages) {
+export function checkSigCryptoKey(key, alg, usage) {
     switch (alg) {
         case 'HS256':
         case 'HS384':
@@ -70,13 +59,8 @@ export function checkSigCryptoKey(key, alg, ...usages) {
                 throw unusable(`SHA-${expected}`, 'algorithm.hash');
             break;
         }
+        case 'Ed25519':
         case 'EdDSA': {
-            if (key.algorithm.name !== 'Ed25519' && key.algorithm.name !== 'Ed448') {
-                throw unusable('Ed25519 or Ed448');
-            }
-            break;
-        }
-        case 'Ed25519': {
             if (!isAlgorithm(key.algorithm, 'Ed25519'))
                 throw unusable('Ed25519');
             break;
@@ -95,9 +79,9 @@ export function checkSigCryptoKey(key, alg, ...usages) {
         default:
             throw new TypeError('CryptoKey does not support this operation');
     }
-    checkUsage(key, usages);
+    checkUsage(key, usage);
 }
-export function checkEncCryptoKey(key, alg, ...usages) {
+export function checkEncCryptoKey(key, alg, usage) {
     switch (alg) {
         case 'A128GCM':
         case 'A192GCM':
@@ -125,10 +109,9 @@ export function checkEncCryptoKey(key, alg, ...usages) {
             switch (key.algorithm.name) {
                 case 'ECDH':
                 case 'X25519':
-                case 'X448':
                     break;
                 default:
-                    throw unusable('ECDH, X25519, or X448');
+                    throw unusable('ECDH or X25519');
             }
             break;
         }
@@ -153,5 +136,5 @@ export function checkEncCryptoKey(key, alg, ...usages) {
         default:
             throw new TypeError('CryptoKey does not support this operation');
     }
-    checkUsage(key, usages);
+    checkUsage(key, usage);
 }

package/dist/{browser/runtime → webapi/lib}/decrypt.js

@@ -1,12 +1,29 @@
-import { concat, uint64be } from '../lib/buffer_utils.js';
-import checkIvLength from '../lib/check_iv_length.js';
+import { concat, uint64be } from './buffer_utils.js';
+import checkIvLength from './check_iv_length.js';
 import checkCekLength from './check_cek_length.js';
-import timingSafeEqual from './timing_safe_equal.js';
 import { JOSENotSupported, JWEDecryptionFailed, JWEInvalid } from '../util/errors.js';
-import crypto, { isCryptoKey } from './webcrypto.js';
-import { checkEncCryptoKey } from '../lib/crypto_key.js';
-import invalidKeyInput from '../lib/invalid_key_input.js';
-import { types } from './is_key_like.js';
+import { checkEncCryptoKey } from './crypto_key.js';
+import invalidKeyInput from './invalid_key_input.js';
+import { isCryptoKey } from './is_key_like.js';
+let timingSafeEqual = globalThis.process?.getBuiltinModule?.('node:crypto')?.timingSafeEqual;
+timingSafeEqual ||= (a, b) => {
+    if (!(a instanceof Uint8Array)) {
+        throw new TypeError('First argument must be a buffer');
+    }
+    if (!(b instanceof Uint8Array)) {
+        throw new TypeError('Second argument must be a buffer');
+    }
+    if (a.length !== b.length) {
+        throw new TypeError('Input buffers must have the same length');
+    }
+    const len = a.length;
+    let out = 0;
+    let i = -1;
+    while (++i < len) {
+        out |= a[i] ^ b[i];
+    }
+    return out === 0;
+};
 async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     if (!(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
@@ -60,9 +77,9 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
         throw new JWEDecryptionFailed();
     }
 }
-const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
+export default async (enc, cek, ciphertext, iv, tag, aad) => {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array'));
+        throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
     }
     if (!iv) {
         throw new JWEInvalid('JWE Initialization Vector missing');
@@ -88,4 +105,3 @@ const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
             throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
     }
 };
-export default decrypt;

package/dist/{node/esm → webapi}/lib/decrypt_key_management.js

@@ -1,18 +1,15 @@
-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 { decode as base64url } from '../runtime/base64url.js';
-import normalize from '../runtime/normalize_key.js';
+import * as aeskw from './aeskw.js';
+import * as ecdhes from './ecdhes.js';
+import * as pbes2kw from './pbes2kw.js';
+import * as rsaes from './rsaes.js';
+import * as base64url from '../lib/base64url.js';
 import { JOSENotSupported, JWEInvalid } from '../util/errors.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, options) {
-    checkKeyType(alg, key, 'decrypt');
-    key = (await normalize.normalizePrivateKey?.(key, alg)) || key;
+import { assertCryptoKey } from './is_key_like.js';
+export default async (alg, key, encryptedKey, joseHeader, options) => {
     switch (alg) {
         case 'dir': {
             if (encryptedKey !== undefined)
@@ -27,16 +24,18 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options)
         case 'ECDH-ES+A256KW': {
             if (!isObject(joseHeader.epk))
                 throw new JWEInvalid(`JOSE Header "epk" (Ephemeral Public Key) missing or invalid`);
-            if (!ECDH.ecdhAllowed(key))
+            assertCryptoKey(key);
+            if (!ecdhes.allowed(key))
                 throw new JOSENotSupported('ECDH with the provided key is not allowed or not supported by your javascript runtime');
             const epk = await importJWK(joseHeader.epk, alg);
+            assertCryptoKey(epk);
             let partyUInfo;
             let partyVInfo;
             if (joseHeader.apu !== undefined) {
                 if (typeof joseHeader.apu !== 'string')
                     throw new JWEInvalid(`JOSE Header "apu" (Agreement PartyUInfo) invalid`);
                 try {
-                    partyUInfo = base64url(joseHeader.apu);
+                    partyUInfo = base64url.decode(joseHeader.apu);
                 }
                 catch {
                     throw new JWEInvalid('Failed to base64url decode the apu');
@@ -46,27 +45,27 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options)
                 if (typeof joseHeader.apv !== 'string')
                     throw new JWEInvalid(`JOSE Header "apv" (Agreement PartyVInfo) invalid`);
                 try {
-                    partyVInfo = base64url(joseHeader.apv);
+                    partyVInfo = base64url.decode(joseHeader.apv);
                 }
                 catch {
                     throw new JWEInvalid('Failed to base64url decode the apv');
                 }
             }
-            const sharedSecret = await ECDH.deriveKey(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, alg === 'ECDH-ES' ? cekLength(joseHeader.enc) : parseInt(alg.slice(-5, -2), 10), partyUInfo, partyVInfo);
+            const sharedSecret = await ecdhes.deriveKey(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, alg === 'ECDH-ES' ? cekLength(joseHeader.enc) : parseInt(alg.slice(-5, -2), 10), partyUInfo, partyVInfo);
             if (alg === 'ECDH-ES')
                 return sharedSecret;
             if (encryptedKey === undefined)
                 throw new JWEInvalid('JWE Encrypted Key missing');
-            return aesKw(alg.slice(-6), sharedSecret, encryptedKey);
+            return aeskw.unwrap(alg.slice(-6), sharedSecret, encryptedKey);
         }
-        case 'RSA1_5':
         case 'RSA-OAEP':
         case 'RSA-OAEP-256':
         case 'RSA-OAEP-384':
         case 'RSA-OAEP-512': {
             if (encryptedKey === undefined)
                 throw new JWEInvalid('JWE Encrypted Key missing');
-            return rsaEs(alg, key, encryptedKey);
+            assertCryptoKey(key);
+            return rsaes.decrypt(alg, key, encryptedKey);
         }
         case 'PBES2-HS256+A128KW':
         case 'PBES2-HS384+A192KW':
@@ -82,19 +81,19 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options)
                 throw new JWEInvalid(`JOSE Header "p2s" (PBES2 Salt) missing or invalid`);
             let p2s;
             try {
-                p2s = base64url(joseHeader.p2s);
+                p2s = base64url.decode(joseHeader.p2s);
             }
             catch {
                 throw new JWEInvalid('Failed to base64url decode the p2s');
             }
-            return pbes2Kw(alg, key, encryptedKey, joseHeader.p2c, p2s);
+            return pbes2kw.unwrap(alg, key, encryptedKey, joseHeader.p2c, p2s);
         }
         case 'A128KW':
         case 'A192KW':
         case 'A256KW': {
             if (encryptedKey === undefined)
                 throw new JWEInvalid('JWE Encrypted Key missing');
-            return aesKw(alg, key, encryptedKey);
+            return aeskw.unwrap(alg, key, encryptedKey);
         }
         case 'A128GCMKW':
         case 'A192GCMKW':
@@ -107,14 +106,14 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options)
                 throw new JWEInvalid(`JOSE Header "tag" (Authentication Tag) missing or invalid`);
             let iv;
             try {
-                iv = base64url(joseHeader.iv);
+                iv = base64url.decode(joseHeader.iv);
             }
             catch {
                 throw new JWEInvalid('Failed to base64url decode the iv');
             }
             let tag;
             try {
-                tag = base64url(joseHeader.tag);
+                tag = base64url.decode(joseHeader.tag);
             }
             catch {
                 throw new JWEInvalid('Failed to base64url decode the tag');
@@ -125,5 +124,4 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader, options)
             throw new JOSENotSupported('Invalid or unsupported "alg" (JWE Algorithm) header value');
         }
     }
-}
-export default decryptKeyManagement;
+};

package/dist/{browser/runtime → webapi/lib}/digest.js

@@ -1,6 +1,4 @@
-import crypto from './webcrypto.js';
-const digest = async (algorithm, data) => {
+export default async (algorithm, data) => {
     const subtleDigest = `SHA-${algorithm.slice(-3)}`;
     return new Uint8Array(await crypto.subtle.digest(subtleDigest, data));
 };
-export default digest;

package/dist/webapi/lib/ecdhes.js

@@ -0,0 +1,46 @@
+import { encoder, concat, uint32be } from './buffer_utils.js';
+import { checkEncCryptoKey } from './crypto_key.js';
+import digest from './digest.js';
+function lengthAndInput(input) {
+    return concat(uint32be(input.length), input);
+}
+async function concatKdf(secret, bits, value) {
+    const iterations = Math.ceil((bits >> 3) / 32);
+    const res = new Uint8Array(iterations * 32);
+    for (let iter = 0; iter < iterations; iter++) {
+        const buf = new Uint8Array(4 + secret.length + value.length);
+        buf.set(uint32be(iter + 1));
+        buf.set(secret, 4);
+        buf.set(value, 4 + secret.length);
+        res.set(await digest('sha256', buf), iter * 32);
+    }
+    return res.slice(0, bits >> 3);
+}
+export async function deriveKey(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) {
+    checkEncCryptoKey(publicKey, 'ECDH');
+    checkEncCryptoKey(privateKey, 'ECDH', 'deriveBits');
+    const value = concat(lengthAndInput(encoder.encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength));
+    let length;
+    if (publicKey.algorithm.name === 'X25519') {
+        length = 256;
+    }
+    else {
+        length =
+            Math.ceil(parseInt(publicKey.algorithm.namedCurve.slice(-3), 10) / 8) << 3;
+    }
+    const sharedSecret = new Uint8Array(await crypto.subtle.deriveBits({
+        name: publicKey.algorithm.name,
+        public: publicKey,
+    }, privateKey, length));
+    return concatKdf(sharedSecret, keyLength, value);
+}
+export function allowed(key) {
+    switch (key.algorithm.namedCurve) {
+        case 'P-256':
+        case 'P-384':
+        case 'P-521':
+            return true;
+        default:
+            return key.algorithm.name === 'X25519';
+    }
+}

package/dist/{browser/runtime → webapi/lib}/encrypt.js

@@ -1,12 +1,11 @@
-import { concat, uint64be } from '../lib/buffer_utils.js';
-import checkIvLength from '../lib/check_iv_length.js';
+import { concat, uint64be } from './buffer_utils.js';
+import checkIvLength from './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 '../lib/invalid_key_input.js';
-import generateIv from '../lib/iv.js';
+import { checkEncCryptoKey } from './crypto_key.js';
+import invalidKeyInput from './invalid_key_input.js';
+import generateIv from './iv.js';
 import { JOSENotSupported } from '../util/errors.js';
-import { types } from './is_key_like.js';
+import { isCryptoKey } from './is_key_like.js';
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     if (!(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
@@ -44,9 +43,9 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
     const ciphertext = encrypted.slice(0, -16);
     return { ciphertext, tag, iv };
 }
-const encrypt = async (enc, plaintext, cek, iv, aad) => {
+export default async (enc, plaintext, cek, iv, aad) => {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array'));
+        throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'KeyObject', 'Uint8Array', 'JSON Web Key'));
     }
     if (iv) {
         checkIvLength(enc, iv);
@@ -73,4 +72,3 @@ const encrypt = async (enc, plaintext, cek, iv, aad) => {
             throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
     }
 };
-export default encrypt;

package/dist/{node/esm → webapi}/lib/encrypt_key_management.js

@@ -1,20 +1,18 @@
-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 { encode as base64url } from '../runtime/base64url.js';
-import normalize from '../runtime/normalize_key.js';
+import * as aeskw from './aeskw.js';
+import * as ecdhes from './ecdhes.js';
+import * as pbes2kw from './pbes2kw.js';
+import * as rsaes from './rsaes.js';
+import * as base64url from '../lib/base64url.js';
+import normalizeKey from './normalize_key.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 = {}) {
+import { assertCryptoKey } from './is_key_like.js';
+export default async (alg, enc, key, providedCek, providedParameters = {}) => {
     let encryptedKey;
     let parameters;
     let cek;
-    checkKeyType(alg, key, 'encrypt');
-    key = (await normalize.normalizePublicKey?.(key, alg)) || key;
     switch (alg) {
         case 'dir': {
             cek = key;
@@ -24,37 +22,43 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
         case 'ECDH-ES+A128KW':
         case 'ECDH-ES+A192KW':
         case 'ECDH-ES+A256KW': {
-            if (!ECDH.ecdhAllowed(key)) {
+            assertCryptoKey(key);
+            if (!ecdhes.allowed(key)) {
                 throw new JOSENotSupported('ECDH with the provided key is not allowed or not supported by your javascript runtime');
             }
             const { apu, apv } = providedParameters;
-            let { epk: ephemeralKey } = providedParameters;
-            ephemeralKey ||= (await ECDH.generateEpk(key)).privateKey;
+            let ephemeralKey;
+            if (providedParameters.epk) {
+                ephemeralKey = (await normalizeKey(providedParameters.epk, alg));
+            }
+            else {
+                ephemeralKey = (await crypto.subtle.generateKey(key.algorithm, true, ['deriveBits'])).privateKey;
+            }
             const { x, y, crv, kty } = await exportJWK(ephemeralKey);
-            const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? cekLength(enc) : parseInt(alg.slice(-5, -2), 10), apu, apv);
+            const sharedSecret = await ecdhes.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? cekLength(enc) : parseInt(alg.slice(-5, -2), 10), apu, apv);
             parameters = { epk: { x, crv, kty } };
             if (kty === 'EC')
                 parameters.epk.y = y;
             if (apu)
-                parameters.apu = base64url(apu);
+                parameters.apu = base64url.encode(apu);
             if (apv)
-                parameters.apv = base64url(apv);
+                parameters.apv = base64url.encode(apv);
             if (alg === 'ECDH-ES') {
                 cek = sharedSecret;
                 break;
             }
             cek = providedCek || generateCek(enc);
             const kwAlg = alg.slice(-6);
-            encryptedKey = await aesKw(kwAlg, sharedSecret, cek);
+            encryptedKey = await aeskw.wrap(kwAlg, sharedSecret, cek);
             break;
         }
-        case 'RSA1_5':
         case 'RSA-OAEP':
         case 'RSA-OAEP-256':
         case 'RSA-OAEP-384':
         case 'RSA-OAEP-512': {
             cek = providedCek || generateCek(enc);
-            encryptedKey = await rsaEs(alg, key, cek);
+            assertCryptoKey(key);
+            encryptedKey = await rsaes.encrypt(alg, key, cek);
             break;
         }
         case 'PBES2-HS256+A128KW':
@@ -62,14 +66,14 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
         case 'PBES2-HS512+A256KW': {
             cek = providedCek || generateCek(enc);
             const { p2c, p2s } = providedParameters;
-            ({ encryptedKey, ...parameters } = await pbes2Kw(alg, key, cek, p2c, p2s));
+            ({ encryptedKey, ...parameters } = await pbes2kw.wrap(alg, key, cek, p2c, p2s));
             break;
         }
         case 'A128KW':
         case 'A192KW':
         case 'A256KW': {
             cek = providedCek || generateCek(enc);
-            encryptedKey = await aesKw(alg, key, cek);
+            encryptedKey = await aeskw.wrap(alg, key, cek);
             break;
         }
         case 'A128GCMKW':
@@ -85,5 +89,4 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
         }
     }
     return { cek, encryptedKey, parameters };
-}
-export default encryptKeyManagement;
+};