jose 4.1.4 → 4.3.0

package/README.md

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

package/dist/browser/index.js

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

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

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

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

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

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

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

package/dist/browser/jws/general/sign.js

@@ -1,32 +1,33 @@
 import { FlattenedSign } from '../flattened/sign.js';
 import { JWSInvalid } from '../../util/errors.js';
-const signatureRef = new WeakMap();
 class IndividualSignature {
+    constructor(sig, key, options) {
+        this.parent = sig;
+        this.key = key;
+        this.options = options;
+    }
     setProtectedHeader(protectedHeader) {
-        if (this._protectedHeader) {
+        if (this.protectedHeader) {
             throw new TypeError('setProtectedHeader can only be called once');
         }
-        this._protectedHeader = protectedHeader;
+        this.protectedHeader = protectedHeader;
         return this;
     }
     setUnprotectedHeader(unprotectedHeader) {
-        if (this._unprotectedHeader) {
+        if (this.unprotectedHeader) {
             throw new TypeError('setUnprotectedHeader can only be called once');
         }
-        this._unprotectedHeader = unprotectedHeader;
+        this.unprotectedHeader = unprotectedHeader;
         return this;
     }
-    set _protectedHeader(value) {
-        signatureRef.get(this).protectedHeader = value;
-    }
-    get _protectedHeader() {
-        return signatureRef.get(this).protectedHeader;
+    addSignature(...args) {
+        return this.parent.addSignature(...args);
     }
-    set _unprotectedHeader(value) {
-        signatureRef.get(this).unprotectedHeader = value;
+    sign(...args) {
+        return this.parent.sign(...args);
     }
-    get _unprotectedHeader() {
-        return signatureRef.get(this).unprotectedHeader;
+    done() {
+        return this.parent;
     }
 }
 export class GeneralSign {
@@ -35,8 +36,7 @@ export class GeneralSign {
         this._payload = payload;
     }
     addSignature(key, options) {
-        const signature = new IndividualSignature();
-        signatureRef.set(signature, { key, options });
+        const signature = new IndividualSignature(this, key, options);
         this._signatures.push(signature);
         return signature;
     }
@@ -48,23 +48,19 @@ export class GeneralSign {
             signatures: [],
             payload: '',
         };
-        let payloads = new Set();
-        await Promise.all(this._signatures.map(async (sig) => {
-            const { protectedHeader, unprotectedHeader, options, key } = signatureRef.get(sig);
+        for (let i = 0; i < this._signatures.length; i++) {
+            const signature = this._signatures[i];
             const flattened = new FlattenedSign(this._payload);
-            if (protectedHeader) {
-                flattened.setProtectedHeader(protectedHeader);
+            flattened.setProtectedHeader(signature.protectedHeader);
+            flattened.setUnprotectedHeader(signature.unprotectedHeader);
+            const { payload, ...rest } = await flattened.sign(signature.key, signature.options);
+            if (i === 0) {
+                jws.payload = payload;
             }
-            if (unprotectedHeader) {
-                flattened.setUnprotectedHeader(unprotectedHeader);
+            else if (jws.payload !== payload) {
+                throw new JWSInvalid('inconsistent use of JWS Unencoded Payload Option (RFC7797)');
             }
-            const { payload, ...rest } = await flattened.sign(key, options);
-            payloads.add(payload);
-            jws.payload = payload;
             jws.signatures.push(rest);
-        }));
-        if (payloads.size !== 1) {
-            throw new JWSInvalid('inconsistent use of JWS Unencoded Payload Option (RFC7797)');
         }
         return jws;
     }

package/dist/browser/key/import.js

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

package/dist/browser/lib/cek.js

@@ -2,18 +2,17 @@ import { JOSENotSupported } from '../util/errors.js';
 import random from '../runtime/random.js';
 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':
+        case 'A128CBC-HS256':
             return 256;
+        case 'A192CBC-HS384':
+            return 384;
+        case 'A256CBC-HS512':
+            return 512;
         default:
             throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }

package/dist/browser/lib/decrypt_key_management.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) || cekLength(joseHeader.enc), partyUInfo, partyVInfo);
+            const sharedSecret = await ECDH.deriveKey(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, alg === 'ECDH-ES' ? cekLength(joseHeader.enc) : parseInt(alg.substr(-5, 3), 10), partyUInfo, partyVInfo);
             if (alg === 'ECDH-ES')
                 return sharedSecret;
             if (encryptedKey === undefined)

package/dist/browser/lib/encrypt_key_management.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) || cekLength(enc), apu, apv);
+            const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? cekLength(enc) : parseInt(alg.substr(-5, 3), 10), apu, apv);
             parameters = { epk: { x, y, crv, kty } };
             if (apu)
                 parameters.apu = base64url(apu);

package/dist/browser/lib/iv.js

@@ -2,24 +2,17 @@ import { JOSENotSupported } from '../util/errors.js';
 import random from '../runtime/random.js';
 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;
+        case 'A128CBC-HS256':
+        case 'A192CBC-HS384':
+        case 'A256CBC-HS512':
+            return 128;
         default:
             throw new JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }

package/dist/browser/runtime/aeskw.js

@@ -2,6 +2,7 @@ import bogusWebCrypto from './bogus.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';
 function checkKeySize(key, alg) {
     if (key.algorithm.length !== parseInt(alg.substr(1, 3), 10)) {
         throw new TypeError(`Invalid key size for alg: ${alg}`);
@@ -15,7 +16,7 @@ function getCryptoKey(key, alg, usage) {
     if (key instanceof Uint8Array) {
         return crypto.subtle.importKey('raw', key, 'AES-KW', true, [usage]);
     }
-    throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'Uint8Array'));
+    throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
 }
 export const wrap = async (alg, key, cek) => {
     const cryptoKey = await getCryptoKey(key, alg, 'wrapKey');

package/dist/browser/runtime/asn1.js

@@ -4,9 +4,10 @@ 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';
+import { types } from './is_key_like.js';
 const genericExport = async (keyType, keyFormat, key) => {
     if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(key, ...types));
     }
     if (!key.extractable) {
         throw new TypeError('CryptoKey is not extractable');

package/dist/browser/runtime/decrypt.js

@@ -6,6 +6,7 @@ import { JOSENotSupported, JWEDecryptionFailed } 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';
 async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     if (!(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
@@ -61,7 +62,7 @@ async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
 }
 const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'Uint8Array'));
+        throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array'));
     }
     checkIvLength(enc, iv);
     switch (enc) {

package/dist/browser/runtime/ecdhes.js

@@ -3,13 +3,14 @@ import crypto, { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import digest from './digest.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.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'));
+        throw new TypeError(invalidKeyInput(publicKey, ...types));
     }
     checkEncCryptoKey(publicKey, 'ECDH-ES');
     if (!isCryptoKey(privateKey)) {
-        throw new TypeError(invalidKeyInput(privateKey, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(privateKey, ...types));
     }
     checkEncCryptoKey(privateKey, 'ECDH-ES', 'deriveBits', 'deriveKey');
     const value = concat(lengthAndInput(encoder.encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength));
@@ -25,13 +26,13 @@ export const deriveKey = async (publicKey, privateKey, algorithm, keyLength, apu
 };
 export const generateEpk = async (key) => {
     if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(key, ...types));
     }
     return (await crypto.subtle.generateKey({ name: 'ECDH', namedCurve: key.algorithm.namedCurve }, true, ['deriveBits'])).privateKey;
 };
 export const ecdhAllowed = (key) => {
     if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(key, ...types));
     }
     return ['P-256', 'P-384', 'P-521'].includes(key.algorithm.namedCurve);
 };

