jose 5.9.6 → 6.0.0

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

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_js_1 = require("../util/errors.js");
-const buffer_utils_js_1 = require("./buffer_utils.js");
-const epoch_js_1 = require("./epoch.js");
-const secs_js_1 = require("./secs.js");
-const is_object_js_1 = require("./is_object.js");
-const normalizeTyp = (value) => value.toLowerCase().replace(/^application\//, '');
-const checkAudiencePresence = (audPayload, audOption) => {
-    if (typeof audPayload === 'string') {
-        return audOption.includes(audPayload);
-    }
-    if (Array.isArray(audPayload)) {
-        return audOption.some(Set.prototype.has.bind(new Set(audPayload)));
-    }
-    return false;
-};
-exports.default = (protectedHeader, encodedPayload, options = {}) => {
-    let payload;
-    try {
-        payload = JSON.parse(buffer_utils_js_1.decoder.decode(encodedPayload));
-    }
-    catch {
-    }
-    if (!(0, is_object_js_1.default)(payload)) {
-        throw new errors_js_1.JWTInvalid('JWT Claims Set must be a top-level JSON object');
-    }
-    const { typ } = options;
-    if (typ &&
-        (typeof protectedHeader.typ !== 'string' ||
-            normalizeTyp(protectedHeader.typ) !== normalizeTyp(typ))) {
-        throw new errors_js_1.JWTClaimValidationFailed('unexpected "typ" JWT header value', payload, 'typ', 'check_failed');
-    }
-    const { requiredClaims = [], issuer, subject, audience, maxTokenAge } = options;
-    const presenceCheck = [...requiredClaims];
-    if (maxTokenAge !== undefined)
-        presenceCheck.push('iat');
-    if (audience !== undefined)
-        presenceCheck.push('aud');
-    if (subject !== undefined)
-        presenceCheck.push('sub');
-    if (issuer !== undefined)
-        presenceCheck.push('iss');
-    for (const claim of new Set(presenceCheck.reverse())) {
-        if (!(claim in payload)) {
-            throw new errors_js_1.JWTClaimValidationFailed(`missing required "${claim}" claim`, payload, claim, 'missing');
-        }
-    }
-    if (issuer &&
-        !(Array.isArray(issuer) ? issuer : [issuer]).includes(payload.iss)) {
-        throw new errors_js_1.JWTClaimValidationFailed('unexpected "iss" claim value', payload, 'iss', 'check_failed');
-    }
-    if (subject && payload.sub !== subject) {
-        throw new errors_js_1.JWTClaimValidationFailed('unexpected "sub" claim value', payload, 'sub', 'check_failed');
-    }
-    if (audience &&
-        !checkAudiencePresence(payload.aud, typeof audience === 'string' ? [audience] : audience)) {
-        throw new errors_js_1.JWTClaimValidationFailed('unexpected "aud" claim value', payload, 'aud', 'check_failed');
-    }
-    let tolerance;
-    switch (typeof options.clockTolerance) {
-        case 'string':
-            tolerance = (0, secs_js_1.default)(options.clockTolerance);
-            break;
-        case 'number':
-            tolerance = options.clockTolerance;
-            break;
-        case 'undefined':
-            tolerance = 0;
-            break;
-        default:
-            throw new TypeError('Invalid clockTolerance option type');
-    }
-    const { currentDate } = options;
-    const now = (0, epoch_js_1.default)(currentDate || new Date());
-    if ((payload.iat !== undefined || maxTokenAge) && typeof payload.iat !== 'number') {
-        throw new errors_js_1.JWTClaimValidationFailed('"iat" claim must be a number', payload, 'iat', 'invalid');
-    }
-    if (payload.nbf !== undefined) {
-        if (typeof payload.nbf !== 'number') {
-            throw new errors_js_1.JWTClaimValidationFailed('"nbf" claim must be a number', payload, 'nbf', 'invalid');
-        }
-        if (payload.nbf > now + tolerance) {
-            throw new errors_js_1.JWTClaimValidationFailed('"nbf" claim timestamp check failed', payload, 'nbf', 'check_failed');
-        }
-    }
-    if (payload.exp !== undefined) {
-        if (typeof payload.exp !== 'number') {
-            throw new errors_js_1.JWTClaimValidationFailed('"exp" claim must be a number', payload, 'exp', 'invalid');
-        }
-        if (payload.exp <= now - tolerance) {
-            throw new errors_js_1.JWTExpired('"exp" claim timestamp check failed', payload, 'exp', 'check_failed');
-        }
-    }
-    if (maxTokenAge) {
-        const age = now - payload.iat;
-        const max = typeof maxTokenAge === 'number' ? maxTokenAge : (0, secs_js_1.default)(maxTokenAge);
-        if (age - tolerance > max) {
-            throw new errors_js_1.JWTExpired('"iat" claim timestamp check failed (too far in the past)', payload, 'iat', 'check_failed');
-        }
-        if (age < 0 - tolerance) {
-            throw new errors_js_1.JWTClaimValidationFailed('"iat" claim timestamp check failed (it should be in the past)', payload, 'iat', 'check_failed');
-        }
-    }
-    return payload;
-};

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

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unprotected = void 0;
-exports.unprotected = Symbol();

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

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const minute = 60;
-const hour = minute * 60;
-const day = hour * 24;
-const week = day * 7;
-const year = day * 365.25;
-const REGEX = /^(\+|\-)? ?(\d+|\d+\.\d+) ?(seconds?|secs?|s|minutes?|mins?|m|hours?|hrs?|h|days?|d|weeks?|w|years?|yrs?|y)(?: (ago|from now))?$/i;
-exports.default = (str) => {
-    const matched = REGEX.exec(str);
-    if (!matched || (matched[4] && matched[1])) {
-        throw new TypeError('Invalid time period format');
-    }
-    const value = parseFloat(matched[2]);
-    const unit = matched[3].toLowerCase();
-    let numericDate;
-    switch (unit) {
-        case 'sec':
-        case 'secs':
-        case 'second':
-        case 'seconds':
-        case 's':
-            numericDate = Math.round(value);
-            break;
-        case 'minute':
-        case 'minutes':
-        case 'min':
-        case 'mins':
-        case 'm':
-            numericDate = Math.round(value * minute);
-            break;
-        case 'hour':
-        case 'hours':
-        case 'hr':
-        case 'hrs':
-        case 'h':
-            numericDate = Math.round(value * hour);
-            break;
-        case 'day':
-        case 'days':
-        case 'd':
-            numericDate = Math.round(value * day);
-            break;
-        case 'week':
-        case 'weeks':
-        case 'w':
-            numericDate = Math.round(value * week);
-            break;
-        default:
-            numericDate = Math.round(value * year);
-            break;
-    }
-    if (matched[1] === '-' || matched[4] === 'ago') {
-        return -numericDate;
-    }
-    return numericDate;
-};

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

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const validateAlgorithms = (option, algorithms) => {
-    if (algorithms !== undefined &&
-        (!Array.isArray(algorithms) || algorithms.some((s) => typeof s !== 'string'))) {
-        throw new TypeError(`"${option}" option must be an array of strings`);
-    }
-    if (!algorithms) {
-        return undefined;
-    }
-    return new Set(algorithms);
-};
-exports.default = validateAlgorithms;

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

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_js_1 = require("../util/errors.js");
-function validateCrit(Err, recognizedDefault, recognizedOption, protectedHeader, joseHeader) {
-    if (joseHeader.crit !== undefined && protectedHeader?.crit === undefined) {
-        throw new Err('"crit" (Critical) Header Parameter MUST be integrity protected');
-    }
-    if (!protectedHeader || protectedHeader.crit === undefined) {
-        return new Set();
-    }
-    if (!Array.isArray(protectedHeader.crit) ||
-        protectedHeader.crit.length === 0 ||
-        protectedHeader.crit.some((input) => typeof input !== 'string' || input.length === 0)) {
-        throw new Err('"crit" (Critical) Header Parameter MUST be an array of non-empty strings when present');
-    }
-    let recognized;
-    if (recognizedOption !== undefined) {
-        recognized = new Map([...Object.entries(recognizedOption), ...recognizedDefault.entries()]);
-    }
-    else {
-        recognized = recognizedDefault;
-    }
-    for (const parameter of protectedHeader.crit) {
-        if (!recognized.has(parameter)) {
-            throw new errors_js_1.JOSENotSupported(`Extension Header Parameter "${parameter}" is not recognized`);
-        }
-        if (joseHeader[parameter] === undefined) {
-            throw new Err(`Extension Header Parameter "${parameter}" is missing`);
-        }
-        if (recognized.get(parameter) && protectedHeader[parameter] === undefined) {
-            throw new Err(`Extension Header Parameter "${parameter}" MUST be integrity protected`);
-        }
-    }
-    return new Set(protectedHeader.crit);
-}
-exports.default = validateCrit;

package/dist/node/cjs/runtime/aeskw.js

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unwrap = exports.wrap = void 0;
-const node_buffer_1 = require("node:buffer");
-const node_crypto_1 = require("node:crypto");
-const errors_js_1 = require("../util/errors.js");
-const buffer_utils_js_1 = require("../lib/buffer_utils.js");
-const webcrypto_js_1 = require("./webcrypto.js");
-const crypto_key_js_1 = require("../lib/crypto_key.js");
-const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
-const ciphers_js_1 = require("./ciphers.js");
-const is_key_like_js_1 = require("./is_key_like.js");
-function checkKeySize(key, alg) {
-    if (key.symmetricKeySize << 3 !== parseInt(alg.slice(1, 4), 10)) {
-        throw new TypeError(`Invalid key size for alg: ${alg}`);
-    }
-}
-function ensureKeyObject(key, alg, usage) {
-    if ((0, is_key_object_js_1.default)(key)) {
-        return key;
-    }
-    if (key instanceof Uint8Array) {
-        return (0, node_crypto_1.createSecretKey)(key);
-    }
-    if ((0, webcrypto_js_1.isCryptoKey)(key)) {
-        (0, crypto_key_js_1.checkEncCryptoKey)(key, alg, usage);
-        return node_crypto_1.KeyObject.from(key);
-    }
-    throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types, 'Uint8Array'));
-}
-const wrap = (alg, key, cek) => {
-    const size = parseInt(alg.slice(1, 4), 10);
-    const algorithm = `aes${size}-wrap`;
-    if (!(0, ciphers_js_1.default)(algorithm)) {
-        throw new errors_js_1.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-    }
-    const keyObject = ensureKeyObject(key, alg, 'wrapKey');
-    checkKeySize(keyObject, alg);
-    const cipher = (0, node_crypto_1.createCipheriv)(algorithm, keyObject, node_buffer_1.Buffer.alloc(8, 0xa6));
-    return (0, buffer_utils_js_1.concat)(cipher.update(cek), cipher.final());
-};
-exports.wrap = wrap;
-const unwrap = (alg, key, encryptedKey) => {
-    const size = parseInt(alg.slice(1, 4), 10);
-    const algorithm = `aes${size}-wrap`;
-    if (!(0, ciphers_js_1.default)(algorithm)) {
-        throw new errors_js_1.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-    }
-    const keyObject = ensureKeyObject(key, alg, 'unwrapKey');
-    checkKeySize(keyObject, alg);
-    const cipher = (0, node_crypto_1.createDecipheriv)(algorithm, keyObject, node_buffer_1.Buffer.alloc(8, 0xa6));
-    return (0, buffer_utils_js_1.concat)(cipher.update(encryptedKey), cipher.final());
-};
-exports.unwrap = unwrap;

