jose 6.0.11 → 6.0.13

package/dist/types/jwe/compact/encrypt.d.ts

@@ -46,9 +46,10 @@ export declare class CompactEncrypt {
      */
     setProtectedHeader(protectedHeader: types.CompactJWEHeaderParameters): this;
     /**
-     * Sets the JWE Key Management parameters to be used when encrypting the Content Encryption Key.
-     * You do not need to invoke this method, it is only really intended for test and vector
-     * validation purposes.
+     * Sets the JWE Key Management parameters to be used when encrypting. Use of this is method is
+     * really only needed for ECDH based algorithms when utilizing the Agreement PartyUInfo or
+     * Agreement PartyVInfo parameters. Other parameters will always be randomly generated when needed
+     * and missing.
      *
      * @param parameters JWE Key Management parameters.
      */

package/dist/types/jwe/flattened/encrypt.d.ts

@@ -21,9 +21,9 @@ export declare class FlattenedEncrypt {
     constructor(plaintext: Uint8Array);
     /**
      * Sets the JWE Key Management parameters to be used when encrypting. Use of this is method is
-     * really only needed for ECDH based algorithms when utilizing the Agreement PartyUInfo or
-     * Agreement PartyVInfo parameters. Other parameters will always be randomly generated when needed
-     * and missing.
+     * really only needed for ECDH based algorithms when utilizing the "apu" (Agreement PartyUInfo) or
+     * "apv" (Agreement PartyVInfo) parameters. Other parameters will always be randomly generated
+     * when needed and missing.
      *
      * @param parameters JWE Key Management parameters.
      */

package/dist/types/jwks/local.d.ts

@@ -17,8 +17,9 @@ import type * as types from '../types.d.ts';
  * multiple keys get matched it is possible to opt-in to iterate over the matched keys and attempt
  * verification in an iterative manner.
  *
- * Note: The function's purpose is to resolve public keys used for verifying signatures and will not
- * work for public encryption keys.
+ * > [!NOTE]\
+ * > The function's purpose is to resolve public keys used for verifying signatures and will not work
+ * > for public encryption keys.
  *
  * This function is exported (as a named export) from the main `'jose'` module entry point as well
  * as from its subpath export `'jose/jwks/local'`.

package/dist/types/jwks/remote.d.ts

@@ -8,6 +8,10 @@ import type * as types from '../types.d.ts';
  * When passed to {@link jwks/remote.createRemoteJWKSet createRemoteJWKSet} this allows the resolver
  * to make use of advanced fetch configurations, HTTP Proxies, retry on network errors, etc.
  *
+ * > [!NOTE]\
+ * > Known caveat: Expect Type-related issues when passing the inputs through to fetch-like modules,
+ * > they hardly ever get their typings inline with actual fetch, you should `@ts-expect-error` them.
+ *
  * import ky from 'ky'
  *
  * let logRequest!: (request: Request) => void
@@ -109,9 +113,10 @@ options: {
     signal: AbortSignal;
 }) => Promise<Response>;
 /**
- * DANGER ZONE - This option has security implications that must be understood, assessed for
- * applicability, and accepted before use. It is critical that the JSON Web Key Set cache only be
- * writable by your own code.
+ * > [!WARNING]\
+ * > This option has security implications that must be understood, assessed for applicability, and
+ * > accepted before use. It is critical that the JSON Web Key Set cache only be writable by your own
+ * > code.
  *
  * This option is intended for cloud computing runtimes that cannot keep an in memory cache between
  * their code's invocations. Use in runtimes where an in memory cache between requests is available
@@ -207,8 +212,9 @@ export type JWKSCacheInput = ExportedJWKSCache | Record<string, never>;
  * multiple keys get matched it is possible to opt-in to iterate over the matched keys and attempt
  * verification in an iterative manner.
  *
- * Note: The function's purpose is to resolve public keys used for verifying signatures and will not
- * work for public encryption keys.
+ * > [!NOTE]\
+ * > The function's purpose is to resolve public keys used for verifying signatures and will not work
+ * > for public encryption keys.
  *
  * This function is exported (as a named export) from the main `'jose'` module entry point as well
  * as from its subpath export `'jose/jwks/remote'`.

package/dist/types/jwt/encrypt.d.ts

@@ -35,9 +35,9 @@ export declare class EncryptJWT implements types.ProduceJWT {
     setProtectedHeader(protectedHeader: types.CompactJWEHeaderParameters): this;
     /**
      * Sets the JWE Key Management parameters to be used when encrypting. Use of this is method is
-     * really only needed for ECDH based algorithms when utilizing the Agreement PartyUInfo or
-     * Agreement PartyVInfo parameters. Other parameters will always be randomly generated when needed
-     * and missing.
+     * really only needed for ECDH based algorithms when utilizing the "apu" (Agreement PartyUInfo) or
+     * "apv" (Agreement PartyVInfo) parameters. Other parameters will always be randomly generated
+     * when needed and missing.
      *
      * @param parameters JWE Key Management parameters.
      */

package/dist/types/key/generate_key_pair.d.ts

@@ -33,8 +33,9 @@ export interface GenerateKeyPairOptions {
  * Generates a private and a public key for a given JWA algorithm identifier. This can only generate
  * asymmetric key pairs. For symmetric secrets use the `generateSecret` function.
  *
- * Note: The `privateKey` is generated with `extractable` set to `false` by default. See
- * {@link GenerateKeyPairOptions.extractable} to generate an extractable `privateKey`.
+ * > [!NOTE]\
+ * > The `privateKey` is generated with `extractable` set to `false` by default. See
+ * > {@link GenerateKeyPairOptions.extractable} to generate an extractable `privateKey`.
  *
  * This function is exported (as a named export) from the main `'jose'` module entry point as well
  * as from its subpath export `'jose/generate/keypair'`.

package/dist/types/key/generate_secret.d.ts

@@ -9,18 +9,21 @@ export interface GenerateSecretOptions {
     /**
      * The value to use as {@link !SubtleCrypto.generateKey} `extractable` argument. Default is false.
      *
-     * Note: Because A128CBC-HS256, A192CBC-HS384, and A256CBC-HS512 secrets cannot be represented as
-     * {@link !CryptoKey} this option has no effect for them.
+     * > [!NOTE]\
+     * > Because A128CBC-HS256, A192CBC-HS384, and A256CBC-HS512 secrets cannot be represented as
+     * > {@link !CryptoKey} this option has no effect for them.
      */
     extractable?: boolean;
 }
 /**
  * Generates a symmetric secret key for a given JWA algorithm identifier.
  *
- * Note: The secret key is generated with `extractable` set to `false` by default.
+ * > [!NOTE]\
+ * > The secret key is generated with `extractable` set to `false` by default.
  *
- * Note: Because A128CBC-HS256, A192CBC-HS384, and A256CBC-HS512 secrets cannot be represented as
- * {@link !CryptoKey} this method yields a {@link !Uint8Array} for them instead.
+ * > [!NOTE]\
+ * > Because A128CBC-HS256, A192CBC-HS384, and A256CBC-HS512 secrets cannot be represented as
+ * > {@link !CryptoKey} this method yields a {@link !Uint8Array} for them instead.
  *
  * This function is exported (as a named export) from the main `'jose'` module entry point as well
  * as from its subpath export `'jose/generate/secret'`.

package/dist/types/key/import.d.ts

@@ -15,9 +15,10 @@ export interface KeyImportOptions {
 /**
  * Imports a PEM-encoded SPKI string as a {@link !CryptoKey}.
  *
- * Note: The OID id-RSASSA-PSS (1.2.840.113549.1.1.10) is not supported in
- * {@link https://w3c.github.io/webcrypto/ Web Cryptography API}, use the OID rsaEncryption
- * (1.2.840.113549.1.1.1) instead for all RSA algorithms.
+ * > [!NOTE]\
+ * > The OID id-RSASSA-PSS (1.2.840.113549.1.1.10) is not supported in
+ * > {@link https://w3c.github.io/webcrypto/ Web Cryptography API}, use the OID rsaEncryption
+ * > (1.2.840.113549.1.1.1) instead for all RSA algorithms.
  *
  * This function is exported (as a named export) from the main `'jose'` module entry point as well
  * as from its subpath export `'jose/key/import'`.
@@ -30,9 +31,10 @@ export declare function importSPKI(spki: string, alg: string, options?: KeyImpor
 /**
  * Imports the SPKI from an X.509 string certificate as a {@link !CryptoKey}.
  *
- * Note: The OID id-RSASSA-PSS (1.2.840.113549.1.1.10) is not supported in
- * {@link https://w3c.github.io/webcrypto/ Web Cryptography API}, use the OID rsaEncryption
- * (1.2.840.113549.1.1.1) instead for all RSA algorithms.
+ * > [!NOTE]\
+ * > The OID id-RSASSA-PSS (1.2.840.113549.1.1.10) is not supported in
+ * > {@link https://w3c.github.io/webcrypto/ Web Cryptography API}, use the OID rsaEncryption
+ * > (1.2.840.113549.1.1.1) instead for all RSA algorithms.
  *
  * This function is exported (as a named export) from the main `'jose'` module entry point as well
  * as from its subpath export `'jose/key/import'`.
@@ -45,9 +47,10 @@ export declare function importX509(x509: string, alg: string, options?: KeyImpor
 /**
  * Imports a PEM-encoded PKCS#8 string as a {@link !CryptoKey}.
  *
- * Note: The OID id-RSASSA-PSS (1.2.840.113549.1.1.10) is not supported in
- * {@link https://w3c.github.io/webcrypto/ Web Cryptography API}, use the OID rsaEncryption
- * (1.2.840.113549.1.1.1) instead for all RSA algorithms.
+ * > [!NOTE]\
+ * > The OID id-RSASSA-PSS (1.2.840.113549.1.1.10) is not supported in
+ * > {@link https://w3c.github.io/webcrypto/ Web Cryptography API}, use the OID rsaEncryption
+ * > (1.2.840.113549.1.1.1) instead for all RSA algorithms.
  *
  * This function is exported (as a named export) from the main `'jose'` module entry point as well
  * as from its subpath export `'jose/key/import'`.
@@ -61,11 +64,13 @@ export declare function importPKCS8(pkcs8: string, alg: string, options?: KeyImp
  * Imports a JWK to a {@link !CryptoKey}. Either the JWK "alg" (Algorithm) Parameter, or the optional
  * "alg" argument, must be present for asymmetric JSON Web Key imports.
  *
- * Note: The JSON Web Key parameters "use", "key_ops", and "ext" are also used in the
- * {@link !CryptoKey} import process.
+ * > [!NOTE]\
+ * > The JSON Web Key parameters "use", "key_ops", and "ext" are also used in the {@link !CryptoKey}
+ * > import process.
  *
- * Note: Symmetric JSON Web Keys (i.e. `kty: "oct"`) yield back an {@link !Uint8Array} instead of a
- * {@link !CryptoKey}.
+ * > [!NOTE]\
+ * > Symmetric JSON Web Keys (i.e. `kty: "oct"`) yield back an {@link !Uint8Array} instead of a
+ * > {@link !CryptoKey}.
  *
  * This function is exported (as a named export) from the main `'jose'` module entry point as well
  * as from its subpath export `'jose/key/import'`.

package/dist/types/types.d.ts

@@ -522,7 +522,8 @@ export interface VerifyOptions extends CritOption {
    * A list of accepted JWS "alg" (Algorithm) Header Parameter values. By default all "alg"
    * (Algorithm) values applicable for the used key/secret are allowed.
    *
-   * Note: Unsecured JWTs (`{ "alg": "none" }`) are never accepted by this API.
+   * > [!NOTE]\
+   * > Unsecured JWTs (`{ "alg": "none" }`) are never accepted by this API.
    */
   algorithms?: 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.11';
+    const VERSION = 'v6.0.13';
     USER_AGENT = `${NAME}/${VERSION}`;
 }
 export const customFetch = Symbol();

package/dist/webapi/lib/asn1.js

@@ -30,50 +30,112 @@ 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);
-    }
-    const i = keyData.indexOf(oid[0], from);
-    if (i === -1)
-        return false;
-    const sub = keyData.subarray(i, i + oid.length);
-    if (sub.length !== oid.length)
+const bytesEqual = (a, b) => {
+    if (a.byteLength !== b.length)
         return false;
-    return sub.every((value, index) => value === oid[index]) || findOid(keyData, oid, i + 1);
-};
-const getNamedCurve = (keyData) => {
-    switch (true) {
-        case findOid(keyData, [0x2a, 0x86, 0x48, 0xce, 0x3d, 0x03, 0x01, 0x07]):
-            return 'P-256';
-        case findOid(keyData, [0x2b, 0x81, 0x04, 0x00, 0x22]):
-            return 'P-384';
-        case findOid(keyData, [0x2b, 0x81, 0x04, 0x00, 0x23]):
-            return 'P-521';
-        default:
-            return undefined;
+    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);
+    }
+};
+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 (replace, keyFormat, pem, alg, options) => {
+const genericImport = async (keyFormat, keyData, alg, options) => {
     let algorithm;
     let keyUsages;
-    const keyData = new Uint8Array(atob(pem.replace(replace, ''))
-        .split('')
-        .map((c) => c.charCodeAt(0)));
     const isPublic = keyFormat === 'spki';
+    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 = isPublic ? ['verify'] : ['sign'];
+            keyUsages = getSigUsages();
             break;
         case 'RS256':
         case 'RS384':
         case 'RS512':
             algorithm = { name: 'RSASSA-PKCS1-v1_5', hash: `SHA-${alg.slice(-3)}` };
-            keyUsages = isPublic ? ['verify'] : ['sign'];
+            keyUsages = getSigUsages();
             break;
         case 'RSA-OAEP':
         case 'RSA-OAEP-256':
@@ -83,133 +145,97 @@ const genericImport = async (replace, keyFormat, pem, alg, options) => {
                 name: 'RSA-OAEP',
                 hash: `SHA-${parseInt(alg.slice(-3), 10) || 1}`,
             };
-            keyUsages = isPublic ? ['encrypt', 'wrapKey'] : ['decrypt', 'unwrapKey'];
+            keyUsages = getEncUsages();
             break;
         case 'ES256':
-            algorithm = { name: 'ECDSA', namedCurve: 'P-256' };
-            keyUsages = isPublic ? ['verify'] : ['sign'];
-            break;
         case 'ES384':
-            algorithm = { name: 'ECDSA', namedCurve: 'P-384' };
-            keyUsages = isPublic ? ['verify'] : ['sign'];
-            break;
-        case 'ES512':
-            algorithm = { name: 'ECDSA', namedCurve: 'P-521' };
-            keyUsages = isPublic ? ['verify'] : ['sign'];
+        case 'ES512': {
+            const curveMap = { ES256: 'P-256', ES384: 'P-384', ES512: 'P-521' };
+            algorithm = { name: 'ECDSA', namedCurve: curveMap[alg] };
+            keyUsages = getSigUsages();
             break;
+        }
         case 'ECDH-ES':
         case 'ECDH-ES+A128KW':
         case 'ECDH-ES+A192KW':
         case 'ECDH-ES+A256KW': {
-            const namedCurve = getNamedCurve(keyData);
-            algorithm = namedCurve?.startsWith('P-') ? { 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 = isPublic ? ['verify'] : ['sign'];
+            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) => {
-    return genericImport(/(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g, 'pkcs8', pem, 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) => {
-    return genericImport(/(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g, 'spki', pem, alg, options);
-};
-function getElement(seq) {
-    const result = [];
-    let next = 0;
-    while (next < seq.length) {
-        const nextPart = parseElement(seq.subarray(next));
-        result.push(nextPart);
-        next += nextPart.byteLength;
-    }
-    return result;
-}
-function parseElement(bytes) {
-    let position = 0;
-    let tag = bytes[0] & 0x1f;
-    position++;
-    if (tag === 0x1f) {
-        tag = 0;
-        while (bytes[position] >= 0x80) {
-            tag = tag * 128 + bytes[position] - 0x80;
-            position++;
-        }
-        tag = tag * 128 + bytes[position] - 0x80;
-        position++;
-    }
-    let length = 0;
-    if (bytes[position] < 0x80) {
-        length = bytes[position];
-        position++;
-    }
-    else if (length === 0x80) {
-        length = 0;
-        while (bytes[position + length] !== 0 || bytes[position + length + 1] !== 0) {
-            if (length > bytes.byteLength) {
-                throw new TypeError('invalid indefinite form length');
-            }
-            length++;
-        }
-        const byteLength = position + length + 2;
-        return {
-            byteLength,
-            contents: bytes.subarray(position, position + length),
-            raw: bytes.subarray(0, byteLength),
+    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);
         };
     }
-    else {
-        const numberOfDigits = bytes[position] & 0x7f;
-        position++;
-        length = 0;
-        for (let i = 0; i < numberOfDigits; i++) {
-            length = length * 256 + bytes[position];
-            position++;
-        }
-    }
-    const byteLength = position + length;
-    return {
-        byteLength,
-        contents: bytes.subarray(position, byteLength),
-        raw: bytes.subarray(0, byteLength),
-    };
-}
+    return genericImport('spki', keyData, alg, opts);
+};
 function spkiFromX509(buf) {
-    const tbsCertificate = getElement(getElement(parseElement(buf).contents)[0].contents);
-    return encodeBase64(tbsCertificate[tbsCertificate[0].raw[0] === 0xa0 ? 6 : 5].raw);
-}
-let createPublicKey;
-function getSPKI(x509) {
-    try {
-        createPublicKey ??= globalThis.process?.getBuiltinModule?.('node:crypto')?.createPublicKey;
-    }
-    catch {
-        createPublicKey = 0;
+    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);
     }
-    if (createPublicKey) {
-        try {
-            return new createPublicKey(x509).export({ format: 'pem', type: 'spki' });
-        }
-        catch { }
+    else {
+        skipElement(state, 5);
     }
-    const pem = x509.replace(/(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g, '');
-    const raw = decodeBase64(pem);
-    return formatPEM(spkiFromX509(raw), 'PUBLIC KEY');
+    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 derBytes = processPEMData(x509, /(?:-----(?:BEGIN|END) CERTIFICATE-----|\s)/g);
+    return spkiFromX509(derBytes);
 }
 export const fromX509 = (pem, alg, options) => {
     let spki;
     try {
-        spki = getSPKI(pem);
+        spki = extractX509SPKI(pem);
     }
     catch (cause) {
         throw new TypeError('Failed to parse the X.509 certificate', { cause });
     }
-    return fromSPKI(spki, alg, options);
+    return fromSPKI(formatPEM(encodeBase64(spki), 'PUBLIC KEY'), alg, options);
 };

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jose",
-  "version": "6.0.11",
+  "version": "6.0.13",
   "description": "JWA, JWS, JWE, JWT, JWK, JWKS for Node.js, Browser, Cloudflare Workers, Deno, Bun, and other Web-interoperable runtimes",
   "keywords": [
     "browser",