package/dist/browser/runtime/encrypt.js

@@ -5,6 +5,7 @@ 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';
+import { types } from './is_key_like.js';
 async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     if (!(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
@@ -44,7 +45,7 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
 }
 const encrypt = async (enc, plaintext, cek, iv, aad) => {
     if (!isCryptoKey(cek) && !(cek instanceof Uint8Array)) {
-        throw new TypeError(invalidKeyInput(cek, 'CryptoKey', 'Uint8Array'));
+        throw new TypeError(invalidKeyInput(cek, ...types, 'Uint8Array'));
     }
     checkIvLength(enc, iv);
     switch (enc) {

package/dist/browser/runtime/get_sign_verify_key.js

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

package/dist/browser/runtime/key_to_jwk.js

@@ -1,6 +1,7 @@
 import crypto, { isCryptoKey } from './webcrypto.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
 import { encode as base64url } from './base64url.js';
+import { types } from './is_key_like.js';
 const keyToJWK = async (key) => {
     if (key instanceof Uint8Array) {
         return {
@@ -9,7 +10,7 @@ const keyToJWK = async (key) => {
         };
     }
     if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'Uint8Array'));
+        throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
     }
     if (!key.extractable) {
         throw new TypeError('non-extractable CryptoKey cannot be exported as a JWK');

package/dist/browser/runtime/pbes2kw.js

@@ -6,6 +6,7 @@ import checkP2s from '../lib/check_p2s.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';
 function getCryptoKey(key, alg) {
     if (key instanceof Uint8Array) {
         return crypto.subtle.importKey('raw', key, 'PBKDF2', false, ['deriveBits']);
@@ -14,7 +15,7 @@ function getCryptoKey(key, alg) {
         checkEncCryptoKey(key, alg, 'deriveBits', 'deriveKey');
         return key;
     }
-    throw new TypeError(invalidKeyInput(key, 'CryptoKey', 'Uint8Array'));
+    throw new TypeError(invalidKeyInput(key, ...types, 'Uint8Array'));
 }
 async function deriveKey(p2s, alg, p2c, key) {
     checkP2s(p2s);

package/dist/browser/runtime/rsaes.js

@@ -4,9 +4,10 @@ import crypto, { isCryptoKey } from './webcrypto.js';
 import { checkEncCryptoKey } from '../lib/crypto_key.js';
 import checkKeyLength from './check_key_length.js';
 import invalidKeyInput from '../lib/invalid_key_input.js';
+import { types } from './is_key_like.js';
 export const encrypt = async (alg, key, cek) => {
     if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(key, ...types));
     }
     checkEncCryptoKey(key, alg, 'encrypt', 'wrapKey');
     checkKeyLength(alg, key);
@@ -21,7 +22,7 @@ export const encrypt = async (alg, key, cek) => {
 };
 export const decrypt = async (alg, key, encryptedKey) => {
     if (!isCryptoKey(key)) {
-        throw new TypeError(invalidKeyInput(key, 'CryptoKey'));
+        throw new TypeError(invalidKeyInput(key, ...types));
     }
     checkEncCryptoKey(key, alg, 'decrypt', 'unwrapKey');
     checkKeyLength(alg, key);