package/dist/node/cjs/runtime/asn1.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fromX509 = exports.fromSPKI = exports.fromPKCS8 = exports.toPKCS8 = exports.toSPKI = void 0;
-const node_crypto_1 = require("node:crypto");
-const node_buffer_1 = require("node:buffer");
-const webcrypto_js_1 = require("./webcrypto.js");
-const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
-const is_key_like_js_1 = require("./is_key_like.js");
-const genericExport = (keyType, keyFormat, key) => {
-    let keyObject;
-    if ((0, webcrypto_js_1.isCryptoKey)(key)) {
-        if (!key.extractable) {
-            throw new TypeError('CryptoKey is not extractable');
-        }
-        keyObject = node_crypto_1.KeyObject.from(key);
-    }
-    else if ((0, is_key_object_js_1.default)(key)) {
-        keyObject = key;
-    }
-    else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(key, ...is_key_like_js_1.types));
-    }
-    if (keyObject.type !== keyType) {
-        throw new TypeError(`key is not a ${keyType} key`);
-    }
-    return keyObject.export({ format: 'pem', type: keyFormat });
-};
-const toSPKI = (key) => {
-    return genericExport('public', 'spki', key);
-};
-exports.toSPKI = toSPKI;
-const toPKCS8 = (key) => {
-    return genericExport('private', 'pkcs8', key);
-};
-exports.toPKCS8 = toPKCS8;
-const fromPKCS8 = (pem) => (0, node_crypto_1.createPrivateKey)({
-    key: node_buffer_1.Buffer.from(pem.replace(/(?:-----(?:BEGIN|END) PRIVATE KEY-----|\s)/g, ''), 'base64'),
-    type: 'pkcs8',
-    format: 'der',
-});
-exports.fromPKCS8 = fromPKCS8;
-const fromSPKI = (pem) => (0, node_crypto_1.createPublicKey)({
-    key: node_buffer_1.Buffer.from(pem.replace(/(?:-----(?:BEGIN|END) PUBLIC KEY-----|\s)/g, ''), 'base64'),
-    type: 'spki',
-    format: 'der',
-});
-exports.fromSPKI = fromSPKI;
-const fromX509 = (pem) => (0, node_crypto_1.createPublicKey)({
-    key: pem,
-    type: 'spki',
-    format: 'pem',
-});
-exports.fromX509 = fromX509;

