jose 4.1.3 → 4.2.1

package/dist/node/cjs/jwe/flattened/encrypt.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FlattenedEncrypt = void 0;
+exports.FlattenedEncrypt = exports.unprotected = void 0;
 const base64url_js_1 = require("../../runtime/base64url.js");
 const encrypt_js_1 = require("../../runtime/encrypt.js");
 const zlib_js_1 = require("../../runtime/zlib.js");
@@ -10,6 +10,7 @@ const errors_js_1 = require("../../util/errors.js");
 const is_disjoint_js_1 = require("../../lib/is_disjoint.js");
 const buffer_utils_js_1 = require("../../lib/buffer_utils.js");
 const validate_crit_js_1 = require("../../lib/validate_crit.js");
+exports.unprotected = Symbol();
 class FlattenedEncrypt {
     constructor(plaintext) {
         if (!(plaintext instanceof Uint8Array)) {
@@ -68,7 +69,7 @@ class FlattenedEncrypt {
             throw new errors_js_1.JWEInvalid('either setProtectedHeader, setUnprotectedHeader, or sharedUnprotectedHeader must be called before #encrypt()');
         }
         if (!(0, is_disjoint_js_1.default)(this._protectedHeader, this._unprotectedHeader, this._sharedUnprotectedHeader)) {
-            throw new errors_js_1.JWEInvalid('JWE Shared Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
+            throw new errors_js_1.JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
         }
         const joseHeader = {
             ...this._protectedHeader,
@@ -107,11 +108,21 @@ class FlattenedEncrypt {
             let parameters;
             ({ cek, encryptedKey, parameters } = await (0, encrypt_key_management_js_1.default)(alg, enc, key, this._cek, this._keyManagementParameters));
             if (parameters) {
-                if (!this._protectedHeader) {
-                    this.setProtectedHeader(parameters);
+                if (options && exports.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/node/cjs/jwe/general/decrypt.js

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

package/dist/node/cjs/jwe/general/encrypt.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneralEncrypt = void 0;
+const encrypt_js_1 = require("../flattened/encrypt.js");
+const errors_js_1 = require("../../util/errors.js");
+const cek_js_1 = require("../../lib/cek.js");
+const is_disjoint_js_1 = require("../../lib/is_disjoint.js");
+const encrypt_key_management_js_1 = require("../../lib/encrypt_key_management.js");
+const base64url_js_1 = require("../../runtime/base64url.js");
+const validate_crit_js_1 = require("../../lib/validate_crit.js");
+const recipientRef = new WeakMap();
+class IndividualRecipient {
+    setUnprotectedHeader(unprotectedHeader) {
+        const ref = recipientRef.get(this);
+        if (ref.unprotectedHeader) {
+            throw new TypeError('setUnprotectedHeader can only be called once');
+        }
+        ref.unprotectedHeader = unprotectedHeader;
+        return this;
+    }
+}
+class GeneralEncrypt {
+    constructor(plaintext) {
+        this._recipients = [];
+        this._plaintext = plaintext;
+    }
+    addRecipient(key, options) {
+        const recipient = new IndividualRecipient();
+        recipientRef.set(recipient, { key, options: { 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;
+        if (!this._recipients.length) {
+            throw new errors_js_1.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 { unprotectedHeader, options: recipientOpts, key, } = recipientRef.get(this._recipients[0]);
+            const flattened = await new encrypt_js_1.FlattenedEncrypt(this._plaintext)
+                .setAdditionalAuthenticatedData(this._aad)
+                .setProtectedHeader(this._protectedHeader)
+                .setSharedUnprotectedHeader(this._unprotectedHeader)
+                .setUnprotectedHeader(unprotectedHeader)
+                .encrypt(key, { ...recipientOpts, ...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];
+            const { unprotectedHeader, options: recipientOpts } = recipientRef.get(recipient);
+            if (!(0, is_disjoint_js_1.default)(this._protectedHeader, this._unprotectedHeader, unprotectedHeader)) {
+                throw new errors_js_1.JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
+            }
+            const joseHeader = {
+                ...this._protectedHeader,
+                ...this._unprotectedHeader,
+                ...unprotectedHeader,
+            };
+            const { alg } = joseHeader;
+            if (typeof alg !== 'string' || !alg) {
+                throw new errors_js_1.JWEInvalid('JWE "alg" (Algorithm) Header Parameter missing or invalid');
+            }
+            if (alg === 'dir' || alg === 'ECDH-ES') {
+                throw new errors_js_1.JWEInvalid('"dir" and "ECDH-ES" alg may only be used with a single recipient');
+            }
+            if (typeof joseHeader.enc !== 'string' || !joseHeader.enc) {
+                throw new errors_js_1.JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');
+            }
+            if (!enc) {
+                enc = joseHeader.enc;
+            }
+            else if (enc !== joseHeader.enc) {
+                throw new errors_js_1.JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter must be the same for all recipients');
+            }
+            (0, validate_crit_js_1.default)(errors_js_1.JWEInvalid, new Map(), recipientOpts === null || recipientOpts === void 0 ? void 0 : recipientOpts.crit, this._protectedHeader, joseHeader);
+            if (joseHeader.zip !== undefined) {
+                if (!this._protectedHeader || !this._protectedHeader.zip) {
+                    throw new errors_js_1.JWEInvalid('JWE "zip" (Compression Algorithm) Header MUST be integrity protected');
+                }
+            }
+        }
+        const cek = (0, cek_js_1.default)(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);
+            const { unprotectedHeader, options: recipientOpts, key } = recipientRef.get(recipient);
+            if (i === 0) {
+                const flattened = await new encrypt_js_1.FlattenedEncrypt(this._plaintext)
+                    .setAdditionalAuthenticatedData(this._aad)
+                    .setContentEncryptionKey(cek)
+                    .setProtectedHeader(this._protectedHeader)
+                    .setSharedUnprotectedHeader(this._unprotectedHeader)
+                    .setUnprotectedHeader(unprotectedHeader)
+                    .encrypt(key, { ...recipientOpts, ...options, [encrypt_js_1.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 (0, encrypt_key_management_js_1.default)((unprotectedHeader === null || unprotectedHeader === void 0 ? void 0 : unprotectedHeader.alg) || ((_a = this._protectedHeader) === null || _a === void 0 ? void 0 : _a.alg) || ((_b = this._unprotectedHeader) === null || _b === void 0 ? void 0 : _b.alg), enc, key, cek);
+            target.encrypted_key = (0, base64url_js_1.encode)(encryptedKey);
+            if (unprotectedHeader || parameters)
+                target.header = { ...unprotectedHeader, ...parameters };
+        }
+        return jwe;
+    }
+}
+exports.GeneralEncrypt = GeneralEncrypt;

package/dist/node/cjs/jws/general/sign.js

@@ -6,31 +6,21 @@ const errors_js_1 = require("../../util/errors.js");
 const signatureRef = new WeakMap();
 class IndividualSignature {
     setProtectedHeader(protectedHeader) {
-        if (this._protectedHeader) {
+        const ref = signatureRef.get(this);
+        if (ref.protectedHeader) {
             throw new TypeError('setProtectedHeader can only be called once');
         }
-        this._protectedHeader = protectedHeader;
+        ref.protectedHeader = protectedHeader;
         return this;
     }
     setUnprotectedHeader(unprotectedHeader) {
-        if (this._unprotectedHeader) {
+        const ref = signatureRef.get(this);
+        if (ref.unprotectedHeader) {
             throw new TypeError('setUnprotectedHeader can only be called once');
         }
-        this._unprotectedHeader = unprotectedHeader;
+        ref.unprotectedHeader = unprotectedHeader;
         return this;
     }
-    set _protectedHeader(value) {
-        signatureRef.get(this).protectedHeader = value;
-    }
-    get _protectedHeader() {
-        return signatureRef.get(this).protectedHeader;
-    }
-    set _unprotectedHeader(value) {
-        signatureRef.get(this).unprotectedHeader = value;
-    }
-    get _unprotectedHeader() {
-        return signatureRef.get(this).unprotectedHeader;
-    }
 }
 class GeneralSign {
     constructor(payload) {

package/dist/node/cjs/key/import.js

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

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

@@ -5,18 +5,17 @@ const errors_js_1 = require("../util/errors.js");
 const random_js_1 = require("../runtime/random.js");
 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 errors_js_1.JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }

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

@@ -42,7 +42,7 @@ async function decryptKeyManagement(alg, key, encryptedKey, joseHeader) {
                     throw new errors_js_1.JWEInvalid(`JOSE Header "apv" (Agreement PartyVInfo) invalid`);
                 partyVInfo = (0, base64url_js_1.decode)(joseHeader.apv);
             }
-            const sharedSecret = await ECDH.deriveKey(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, parseInt(alg.substr(-5, 3), 10) || (0, cek_js_1.bitLength)(joseHeader.enc), partyUInfo, partyVInfo);
+            const sharedSecret = await ECDH.deriveKey(epk, key, alg === 'ECDH-ES' ? joseHeader.enc : alg, alg === 'ECDH-ES' ? (0, cek_js_1.bitLength)(joseHeader.enc) : parseInt(alg.substr(-5, 3), 10), partyUInfo, partyVInfo);
             if (alg === 'ECDH-ES')
                 return sharedSecret;
             if (encryptedKey === undefined)

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

@@ -31,7 +31,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 (0, export_js_1.exportJWK)(ephemeralKey);
-            const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, parseInt(alg.substr(-5, 3), 10) || (0, cek_js_1.bitLength)(enc), apu, apv);
+            const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? (0, cek_js_1.bitLength)(enc) : parseInt(alg.substr(-5, 3), 10), apu, apv);
             parameters = { epk: { x, y, crv, kty } };
             if (apu)
                 parameters.apu = (0, base64url_js_1.encode)(apu);

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

@@ -5,24 +5,17 @@ const errors_js_1 = require("../util/errors.js");
 const random_js_1 = require("../runtime/random.js");
 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 errors_js_1.JOSENotSupported(`Unsupported JWE Algorithm: ${alg}`);
     }

package/dist/node/cjs/runtime/aeskw.js

@@ -11,6 +11,7 @@ const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const ciphers_js_1 = require("./ciphers.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 function checkKeySize(key, alg) {
     if (key.symmetricKeySize << 3 !== parseInt(alg.substr(1, 3), 10)) {
         throw new TypeError(`Invalid key size for alg: ${alg}`);
@@ -27,9 +28,9 @@ function ensureKeyObject(key, alg, usage) {
         (0, crypto_key_js_1.checkEncCryptoKey)(key, alg, usage);
         return crypto_1.KeyObject.from(key);
     }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+    throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array'));
 }
-const wrap = async (alg, key, cek) => {
+const wrap = (alg, key, cek) => {
     const size = parseInt(alg.substr(1, 3), 10);
     const algorithm = `aes${size}-wrap`;
     if (!(0, ciphers_js_1.default)(algorithm)) {
@@ -41,7 +42,7 @@ const wrap = async (alg, key, cek) => {
     return (0, buffer_utils_js_1.concat)(cipher.update(cek), cipher.final());
 };
 exports.wrap = wrap;
-const unwrap = async (alg, key, encryptedKey) => {
+const unwrap = (alg, key, encryptedKey) => {
     const size = parseInt(alg.substr(1, 3), 10);
     const algorithm = `aes${size}-wrap`;
     if (!(0, ciphers_js_1.default)(algorithm)) {

package/dist/node/cjs/runtime/asn1.js

@@ -6,6 +6,7 @@ const buffer_1 = require("buffer");
 const webcrypto_js_1 = require("./webcrypto.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 const genericExport = (keyType, keyFormat, key) => {
     let keyObject;
     if ((0, webcrypto_js_1.isCryptoKey)(key)) {
@@ -18,7 +19,7 @@ const genericExport = (keyType, keyFormat, key) => {
         keyObject = key;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
     }
     if (keyObject.type !== keyType) {
         throw new TypeError(`key is not a ${keyType} key`);

package/dist/node/cjs/runtime/decrypt.js

@@ -12,7 +12,8 @@ const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const ciphers_js_1 = require("./ciphers.js");
-async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
+const is_key_like_js_1 = require("./is_key_like.js");
+function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);
     if ((0, is_key_object_js_1.default)(cek)) {
         cek = cek.export();
@@ -36,8 +37,8 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     }
     let plaintext;
     try {
-        const cipher = (0, crypto_1.createDecipheriv)(algorithm, encKey, iv);
-        plaintext = (0, buffer_utils_js_1.concat)(cipher.update(ciphertext), cipher.final());
+        const decipher = (0, crypto_1.createDecipheriv)(algorithm, encKey, iv);
+        plaintext = (0, buffer_utils_js_1.concat)(decipher.update(ciphertext), decipher.final());
     }
     catch {
     }
@@ -46,25 +47,27 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     }
     return plaintext;
 }
-async function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
+function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);
     const algorithm = `aes-${keySize}-gcm`;
     if (!(0, ciphers_js_1.default)(algorithm)) {
         throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
     }
     try {
-        const cipher = (0, crypto_1.createDecipheriv)(algorithm, cek, iv, { authTagLength: 16 });
-        cipher.setAuthTag(tag);
+        const decipher = (0, crypto_1.createDecipheriv)(algorithm, cek, iv, { authTagLength: 16 });
+        decipher.setAuthTag(tag);
         if (aad.byteLength) {
-            cipher.setAAD(aad, { plaintextLength: ciphertext.length });
+            decipher.setAAD(aad, { plaintextLength: ciphertext.length });
         }
-        return (0, buffer_utils_js_1.concat)(cipher.update(ciphertext), cipher.final());
+        const plaintext = decipher.update(ciphertext);
+        decipher.final();
+        return plaintext;
     }
     catch {
         throw new errors_js_1.JWEDecryptionFailed();
     }
 }
-const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
+const decrypt = (enc, cek, ciphertext, iv, tag, aad) => {
     let key;
     if ((0, webcrypto_js_1.isCryptoKey)(cek)) {
         (0, crypto_key_js_1.checkEncCryptoKey)(cek, enc, 'decrypt');
@@ -74,7 +77,7 @@ const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
         key = cek;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(cek, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(cek, ...is_key_like_js_1.types, 'Uint8Array'));
     }
     (0, check_cek_length_js_1.default)(enc, key);
     (0, check_iv_length_js_1.default)(enc, iv);

package/dist/node/cjs/runtime/ecdhes.js

@@ -11,8 +11,9 @@ const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 const generateKeyPair = (0, util_1.promisify)(crypto_1.generateKeyPair);
-const deriveKey = async (publicKee, privateKee, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) => {
+const deriveKey = (publicKee, privateKee, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) => {
     let publicKey;
     if ((0, webcrypto_js_1.isCryptoKey)(publicKee)) {
         (0, crypto_key_js_1.checkEncCryptoKey)(publicKee, 'ECDH-ES');
@@ -22,7 +23,7 @@ const deriveKey = async (publicKee, privateKee, algorithm, keyLength, apu = new
         publicKey = publicKee;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(publicKee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(publicKee, ...is_key_like_js_1.types));
     }
     let privateKey;
     if ((0, webcrypto_js_1.isCryptoKey)(privateKee)) {
@@ -33,7 +34,7 @@ const deriveKey = async (publicKee, privateKee, algorithm, keyLength, apu = new
         privateKey = privateKee;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(privateKee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(privateKee, ...is_key_like_js_1.types));
     }
     const value = (0, buffer_utils_js_1.concat)((0, buffer_utils_js_1.lengthAndInput)(buffer_utils_js_1.encoder.encode(algorithm)), (0, buffer_utils_js_1.lengthAndInput)(apu), (0, buffer_utils_js_1.lengthAndInput)(apv), (0, buffer_utils_js_1.uint32be)(keyLength));
     const sharedSecret = (0, crypto_1.diffieHellman)({ privateKey, publicKey });
@@ -49,7 +50,7 @@ const generateEpk = async (kee) => {
         key = kee;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(kee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(kee, ...is_key_like_js_1.types));
     }
     switch (key.asymmetricKeyType) {
         case 'x25519':

package/dist/node/cjs/runtime/encrypt.js

@@ -11,7 +11,8 @@ const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
 const errors_js_1 = require("../util/errors.js");
 const ciphers_js_1 = require("./ciphers.js");
-async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
+const is_key_like_js_1 = require("./is_key_like.js");
+function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);
     if ((0, is_key_object_js_1.default)(cek)) {
         cek = cek.export();
@@ -28,7 +29,7 @@ async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     const tag = (0, cbc_tag_js_1.default)(aad, iv, ciphertext, macSize, macKey, keySize);
     return { ciphertext, tag };
 }
-async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
+function gcmEncrypt(enc, plaintext, cek, iv, aad) {
     const keySize = parseInt(enc.substr(1, 3), 10);
     const algorithm = `aes-${keySize}-gcm`;
     if (!(0, ciphers_js_1.default)(algorithm)) {
@@ -38,11 +39,12 @@ async function gcmEncrypt(enc, plaintext, cek, iv, aad) {
     if (aad.byteLength) {
         cipher.setAAD(aad, { plaintextLength: plaintext.length });
     }
-    const ciphertext = (0, buffer_utils_js_1.concat)(cipher.update(plaintext), cipher.final());
+    const ciphertext = cipher.update(plaintext);
+    cipher.final();
     const tag = cipher.getAuthTag();
     return { ciphertext, tag };
 }
-const encrypt = async (enc, plaintext, cek, iv, aad) => {
+const encrypt = (enc, plaintext, cek, iv, aad) => {
     let key;
     if ((0, webcrypto_js_1.isCryptoKey)(cek)) {
         (0, crypto_key_js_1.checkEncCryptoKey)(cek, enc, 'encrypt');
@@ -52,7 +54,7 @@ const encrypt = async (enc, plaintext, cek, iv, aad) => {
         key = cek;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(cek, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(cek, ...is_key_like_js_1.types, 'Uint8Array'));
     }
     (0, check_cek_length_js_1.default)(enc, key);
     (0, check_iv_length_js_1.default)(enc, iv);

package/dist/node/cjs/runtime/get_named_curve.js

@@ -7,6 +7,7 @@ const errors_js_1 = require("../util/errors.js");
 const webcrypto_js_1 = require("./webcrypto.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 const p256 = buffer_1.Buffer.from([42, 134, 72, 206, 61, 3, 1, 7]);
 const p384 = buffer_1.Buffer.from([43, 129, 4, 0, 34]);
 const p521 = buffer_1.Buffer.from([43, 129, 4, 0, 35]);
@@ -36,7 +37,7 @@ const getNamedCurve = (kee, raw) => {
         key = kee;
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(kee, 'KeyObject', 'CryptoKey'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(kee, ...is_key_like_js_1.types));
     }
     if (key.type === 'secret') {
         throw new TypeError('only "private" or "public" type keys can be used for this operation');

package/dist/node/cjs/runtime/get_sign_verify_key.js

@@ -5,10 +5,11 @@ const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const secret_key_js_1 = require("./secret_key.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 function getSignVerifyKey(alg, key, usage) {
     if (key instanceof Uint8Array) {
         if (!alg.startsWith('HS')) {
-            throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey'));
+            throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
         }
         return (0, secret_key_js_1.default)(key);
     }
@@ -19,6 +20,6 @@ function getSignVerifyKey(alg, key, usage) {
         (0, crypto_key_js_1.checkSigCryptoKey)(key, alg, usage);
         return crypto_1.KeyObject.from(key);
     }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+    throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array'));
 }
 exports.default = getSignVerifyKey;

package/dist/node/cjs/runtime/key_to_jwk.js

@@ -8,6 +8,7 @@ const get_named_curve_js_1 = require("./get_named_curve.js");
 const webcrypto_js_1 = require("./webcrypto.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 const [major, minor] = process.version
     .substr(1)
     .split('.')
@@ -31,7 +32,7 @@ const keyToJWK = (key) => {
         };
     }
     else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+        throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array'));
     }
     if (jwkExportSupported) {
         return keyObject.export({ format: 'jwk' });

package/dist/node/cjs/runtime/pbes2kw.js

@@ -12,6 +12,7 @@ const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 const pbkdf2 = (0, util_1.promisify)(crypto_1.pbkdf2);
 function getPassword(key, alg) {
     if ((0, is_key_object_js_1.default)(key)) {
@@ -24,7 +25,7 @@ function getPassword(key, alg) {
         (0, crypto_key_js_1.checkEncCryptoKey)(key, alg, 'deriveBits', 'deriveKey');
         return crypto_1.KeyObject.from(key).export();
     }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey', 'Uint8Array'));
+    throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array'));
 }
 const encrypt = async (alg, key, cek, p2c = Math.floor(Math.random() * 2049) + 2048, p2s = (0, random_js_1.default)(new Uint8Array(16))) => {
     (0, check_p2s_js_1.default)(p2s);

package/dist/node/cjs/runtime/rsaes.js

@@ -7,6 +7,7 @@ const webcrypto_js_1 = require("./webcrypto.js");
 const crypto_key_js_1 = require("../lib/crypto_key.js");
 const is_key_object_js_1 = require("./is_key_object.js");
 const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
+const is_key_like_js_1 = require("./is_key_like.js");
 const checkKey = (key, alg) => {
     if (key.asymmetricKeyType !== 'rsa') {
         throw new TypeError('Invalid key for this operation, its asymmetricKeyType must be rsa');
@@ -48,9 +49,9 @@ function ensureKeyObject(key, alg, ...usages) {
         (0, crypto_key_js_1.checkEncCryptoKey)(key, alg, ...usages);
         return crypto_1.KeyObject.from(key);
     }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, 'KeyObject', 'CryptoKey'));
+    throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
 }
-const encrypt = async (alg, key, cek) => {
+const encrypt = (alg, key, cek) => {
     const padding = resolvePadding(alg);
     const oaepHash = resolveOaepHash(alg);
     const keyObject = ensureKeyObject(key, alg, 'wrapKey', 'encrypt');
@@ -58,7 +59,7 @@ const encrypt = async (alg, key, cek) => {
     return (0, crypto_1.publicEncrypt)({ key: keyObject, oaepHash, padding }, cek);
 };
 exports.encrypt = encrypt;
-const decrypt = async (alg, key, encryptedKey) => {
+const decrypt = (alg, key, encryptedKey) => {
     const padding = resolvePadding(alg);
     const oaepHash = resolveOaepHash(alg);
     const keyObject = ensureKeyObject(key, alg, 'unwrapKey', 'decrypt');