jose 6.2.6 → 6.2.8

package/dist/webapi/lib/jwe_decrypt.js

@@ -9,88 +9,94 @@ import { prepareKey } from './key.js';
 import { jweAlgorithm, jweEncryption } from './jwe_algorithms.js';
 import { decompress } from './deflate.js';
 export function checkShared(jwe) {
+    const { ciphertext, protected: encodedProtected, unprotected } = jwe;
     if (jwe.iv !== undefined && typeof jwe.iv !== 'string') {
         throw new JWEInvalid('JWE Initialization Vector incorrect type');
     }
-    if (typeof jwe.ciphertext !== 'string') {
+    if (typeof ciphertext !== 'string') {
         throw new JWEInvalid('JWE Ciphertext missing or incorrect type');
     }
     if (jwe.tag !== undefined && typeof jwe.tag !== 'string') {
         throw new JWEInvalid('JWE Authentication Tag incorrect type');
     }
-    if (jwe.protected !== undefined && typeof jwe.protected !== 'string') {
+    if (encodedProtected !== undefined && typeof encodedProtected !== 'string') {
         throw new JWEInvalid('JWE Protected Header incorrect type');
     }
     if (jwe.aad !== undefined && typeof jwe.aad !== 'string') {
         throw new JWEInvalid('JWE AAD incorrect type');
     }
-    if (jwe.unprotected !== undefined && !isObject(jwe.unprotected)) {
+    if (unprotected !== undefined && !isObject(unprotected)) {
         throw new JWEInvalid('JWE Shared Unprotected Header incorrect type');
     }
 }
 export function checkRecipient(jwe) {
-    if (jwe.encrypted_key !== undefined && typeof jwe.encrypted_key !== 'string') {
+    const { encrypted_key: encryptedKey, header } = jwe;
+    if (encryptedKey !== undefined && typeof encryptedKey !== 'string') {
         throw new JWEInvalid('JWE Encrypted Key incorrect type');
     }
-    if (jwe.header !== undefined && !isObject(jwe.header)) {
+    if (header !== undefined && !isObject(header)) {
         throw new JWEInvalid('JWE Per-Recipient Unprotected Header incorrect type');
     }
-    if (jwe.protected === undefined && jwe.header === undefined && jwe.unprotected === undefined) {
+    if (jwe.protected === undefined && header === undefined && jwe.unprotected === undefined) {
         throw new JWEInvalid('JOSE Header missing');
     }
 }
 export function shareJWE(jwe) {
+    const { protected: encodedProtected, ciphertext, iv, tag, aad } = jwe;
     let parsedProt;
-    if (jwe.protected) {
-        parsedProt = parseJoseHeader(jwe.protected, JWEInvalid, 'JWE Protected Header is invalid');
+    if (encodedProtected) {
+        parsedProt = parseJoseHeader(encodedProtected, JWEInvalid, 'JWE Protected Header is invalid');
     }
-    const protectedHeader = jwe.protected !== undefined ? encode(jwe.protected) : new Uint8Array();
-    return {
+    const protectedHeader = encodedProtected !== undefined ? encode(encodedProtected) : new Uint8Array();
+    return [
         parsedProt,
-        ciphertext: decodeBase64url(jwe.ciphertext, 'ciphertext', JWEInvalid),
-        iv: jwe.iv !== undefined ? decodeBase64url(jwe.iv, 'iv', JWEInvalid) : undefined,
-        tag: jwe.tag !== undefined ? decodeBase64url(jwe.tag, 'tag', JWEInvalid) : undefined,
-        additionalData: jwe.aad !== undefined
-            ? concat(protectedHeader, encode('.'), encodeBase64url(jwe.aad, 'aad', JWEInvalid))
+        decodeBase64url(ciphertext, 'ciphertext', JWEInvalid),
+        iv !== undefined ? decodeBase64url(iv, 'iv', JWEInvalid) : undefined,
+        tag !== undefined ? decodeBase64url(tag, 'tag', JWEInvalid) : undefined,
+        aad !== undefined
+            ? concat(protectedHeader, encode('.'), encodeBase64url(aad, 'aad', JWEInvalid))
             : protectedHeader,
-    };
+    ];
 }
 export function decryptResult(jwe, decrypted) {
-    const result = { plaintext: decrypted.plaintext };
-    if (jwe.protected !== undefined) {
-        result.protectedHeader = decrypted.parsedProt;
+    const [plaintext, parsedProt, key, resolvedKey] = decrypted;
+    const { protected: encodedProtected, aad, unprotected, header } = jwe;
+    const result = { plaintext };
+    if (encodedProtected !== undefined) {
+        result.protectedHeader = parsedProt;
     }
-    if (jwe.aad !== undefined) {
-        result.additionalAuthenticatedData = decodeBase64url(jwe.aad, 'aad', JWEInvalid);
+    if (aad !== undefined) {
+        result.additionalAuthenticatedData = decodeBase64url(aad, 'aad', JWEInvalid);
     }
-    if (jwe.unprotected !== undefined) {
-        result.sharedUnprotectedHeader = jwe.unprotected;
+    if (unprotected !== undefined) {
+        result.sharedUnprotectedHeader = unprotected;
     }
-    if (jwe.header !== undefined) {
-        result.unprotectedHeader = jwe.header;
+    if (header !== undefined) {
+        result.unprotectedHeader = header;
     }
-    if (decrypted.resolvedKey) {
-        return { ...result, key: decrypted.key };
+    if (resolvedKey) {
+        return { ...result, key };
     }
     return result;
 }
 export function prepareDecrypt(options) {
-    return {
-        keyManagementAlgorithms: options && validateAlgorithms('keyManagementAlgorithms', options.keyManagementAlgorithms),
-        contentEncryptionAlgorithms: options &&
+    return [
+        options && validateAlgorithms('keyManagementAlgorithms', options.keyManagementAlgorithms),
+        options &&
             validateAlgorithms('contentEncryptionAlgorithms', options.contentEncryptionAlgorithms),
         options,
-    };
+    ];
 }
 export async function decryptRecipient(jwe, token, shared, key) {
-    const { options } = shared;
-    const { parsedProt } = token;
+    const [keyManagementAlgorithms, contentEncryptionAlgorithms, options] = shared;
+    const [parsedProt, ciphertext, iv, tag, additionalData] = token;
+    const { encrypted_key: encodedKey, header, unprotected } = jwe;
     let joseHeader;
-    if (jwe.header !== undefined || jwe.unprotected !== undefined) {
-        if (!isDisjoint(parsedProt, jwe.header, jwe.unprotected)) {
+    if (header !== undefined || unprotected !== undefined) {
+        if (!isDisjoint(parsedProt, header, unprotected)) {
             throw new JWEInvalid('JWE Protected, JWE Unprotected Header, and JWE Per-Recipient Unprotected Header Parameter names must be disjoint');
         }
-        joseHeader = { ...parsedProt, ...jwe.header, ...jwe.unprotected };
+        joseHeader = { ...parsedProt, ...header, ...unprotected };
     }
     else {
         joseHeader = parsedProt ?? {};
@@ -109,7 +115,6 @@ export async function decryptRecipient(jwe, token, shared, key) {
     if (typeof enc !== 'string' || !enc) {
         throw new JWEInvalid('missing JWE Encryption Algorithm (enc) in JWE Header');
     }
-    const { keyManagementAlgorithms, contentEncryptionAlgorithms } = shared;
     if ((keyManagementAlgorithms && !keyManagementAlgorithms.has(alg)) ||
         (!keyManagementAlgorithms && alg.startsWith('PBES2'))) {
         throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter value not allowed');
@@ -119,8 +124,8 @@ export async function decryptRecipient(jwe, token, shared, key) {
     }
     const encEntry = jweEncryption(enc);
     let encryptedKey;
-    if (jwe.encrypted_key !== undefined) {
-        encryptedKey = decodeBase64url(jwe.encrypted_key, 'encrypted_key', JWEInvalid);
+    if (encodedKey !== undefined) {
+        encryptedKey = decodeBase64url(encodedKey, 'encrypted_key', JWEInvalid);
     }
     let resolvedKey = false;
     if (typeof key === 'function') {
@@ -139,7 +144,7 @@ export async function decryptRecipient(jwe, token, shared, key) {
         }
         cek = generateCek(encEntry);
     }
-    let plaintext = await decrypt(encEntry, cek, token.ciphertext, token.iv, token.tag, token.additionalData);
+    let plaintext = await decrypt(encEntry, cek, ciphertext, iv, tag, additionalData);
     if (joseHeader.zip === 'DEF') {
         const maxDecompressedLength = options?.maxDecompressedLength ?? 250_000;
         if (maxDecompressedLength === 0) {
@@ -155,7 +160,7 @@ export async function decryptRecipient(jwe, token, shared, key) {
             throw new JWEInvalid('Failed to decompress plaintext', { cause });
         });
     }
-    return { plaintext, parsedProt, key: k, resolvedKey };
+    return [plaintext, parsedProt, k, resolvedKey];
 }
 export async function decryptJWE(jwe, shared, key) {
     return decryptRecipient(jwe, shareJWE(jwe), shared, key);

package/dist/webapi/lib/jwe_encrypt.js

@@ -9,7 +9,7 @@ import { prepareKey } from './key.js';
 import { jweAlgorithm, jweEncryption } from './jwe_algorithms.js';
 import { compress } from './deflate.js';
 export function checkEncryptHeaders(input) {
-    const { protectedHeader, unprotectedHeader, sharedUnprotectedHeader } = input;
+    const [, protectedHeader, unprotectedHeader, sharedUnprotectedHeader, , , , , crit] = input;
     if (!isDisjoint(protectedHeader, unprotectedHeader, sharedUnprotectedHeader)) {
         throw new JWEInvalid('JWE Protected, JWE Shared Unprotected and JWE Per-Recipient Header Parameter names must be disjoint');
     }
@@ -18,7 +18,7 @@ export function checkEncryptHeaders(input) {
         ...unprotectedHeader,
         ...sharedUnprotectedHeader,
     };
-    validateCrit(JWEInvalid, JWE_RECOGNIZED, input.crit, protectedHeader, joseHeader);
+    validateCrit(JWEInvalid, JWE_RECOGNIZED, crit, protectedHeader, joseHeader);
     if (joseHeader.zip !== undefined && joseHeader.zip !== 'DEF') {
         throw new JOSENotSupported('Unsupported JWE "zip" (Compression Algorithm) Header Parameter value.');
     }
@@ -32,20 +32,21 @@ export function checkEncryptHeaders(input) {
     if (typeof enc !== 'string' || !enc) {
         throw new JWEInvalid('JWE "enc" (Encryption Algorithm) Header Parameter missing or invalid');
     }
-    return { joseHeader, alg, enc, encEntry: jweEncryption(enc) };
+    return [joseHeader, alg, enc, jweEncryption(enc)];
 }
 export async function encryptJWE(input, checked, key) {
-    const { joseHeader, alg, encEntry } = checked;
-    let { protectedHeader, unprotectedHeader } = input;
-    const { sharedUnprotectedHeader } = input;
-    if (input.cek && (alg === 'dir' || alg === 'ECDH-ES')) {
+    const [joseHeader, alg, , encEntry] = checked;
+    const [inputPlaintext, inputProtectedHeader, inputUnprotectedHeader, sharedUnprotectedHeader, aad, providedCek, inputIv, keyManagementParameters, , unprotectedParameters,] = input;
+    let protectedHeader = inputProtectedHeader;
+    let unprotectedHeader = inputUnprotectedHeader;
+    if (providedCek && (alg === 'dir' || alg === 'ECDH-ES')) {
         throw new TypeError(`setContentEncryptionKey cannot be called with JWE "alg" (Algorithm) Header ${alg}`);
     }
     const algEntry = jweAlgorithm(alg);
     const k = await prepareKey(alg === 'dir' ? encEntry : algEntry, key, 'encrypt');
-    const { cek, encryptedKey, parameters } = await encryptKeyManagement(alg, encEntry, k, input.cek, input.keyManagementParameters);
+    const [cek, encryptedKey, parameters] = await encryptKeyManagement(alg, encEntry, k, providedCek, keyManagementParameters);
     if (parameters) {
-        if (input.unprotectedParameters) {
+        if (unprotectedParameters) {
             unprotectedHeader = unprotectedHeader ? { ...unprotectedHeader, ...parameters } : parameters;
         }
         else {
@@ -64,20 +65,20 @@ export async function encryptJWE(input, checked, key) {
     }
     let additionalData;
     let aadMember;
-    if (input.aad?.byteLength) {
-        aadMember = b64u(input.aad);
+    if (aad?.byteLength) {
+        aadMember = b64u(aad);
         additionalData = concat(protectedHeaderB, encode('.'), encode(aadMember));
     }
     else {
         additionalData = protectedHeaderB;
     }
-    let plaintext = input.plaintext;
+    let plaintext = inputPlaintext;
     if (joseHeader.zip === 'DEF') {
         plaintext = await compress(plaintext).catch((cause) => {
             throw new JWEInvalid('Failed to compress plaintext', { cause });
         });
     }
-    const { ciphertext, tag, iv } = await encrypt(encEntry, plaintext, cek, input.iv, additionalData);
+    const { ciphertext, tag, iv } = await encrypt(encEntry, plaintext, cek, inputIv, additionalData);
     const jwe = {
         ciphertext: b64u(ciphertext),
     };

package/dist/webapi/lib/jwk_to_key.js

@@ -1,22 +1,17 @@
 import { JOSENotSupported } from '../util/errors.js';
-const unsupportedAlg = 'Invalid or unsupported JWK "alg" (Algorithm) Parameter value';
-function subtleParams(entry, jwk) {
-    if (!entry.kty.includes(jwk.kty)) {
-        throw new JOSENotSupported(unsupportedAlg);
-    }
-    return entry.subtleFor?.({ kty: jwk.kty, crv: jwk.crv }) ?? entry.subtle;
-}
 export async function jwkToKey(entry, jwk) {
     if (jwk.kty === 'RSA' && 'oth' in jwk && jwk.oth !== undefined) {
         throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
     }
-    const algorithm = subtleParams(entry, jwk);
+    if (!entry.kty.includes(jwk.kty)) {
+        throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+    }
+    const algorithm = entry.resolve?.({ kty: jwk.kty, crv: jwk.crv }) ?? entry.subtle;
     const isPrivate = !!(jwk.d || jwk.priv);
-    const keyUsages = isPrivate ? entry.usages.private : entry.usages.public;
     const keyData = { ...jwk };
     if (keyData.kty !== 'AKP') {
         delete keyData.alg;
     }
     delete keyData.use;
-    return crypto.subtle.importKey('jwk', keyData, algorithm, jwk.ext ?? (isPrivate ? false : true), jwk.key_ops ?? keyUsages);
+    return crypto.subtle.importKey('jwk', keyData, algorithm, jwk.ext ?? !isPrivate, jwk.key_ops ?? entry.usages[isPrivate ? 1 : 0]);
 }

package/dist/webapi/lib/jws_algorithms.js

@@ -1,18 +1,19 @@
 import { JOSENotSupported } from '../util/errors.js';
 import { table } from './key_descriptor.js';
-const sig = { public: ['verify'], private: ['sign'] };
+const sig = [['verify'], ['sign']];
 function hmac(bits) {
     const subtle = { name: 'HMAC', hash: `SHA-${bits}` };
-    return { kty: ['oct'], symmetric: true, subtle, operation: subtle, usages: sig };
+    return { kty: ['oct'], secret: true, subtle, signing: subtle, usages: sig };
 }
-function rsa(name, bits, saltLength) {
+function rsa(bits, saltLength) {
+    const name = saltLength ? 'RSA-PSS' : 'RSASSA-PKCS1-v1_5';
     const subtle = { name, hash: `SHA-${bits}` };
     return {
         kty: ['RSA'],
         subtle,
-        operation: saltLength ? { ...subtle, saltLength } : subtle,
+        signing: saltLength ? { ...subtle, saltLength } : subtle,
         usages: sig,
-        minModulusLength: 2048,
+        minRsaBits: 2048,
     };
 }
 function ecdsa(crv, bits) {
@@ -20,7 +21,7 @@ function ecdsa(crv, bits) {
         kty: ['EC'],
         crv,
         subtle: { name: 'ECDSA', namedCurve: crv },
-        operation: { name: 'ECDSA', hash: `SHA-${bits}` },
+        signing: { name: 'ECDSA', hash: `SHA-${bits}` },
         usages: sig,
     };
 }
@@ -30,45 +31,43 @@ function eddsa() {
         kty: ['OKP'],
         crv: 'Ed25519',
         subtle,
-        operation: subtle,
+        signing: subtle,
         usages: sig,
     };
 }
-function mldsa(name) {
+function mldsa(bits) {
+    const name = `ML-DSA-${bits}`;
     const subtle = { name };
     return {
         kty: ['AKP'],
         subtle,
-        operation: subtle,
+        signing: subtle,
         usages: sig,
     };
 }
-const JWS = table({
+export const JWS = table({
     HS256: hmac(256),
     HS384: hmac(384),
     HS512: hmac(512),
-    RS256: rsa('RSASSA-PKCS1-v1_5', 256),
-    RS384: rsa('RSASSA-PKCS1-v1_5', 384),
-    RS512: rsa('RSASSA-PKCS1-v1_5', 512),
-    PS256: rsa('RSA-PSS', 256, 32),
-    PS384: rsa('RSA-PSS', 384, 48),
-    PS512: rsa('RSA-PSS', 512, 64),
+    RS256: rsa(256),
+    RS384: rsa(384),
+    RS512: rsa(512),
+    PS256: rsa(256, 32),
+    PS384: rsa(384, 48),
+    PS512: rsa(512, 64),
     ES256: ecdsa('P-256', 256),
     ES384: ecdsa('P-384', 384),
     ES512: ecdsa('P-521', 512),
     EdDSA: eddsa(),
     Ed25519: eddsa(),
-    'ML-DSA-44': mldsa('ML-DSA-44'),
-    'ML-DSA-65': mldsa('ML-DSA-65'),
-    'ML-DSA-87': mldsa('ML-DSA-87'),
+    'ML-DSA-44': mldsa(44),
+    'ML-DSA-65': mldsa(65),
+    'ML-DSA-87': mldsa(87),
 });
 export function jwsAlgorithm(alg) {
-    const entry = JWS[alg];
+    const entry = typeof alg === 'string' ? JWS[alg] : undefined;
     if (!entry) {
         throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
     }
     return entry;
 }
-export function maybeJWSAlgorithm(alg) {
-    return JWS[alg];
-}

package/dist/webapi/lib/jws_sign.js

@@ -13,6 +13,9 @@ export function unencodedPayload(protectedHeader) {
 }
 export async function createSignature(input, key) {
     const { protectedHeader, unprotectedHeader } = input;
+    if (!protectedHeader && !unprotectedHeader) {
+        throw new JWSInvalid('either setProtectedHeader or setUnprotectedHeader must be called before #sign()');
+    }
     if (!isDisjoint(protectedHeader, unprotectedHeader)) {
         throw new JWSInvalid('JWS Protected and JWS Unprotected Header Parameter names must be disjoint');
     }
@@ -20,7 +23,7 @@ export async function createSignature(input, key) {
     validateCritDuplicates(JWSInvalid, protectedHeader);
     const extensions = validateCrit(JWSInvalid, JWS_RECOGNIZED, input.crit, protectedHeader, joseHeader);
     let b64 = true;
-    if (extensions.has('b64')) {
+    if (extensions.includes('b64')) {
         b64 = protectedHeader.b64;
         if (typeof b64 !== 'boolean') {
             throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
@@ -34,11 +37,11 @@ export async function createSignature(input, key) {
     let payloadS;
     let payloadB;
     if (b64) {
-        const encoded = (input.encoded ??= {});
-        encoded.b64 ??= b64u(input.payload);
-        encoded.raw ??= encode(encoded.b64);
-        payloadS = encoded.b64;
-        payloadB = encoded.raw;
+        const encoded = (input.encoded ??= []);
+        encoded[0] ??= b64u(input.payload);
+        encoded[1] ??= encode(encoded[0]);
+        payloadS = encoded[0];
+        payloadB = encoded[1];
     }
     else {
         payloadB = input.payload;
@@ -64,5 +67,8 @@ export async function createSignature(input, key) {
     if (protectedHeader) {
         jws.protected = protectedHeaderString;
     }
+    if (unprotectedHeader) {
+        jws.header = unprotectedHeader;
+    }
     return jws;
 }

package/dist/webapi/lib/jws_verify.js

@@ -7,42 +7,41 @@ import { isDisjoint } from './type_checks.js';
 import { validateCrit, validateAlgorithms, JWS_RECOGNIZED } from './options.js';
 import { prepareKey } from './key.js';
 export function verifyResult(jws, verified) {
-    const result = { payload: verified.payload };
+    const [payload, parsedProt, , key, resolvedKey] = verified;
+    const result = { payload };
     if (jws.protected !== undefined) {
-        result.protectedHeader = verified.parsedProt;
+        result.protectedHeader = parsedProt;
     }
     if (jws.header !== undefined) {
         result.unprotectedHeader = jws.header;
     }
-    if (verified.resolvedKey) {
-        return { ...result, key: verified.key };
+    if (resolvedKey) {
+        return { ...result, key };
     }
     return result;
 }
 export function prepareVerify(options) {
-    return {
-        algorithms: options && validateAlgorithms('algorithms', options.algorithms),
-        crit: options?.crit,
-    };
+    return [options && validateAlgorithms('algorithms', options.algorithms), options?.crit];
 }
 export async function verifySignature(jws, shared, key) {
+    const { protected: encodedProtected, header, payload: inputPayload } = jws;
     let parsedProt = {};
-    if (jws.protected) {
-        parsedProt = parseJoseHeader(jws.protected, JWSInvalid, 'JWS Protected Header is invalid');
+    if (encodedProtected) {
+        parsedProt = parseJoseHeader(encodedProtected, JWSInvalid, 'JWS Protected Header is invalid');
     }
     let joseHeader;
-    if (jws.header !== undefined) {
-        if (!isDisjoint(parsedProt, jws.header)) {
+    if (header !== undefined) {
+        if (!isDisjoint(parsedProt, header)) {
             throw new JWSInvalid('JWS Protected and JWS Unprotected Header Parameter names must be disjoint');
         }
-        joseHeader = { ...parsedProt, ...jws.header };
+        joseHeader = { ...parsedProt, ...header };
     }
     else {
         joseHeader = parsedProt;
     }
-    const extensions = validateCrit(JWSInvalid, JWS_RECOGNIZED, shared.crit, parsedProt, joseHeader);
+    const extensions = validateCrit(JWSInvalid, JWS_RECOGNIZED, shared[1], parsedProt, joseHeader);
     let b64 = true;
-    if (extensions.has('b64')) {
+    if (extensions.includes('b64')) {
         b64 = parsedProt.b64;
         if (typeof b64 !== 'boolean') {
             throw new JWSInvalid('The "b64" (base64url-encode payload) Header Parameter must be a boolean');
@@ -52,15 +51,15 @@ export async function verifySignature(jws, shared, key) {
     if (typeof alg !== 'string' || !alg) {
         throw new JWSInvalid('JWS "alg" (Algorithm) Header Parameter missing or invalid');
     }
-    if (shared.algorithms && !shared.algorithms.has(alg)) {
+    if (shared[0] && !shared[0].has(alg)) {
         throw new JOSEAlgNotAllowed('"alg" (Algorithm) Header Parameter value not allowed');
     }
     if (b64) {
-        if (typeof jws.payload !== 'string') {
+        if (typeof inputPayload !== 'string') {
             throw new JWSInvalid('JWS Payload must be a string');
         }
     }
-    else if (typeof jws.payload !== 'string' && !(jws.payload instanceof Uint8Array)) {
+    else if (typeof inputPayload !== 'string' && !(inputPayload instanceof Uint8Array)) {
         throw new JWSInvalid('JWS Payload must be a string or an Uint8Array instance');
     }
     let resolvedKey = false;
@@ -69,12 +68,12 @@ export async function verifySignature(jws, shared, key) {
         resolvedKey = true;
     }
     const entry = jwsAlgorithm(alg);
-    const data = concat(jws.protected !== undefined ? encode(jws.protected) : new Uint8Array(), encode('.'), typeof jws.payload === 'string'
+    const data = concat(encodedProtected !== undefined ? encode(encodedProtected) : new Uint8Array(), encode('.'), typeof inputPayload === 'string'
         ? b64
             ?
-                (shared.b64p ??= encodeBase64url(jws.payload, 'payload', JWSInvalid))
-            : encoder.encode(jws.payload)
-        : jws.payload);
+                (shared[2] ??= encodeBase64url(inputPayload, 'payload', JWSInvalid))
+            : encoder.encode(inputPayload)
+        : inputPayload);
     const signature = decodeBase64url(jws.signature, 'signature', JWSInvalid);
     const k = await prepareKey(entry, key, 'verify');
     const verified = await verify(entry, k, signature, data);
@@ -83,15 +82,15 @@ export async function verifySignature(jws, shared, key) {
     }
     let payload;
     if (b64) {
-        payload = decodeBase64url(jws.payload, 'payload', JWSInvalid);
+        payload = decodeBase64url(inputPayload, 'payload', JWSInvalid);
     }
-    else if (typeof jws.payload === 'string') {
-        payload = encoder.encode(jws.payload);
+    else if (typeof inputPayload === 'string') {
+        payload = encoder.encode(inputPayload);
     }
     else {
-        payload = jws.payload;
+        payload = inputPayload;
     }
-    return { payload, parsedProt, b64, key: k, resolvedKey };
+    return [payload, parsedProt, b64, k, resolvedKey];
 }
 export async function verifyCompact(jws, shared, key) {
     if (jws instanceof Uint8Array) {