package/dist/node/cjs/runtime/base64url.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.decode = exports.encode = exports.encodeBase64 = exports.decodeBase64 = void 0;
-const node_buffer_1 = require("node:buffer");
-const buffer_utils_js_1 = require("../lib/buffer_utils.js");
-function normalize(input) {
-    let encoded = input;
-    if (encoded instanceof Uint8Array) {
-        encoded = buffer_utils_js_1.decoder.decode(encoded);
-    }
-    return encoded;
-}
-const encode = (input) => node_buffer_1.Buffer.from(input).toString('base64url');
-exports.encode = encode;
-const decodeBase64 = (input) => new Uint8Array(node_buffer_1.Buffer.from(input, 'base64'));
-exports.decodeBase64 = decodeBase64;
-const encodeBase64 = (input) => node_buffer_1.Buffer.from(input).toString('base64');
-exports.encodeBase64 = encodeBase64;
-const decode = (input) => new Uint8Array(node_buffer_1.Buffer.from(normalize(input), 'base64url'));
-exports.decode = decode;

package/dist/node/cjs/runtime/cbc_tag.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = cbcTag;
-const node_crypto_1 = require("node:crypto");
-const buffer_utils_js_1 = require("../lib/buffer_utils.js");
-function cbcTag(aad, iv, ciphertext, macSize, macKey, keySize) {
-    const macData = (0, buffer_utils_js_1.concat)(aad, iv, ciphertext, (0, buffer_utils_js_1.uint64be)(aad.length << 3));
-    const hmac = (0, node_crypto_1.createHmac)(`sha${macSize}`, macKey);
-    hmac.update(macData);
-    return hmac.digest().slice(0, keySize >> 3);
-}

