jose 6.0.12 → 6.1.0

package/dist/types/types.d.ts

@@ -35,11 +35,25 @@ export interface JWK_OKP_Public extends JWKParameters {
 }
 
 /** Convenience interface for Private OKP JSON Web Keys */
-export interface JWK_OKP_Private extends JWK_OKP_Public, JWKParameters {
+export interface JWK_OKP_Private extends JWK_OKP_Public {
   /** OKP JWK "d" (The Private Key) Parameter */
   d: string
 }
 
+/** Convenience interface for Public AKP JSON Web Keys */
+export interface JWK_AKP_Public extends JWKParameters {
+  /** JWK "alg" (Algorithm) Parameter */
+  alg: string
+  /** AKP JWK "pub" (The Public key) Parameter */
+  pub: string
+}
+
+/** Convenience interface for Private AKP JSON Web Keys */
+export interface JWK_AKP_Private extends JWK_AKP_Public {
+  /** AKP JWK "priv" (The Private Key) Parameter */
+  priv: string
+}
+
 /** Convenience interface for Public EC JSON Web Keys */
 export interface JWK_EC_Public extends JWKParameters {
   /** EC JWK "crv" (Curve) Parameter */
@@ -51,7 +65,7 @@ export interface JWK_EC_Public extends JWKParameters {
 }
 
 /** Convenience interface for Private EC JSON Web Keys */
-export interface JWK_EC_Private extends JWK_EC_Public, JWKParameters {
+export interface JWK_EC_Private extends JWK_EC_Public {
   /** EC JWK "d" (ECC Private Key) Parameter */
   d: string
 }
@@ -65,7 +79,7 @@ export interface JWK_RSA_Public extends JWKParameters {
 }
 
 /** Convenience interface for Private RSA JSON Web Keys */
-export interface JWK_RSA_Private extends JWK_RSA_Public, JWKParameters {
+export interface JWK_RSA_Private extends JWK_RSA_Public {
   /** RSA JWK "d" (Private Exponent) Parameter */
   d: string
   /** RSA JWK "dp" (First Factor CRT Exponent) Parameter */
@@ -87,9 +101,11 @@ export interface JWK_oct extends JWKParameters {
 }
 
 /**
- * JSON Web Key ({@link https://www.rfc-editor.org/rfc/rfc7517 JWK}). "RSA", "EC", "OKP", and "oct"
- * key types are supported.
+ * JSON Web Key ({@link https://www.rfc-editor.org/rfc/rfc7517 JWK}). "RSA", "EC", "OKP", "AKP", and
+ * "oct" key types are supported.
  *
+ * @see {@link JWK_AKP_Public}
+ * @see {@link JWK_AKP_Private}
  * @see {@link JWK_OKP_Public}
  * @see {@link JWK_OKP_Private}
  * @see {@link JWK_EC_Public}
@@ -133,6 +149,10 @@ export interface JWK extends JWKParameters {
   x?: string
   /** EC JWK "y" (Y Coordinate) Parameter */
   y?: string
+  /** AKP JWK "pub" (Public Key) Parameter */
+  pub?: string
+  /** AKP JWK "priv" (Private key) Parameter */
+  priv?: string
 }
 
 /**
@@ -251,7 +271,7 @@ export interface JoseHeaderParameters {
   jku?: string
 
   /** "jwk" (JSON Web Key) Header Parameter */
-  jwk?: Pick<JWK, 'kty' | 'crv' | 'x' | 'y' | 'e' | 'n'>
+  jwk?: Pick<JWK, 'kty' | 'crv' | 'x' | 'y' | 'e' | 'n' | 'alg' | 'pub'>
 
   /** "typ" (Type) Header Parameter */
   typ?: string

package/dist/webapi/jwk/thumbprint.js

@@ -30,6 +30,11 @@ export async function calculateJwkThumbprint(key, digestAlgorithm) {
     }
     let components;
     switch (jwk.kty) {
+        case 'AKP':
+            check(jwk.alg, '"alg" (Algorithm) Parameter');
+            check(jwk.pub, '"pub" (Public key) Parameter');
+            components = { alg: jwk.alg, kty: jwk.kty, pub: jwk.pub };
+            break;
         case 'EC':
             check(jwk.crv, '"crv" (Curve) Parameter');
             check(jwk.x, '"x" (X Coordinate) Parameter');

package/dist/webapi/jwks/local.js

@@ -10,6 +10,8 @@ function getKtyFromAlg(alg) {
             return 'EC';
         case 'Ed':
             return 'OKP';
+        case 'ML':
+            return 'AKP';
         default:
             throw new JOSENotSupported('Unsupported "alg" value for a JSON Web Key Set');
     }
@@ -43,7 +45,7 @@ class LocalJWKSet {
             if (candidate && typeof kid === 'string') {
                 candidate = kid === jwk.kid;
             }
-            if (candidate && typeof jwk.alg === 'string') {
+            if (candidate && (typeof jwk.alg === 'string' || kty === 'AKP')) {
                 candidate = alg === jwk.alg;
             }
             if (candidate && typeof jwk.use === 'string') {

package/dist/webapi/jwks/remote.js

@@ -9,7 +9,7 @@ function isCloudflareWorkers() {
 let USER_AGENT;
 if (typeof navigator === 'undefined' || !navigator.userAgent?.startsWith?.('Mozilla/5.0 ')) {
     const NAME = 'jose';
-    const VERSION = 'v6.0.12';
+    const VERSION = 'v6.1.0';
     USER_AGENT = `${NAME}/${VERSION}`;
 }
 export const customFetch = Symbol();

package/dist/webapi/key/generate_key_pair.js

@@ -62,6 +62,13 @@ export async function generateKeyPair(alg, options) {
             algorithm = { name: 'Ed25519' };
             break;
         }
+        case 'ML-DSA-44':
+        case 'ML-DSA-65':
+        case 'ML-DSA-87': {
+            keyUsages = ['sign', 'verify'];
+            algorithm = { name: alg };
+            break;
+        }
         case 'ECDH-ES':
         case 'ECDH-ES+A128KW':
         case 'ECDH-ES+A192KW':

package/dist/webapi/key/import.js

@@ -38,6 +38,16 @@ export async function importJWK(jwk, alg, options) {
             if ('oth' in jwk && jwk.oth !== undefined) {
                 throw new JOSENotSupported('RSA JWK "oth" (Other Primes Info) Parameter value is not supported');
             }
+            return toCryptoKey({ ...jwk, alg, ext });
+        case 'AKP': {
+            if (typeof jwk.alg !== 'string' || !jwk.alg) {
+                throw new TypeError('missing "alg" (Algorithm) Parameter value');
+            }
+            if (alg !== undefined && alg !== jwk.alg) {
+                throw new TypeError('JWK alg and alg option value mismatch');
+            }
+            return toCryptoKey({ ...jwk, ext });
+        }
         case 'EC':
         case 'OKP':
             return toCryptoKey({ ...jwk, alg, ext });

package/dist/webapi/lib/asn1.js

@@ -30,42 +30,112 @@ export const toSPKI = (key) => {
 export const toPKCS8 = (key) => {
     return genericExport('private', 'pkcs8', key);
 };
-const getNamedCurve = (keyData) => {
-    const patterns = Object.entries({
-        'P-256': [0x06, 0x08, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07],
-        'P-384': [0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x22],
-        'P-521': [0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x23],
-    });
-    const maxPatternLen = Math.max(...patterns.map(([, bytes]) => bytes.length));
-    for (let i = 0; i <= keyData.byteLength - maxPatternLen; i++) {
-        for (const [curve, bytes] of patterns) {
-            if (i <= keyData.byteLength - bytes.length) {
-                if (keyData.subarray(i, i + bytes.length).every((byte, idx) => byte === bytes[idx])) {
-                    return curve;
-                }
-            }
+const bytesEqual = (a, b) => {
+    if (a.byteLength !== b.length)
+        return false;
+    for (let i = 0; i < a.byteLength; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+};
+const createASN1State = (data) => ({ data, pos: 0 });
+const parseLength = (state) => {
+    const first = state.data[state.pos++];
+    if (first & 0x80) {
+        const lengthOfLen = first & 0x7f;
+        let length = 0;
+        for (let i = 0; i < lengthOfLen; i++) {
+            length = (length << 8) | state.data[state.pos++];
         }
+        return length;
+    }
+    return first;
+};
+const skipElement = (state, count = 1) => {
+    if (count <= 0)
+        return;
+    state.pos++;
+    const length = parseLength(state);
+    state.pos += length;
+    if (count > 1) {
+        skipElement(state, count - 1);
+    }
+};
+const expectTag = (state, expectedTag, errorMessage) => {
+    if (state.data[state.pos++] !== expectedTag) {
+        throw new Error(errorMessage);
     }
-    return undefined;
+};
+const getSubarray = (state, length) => {
+    const result = state.data.subarray(state.pos, state.pos + length);
+    state.pos += length;
+    return result;
+};
+const parseAlgorithmOID = (state) => {
+    expectTag(state, 0x06, 'Expected algorithm OID');
+    const oidLen = parseLength(state);
+    return getSubarray(state, oidLen);
+};
+function parsePKCS8Header(state) {
+    expectTag(state, 0x30, 'Invalid PKCS#8 structure');
+    parseLength(state);
+    expectTag(state, 0x02, 'Expected version field');
+    const verLen = parseLength(state);
+    state.pos += verLen;
+    expectTag(state, 0x30, 'Expected algorithm identifier');
+    const algIdLen = parseLength(state);
+    const algIdStart = state.pos;
+    return { algIdStart, algIdLength: algIdLen };
+}
+function parseSPKIHeader(state) {
+    expectTag(state, 0x30, 'Invalid SPKI structure');
+    parseLength(state);
+    expectTag(state, 0x30, 'Expected algorithm identifier');
+    const algIdLen = parseLength(state);
+    const algIdStart = state.pos;
+    return { algIdStart, algIdLength: algIdLen };
+}
+const parseECAlgorithmIdentifier = (state) => {
+    const algOid = parseAlgorithmOID(state);
+    if (bytesEqual(algOid, [0x2b, 0x65, 0x6e])) {
+        return 'X25519';
+    }
+    if (!bytesEqual(algOid, [0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01])) {
+        throw new Error('Unsupported key algorithm');
+    }
+    expectTag(state, 0x06, 'Expected curve OID');
+    const curveOidLen = parseLength(state);
+    const curveOid = getSubarray(state, curveOidLen);
+    for (const { name, oid } of [
+        { name: 'P-256', oid: [0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07] },
+        { name: 'P-384', oid: [0x2b, 0x81, 0x04, 0x00, 0x22] },
+        { name: 'P-521', oid: [0x2b, 0x81, 0x04, 0x00, 0x23] },
+    ]) {
+        if (bytesEqual(curveOid, oid)) {
+            return name;
+        }
+    }
+    throw new Error('Unsupported named curve');
 };
 const genericImport = async (keyFormat, keyData, alg, options) => {
     let algorithm;
     let keyUsages;
     const isPublic = keyFormat === 'spki';
-    const getSignatureUsages = () => (isPublic ? ['verify'] : ['sign']);
-    const getEncryptionUsages = () => isPublic ? ['encrypt', 'wrapKey'] : ['decrypt', 'unwrapKey'];
+    const getSigUsages = () => (isPublic ? ['verify'] : ['sign']);
+    const getEncUsages = () => isPublic ? ['encrypt', 'wrapKey'] : ['decrypt', 'unwrapKey'];
     switch (alg) {
         case 'PS256':
         case 'PS384':
         case 'PS512':
             algorithm = { name: 'RSA-PSS', hash: `SHA-${alg.slice(-3)}` };
-            keyUsages = getSignatureUsages();
+            keyUsages = getSigUsages();
             break;
         case 'RS256':
         case 'RS384':
         case 'RS512':
             algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: `SHA-${alg.slice(-3)}` };
-            keyUsages = getSignatureUsages();
+            keyUsages = getSigUsages();
             break;
         case 'RSA-OAEP':
         case 'RSA-OAEP-256':
@@ -75,88 +145,94 @@ const genericImport = async (keyFormat, keyData, alg, options) => {
                 name: 'RSA-OAEP',
                 hash: `SHA-${parseInt(alg.slice(-3), 10) || 1}`,
             };
-            keyUsages = getEncryptionUsages();
+            keyUsages = getEncUsages();
             break;
         case 'ES256':
         case 'ES384':
         case 'ES512': {
             const curveMap = { ES256: 'P-256', ES384: 'P-384', ES512: 'P-521' };
             algorithm = { name: 'ECDSA', namedCurve: curveMap[alg] };
-            keyUsages = getSignatureUsages();
+            keyUsages = getSigUsages();
             break;
         }
         case 'ECDH-ES':
         case 'ECDH-ES+A128KW':
         case 'ECDH-ES+A192KW':
         case 'ECDH-ES+A256KW': {
-            const namedCurve = getNamedCurve(keyData);
-            algorithm = namedCurve ? { name: 'ECDH', namedCurve } : { name: 'X25519' };
+            try {
+                const namedCurve = options.getNamedCurve(keyData);
+                algorithm = namedCurve === 'X25519' ? { name: 'X25519' } : { name: 'ECDH', namedCurve };
+            }
+            catch (cause) {
+                throw new JOSENotSupported('Invalid or unsupported key format');
+            }
             keyUsages = isPublic ? [] : ['deriveBits'];
             break;
         }
         case 'Ed25519':
         case 'EdDSA':
             algorithm = { name: 'Ed25519' };
-            keyUsages = getSignatureUsages();
+            keyUsages = getSigUsages();
+            break;
+        case 'ML-DSA-44':
+        case 'ML-DSA-65':
+        case 'ML-DSA-87':
+            algorithm = { name: alg };
+            keyUsages = getSigUsages();
             break;
         default:
             throw new JOSENotSupported('Invalid or unsupported "alg" (Algorithm) value');
     }
     return crypto.subtle.importKey(keyFormat, keyData, algorithm, options?.extractable ?? (isPublic ? true : false), keyUsages);
 };
+const processPEMData = (pem, pattern) => {
+    return decodeBase64(pem.replace(pattern, ''));
+};
 export const fromPKCS8 = (pem, alg, options) => {
-    const keyData = decodeBase64(pem.replace(/(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g, ''));
-    return genericImport('pkcs8', keyData, alg, options);
+    const keyData = processPEMData(pem, /(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g);
+    let opts = options;
+    if (alg?.startsWith?.('ECDH-ES')) {
+        opts ||= {};
+        opts.getNamedCurve = (keyData) => {
+            const state = createASN1State(keyData);
+            parsePKCS8Header(state);
+            return parseECAlgorithmIdentifier(state);
+        };
+    }
+    return genericImport('pkcs8', keyData, alg, opts);
 };
 export const fromSPKI = (pem, alg, options) => {
-    const keyData = decodeBase64(pem.replace(/(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g, ''));
-    return genericImport('spki', keyData, alg, options);
+    const keyData = processPEMData(pem, /(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g);
+    let opts = options;
+    if (alg?.startsWith?.('ECDH-ES')) {
+        opts ||= {};
+        opts.getNamedCurve = (keyData) => {
+            const state = createASN1State(keyData);
+            parseSPKIHeader(state);
+            return parseECAlgorithmIdentifier(state);
+        };
+    }
+    return genericImport('spki', keyData, alg, opts);
 };
 function spkiFromX509(buf) {
-    let pos = 0;
-    const parseLength = () => {
-        const first = buf[pos++];
-        if (first & 0x80) {
-            const lengthOfLength = first & 0x7f;
-            let length = 0;
-            for (let i = 0; i < lengthOfLength; i++) {
-                length = (length << 8) | buf[pos++];
-            }
-            return length;
-        }
-        return first;
-    };
-    const skipElement = (count = 1) => {
-        if (count <= 0)
-            return;
-        pos++;
-        const length = parseLength();
-        pos += length;
-        if (count > 1) {
-            skipElement(count - 1);
-        }
-    };
-    if (buf[pos++] !== 0x30)
-        throw new Error('Invalid certificate structure');
-    parseLength();
-    if (buf[pos++] !== 0x30)
-        throw new Error('Invalid tbsCertificate structure');
-    parseLength();
-    if (buf[pos] === 0xa0) {
-        skipElement(6);
+    const state = createASN1State(buf);
+    expectTag(state, 0x30, 'Invalid certificate structure');
+    parseLength(state);
+    expectTag(state, 0x30, 'Invalid tbsCertificate structure');
+    parseLength(state);
+    if (buf[state.pos] === 0xa0) {
+        skipElement(state, 6);
     }
     else {
-        skipElement(5);
+        skipElement(state, 5);
     }
-    const spkiStart = pos;
-    if (buf[pos++] !== 0x30)
-        throw new Error('Invalid SPKI structure');
-    const spkiContentLength = parseLength();
-    return buf.subarray(spkiStart, spkiStart + spkiContentLength + (pos - spkiStart));
+    const spkiStart = state.pos;
+    expectTag(state, 0x30, 'Invalid SPKI structure');
+    const spkiContentLen = parseLength(state);
+    return buf.subarray(spkiStart, spkiStart + spkiContentLen + (state.pos - spkiStart));
 }
 function extractX509SPKI(x509) {
-    const base64Content = x509.replace(/(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g, '');
-    const derBytes = decodeBase64(base64Content);
+    const derBytes = processPEMData(x509, /(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g);
     return spkiFromX509(derBytes);
 }
 export const fromX509 = (pem, alg, options) => {
@@ -167,5 +243,5 @@ export const fromX509 = (pem, alg, options) => {
     catch (cause) {
         throw new TypeError('Failed to parse the X.509 certificate', { cause });
     }
-    return genericImport('spki', spki, alg, options);
+    return fromSPKI(formatPEM(encodeBase64(spki), 'PUBLIC KEY'), alg, options);
 };

package/dist/webapi/lib/crypto_key.js

@@ -65,6 +65,13 @@ export function checkSigCryptoKey(key, alg, usage) {
                 throw unusable('Ed25519');
             break;
         }
+        case 'ML-DSA-44':
+        case 'ML-DSA-65':
+        case 'ML-DSA-87': {
+            if (!isAlgorithm(key.algorithm, alg))
+                throw unusable(alg);
+            break;
+        }
         case 'ES256':
         case 'ES384':
         case 'ES512': {

package/dist/webapi/lib/ecdhes.js

@@ -4,35 +4,41 @@ import digest from './digest.js';
 function lengthAndInput(input) {
     return concat(uint32be(input.length), input);
 }
-async function concatKdf(secret, bits, value) {
-    const iterations = Math.ceil((bits >> 3) / 32);
-    const res = new Uint8Array(iterations * 32);
-    for (let iter = 0; iter < iterations; iter++) {
-        const buf = new Uint8Array(4 + secret.length + value.length);
-        buf.set(uint32be(iter + 1));
-        buf.set(secret, 4);
-        buf.set(value, 4 + secret.length);
-        res.set(await digest('sha256', buf), iter * 32);
+async function concatKdf(Z, L, OtherInfo) {
+    const dkLen = L >> 3;
+    const hashLen = 32;
+    const reps = Math.ceil(dkLen / hashLen);
+    const dk = new Uint8Array(reps * hashLen);
+    for (let i = 1; i <= reps; i++) {
+        const hashInput = new Uint8Array(4 + Z.length + OtherInfo.length);
+        hashInput.set(uint32be(i), 0);
+        hashInput.set(Z, 4);
+        hashInput.set(OtherInfo, 4 + Z.length);
+        const hashResult = await digest('sha256', hashInput);
+        dk.set(hashResult, (i - 1) * hashLen);
     }
-    return res.slice(0, bits >> 3);
+    return dk.slice(0, dkLen);
 }
 export async function deriveKey(publicKey, privateKey, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) {
     checkEncCryptoKey(publicKey, 'ECDH');
     checkEncCryptoKey(privateKey, 'ECDH', 'deriveBits');
-    const value = concat(lengthAndInput(encoder.encode(algorithm)), lengthAndInput(apu), lengthAndInput(apv), uint32be(keyLength));
-    let length;
-    if (publicKey.algorithm.name === 'X25519') {
-        length = 256;
-    }
-    else {
-        length =
-            Math.ceil(parseInt(publicKey.algorithm.namedCurve.slice(-3), 10) / 8) << 3;
-    }
-    const sharedSecret = new Uint8Array(await crypto.subtle.deriveBits({
+    const algorithmID = lengthAndInput(encoder.encode(algorithm));
+    const partyUInfo = lengthAndInput(apu);
+    const partyVInfo = lengthAndInput(apv);
+    const suppPubInfo = uint32be(keyLength);
+    const suppPrivInfo = new Uint8Array(0);
+    const otherInfo = concat(algorithmID, partyUInfo, partyVInfo, suppPubInfo, suppPrivInfo);
+    const Z = new Uint8Array(await crypto.subtle.deriveBits({
         name: publicKey.algorithm.name,
         public: publicKey,
-    }, privateKey, length));
-    return concatKdf(sharedSecret, keyLength, value);
+    }, privateKey, getEcdhBitLength(publicKey)));
+    return concatKdf(Z, keyLength, otherInfo);
+}
+function getEcdhBitLength(publicKey) {
+    if (publicKey.algorithm.name === 'X25519') {
+        return 256;
+    }
+    return (Math.ceil(parseInt(publicKey.algorithm.namedCurve.slice(-3), 10) / 8) << 3);
 }
 export function allowed(key) {
     switch (key.algorithm.namedCurve) {

package/dist/webapi/lib/is_jwk.js

@@ -3,10 +3,11 @@ export function isJWK(key) {
     return isObject(key) && typeof key.kty === 'string';
 }
 export function isPrivateJWK(key) {
-    return key.kty !== 'oct' && typeof key.d === 'string';
+    return (key.kty !== 'oct' &&
+        ((key.kty === 'AKP' && typeof key.priv === 'string') || typeof key.d === 'string'));
 }
 export function isPublicJWK(key) {
-    return key.kty !== 'oct' && typeof key.d === 'undefined';
+    return key.kty !== 'oct' && typeof key.d === 'undefined' && typeof key.priv === 'undefined';
 }
 export function isSecretJWK(key) {
     return key.kty === 'oct' && typeof key.k === 'string';

package/dist/webapi/lib/jwk_to_key.js

@@ -3,6 +3,19 @@ function subtleMapping(jwk) {
     let algorithm;
     let keyUsages;
     switch (jwk.kty) {
+        case 'AKP': {
+            switch (jwk.alg) {
+                case 'ML-DSA-44':
+                case 'ML-DSA-65':
+                case 'ML-DSA-87':
+                    algorithm = { name: jwk.alg };
+                    keyUsages = jwk.priv ? ['sign'] : ['verify'];
+                    break;
+                default:
+                    throw new JOSENotSupported('Invalid or unsupported JWK "alg" (Algorithm) Parameter value');
+            }
+            break;
+        }
         case 'RSA': {
             switch (jwk.alg) {
                 case 'PS256':
@@ -88,7 +101,9 @@ export default async (jwk) => {
     }
     const { algorithm, keyUsages } = subtleMapping(jwk);
     const keyData = { ...jwk };
-    delete keyData.alg;
+    if (keyData.kty !== 'AKP') {
+        delete keyData.alg;
+    }
     delete keyData.use;
-    return crypto.subtle.importKey('jwk', keyData, algorithm, jwk.ext ?? (jwk.d ? false : true), jwk.key_ops ?? keyUsages);
+    return crypto.subtle.importKey('jwk', keyData, algorithm, jwk.ext ?? (jwk.d || jwk.priv ? false : true), jwk.key_ops ?? keyUsages);
 };

package/dist/webapi/lib/key_to_jwk.js

@@ -23,5 +23,9 @@ export default async function keyToJWK(key) {
         throw new TypeError('non-extractable CryptoKey cannot be exported as a JWK');
     }
     const { ext, key_ops, alg, use, ...jwk } = await crypto.subtle.exportKey('jwk', key);
+    if (jwk.kty === 'AKP') {
+        ;
+        jwk.alg = alg;
+    }
     return jwk;
 }

package/dist/webapi/lib/normalize_key.js

@@ -49,6 +49,18 @@ const handleKeyObject = (keyObject, alg) => {
             isPublic ? 'verify' : 'sign',
         ]);
     }
+    switch (keyObject.asymmetricKeyType) {
+        case 'ml-dsa-44':
+        case 'ml-dsa-65':
+        case 'ml-dsa-87': {
+            if (alg !== keyObject.asymmetricKeyType.toUpperCase()) {
+                throw new TypeError('given KeyObject instance cannot be used for this algorithm');
+            }
+            cryptoKey = keyObject.toCryptoKey(keyObject.asymmetricKeyType, extractable, [
+                isPublic ? 'verify' : 'sign',
+            ]);
+        }
+    }
     if (keyObject.asymmetricKeyType === 'rsa') {
         let hash;
         switch (alg) {

package/dist/webapi/lib/subtle_dsa.js

@@ -21,6 +21,10 @@ export default (alg, algorithm) => {
         case 'Ed25519':
         case 'EdDSA':
             return { name: 'Ed25519' };
+        case 'ML-DSA-44':
+        case 'ML-DSA-65':
+        case 'ML-DSA-87':
+            return { name: alg };
         default:
             throw new JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
     }

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "jose",
-  "version": "6.0.12",
+  "version": "6.1.0",
   "description": "JWA, JWS, JWE, JWT, JWK, JWKS for Node.js, Browser, Cloudflare Workers, Deno, Bun, and other Web-interoperable runtimes",
   "keywords": [
+    "akp",
     "browser",
     "bun",
     "cloudflare",
@@ -29,8 +30,9 @@
     "jwk",
     "jwks",
     "jws",
-    "jwt",
     "jwt-decode",
+    "jwt",
+    "ml-dsa",
     "netlify",
     "next",
     "nextjs",