jose 4.3.6 → 4.4.0

package/README.md

@@ -61,6 +61,7 @@ import * as jose from 'https://deno.land/x/jose/index.ts'
   - [Thumbprints](docs/functions/jwk_thumbprint.calculateJwkThumbprint.md#readme)
   - [EmbeddedJWK](docs/functions/jwk_embedded.EmbeddedJWK.md#readme)
 - JSON Web Key Set (JWKS)
+  - [Verify using a local JWKSet](docs/functions/jwks_local.createLocalJWKSet.md#readme)
   - [Verify using a remote JWKSet](docs/functions/jwks_remote.createRemoteJWKSet.md#readme)
 - Key Pair or Secret Generation
   - [Asymmetric Key Pair Generation](docs/functions/key_generate_key_pair.generateKeyPair.md#readme)

package/dist/browser/index.js

@@ -16,6 +16,7 @@ export { SignJWT } from './jwt/sign.js';
 export { EncryptJWT } from './jwt/encrypt.js';
 export { calculateJwkThumbprint } from './jwk/thumbprint.js';
 export { EmbeddedJWK } from './jwk/embedded.js';
+export { createLocalJWKSet } from './jwks/local.js';
 export { createRemoteJWKSet } from './jwks/remote.js';
 export { UnsecuredJWT } from './jwt/unsecured.js';
 export { exportPKCS8, exportSPKI, exportJWK } from './key/export.js';

package/dist/browser/jwks/local.js

@@ -0,0 +1,101 @@
+import { importJWK } from '../key/import.js';
+import { JWKSInvalid, JOSENotSupported, JWKSNoMatchingKey, JWKSMultipleMatchingKeys, } from '../util/errors.js';
+import isObject from '../lib/is_object.js';
+function getKtyFromAlg(alg) {
+    switch (typeof alg === 'string' && alg.slice(0, 2)) {
+        case 'RS':
+        case 'PS':
+            return 'RSA';
+        case 'ES':
+            return 'EC';
+        case 'Ed':
+            return 'OKP';
+        default:
+            throw new JOSENotSupported('Unsupported "alg" value for a JSON Web Key Set');
+    }
+}
+export function isJWKSLike(jwks) {
+    return (jwks &&
+        typeof jwks === 'object' &&
+        Array.isArray(jwks.keys) &&
+        jwks.keys.every(isJWKLike));
+}
+function isJWKLike(key) {
+    return isObject(key);
+}
+function clone(obj) {
+    if (typeof structuredClone === 'function') {
+        return structuredClone(obj);
+    }
+    return JSON.parse(JSON.stringify(obj));
+}
+export class LocalJWKSet {
+    constructor(jwks) {
+        this._cached = new WeakMap();
+        if (!isJWKSLike(jwks)) {
+            throw new JWKSInvalid('JSON Web Key Set malformed');
+        }
+        this._jwks = clone(jwks);
+    }
+    async getKey(protectedHeader, token) {
+        const joseHeader = {
+            ...protectedHeader,
+            ...token.header,
+        };
+        const candidates = this._jwks.keys.filter((jwk) => {
+            let candidate = jwk.kty === getKtyFromAlg(joseHeader.alg);
+            if (candidate && typeof joseHeader.kid === 'string') {
+                candidate = joseHeader.kid === jwk.kid;
+            }
+            if (candidate && typeof jwk.alg === 'string') {
+                candidate = joseHeader.alg === jwk.alg;
+            }
+            if (candidate && typeof jwk.use === 'string') {
+                candidate = jwk.use === 'sig';
+            }
+            if (candidate && Array.isArray(jwk.key_ops)) {
+                candidate = jwk.key_ops.includes('verify');
+            }
+            if (candidate && joseHeader.alg === 'EdDSA') {
+                candidate = jwk.crv === 'Ed25519' || jwk.crv === 'Ed448';
+            }
+            if (candidate) {
+                switch (joseHeader.alg) {
+                    case 'ES256':
+                        candidate = jwk.crv === 'P-256';
+                        break;
+                    case 'ES256K':
+                        candidate = jwk.crv === 'secp256k1';
+                        break;
+                    case 'ES384':
+                        candidate = jwk.crv === 'P-384';
+                        break;
+                    case 'ES512':
+                        candidate = jwk.crv === 'P-521';
+                        break;
+                    default:
+                }
+            }
+            return candidate;
+        });
+        const { 0: jwk, length } = candidates;
+        if (length === 0) {
+            throw new JWKSNoMatchingKey();
+        }
+        else if (length !== 1) {
+            throw new JWKSMultipleMatchingKeys();
+        }
+        const cached = this._cached.get(jwk) || this._cached.set(jwk, {}).get(jwk);
+        if (cached[joseHeader.alg] === undefined) {
+            const keyObject = await importJWK({ ...jwk, ext: true }, joseHeader.alg);
+            if (keyObject instanceof Uint8Array || keyObject.type !== 'public') {
+                throw new JWKSInvalid('JSON Web Key Set members must be public keys');
+            }
+            cached[joseHeader.alg] = keyObject;
+        }
+        return cached[joseHeader.alg];
+    }
+}
+export function createLocalJWKSet(jwks) {
+    return LocalJWKSet.prototype.getKey.bind(new LocalJWKSet(jwks));
+}

package/dist/browser/jwks/remote.js

@@ -1,26 +1,10 @@
 import fetchJwks from '../runtime/fetch_jwks.js';
-import { importJWK } from '../key/import.js';
-import { JWKSInvalid, JOSENotSupported, JWKSNoMatchingKey, JWKSMultipleMatchingKeys, } from '../util/errors.js';
-import isObject from '../lib/is_object.js';
-function getKtyFromAlg(alg) {
-    switch (typeof alg === 'string' && alg.substr(0, 2)) {
-        case 'RS':
-        case 'PS':
-            return 'RSA';
-        case 'ES':
-            return 'EC';
-        case 'Ed':
-            return 'OKP';
-        default:
-            throw new JOSENotSupported('Unsupported "alg" value for a JSON Web Key Set');
-    }
-}
-function isJWKLike(key) {
-    return isObject(key);
-}
-class RemoteJWKSet {
+import { JWKSInvalid, JWKSNoMatchingKey } from '../util/errors.js';
+import { isJWKSLike, LocalJWKSet } from './local.js';
+class RemoteJWKSet extends LocalJWKSet {
     constructor(url, options) {
-        this._cached = new WeakMap();
+        super({ keys: [] });
+        this._jwks = undefined;
         if (!(url instanceof URL)) {
             throw new TypeError('url must be an instance of URL');
         }
@@ -38,78 +22,27 @@ class RemoteJWKSet {
         return Date.now() < this._cooldownStarted + this._cooldownDuration;
     }
     async getKey(protectedHeader, token) {
-        const joseHeader = {
-            ...protectedHeader,
-            ...token.header,
-        };
         if (!this._jwks) {
             await this.reload();
         }
-        const candidates = this._jwks.keys.filter((jwk) => {
-            let candidate = jwk.kty === getKtyFromAlg(joseHeader.alg);
-            if (candidate && typeof joseHeader.kid === 'string') {
-                candidate = joseHeader.kid === jwk.kid;
-            }
-            if (candidate && typeof jwk.alg === 'string') {
-                candidate = joseHeader.alg === jwk.alg;
-            }
-            if (candidate && typeof jwk.use === 'string') {
-                candidate = jwk.use === 'sig';
-            }
-            if (candidate && Array.isArray(jwk.key_ops)) {
-                candidate = jwk.key_ops.includes('verify');
-            }
-            if (candidate && joseHeader.alg === 'EdDSA') {
-                candidate = jwk.crv === 'Ed25519' || jwk.crv === 'Ed448';
-            }
-            if (candidate) {
-                switch (joseHeader.alg) {
-                    case 'ES256':
-                        candidate = jwk.crv === 'P-256';
-                        break;
-                    case 'ES256K':
-                        candidate = jwk.crv === 'secp256k1';
-                        break;
-                    case 'ES384':
-                        candidate = jwk.crv === 'P-384';
-                        break;
-                    case 'ES512':
-                        candidate = jwk.crv === 'P-521';
-                        break;
-                    default:
-                }
-            }
-            return candidate;
-        });
-        const { 0: jwk, length } = candidates;
-        if (length === 0) {
-            if (this.coolingDown() === false) {
-                await this.reload();
-                return this.getKey(protectedHeader, token);
-            }
-            throw new JWKSNoMatchingKey();
-        }
-        else if (length !== 1) {
-            throw new JWKSMultipleMatchingKeys();
+        try {
+            return await super.getKey(protectedHeader, token);
         }
-        const cached = this._cached.get(jwk) || this._cached.set(jwk, {}).get(jwk);
-        if (cached[joseHeader.alg] === undefined) {
-            const keyObject = await importJWK({ ...jwk, ext: true }, joseHeader.alg);
-            if (keyObject instanceof Uint8Array || keyObject.type !== 'public') {
-                throw new JWKSInvalid('JSON Web Key Set members must be public keys');
+        catch (err) {
+            if (err instanceof JWKSNoMatchingKey) {
+                if (this.coolingDown() === false) {
+                    await this.reload();
+                    return super.getKey(protectedHeader, token);
+                }
             }
-            cached[joseHeader.alg] = keyObject;
+            throw err;
         }
-        return cached[joseHeader.alg];
     }
     async reload() {
         if (!this._pendingFetch) {
             this._pendingFetch = fetchJwks(this._url, this._timeoutDuration, this._options)
                 .then((json) => {
-                if (typeof json !== 'object' ||
-                    !json ||
-                    !Array.isArray(json.keys) ||
-                    !json.keys.every(isJWKLike)) {
+                if (!isJWKSLike(json)) {
                     throw new JWKSInvalid('JSON Web Key Set malformed');
                 }
                 this._jwks = { keys: json.keys };

package/dist/browser/lib/aesgcmkw.js

@@ -3,12 +3,12 @@ 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);
+    const jweAlgorithm = alg.slice(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 async function unwrap(alg, key, encryptedKey, iv, tag) {
-    const jweAlgorithm = alg.substr(0, 7);
+    const jweAlgorithm = alg.slice(0, 7);
     return decrypt(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array(0));
 }

package/dist/browser/lib/crypto_key.js

@@ -6,7 +6,7 @@ function isAlgorithm(algorithm, name) {
     return algorithm.name === name;
 }
 function getHashLength(hash) {
-    return parseInt(hash.name.substr(4), 10);
+    return parseInt(hash.name.slice(4), 10);
 }
 function getNamedCurve(alg) {
     switch (alg) {
@@ -43,7 +43,7 @@ export function checkSigCryptoKey(key, alg, ...usages) {
         case 'HS512': {
             if (!isAlgorithm(key.algorithm, 'HMAC'))
                 throw unusable('HMAC');
-            const expected = parseInt(alg.substr(2), 10);
+            const expected = parseInt(alg.slice(2), 10);
             const actual = getHashLength(key.algorithm.hash);
             if (actual !== expected)
                 throw unusable(`SHA-${expected}`, 'algorithm.hash');
@@ -54,7 +54,7 @@ export function checkSigCryptoKey(key, alg, ...usages) {
         case 'RS512': {
             if (!isAlgorithm(key.algorithm, 'RSASSA-PKCS1-v1_5'))
                 throw unusable('RSASSA-PKCS1-v1_5');
-            const expected = parseInt(alg.substr(2), 10);
+            const expected = parseInt(alg.slice(2), 10);
             const actual = getHashLength(key.algorithm.hash);
             if (actual !== expected)
                 throw unusable(`SHA-${expected}`, 'algorithm.hash');
@@ -65,7 +65,7 @@ export function checkSigCryptoKey(key, alg, ...usages) {
         case 'PS512': {
             if (!isAlgorithm(key.algorithm, 'RSA-PSS'))
                 throw unusable('RSA-PSS');
-            const expected = parseInt(alg.substr(2), 10);
+            const expected = parseInt(alg.slice(2), 10);
             const actual = getHashLength(key.algorithm.hash);
             if (actual !== expected)
                 throw unusable(`SHA-${expected}`, 'algorithm.hash');
@@ -104,7 +104,7 @@ export function checkEncCryptoKey(key, alg, ...usages) {
         case 'A256GCM': {
             if (!isAlgorithm(key.algorithm, 'AES-GCM'))
                 throw unusable('AES-GCM');
-            const expected = parseInt(alg.substr(1, 3), 10);
+            const expected = parseInt(alg.slice(1, 4), 10);
             const actual = key.algorithm.length;
             if (actual !== expected)
                 throw unusable(expected, 'algorithm.length');
@@ -115,7 +115,7 @@ export function checkEncCryptoKey(key, alg, ...usages) {
         case 'A256KW': {
             if (!isAlgorithm(key.algorithm, 'AES-KW'))
                 throw unusable('AES-KW');
-            const expected = parseInt(alg.substr(1, 3), 10);
+            const expected = parseInt(alg.slice(1, 4), 10);
             const actual = key.algorithm.length;
             if (actual !== expected)
                 throw unusable(expected, 'algorithm.length');
@@ -137,7 +137,7 @@ export function checkEncCryptoKey(key, alg, ...usages) {
         case 'RSA-OAEP-512': {
             if (!isAlgorithm(key.algorithm, 'RSA-OAEP'))
                 throw unusable('RSA-OAEP');
-            const expected = parseInt(alg.substr(9), 10) || 1;
+            const expected = parseInt(alg.slice(9), 10) || 1;
             const actual = getHashLength(key.algorithm.hash);
             if (actual !== expected)
                 throw unusable(`SHA-${expected}`, 'algorithm.hash');

package/dist/browser/lib/decrypt_key_management.js

@@ -40,12 +40,12 @@ 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, alg === 'ECDH-ES' ? cekLength(joseHeader.enc) : parseInt(alg.substr(-5, 3), 10), partyUInfo, partyVInfo);
+            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);
             if (alg === 'ECDH-ES')
                 return sharedSecret;
             if (encryptedKey === undefined)
                 throw new JWEInvalid('JWE Encrypted Key missing');
-            return aesKw(alg.substr(-6), sharedSecret, encryptedKey);
+            return aesKw(alg.slice(-6), sharedSecret, encryptedKey);
         }
         case 'RSA1_5':
         case 'RSA-OAEP':

package/dist/browser/lib/encrypt_key_management.js

@@ -27,10 +27,12 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
             }
             const { apu, apv } = providedParameters;
             let { epk: ephemeralKey } = providedParameters;
-            ephemeralKey || (ephemeralKey = await ECDH.generateEpk(key));
+            ephemeralKey || (ephemeralKey = (await ECDH.generateEpk(key)).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.substr(-5, 3), 10), apu, apv);
-            parameters = { epk: { x, y, crv, kty } };
+            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);
+            parameters = { epk: { x, crv, kty } };
+            if (kty === 'EC')
+                parameters.epk.y = y;
             if (apu)
                 parameters.apu = base64url(apu);
             if (apv)
@@ -40,7 +42,7 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
                 break;
             }
             cek = providedCek || generateCek(enc);
-            const kwAlg = alg.substr(-6);
+            const kwAlg = alg.slice(-6);
             encryptedKey = await aesKw(kwAlg, sharedSecret, cek);
             break;
         }

package/dist/browser/runtime/aeskw.js

@@ -4,7 +4,7 @@ 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)) {
+    if (key.algorithm.length !== parseInt(alg.slice(1, 4), 10)) {
         throw new TypeError(`Invalid key size for alg: ${alg}`);
     }
 }

package/dist/browser/runtime/asn1.js

@@ -23,29 +23,30 @@ export const toSPKI = (key) => {
 export const toPKCS8 = (key) => {
     return genericExport('private', 'pkcs8', key);
 };
+const findOid = (keyData, oid, from = 0) => {
+    if (from === 0) {
+        oid.unshift(oid.length);
+        oid.unshift(0x06);
+    }
+    let i = keyData.indexOf(oid[0], from);
+    if (i === -1)
+        return false;
+    const sub = keyData.subarray(i, i + oid.length);
+    if (sub.length !== oid.length)
+        return false;
+    return sub.every((value, index) => value === oid[index]) || findOid(keyData, oid, i + 1);
+};
 const getNamedCurve = (keyData) => {
-    const keyDataStr = keyData.toString();
     switch (true) {
-        case keyDataStr.includes(new Uint8Array([
-            0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x08, 0x2a, 0x86, 0x48, 0xce,
-            0x3d, 0x03, 0x01, 0x07,
-        ]).toString()):
+        case findOid(keyData, [0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07]):
             return 'P-256';
-        case keyDataStr.includes(new Uint8Array([
-            0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00,
-            0x22,
-        ]).toString()):
+        case findOid(keyData, [0x2b, 0x81, 0x04, 0x00, 0x22]):
             return 'P-384';
-        case keyDataStr.includes(new Uint8Array([
-            0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01, 0x06, 0x05, 0x2b, 0x81, 0x04, 0x00,
-            0x23,
-        ]).toString()):
+        case findOid(keyData, [0x2b, 0x81, 0x04, 0x00, 0x23]):
             return 'P-521';
-        case (isCloudflareWorkers() || isNodeJs()) &&
-            keyDataStr.includes(new Uint8Array([0x06, 0x03, 0x2b, 0x65, 0x70]).toString()):
+        case (isCloudflareWorkers() || isNodeJs()) && findOid(keyData, [0x2b, 0x65, 0x70]):
             return 'Ed25519';
-        case isNodeJs() &&
-            keyDataStr.includes(new Uint8Array([0x06, 0x03, 0x2b, 0x65, 0x71]).toString()):
+        case isNodeJs() && findOid(keyData, [0x2b, 0x65, 0x71]):
             return 'Ed448';
         default:
             throw new JOSENotSupported('Invalid or unsupported EC Key Curve or OKP Key Sub Type');
@@ -63,13 +64,13 @@ const genericImport = async (replace, keyFormat, pem, alg, options) => {
         case 'PS256':
         case 'PS384':
         case 'PS512':
-            algorithm = { name: 'RSA-PSS', hash: `SHA-${alg.substr(-3)}` };
+            algorithm = { name: 'RSA-PSS', hash: `SHA-${alg.slice(-3)}` };
             keyUsages = isPublic ? ['verify'] : ['sign'];
             break;
         case 'RS256':
         case 'RS384':
         case 'RS512':
-            algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: `SHA-${alg.substr(-3)}` };
+            algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: `SHA-${alg.slice(-3)}` };
             keyUsages = isPublic ? ['verify'] : ['sign'];
             break;
         case 'RSA-OAEP':
@@ -78,7 +79,7 @@ const genericImport = async (replace, keyFormat, pem, alg, options) => {
         case 'RSA-OAEP-512':
             algorithm = {
                 name: 'RSA-OAEP',
-                hash: `SHA-${parseInt(alg.substr(-3), 10) || 1}`,
+                hash: `SHA-${parseInt(alg.slice(-3), 10) || 1}`,
             };
             keyUsages = isPublic ? ['encrypt', 'wrapKey'] : ['decrypt', 'unwrapKey'];
             break;

package/dist/browser/runtime/decrypt.js

@@ -11,7 +11,7 @@ async function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
     if (!(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
     }
-    const keySize = parseInt(enc.substr(1, 3), 10);
+    const keySize = parseInt(enc.slice(1, 4), 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: `SHA-${keySize << 1}`,
@@ -70,13 +70,13 @@ const decrypt = async (enc, cek, ciphertext, iv, tag, aad) => {
         case 'A192CBC-HS384':
         case 'A256CBC-HS512':
             if (cek instanceof Uint8Array)
-                checkCekLength(cek, parseInt(enc.substr(-3), 10));
+                checkCekLength(cek, parseInt(enc.slice(-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));
+                checkCekLength(cek, parseInt(enc.slice(1, 4), 10));
             return gcmDecrypt(enc, cek, ciphertext, iv, tag, aad);
         default:
             throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');

package/dist/browser/runtime/digest.js

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

package/dist/browser/runtime/ecdhes.js

@@ -4,7 +4,7 @@ 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)) => {
+export async function deriveKey(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) {
     if (!isCryptoKey(publicKey)) {
         throw new TypeError(invalidKeyInput(publicKey, ...types));
     }
@@ -20,19 +20,18 @@ export const deriveKey = async (publicKey, privateKey, algorithm, keyLength, apu
     const sharedSecret = new Uint8Array(await crypto.subtle.deriveBits({
         name: 'ECDH',
         public: publicKey,
-    }, privateKey, Math.ceil(parseInt(privateKey.algorithm.namedCurve.substr(-3), 10) / 8) <<
-        3));
+    }, privateKey, Math.ceil(parseInt(privateKey.algorithm.namedCurve.slice(-3), 10) / 8) << 3));
     return concatKdf(digest, sharedSecret, keyLength, value);
-};
-export const generateEpk = async (key) => {
+}
+export async function generateEpk(key) {
     if (!isCryptoKey(key)) {
         throw new TypeError(invalidKeyInput(key, ...types));
     }
-    return (await crypto.subtle.generateKey({ name: 'ECDH', namedCurve: key.algorithm.namedCurve }, true, ['deriveBits'])).privateKey;
-};
-export const ecdhAllowed = (key) => {
+    return crypto.subtle.generateKey(key.algorithm, true, ['deriveBits']);
+}
+export function ecdhAllowed(key) {
     if (!isCryptoKey(key)) {
         throw new TypeError(invalidKeyInput(key, ...types));
     }
     return ['P-256', 'P-384', 'P-521'].includes(key.algorithm.namedCurve);
-};
+}

package/dist/browser/runtime/encrypt.js

@@ -10,7 +10,7 @@ async function cbcEncrypt(enc, plaintext, cek, iv, aad) {
     if (!(cek instanceof Uint8Array)) {
         throw new TypeError(invalidKeyInput(cek, 'Uint8Array'));
     }
-    const keySize = parseInt(enc.substr(1, 3), 10);
+    const keySize = parseInt(enc.slice(1, 4), 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: `SHA-${keySize << 1}`,
@@ -53,13 +53,13 @@ const encrypt = async (enc, plaintext, cek, iv, aad) => {
         case 'A192CBC-HS384':
         case 'A256CBC-HS512':
             if (cek instanceof Uint8Array)
-                checkCekLength(cek, parseInt(enc.substr(-3), 10));
+                checkCekLength(cek, parseInt(enc.slice(-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));
+                checkCekLength(cek, parseInt(enc.slice(1, 4), 10));
             return gcmEncrypt(enc, plaintext, cek, iv, aad);
         default:
             throw new JOSENotSupported('Unsupported JWE Content Encryption Algorithm');

package/dist/browser/runtime/generate.js

@@ -11,19 +11,19 @@ export async function generateSecret(alg, options) {
         case 'HS256':
         case 'HS384':
         case 'HS512':
-            length = parseInt(alg.substr(-3), 10);
+            length = parseInt(alg.slice(-3), 10);
             algorithm = { name: 'HMAC', hash: `SHA-${length}`, length };
             keyUsages = ['sign', 'verify'];
             break;
         case 'A128CBC-HS256':
         case 'A192CBC-HS384':
         case 'A256CBC-HS512':
-            length = parseInt(alg.substr(-3), 10);
+            length = parseInt(alg.slice(-3), 10);
             return random(new Uint8Array(length >> 3));
         case 'A128KW':
         case 'A192KW':
         case 'A256KW':
-            length = parseInt(alg.substring(1, 4), 10);
+            length = parseInt(alg.slice(1, 4), 10);
             algorithm = { name: 'AES-KW', length };
             keyUsages = ['wrapKey', 'unwrapKey'];
             break;
@@ -33,7 +33,7 @@ export async function generateSecret(alg, options) {
         case 'A128GCM':
         case 'A192GCM':
         case 'A256GCM':
-            length = parseInt(alg.substring(1, 4), 10);
+            length = parseInt(alg.slice(1, 4), 10);
             algorithm = { name: 'AES-GCM', length };
             keyUsages = ['encrypt', 'decrypt'];
             break;
@@ -60,7 +60,7 @@ export async function generateKeyPair(alg, options) {
         case 'PS512':
             algorithm = {
                 name: 'RSA-PSS',
-                hash: `SHA-${alg.substr(-3)}`,
+                hash: `SHA-${alg.slice(-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: `SHA-${alg.substr(-3)}`,
+                hash: `SHA-${alg.slice(-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: `SHA-${parseInt(alg.substr(-3), 10) || 1}`,
+                hash: `SHA-${parseInt(alg.slice(-3), 10) || 1}`,
                 publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
                 modulusLength: getModulusLengthOption(options),
             };

package/dist/browser/runtime/get_sign_verify_key.js

@@ -11,7 +11,7 @@ export default function getCryptoKey(alg, key, usage) {
         if (!alg.startsWith('HS')) {
             throw new TypeError(invalidKeyInput(key, ...types));
         }
-        return crypto.subtle.importKey('raw', key, { hash: `SHA-${alg.substr(-3)}`, name: 'HMAC' }, false, [usage]);
+        return crypto.subtle.importKey('raw', key, { hash: `SHA-${alg.slice(-3)}`, name: 'HMAC' }, false, [usage]);
     }
     throw new TypeError(invalidKeyInput(key, ...types, '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: `SHA-${jwk.alg.substr(-3)}` };
+                    algorithm = { name: 'HMAC', hash: `SHA-${jwk.alg.slice(-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: `SHA-${jwk.alg.substr(-3)}` };
+                    algorithm = { name: 'RSA-PSS', hash: `SHA-${jwk.alg.slice(-3)}` };
                     keyUsages = jwk.d ? ['sign'] : ['verify'];
                     break;
                 case 'RS256':
                 case 'RS384':
                 case 'RS512':
-                    algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: `SHA-${jwk.alg.substr(-3)}` };
+                    algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: `SHA-${jwk.alg.slice(-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: `SHA-${parseInt(jwk.alg.substr(-3), 10) || 1}`,
+                        hash: `SHA-${parseInt(jwk.alg.slice(-3), 10) || 1}`,
                     };
                     keyUsages = jwk.d ? ['decrypt', 'unwrapKey'] : ['encrypt', 'wrapKey'];
                     break;