package/dist/node/cjs/runtime/check_cek_length.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_js_1 = require("../util/errors.js");
-const is_key_object_js_1 = require("./is_key_object.js");
-const checkCekLength = (enc, cek) => {
-    let expected;
-    switch (enc) {
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            expected = parseInt(enc.slice(-3), 10);
-            break;
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM':
-            expected = parseInt(enc.slice(1, 4), 10);
-            break;
-        default:
-            throw new errors_js_1.JOSENotSupported(`Content Encryption Algorithm ${enc} is not supported either by JOSE or your javascript runtime`);
-    }
-    if (cek instanceof Uint8Array) {
-        const actual = cek.byteLength << 3;
-        if (actual !== expected) {
-            throw new errors_js_1.JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
-        }
-        return;
-    }
-    if ((0, is_key_object_js_1.default)(cek) && cek.type === 'secret') {
-        const actual = cek.symmetricKeySize << 3;
-        if (actual !== expected) {
-            throw new errors_js_1.JWEInvalid(`Invalid Content Encryption Key length. Expected ${expected} bits, got ${actual} bits`);
-        }
-        return;
-    }
-    throw new TypeError('Invalid Content Encryption Key type');
-};
-exports.default = checkCekLength;

package/dist/node/cjs/runtime/check_key_length.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_crypto_1 = require("node:crypto");
-exports.default = (key, alg) => {
-    let modulusLength;
-    try {
-        if (key instanceof node_crypto_1.KeyObject) {
-            modulusLength = key.asymmetricKeyDetails?.modulusLength;
-        }
-        else {
-            modulusLength = Buffer.from(key.n, 'base64url').byteLength << 3;
-        }
-    }
-    catch { }
-    if (typeof modulusLength !== 'number' || modulusLength < 2048) {
-        throw new TypeError(`${alg} requires key modulusLength to be 2048 bits or larger`);
-    }
-};

