jose 4.3.4 → 4.3.8

package/dist/browser/jwks/remote.js

@@ -3,7 +3,7 @@ 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)) {
+    switch (typeof alg === 'string' && alg.slice(0, 2)) {
         case 'RS':
         case 'PS':
             return 'RSA';

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,9 +27,9 @@ 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);
+            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, y, crv, kty } };
             if (apu)
                 parameters.apu = base64url(apu);
@@ -40,7 +40,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;

package/dist/browser/runtime/pbes2kw.js

@@ -20,9 +20,9 @@ function getCryptoKey(key, alg) {
 async function deriveKey(p2s, alg, p2c, key) {
     checkP2s(p2s);
     const salt = concatSalt(alg, p2s);
-    const keylen = parseInt(alg.substr(13, 3), 10);
+    const keylen = parseInt(alg.slice(13, 16), 10);
     const subtleAlg = {
-        hash: `SHA-${alg.substr(8, 3)}`,
+        hash: `SHA-${alg.slice(8, 11)}`,
         iterations: p2c,
         name: 'PBKDF2',
         salt,
@@ -42,10 +42,10 @@ async function deriveKey(p2s, alg, p2c, key) {
 }
 export const encrypt = async (alg, key, cek, p2c = Math.floor(Math.random() * 2049) + 2048, p2s = random(new Uint8Array(16))) => {
     const derived = await deriveKey(p2s, alg, p2c, key);
-    const encryptedKey = await wrap(alg.substr(-6), derived, cek);
+    const encryptedKey = await wrap(alg.slice(-6), derived, cek);
     return { encryptedKey, p2c, p2s: base64url(p2s) };
 };
 export const decrypt = async (alg, key, encryptedKey, p2c, p2s) => {
     const derived = await deriveKey(p2s, alg, p2c, key);
-    return unwrap(alg.substr(-6), derived, encryptedKey);
+    return unwrap(alg.slice(-6), derived, encryptedKey);
 };

package/dist/browser/runtime/sign.js

@@ -5,7 +5,7 @@ import getSignKey from './get_sign_verify_key.js';
 const sign = async (alg, key, data) => {
     const cryptoKey = await getSignKey(alg, key, 'sign');
     checkKeyLength(alg, cryptoKey);
-    const signature = await crypto.subtle.sign(subtleAlgorithm(alg, cryptoKey.algorithm.namedCurve), cryptoKey, data);
+    const signature = await crypto.subtle.sign(subtleAlgorithm(alg, cryptoKey.algorithm), cryptoKey, data);
     return new Uint8Array(signature);
 };
 export default sign;

package/dist/browser/runtime/subtle_dsa.js

@@ -1,25 +1,26 @@
 import { isCloudflareWorkers, isNodeJs } from './env.js';
 import { JOSENotSupported } from '../util/errors.js';
-export default function subtleDsa(alg, namedCurve) {
-    const length = parseInt(alg.substr(-3), 10);
+export default function subtleDsa(alg, algorithm) {
+    const hash = `SHA-${alg.slice(-3)}`;
     switch (alg) {
         case 'HS256':
         case 'HS384':
         case 'HS512':
-            return { hash: `SHA-${length}`, name: 'HMAC' };
+            return { hash, name: 'HMAC' };
         case 'PS256':
         case 'PS384':
         case 'PS512':
-            return { hash: `SHA-${length}`, name: 'RSA-PSS', saltLength: length >> 3 };
+            return { hash, name: 'RSA-PSS', saltLength: alg.slice(-3) >> 3 };
         case 'RS256':
         case 'RS384':
         case 'RS512':
-            return { hash: `SHA-${length}`, name: 'RSASSA-PKCS1-v1_5' };
+            return { hash, name: 'RSASSA-PKCS1-v1_5' };
         case 'ES256':
         case 'ES384':
         case 'ES512':
-            return { hash: `SHA-${length}`, name: 'ECDSA', namedCurve };
+            return { hash, name: 'ECDSA', namedCurve: algorithm.namedCurve };
         case (isCloudflareWorkers() || isNodeJs()) && 'EdDSA':
+            const { namedCurve } = algorithm;
             return { name: namedCurve, namedCurve };
         default:
             throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);

package/dist/browser/runtime/verify.js

@@ -5,7 +5,7 @@ import getVerifyKey from './get_sign_verify_key.js';
 const verify = async (alg, key, signature, data) => {
     const cryptoKey = await getVerifyKey(alg, key, 'verify');
     checkKeyLength(alg, cryptoKey);
-    const algorithm = subtleAlgorithm(alg, cryptoKey.algorithm.namedCurve);
+    const algorithm = subtleAlgorithm(alg, cryptoKey.algorithm);
     try {
         return await crypto.subtle.verify(algorithm, cryptoKey, signature, data);
     }

package/dist/node/cjs/jwks/remote.js

@@ -6,7 +6,7 @@ const import_js_1 = require("../key/import.js");
 const errors_js_1 = require("../util/errors.js");
 const is_object_js_1 = require("../lib/is_object.js");
 function getKtyFromAlg(alg) {
-    switch (typeof alg === 'string' && alg.substr(0, 2)) {
+    switch (typeof alg === 'string' && alg.slice(0, 2)) {
         case 'RS':
         case 'PS':
             return 'RSA';

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

@@ -6,14 +6,14 @@ const decrypt_js_1 = require("../runtime/decrypt.js");
 const iv_js_1 = require("./iv.js");
 const base64url_js_1 = require("../runtime/base64url.js");
 async function wrap(alg, key, cek, iv) {
-    const jweAlgorithm = alg.substr(0, 7);
+    const jweAlgorithm = alg.slice(0, 7);
     iv || (iv = (0, iv_js_1.default)(jweAlgorithm));
     const { ciphertext: encryptedKey, tag } = await (0, encrypt_js_1.default)(jweAlgorithm, cek, key, iv, new Uint8Array(0));
     return { encryptedKey, iv: (0, base64url_js_1.encode)(iv), tag: (0, base64url_js_1.encode)(tag) };
 }
 exports.wrap = wrap;
 async function unwrap(alg, key, encryptedKey, iv, tag) {
-    const jweAlgorithm = alg.substr(0, 7);
+    const jweAlgorithm = alg.slice(0, 7);
     return (0, decrypt_js_1.default)(jweAlgorithm, key, encryptedKey, iv, tag, new Uint8Array(0));
 }
 exports.unwrap = unwrap;

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

@@ -9,7 +9,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) {
@@ -46,7 +46,7 @@ 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');
@@ -57,7 +57,7 @@ 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');
@@ -68,7 +68,7 @@ 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');
@@ -108,7 +108,7 @@ 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');
@@ -119,7 +119,7 @@ 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');
@@ -141,7 +141,7 @@ 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/node/cjs/lib/decrypt_key_management.js

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

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

@@ -29,9 +29,9 @@ 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 (0, export_js_1.exportJWK)(ephemeralKey);
-            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);
+            const sharedSecret = await ECDH.deriveKey(key, ephemeralKey, alg === 'ECDH-ES' ? enc : alg, alg === 'ECDH-ES' ? (0, cek_js_1.bitLength)(enc) : parseInt(alg.slice(-5, -2), 10), apu, apv);
             parameters = { epk: { x, y, crv, kty } };
             if (apu)
                 parameters.apu = (0, base64url_js_1.encode)(apu);
@@ -42,7 +42,7 @@ async function encryptKeyManagement(alg, enc, key, providedCek, providedParamete
                 break;
             }
             cek = providedCek || (0, cek_js_1.default)(enc);
-            const kwAlg = alg.substr(-6);
+            const kwAlg = alg.slice(-6);
             encryptedKey = await (0, aeskw_js_1.wrap)(kwAlg, sharedSecret, cek);
             break;
         }