package/dist/node/cjs/runtime/ciphers.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_crypto_1 = require("node:crypto");
-let ciphers;
-exports.default = (algorithm) => {
-    ciphers ||= new Set((0, node_crypto_1.getCiphers)());
-    return ciphers.has(algorithm);
-};

package/dist/node/cjs/runtime/decrypt.js

@@ -1,103 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_crypto_1 = require("node:crypto");
-const check_iv_length_js_1 = require("../lib/check_iv_length.js");
-const check_cek_length_js_1 = require("./check_cek_length.js");
-const buffer_utils_js_1 = require("../lib/buffer_utils.js");
-const errors_js_1 = require("../util/errors.js");
-const timing_safe_equal_js_1 = require("./timing_safe_equal.js");
-const cbc_tag_js_1 = require("./cbc_tag.js");
-const webcrypto_js_1 = require("./webcrypto.js");
-const crypto_key_js_1 = require("../lib/crypto_key.js");
-const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
-const ciphers_js_1 = require("./ciphers.js");
-const is_key_like_js_1 = require("./is_key_like.js");
-function cbcDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-    const keySize = parseInt(enc.slice(1, 4), 10);
-    if ((0, is_key_object_js_1.default)(cek)) {
-        cek = cek.export();
-    }
-    const encKey = cek.subarray(keySize >> 3);
-    const macKey = cek.subarray(0, keySize >> 3);
-    const macSize = parseInt(enc.slice(-3), 10);
-    const algorithm = `aes-${keySize}-cbc`;
-    if (!(0, ciphers_js_1.default)(algorithm)) {
-        throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
-    }
-    const expectedTag = (0, cbc_tag_js_1.default)(aad, iv, ciphertext, macSize, macKey, keySize);
-    let macCheckPassed;
-    try {
-        macCheckPassed = (0, timing_safe_equal_js_1.default)(tag, expectedTag);
-    }
-    catch {
-    }
-    if (!macCheckPassed) {
-        throw new errors_js_1.JWEDecryptionFailed();
-    }
-    let plaintext;
-    try {
-        const decipher = (0, node_crypto_1.createDecipheriv)(algorithm, encKey, iv);
-        plaintext = (0, buffer_utils_js_1.concat)(decipher.update(ciphertext), decipher.final());
-    }
-    catch {
-    }
-    if (!plaintext) {
-        throw new errors_js_1.JWEDecryptionFailed();
-    }
-    return plaintext;
-}
-function gcmDecrypt(enc, cek, ciphertext, iv, tag, aad) {
-    const keySize = parseInt(enc.slice(1, 4), 10);
-    const algorithm = `aes-${keySize}-gcm`;
-    if (!(0, ciphers_js_1.default)(algorithm)) {
-        throw new errors_js_1.JOSENotSupported(`alg ${enc} is not supported by your javascript runtime`);
-    }
-    try {
-        const decipher = (0, node_crypto_1.createDecipheriv)(algorithm, cek, iv, { authTagLength: 16 });
-        decipher.setAuthTag(tag);
-        if (aad.byteLength) {
-            decipher.setAAD(aad, { plaintextLength: ciphertext.length });
-        }
-        const plaintext = decipher.update(ciphertext);
-        decipher.final();
-        return plaintext;
-    }
-    catch {
-        throw new errors_js_1.JWEDecryptionFailed();
-    }
-}
-const decrypt = (enc, cek, ciphertext, iv, tag, aad) => {
-    let key;
-    if ((0, webcrypto_js_1.isCryptoKey)(cek)) {
-        (0, crypto_key_js_1.checkEncCryptoKey)(cek, enc, 'decrypt');
-        key = node_crypto_1.KeyObject.from(cek);
-    }
-    else if (cek instanceof Uint8Array || (0, is_key_object_js_1.default)(cek)) {
-        key = cek;
-    }
-    else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(cek, ...is_key_like_js_1.types, 'Uint8Array'));
-    }
-    if (!iv) {
-        throw new errors_js_1.JWEInvalid('JWE Initialization Vector missing');
-    }
-    if (!tag) {
-        throw new errors_js_1.JWEInvalid('JWE Authentication Tag missing');
-    }
-    (0, check_cek_length_js_1.default)(enc, key);
-    (0, check_iv_length_js_1.default)(enc, iv);
-    switch (enc) {
-        case 'A128CBC-HS256':
-        case 'A192CBC-HS384':
-        case 'A256CBC-HS512':
-            return cbcDecrypt(enc, key, ciphertext, iv, tag, aad);
-        case 'A128GCM':
-        case 'A192GCM':
-        case 'A256GCM':
-            return gcmDecrypt(enc, key, ciphertext, iv, tag, aad);
-        default:
-            throw new errors_js_1.JOSENotSupported('Unsupported JWE Content Encryption Algorithm');
-    }
-};
-exports.default = decrypt;

package/dist/node/cjs/runtime/digest.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_crypto_1 = require("node:crypto");
-const digest = (algorithm, data) => (0, node_crypto_1.createHash)(algorithm).update(data).digest();
-exports.default = digest;

package/dist/node/cjs/runtime/dsa_digest.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = dsaDigest;
-const errors_js_1 = require("../util/errors.js");
-function dsaDigest(alg) {
-    switch (alg) {
-        case 'PS256':
-        case 'RS256':
-        case 'ES256':
-        case 'ES256K':
-            return 'sha256';
-        case 'PS384':
-        case 'RS384':
-        case 'ES384':
-            return 'sha384';
-        case 'PS512':
-        case 'RS512':
-        case 'ES512':
-            return 'sha512';
-        case 'EdDSA':
-            return undefined;
-        default:
-            throw new errors_js_1.JOSENotSupported(`alg ${alg} is not supported either by JOSE or your javascript runtime`);
-    }
-}

package/dist/node/cjs/runtime/ecdhes.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ecdhAllowed = void 0;
-exports.deriveKey = deriveKey;
-exports.generateEpk = generateEpk;
-const node_crypto_1 = require("node:crypto");
-const node_util_1 = require("node:util");
-const get_named_curve_js_1 = require("./get_named_curve.js");
-const buffer_utils_js_1 = require("../lib/buffer_utils.js");
-const errors_js_1 = require("../util/errors.js");
-const webcrypto_js_1 = require("./webcrypto.js");
-const crypto_key_js_1 = require("../lib/crypto_key.js");
-const is_key_object_js_1 = require("./is_key_object.js");
-const invalid_key_input_js_1 = require("../lib/invalid_key_input.js");
-const is_key_like_js_1 = require("./is_key_like.js");
-const generateKeyPair = (0, node_util_1.promisify)(node_crypto_1.generateKeyPair);
-async function deriveKey(publicKee, privateKee, algorithm, keyLength, apu = new Uint8Array(0), apv = new Uint8Array(0)) {
-    let publicKey;
-    if ((0, webcrypto_js_1.isCryptoKey)(publicKee)) {
-        (0, crypto_key_js_1.checkEncCryptoKey)(publicKee, 'ECDH');
-        publicKey = node_crypto_1.KeyObject.from(publicKee);
-    }
-    else if ((0, is_key_object_js_1.default)(publicKee)) {
-        publicKey = publicKee;
-    }
-    else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(publicKee, ...is_key_like_js_1.types));
-    }
-    let privateKey;
-    if ((0, webcrypto_js_1.isCryptoKey)(privateKee)) {
-        (0, crypto_key_js_1.checkEncCryptoKey)(privateKee, 'ECDH', 'deriveBits');
-        privateKey = node_crypto_1.KeyObject.from(privateKee);
-    }
-    else if ((0, is_key_object_js_1.default)(privateKee)) {
-        privateKey = privateKee;
-    }
-    else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(privateKee, ...is_key_like_js_1.types));
-    }
-    const value = (0, buffer_utils_js_1.concat)((0, buffer_utils_js_1.lengthAndInput)(buffer_utils_js_1.encoder.encode(algorithm)), (0, buffer_utils_js_1.lengthAndInput)(apu), (0, buffer_utils_js_1.lengthAndInput)(apv), (0, buffer_utils_js_1.uint32be)(keyLength));
-    const sharedSecret = (0, node_crypto_1.diffieHellman)({ privateKey, publicKey });
-    return (0, buffer_utils_js_1.concatKdf)(sharedSecret, keyLength, value);
-}
-async function generateEpk(kee) {
-    let key;
-    if ((0, webcrypto_js_1.isCryptoKey)(kee)) {
-        key = node_crypto_1.KeyObject.from(kee);
-    }
-    else if ((0, is_key_object_js_1.default)(kee)) {
-        key = kee;
-    }
-    else {
-        throw new TypeError((0, invalid_key_input_js_1.default)(kee, ...is_key_like_js_1.types));
-    }
-    switch (key.asymmetricKeyType) {
-        case 'x25519':
-            return generateKeyPair('x25519');
-        case 'x448': {
-            return generateKeyPair('x448');
-        }
-        case 'ec': {
-            const namedCurve = (0, get_named_curve_js_1.default)(key);
-            return generateKeyPair('ec', { namedCurve });
-        }
-        default:
-            throw new errors_js_1.JOSENotSupported('Invalid or unsupported EPK');
-    }
-}
-const ecdhAllowed = (key) => ['P-256', 'P-384', 'P-521', 'X25519', 'X448'].includes((0, get_named_curve_js_1.default)(key));
-exports.ecdhAllowed = ecdhAllowed;