@sebastienrousseau/crypto-lib 0.0.2 → 0.0.7

package/dist/modern/hash.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HASH_ALGORITHMS = void 0;
+exports.hash = hash;
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const blake2_js_1 = require("@noble/hashes/blake2.js");
+const blake3_js_1 = require("@noble/hashes/blake3.js");
+exports.HASH_ALGORITHMS = [
+    "sha256",
+    "sha384",
+    "sha512",
+    "sha3-256",
+    "sha3-512",
+    "blake2b",
+    "blake3",
+];
+function toBytes(input) {
+    if (input instanceof Uint8Array)
+        return input;
+    return Buffer.from(input, "utf8");
+}
+const hashFunctions = {
+    sha256: (d) => (0, sha2_js_1.sha256)(d),
+    sha384: (d) => (0, sha2_js_1.sha384)(d),
+    sha512: (d) => (0, sha2_js_1.sha512)(d),
+    "sha3-256": (d) => (0, sha3_js_1.sha3_256)(d),
+    "sha3-512": (d) => (0, sha3_js_1.sha3_512)(d),
+    blake2b: (d) => (0, blake2_js_1.blake2b)(d),
+    blake3: (d) => (0, blake3_js_1.blake3)(d),
+};
+function hash(options) {
+    const fn = hashFunctions[options.algorithm];
+    if (!fn) {
+        throw new Error(`Unsupported algorithm: ${options.algorithm}. Supported: ${exports.HASH_ALGORITHMS.join(", ")}`);
+    }
+    const data = toBytes(options.data);
+    const digest = fn(data);
+    return {
+        digest: Buffer.from(digest).toString("hex"),
+        algorithm: options.algorithm,
+        length: digest.length,
+    };
+}
+//# sourceMappingURL=hash.js.map

package/dist/modern/hpke.d.ts

@@ -0,0 +1,47 @@
+export type HpkeKem = "x25519" | "p256";
+export type HpkeAead = "chacha20-poly1305" | "aes-128-gcm";
+export type HpkeMode = "base" | "psk";
+export interface HpkeKeyPair {
+    publicKey: string;
+    privateKey: string;
+}
+export interface HpkeSealResult {
+    ciphertext: string;
+    encapsulatedKey: string;
+}
+export interface HpkeOpenResult {
+    plaintext: string;
+}
+export interface HpkeSuiteOptions {
+    kem?: HpkeKem;
+    aead?: HpkeAead;
+}
+export interface HpkePskOptions {
+    psk: string;
+    pskId: string;
+}
+export declare function hpkeGenerateKeyPair(kem?: HpkeKem): HpkeKeyPair;
+export declare function hpkeSeal(options: {
+    recipientPublicKey: string;
+    plaintext: string;
+    info?: string;
+    aad?: string;
+    suite?: HpkeSuiteOptions;
+    psk?: HpkePskOptions;
+}): HpkeSealResult;
+export declare function hpkeSealWithEphemeral(options: Parameters<typeof hpkeSeal>[0], ephemeralPrivateKey: Uint8Array): HpkeSealResult & {
+    sharedSecret: string;
+    key: string;
+    baseNonce: string;
+    exporterSecret: string;
+};
+export declare function hpkeOpen(options: {
+    recipientPrivateKey: string;
+    encapsulatedKey: string;
+    ciphertext: string;
+    info?: string;
+    aad?: string;
+    suite?: HpkeSuiteOptions;
+    psk?: HpkePskOptions;
+}): HpkeOpenResult;
+//# sourceMappingURL=hpke.d.ts.map

package/dist/modern/hpke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hpke.d.ts","sourceRoot":"","sources":["../../src/modern/hpke.ts"],"names":[],"mappings":"AA4DA,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,MAAM,CAAC;AAUxC,MAAM,MAAM,QAAQ,GAAG,mBAAmB,GAAG,aAAa,CAAC;AAU3D,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,KAAK,CAAC;AAUtC,MAAM,WAAW,WAAW;IAE1B,SAAS,EAAE,MAAM,CAAC;IAElB,UAAU,EAAE,MAAM,CAAC;CACpB;AAUD,MAAM,WAAW,cAAc;IAE7B,UAAU,EAAE,MAAM,CAAC;IAEnB,eAAe,EAAE,MAAM,CAAC;CACzB;AAUD,MAAM,WAAW,cAAc;IAE7B,SAAS,EAAE,MAAM,CAAC;CACnB;AAUD,MAAM,WAAW,gBAAgB;IAE/B,GAAG,CAAC,EAAE,OAAO,CAAC;IAEd,IAAI,CAAC,EAAE,QAAQ,CAAC;CACjB;AAUD,MAAM,WAAW,cAAc;IAE7B,GAAG,EAAE,MAAM,CAAC;IAEZ,KAAK,EAAE,MAAM,CAAC;CACf;AAiWD,wBAAgB,mBAAmB,CAAC,GAAG,GAAE,OAAkB,GAAG,WAAW,CAMxE;AAuBD,wBAAgB,QAAQ,CAAC,OAAO,EAAE;IAEhC,kBAAkB,EAAE,MAAM,CAAC;IAE3B,SAAS,EAAE,MAAM,CAAC;IAElB,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAEzB,GAAG,CAAC,EAAE,cAAc,CAAC;CACtB,GAAG,cAAc,CAOjB;AAUD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,EACvC,mBAAmB,EAAE,UAAU,GAC9B,cAAc,GAAG;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACxB,CA2BA;AA0BD,wBAAgB,QAAQ,CAAC,OAAO,EAAE;IAEhC,mBAAmB,EAAE,MAAM,CAAC;IAE5B,eAAe,EAAE,MAAM,CAAC;IAExB,UAAU,EAAE,MAAM,CAAC;IAEnB,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,GAAG,CAAC,EAAE,MAAM,CAAC;IAEb,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAEzB,GAAG,CAAC,EAAE,cAAc,CAAC;CACtB,GAAG,cAAc,CAgBjB"}

package/dist/modern/hpke.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hpkeGenerateKeyPair = hpkeGenerateKeyPair;
+exports.hpkeSeal = hpkeSeal;
+exports.hpkeSealWithEphemeral = hpkeSealWithEphemeral;
+exports.hpkeOpen = hpkeOpen;
+const ed25519_js_1 = require("@noble/curves/ed25519.js");
+const nist_js_1 = require("@noble/curves/nist.js");
+const hkdf_js_1 = require("@noble/hashes/hkdf.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const chacha_js_1 = require("@noble/ciphers/chacha.js");
+const aes_js_1 = require("@noble/ciphers/aes.js");
+const KEM_X25519 = 0x0020;
+const KEM_P256 = 0x0010;
+const KDF_HKDF_SHA256 = 0x0001;
+const AEAD_AES_128_GCM = 0x0001;
+const AEAD_CHACHA20_POLY1305 = 0x0003;
+const MODE_BASE = 0x00;
+const MODE_PSK = 0x01;
+const HEX_RE = /^[0-9a-fA-F]*$/;
+function hexToBytes(hex) {
+    if (!HEX_RE.test(hex) || hex.length % 2 !== 0) {
+        throw new Error("Invalid hex string");
+    }
+    return Buffer.from(hex, "hex");
+}
+function bytesToHex(bytes) {
+    return Buffer.from(bytes).toString("hex");
+}
+function i2osp2(n) {
+    return new Uint8Array([(n >> 8) & 0xff, n & 0xff]);
+}
+function concat(...arrays) {
+    const len = arrays.reduce((s, a) => s + a.length, 0);
+    const result = new Uint8Array(len);
+    let offset = 0;
+    for (const a of arrays) {
+        result.set(a, offset);
+        offset += a.length;
+    }
+    return result;
+}
+function suiteParams(kem, aead) {
+    const kemId = kem === "x25519" ? KEM_X25519 : KEM_P256;
+    const aeadId = aead === "chacha20-poly1305" ? AEAD_CHACHA20_POLY1305 : AEAD_AES_128_GCM;
+    const nk = aead === "chacha20-poly1305" ? 32 : 16;
+    const nn = 12;
+    const nSecret = 32;
+    let nEnc;
+    let nSk;
+    if (kem === "x25519") {
+        nEnc = 32;
+        nSk = 32;
+    }
+    else {
+        nEnc = 65;
+        nSk = 32;
+    }
+    return {
+        kemId,
+        kdfId: KDF_HKDF_SHA256,
+        aeadId,
+        nk,
+        nn,
+        nSecret,
+        nEnc,
+        nSk,
+    };
+}
+function hpkeSuiteId(params) {
+    return concat(Buffer.from("HPKE"), i2osp2(params.kemId), i2osp2(params.kdfId), i2osp2(params.aeadId));
+}
+function kemSuiteId(kemId) {
+    return concat(Buffer.from("KEM"), i2osp2(kemId));
+}
+function labeledExtract(suiteId, salt, label, ikm) {
+    const labeledIkm = concat(Buffer.from("HPKE-v1"), suiteId, Buffer.from(label), ikm);
+    return (0, hkdf_js_1.extract)(sha2_js_1.sha256, labeledIkm, salt.length > 0 ? salt : undefined);
+}
+function labeledExpand(suiteId, prk, label, info, length) {
+    const labeledInfo = concat(i2osp2(length), Buffer.from("HPKE-v1"), suiteId, Buffer.from(label), info);
+    return (0, hkdf_js_1.expand)(sha2_js_1.sha256, prk, labeledInfo, length);
+}
+function kemPublicKey(kem, sk) {
+    return kem === "x25519"
+        ? ed25519_js_1.x25519.getPublicKey(sk)
+        : nist_js_1.p256.getPublicKey(sk, false);
+}
+function kemRandomPrivateKey(kem) {
+    return kem === "x25519"
+        ? ed25519_js_1.x25519.utils.randomSecretKey()
+        : nist_js_1.p256.utils.randomSecretKey();
+}
+function kemDh(kem, sk, pk) {
+    if (kem === "x25519") {
+        return ed25519_js_1.x25519.getSharedSecret(sk, pk);
+    }
+    return nist_js_1.p256.getSharedSecret(sk, pk, false).subarray(1, 33);
+}
+function extractAndExpand(params, dh, kemContext) {
+    const kemSid = kemSuiteId(params.kemId);
+    const eaePrk = labeledExtract(kemSid, new Uint8Array(0), "eae_prk", dh);
+    return labeledExpand(kemSid, eaePrk, "shared_secret", kemContext, params.nSecret);
+}
+function dhkemEncap(kem, recipientPub, ephPriv, params) {
+    const enc = kemPublicKey(kem, ephPriv);
+    const dh = kemDh(kem, ephPriv, recipientPub);
+    const sharedSecret = extractAndExpand(params, dh, concat(enc, recipientPub));
+    return { sharedSecret, enc };
+}
+function dhkemDecap(kem, enc, recipientPriv, params) {
+    const dh = kemDh(kem, recipientPriv, enc);
+    const recipientPub = kemPublicKey(kem, recipientPriv);
+    return extractAndExpand(params, dh, concat(enc, recipientPub));
+}
+function keySchedule(params, sharedSecret, inputs) {
+    const suiteId = hpkeSuiteId(params);
+    const empty = new Uint8Array(0);
+    const pskIdHash = labeledExtract(suiteId, empty, "psk_id_hash", inputs.pskId);
+    const infoHash = labeledExtract(suiteId, empty, "info_hash", inputs.info);
+    const ksContext = concat(new Uint8Array([inputs.mode]), pskIdHash, infoHash);
+    const secret = labeledExtract(suiteId, sharedSecret, "secret", inputs.psk);
+    return {
+        key: labeledExpand(suiteId, secret, "key", ksContext, params.nk),
+        baseNonce: labeledExpand(suiteId, secret, "base_nonce", ksContext, params.nn),
+        exporterSecret: labeledExpand(suiteId, secret, "exp", ksContext, params.nSecret),
+    };
+}
+function scheduleInputs(options) {
+    const info = options.info ? hexToBytes(options.info) : new Uint8Array(0);
+    if (!options.psk) {
+        return {
+            mode: MODE_BASE,
+            info,
+            psk: new Uint8Array(0),
+            pskId: new Uint8Array(0),
+        };
+    }
+    const psk = hexToBytes(options.psk.psk);
+    const pskId = hexToBytes(options.psk.pskId);
+    if (psk.length === 0 || pskId.length === 0) {
+        throw new Error("PSK mode requires a non-empty psk and pskId");
+    }
+    return { mode: MODE_PSK, info, psk, pskId };
+}
+function aeadSeal(aead, key, nonce, aad, plaintext) {
+    if (aead === "chacha20-poly1305") {
+        return (0, chacha_js_1.chacha20poly1305)(key, nonce, aad).encrypt(plaintext);
+    }
+    return (0, aes_js_1.gcm)(key, nonce, aad).encrypt(plaintext);
+}
+function aeadOpen(aead, key, nonce, aad, ciphertext) {
+    if (aead === "chacha20-poly1305") {
+        return (0, chacha_js_1.chacha20poly1305)(key, nonce, aad).decrypt(ciphertext);
+    }
+    return (0, aes_js_1.gcm)(key, nonce, aad).decrypt(ciphertext);
+}
+function hpkeGenerateKeyPair(kem = "x25519") {
+    const privateKey = kemRandomPrivateKey(kem);
+    return {
+        publicKey: bytesToHex(kemPublicKey(kem, privateKey)),
+        privateKey: bytesToHex(privateKey),
+    };
+}
+function hpkeSeal(options) {
+    const kem = options.suite?.kem ?? "x25519";
+    const sealed = hpkeSealWithEphemeral(options, kemRandomPrivateKey(kem));
+    return {
+        ciphertext: sealed.ciphertext,
+        encapsulatedKey: sealed.encapsulatedKey,
+    };
+}
+function hpkeSealWithEphemeral(options, ephemeralPrivateKey) {
+    const kem = options.suite?.kem ?? "x25519";
+    const aead = options.suite?.aead ?? "chacha20-poly1305";
+    const params = suiteParams(kem, aead);
+    const recipientPub = hexToBytes(options.recipientPublicKey);
+    const plaintext = hexToBytes(options.plaintext);
+    const aad = options.aad ? hexToBytes(options.aad) : new Uint8Array(0);
+    const inputs = scheduleInputs(options);
+    const { sharedSecret, enc } = dhkemEncap(kem, recipientPub, ephemeralPrivateKey, params);
+    const ks = keySchedule(params, sharedSecret, inputs);
+    const ct = aeadSeal(aead, ks.key, ks.baseNonce, aad, plaintext);
+    return {
+        ciphertext: bytesToHex(ct),
+        encapsulatedKey: bytesToHex(enc),
+        sharedSecret: bytesToHex(sharedSecret),
+        key: bytesToHex(ks.key),
+        baseNonce: bytesToHex(ks.baseNonce),
+        exporterSecret: bytesToHex(ks.exporterSecret),
+    };
+}
+function hpkeOpen(options) {
+    const kem = options.suite?.kem ?? "x25519";
+    const aead = options.suite?.aead ?? "chacha20-poly1305";
+    const params = suiteParams(kem, aead);
+    const recipientPriv = hexToBytes(options.recipientPrivateKey);
+    const enc = hexToBytes(options.encapsulatedKey);
+    const ciphertext = hexToBytes(options.ciphertext);
+    const aad = options.aad ? hexToBytes(options.aad) : new Uint8Array(0);
+    const inputs = scheduleInputs(options);
+    const sharedSecret = dhkemDecap(kem, enc, recipientPriv, params);
+    const { key, baseNonce } = keySchedule(params, sharedSecret, inputs);
+    const pt = aeadOpen(aead, key, baseNonce, aad, ciphertext);
+    return { plaintext: bytesToHex(pt) };
+}
+//# sourceMappingURL=hpke.js.map

package/dist/modern/index.d.ts

@@ -0,0 +1,40 @@
+export { aeadEncrypt, aeadDecrypt } from "./aead";
+export type { AeadEncryptOptions, AeadDecryptOptions, AeadEncryptResult, } from "./aead";
+export { aesGcmEncrypt, aesGcmDecrypt, aesGcmSivEncrypt, aesGcmSivDecrypt, } from "./aes";
+export type { AesGcmEncryptOptions, AesGcmEncryptResult, AesGcmDecryptOptions, AesGcmAlgorithm, AesGcmSivEncryptOptions, AesGcmSivEncryptResult, AesGcmSivDecryptOptions, AesGcmSivAlgorithm, } from "./aes";
+export { hash, HASH_ALGORITHMS } from "./hash";
+export type { HashOptions, HashResult, HashAlgorithm } from "./hash";
+export { kdfDerive, KDF_ALGORITHMS } from "./kdf";
+export type { KdfDeriveOptions, KdfResult, KdfAlgorithm } from "./kdf";
+export { generateEd25519KeyPair, ed25519Sign, ed25519Verify } from "./signing";
+export type { Ed25519KeyPair, SignResult, VerifyResult } from "./signing";
+export { generateX25519KeyPair, x25519Exchange } from "./ecdh";
+export type { X25519KeyPair, KeyExchangeResult } from "./ecdh";
+export { mlKemGenerateKeyPair, mlKemEncapsulate, mlKemDecapsulate, hybridGenerateKeyPair, hybridEncapsulate, hybridDecapsulate, } from "./pq";
+export type { MlKemKeyPair, MlKemEncapsulateResult, MlKemDecapsulateResult, HybridKeyPair, HybridEncapsulateResult, HybridDecapsulateResult, } from "./pq";
+export { mlKemKeygen, mlKemEncapsulate as mlKemEncap, mlKemDecapsulate as mlKemDecap, hybridKemKeygen, hybridKemEncapsulate, hybridKemDecapsulate, p256MlKemKeygen, p256MlKemEncapsulate, p256MlKemDecapsulate, x448MlKemKeygen, x448MlKemEncapsulate, x448MlKemDecapsulate, RFC10024_X25519_MLKEM768, RFC10024_SECP256R1_MLKEM768, RFC10024_CODEPOINTS, normalizeHybridKemAlgorithm, } from "./pq-kem";
+export type { MlKemLevel, MlKemAlgorithm, MlKemKeyPairResult, MlKemEncapsulateResult as MlKemEncapResult, MlKemDecapsulateResult as MlKemDecapResult, HybridKemAlgorithm, HybridKemKeyPair, HybridKemEncapsulateResult, HybridKemDecapsulateResult, P256MlKemKeyPair, P256MlKemEncapsulateResult, P256MlKemDecapsulateResult, X448MlKemKeyPair, X448MlKemEncapsulateResult, X448MlKemDecapsulateResult, } from "./pq-kem";
+export { mlDsaKeygen, mlDsaSign, mlDsaVerify, hybridSign, hybridVerify, } from "./pq-sign";
+export type { MlDsaLevel, MlDsaAlgorithm, MlDsaKeyPairResult, MlDsaSignResult, MlDsaVerifyResult, HybridSignResult, HybridVerifyResult, } from "./pq-sign";
+export { fnDsaKeygen, fnDsaSign, fnDsaVerify } from "./fn-dsa";
+export type { FnDsaLevel, FnDsaAlgorithm, FnDsaKeyPairResult, FnDsaSignResult, FnDsaVerifyResult, } from "./fn-dsa";
+export { slhDsaKeygen, slhDsaSign, slhDsaVerify } from "./pq-hash-sign";
+export type { SlhDsaVariant, SlhDsaKeyPairResult, SlhDsaSignResult, SlhDsaVerifyResult, } from "./pq-hash-sign";
+export { computeHmac, verifyHmac, HMAC_ALGORITHMS, computeKmac, verifyKmac, KMAC_ALGORITHMS, } from "./mac";
+export type { HmacAlgorithm, HmacComputeOptions, HmacComputeResult, HmacVerifyOptions, HmacVerifyResult, KmacAlgorithm, KmacComputeOptions, KmacComputeResult, KmacVerifyOptions, KmacVerifyResult, } from "./mac";
+export { hashPassword, verifyPassword, verifyPasswordPhc } from "./password";
+export type { Argon2Variant, Argon2Params, HashPasswordOptions, HashPasswordResult, VerifyPasswordOptions, VerifyPasswordResult, VerifyPhcOptions, } from "./password";
+export { generateP256KeyPair, p256Sign, p256Verify, generateP384KeyPair, p384Sign, p384Verify, generateEd448KeyPair, ed448Sign, ed448Verify, generateX448KeyPair, x448Exchange, ecdhP256, ecdhP384, generateSchnorrKeyPair, schnorrSign, schnorrVerify, } from "./curves";
+export type { P256KeyPair, P256SignResult, P256VerifyResult, P384KeyPair, P384SignResult, P384VerifyResult, Ed448KeyPair, Ed448SignResult, Ed448VerifyResult, X448KeyPair, X448ExchangeResult, EcdhP256Result, EcdhP384Result, SchnorrKeyPair, SchnorrSignResult, SchnorrVerifyResult, } from "./curves";
+export { hpkeGenerateKeyPair, hpkeSeal, hpkeOpen } from "./hpke";
+export type { HpkeKem, HpkeAead, HpkeMode, HpkeKeyPair, HpkeSealResult, HpkeOpenResult, HpkeSuiteOptions, HpkePskOptions, } from "./hpke";
+export declare const SUPPORTED_ALGORITHMS: {
+    readonly encryption: readonly ["xchacha20-poly1305", "aes-128-gcm", "aes-256-gcm", "aes-128-gcm-siv", "aes-256-gcm-siv"];
+    readonly hashing: readonly ["sha256", "sha384", "sha512", "sha3-256", "sha3-512", "blake2b", "blake3"];
+    readonly kdf: readonly ["scrypt", "hkdf-sha256", "pbkdf2-sha256", "argon2id", "argon2i", "argon2d"];
+    readonly mac: readonly ["hmac-sha256", "hmac-sha384", "hmac-sha512", "hmac-sha3-256", "hmac-sha3-512", "kmac-128", "kmac-256"];
+    readonly signing: readonly ["ed25519", "ed448", "ecdsa-p256", "ecdsa-p384", "schnorr", "ml-dsa-44", "ml-dsa-65", "ml-dsa-87", "slh-dsa-sha2-128f", "slh-dsa-sha2-128s", "slh-dsa-sha2-192f", "slh-dsa-sha2-192s", "slh-dsa-sha2-256f", "slh-dsa-sha2-256s", "slh-dsa-shake-128f", "slh-dsa-shake-128s", "slh-dsa-shake-192f", "slh-dsa-shake-192s", "slh-dsa-shake-256f", "slh-dsa-shake-256s", "ed25519-ml-dsa-44", "ed25519-ml-dsa-65", "ed25519-ml-dsa-87", "fn-dsa-512", "fn-dsa-1024"];
+    readonly keyExchange: readonly ["x25519", "x448", "ecdh-p256", "ecdh-p384", "x25519-ml-kem-512", "x25519-ml-kem-768", "x25519-ml-kem-1024", "p256-ml-kem-768", "x448-ml-kem-1024", "hpke-x25519-chacha20", "hpke-x25519-aes128gcm", "hpke-p256-aes128gcm"];
+    readonly postQuantum: readonly ["ml-kem-512", "ml-kem-768", "ml-kem-1024", "ml-dsa-44", "ml-dsa-65", "ml-dsa-87", "slh-dsa-sha2-128f", "slh-dsa-sha2-128s", "slh-dsa-sha2-192f", "slh-dsa-sha2-192s", "slh-dsa-sha2-256f", "slh-dsa-sha2-256s", "slh-dsa-shake-128f", "slh-dsa-shake-128s", "slh-dsa-shake-192f", "slh-dsa-shake-192s", "slh-dsa-shake-256f", "slh-dsa-shake-256s", "fn-dsa-512", "fn-dsa-1024"];
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/modern/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/modern/index.ts"],"names":[],"mappings":"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"}

package/dist/modern/index.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyHmac = exports.computeHmac = exports.slhDsaVerify = exports.slhDsaSign = exports.slhDsaKeygen = exports.fnDsaVerify = exports.fnDsaSign = exports.fnDsaKeygen = exports.hybridVerify = exports.hybridSign = exports.mlDsaVerify = exports.mlDsaSign = exports.mlDsaKeygen = exports.normalizeHybridKemAlgorithm = exports.RFC10024_CODEPOINTS = exports.RFC10024_SECP256R1_MLKEM768 = exports.RFC10024_X25519_MLKEM768 = exports.x448MlKemDecapsulate = exports.x448MlKemEncapsulate = exports.x448MlKemKeygen = exports.p256MlKemDecapsulate = exports.p256MlKemEncapsulate = exports.p256MlKemKeygen = exports.hybridKemDecapsulate = exports.hybridKemEncapsulate = exports.hybridKemKeygen = exports.mlKemDecap = exports.mlKemEncap = exports.mlKemKeygen = exports.hybridDecapsulate = exports.hybridEncapsulate = exports.hybridGenerateKeyPair = exports.mlKemDecapsulate = exports.mlKemEncapsulate = exports.mlKemGenerateKeyPair = exports.x25519Exchange = exports.generateX25519KeyPair = exports.ed25519Verify = exports.ed25519Sign = exports.generateEd25519KeyPair = exports.KDF_ALGORITHMS = exports.kdfDerive = exports.HASH_ALGORITHMS = exports.hash = exports.aesGcmSivDecrypt = exports.aesGcmSivEncrypt = exports.aesGcmDecrypt = exports.aesGcmEncrypt = exports.aeadDecrypt = exports.aeadEncrypt = void 0;
+exports.SUPPORTED_ALGORITHMS = exports.hpkeOpen = exports.hpkeSeal = exports.hpkeGenerateKeyPair = exports.schnorrVerify = exports.schnorrSign = exports.generateSchnorrKeyPair = exports.ecdhP384 = exports.ecdhP256 = exports.x448Exchange = exports.generateX448KeyPair = exports.ed448Verify = exports.ed448Sign = exports.generateEd448KeyPair = exports.p384Verify = exports.p384Sign = exports.generateP384KeyPair = exports.p256Verify = exports.p256Sign = exports.generateP256KeyPair = exports.verifyPasswordPhc = exports.verifyPassword = exports.hashPassword = exports.KMAC_ALGORITHMS = exports.verifyKmac = exports.computeKmac = exports.HMAC_ALGORITHMS = void 0;
+var aead_1 = require("./aead");
+Object.defineProperty(exports, "aeadEncrypt", { enumerable: true, get: function () { return aead_1.aeadEncrypt; } });
+Object.defineProperty(exports, "aeadDecrypt", { enumerable: true, get: function () { return aead_1.aeadDecrypt; } });
+var aes_1 = require("./aes");
+Object.defineProperty(exports, "aesGcmEncrypt", { enumerable: true, get: function () { return aes_1.aesGcmEncrypt; } });
+Object.defineProperty(exports, "aesGcmDecrypt", { enumerable: true, get: function () { return aes_1.aesGcmDecrypt; } });
+Object.defineProperty(exports, "aesGcmSivEncrypt", { enumerable: true, get: function () { return aes_1.aesGcmSivEncrypt; } });
+Object.defineProperty(exports, "aesGcmSivDecrypt", { enumerable: true, get: function () { return aes_1.aesGcmSivDecrypt; } });
+var hash_1 = require("./hash");
+Object.defineProperty(exports, "hash", { enumerable: true, get: function () { return hash_1.hash; } });
+Object.defineProperty(exports, "HASH_ALGORITHMS", { enumerable: true, get: function () { return hash_1.HASH_ALGORITHMS; } });
+var kdf_1 = require("./kdf");
+Object.defineProperty(exports, "kdfDerive", { enumerable: true, get: function () { return kdf_1.kdfDerive; } });
+Object.defineProperty(exports, "KDF_ALGORITHMS", { enumerable: true, get: function () { return kdf_1.KDF_ALGORITHMS; } });
+var signing_1 = require("./signing");
+Object.defineProperty(exports, "generateEd25519KeyPair", { enumerable: true, get: function () { return signing_1.generateEd25519KeyPair; } });
+Object.defineProperty(exports, "ed25519Sign", { enumerable: true, get: function () { return signing_1.ed25519Sign; } });
+Object.defineProperty(exports, "ed25519Verify", { enumerable: true, get: function () { return signing_1.ed25519Verify; } });
+var ecdh_1 = require("./ecdh");
+Object.defineProperty(exports, "generateX25519KeyPair", { enumerable: true, get: function () { return ecdh_1.generateX25519KeyPair; } });
+Object.defineProperty(exports, "x25519Exchange", { enumerable: true, get: function () { return ecdh_1.x25519Exchange; } });
+var pq_1 = require("./pq");
+Object.defineProperty(exports, "mlKemGenerateKeyPair", { enumerable: true, get: function () { return pq_1.mlKemGenerateKeyPair; } });
+Object.defineProperty(exports, "mlKemEncapsulate", { enumerable: true, get: function () { return pq_1.mlKemEncapsulate; } });
+Object.defineProperty(exports, "mlKemDecapsulate", { enumerable: true, get: function () { return pq_1.mlKemDecapsulate; } });
+Object.defineProperty(exports, "hybridGenerateKeyPair", { enumerable: true, get: function () { return pq_1.hybridGenerateKeyPair; } });
+Object.defineProperty(exports, "hybridEncapsulate", { enumerable: true, get: function () { return pq_1.hybridEncapsulate; } });
+Object.defineProperty(exports, "hybridDecapsulate", { enumerable: true, get: function () { return pq_1.hybridDecapsulate; } });
+var pq_kem_1 = require("./pq-kem");
+Object.defineProperty(exports, "mlKemKeygen", { enumerable: true, get: function () { return pq_kem_1.mlKemKeygen; } });
+Object.defineProperty(exports, "mlKemEncap", { enumerable: true, get: function () { return pq_kem_1.mlKemEncapsulate; } });
+Object.defineProperty(exports, "mlKemDecap", { enumerable: true, get: function () { return pq_kem_1.mlKemDecapsulate; } });
+Object.defineProperty(exports, "hybridKemKeygen", { enumerable: true, get: function () { return pq_kem_1.hybridKemKeygen; } });
+Object.defineProperty(exports, "hybridKemEncapsulate", { enumerable: true, get: function () { return pq_kem_1.hybridKemEncapsulate; } });
+Object.defineProperty(exports, "hybridKemDecapsulate", { enumerable: true, get: function () { return pq_kem_1.hybridKemDecapsulate; } });
+Object.defineProperty(exports, "p256MlKemKeygen", { enumerable: true, get: function () { return pq_kem_1.p256MlKemKeygen; } });
+Object.defineProperty(exports, "p256MlKemEncapsulate", { enumerable: true, get: function () { return pq_kem_1.p256MlKemEncapsulate; } });
+Object.defineProperty(exports, "p256MlKemDecapsulate", { enumerable: true, get: function () { return pq_kem_1.p256MlKemDecapsulate; } });
+Object.defineProperty(exports, "x448MlKemKeygen", { enumerable: true, get: function () { return pq_kem_1.x448MlKemKeygen; } });
+Object.defineProperty(exports, "x448MlKemEncapsulate", { enumerable: true, get: function () { return pq_kem_1.x448MlKemEncapsulate; } });
+Object.defineProperty(exports, "x448MlKemDecapsulate", { enumerable: true, get: function () { return pq_kem_1.x448MlKemDecapsulate; } });
+Object.defineProperty(exports, "RFC10024_X25519_MLKEM768", { enumerable: true, get: function () { return pq_kem_1.RFC10024_X25519_MLKEM768; } });
+Object.defineProperty(exports, "RFC10024_SECP256R1_MLKEM768", { enumerable: true, get: function () { return pq_kem_1.RFC10024_SECP256R1_MLKEM768; } });
+Object.defineProperty(exports, "RFC10024_CODEPOINTS", { enumerable: true, get: function () { return pq_kem_1.RFC10024_CODEPOINTS; } });
+Object.defineProperty(exports, "normalizeHybridKemAlgorithm", { enumerable: true, get: function () { return pq_kem_1.normalizeHybridKemAlgorithm; } });
+var pq_sign_1 = require("./pq-sign");
+Object.defineProperty(exports, "mlDsaKeygen", { enumerable: true, get: function () { return pq_sign_1.mlDsaKeygen; } });
+Object.defineProperty(exports, "mlDsaSign", { enumerable: true, get: function () { return pq_sign_1.mlDsaSign; } });
+Object.defineProperty(exports, "mlDsaVerify", { enumerable: true, get: function () { return pq_sign_1.mlDsaVerify; } });
+Object.defineProperty(exports, "hybridSign", { enumerable: true, get: function () { return pq_sign_1.hybridSign; } });
+Object.defineProperty(exports, "hybridVerify", { enumerable: true, get: function () { return pq_sign_1.hybridVerify; } });
+var fn_dsa_1 = require("./fn-dsa");
+Object.defineProperty(exports, "fnDsaKeygen", { enumerable: true, get: function () { return fn_dsa_1.fnDsaKeygen; } });
+Object.defineProperty(exports, "fnDsaSign", { enumerable: true, get: function () { return fn_dsa_1.fnDsaSign; } });
+Object.defineProperty(exports, "fnDsaVerify", { enumerable: true, get: function () { return fn_dsa_1.fnDsaVerify; } });
+var pq_hash_sign_1 = require("./pq-hash-sign");
+Object.defineProperty(exports, "slhDsaKeygen", { enumerable: true, get: function () { return pq_hash_sign_1.slhDsaKeygen; } });
+Object.defineProperty(exports, "slhDsaSign", { enumerable: true, get: function () { return pq_hash_sign_1.slhDsaSign; } });
+Object.defineProperty(exports, "slhDsaVerify", { enumerable: true, get: function () { return pq_hash_sign_1.slhDsaVerify; } });
+var mac_1 = require("./mac");
+Object.defineProperty(exports, "computeHmac", { enumerable: true, get: function () { return mac_1.computeHmac; } });
+Object.defineProperty(exports, "verifyHmac", { enumerable: true, get: function () { return mac_1.verifyHmac; } });
+Object.defineProperty(exports, "HMAC_ALGORITHMS", { enumerable: true, get: function () { return mac_1.HMAC_ALGORITHMS; } });
+Object.defineProperty(exports, "computeKmac", { enumerable: true, get: function () { return mac_1.computeKmac; } });
+Object.defineProperty(exports, "verifyKmac", { enumerable: true, get: function () { return mac_1.verifyKmac; } });
+Object.defineProperty(exports, "KMAC_ALGORITHMS", { enumerable: true, get: function () { return mac_1.KMAC_ALGORITHMS; } });
+var password_1 = require("./password");
+Object.defineProperty(exports, "hashPassword", { enumerable: true, get: function () { return password_1.hashPassword; } });
+Object.defineProperty(exports, "verifyPassword", { enumerable: true, get: function () { return password_1.verifyPassword; } });
+Object.defineProperty(exports, "verifyPasswordPhc", { enumerable: true, get: function () { return password_1.verifyPasswordPhc; } });
+var curves_1 = require("./curves");
+Object.defineProperty(exports, "generateP256KeyPair", { enumerable: true, get: function () { return curves_1.generateP256KeyPair; } });
+Object.defineProperty(exports, "p256Sign", { enumerable: true, get: function () { return curves_1.p256Sign; } });
+Object.defineProperty(exports, "p256Verify", { enumerable: true, get: function () { return curves_1.p256Verify; } });
+Object.defineProperty(exports, "generateP384KeyPair", { enumerable: true, get: function () { return curves_1.generateP384KeyPair; } });
+Object.defineProperty(exports, "p384Sign", { enumerable: true, get: function () { return curves_1.p384Sign; } });
+Object.defineProperty(exports, "p384Verify", { enumerable: true, get: function () { return curves_1.p384Verify; } });
+Object.defineProperty(exports, "generateEd448KeyPair", { enumerable: true, get: function () { return curves_1.generateEd448KeyPair; } });
+Object.defineProperty(exports, "ed448Sign", { enumerable: true, get: function () { return curves_1.ed448Sign; } });
+Object.defineProperty(exports, "ed448Verify", { enumerable: true, get: function () { return curves_1.ed448Verify; } });
+Object.defineProperty(exports, "generateX448KeyPair", { enumerable: true, get: function () { return curves_1.generateX448KeyPair; } });
+Object.defineProperty(exports, "x448Exchange", { enumerable: true, get: function () { return curves_1.x448Exchange; } });
+Object.defineProperty(exports, "ecdhP256", { enumerable: true, get: function () { return curves_1.ecdhP256; } });
+Object.defineProperty(exports, "ecdhP384", { enumerable: true, get: function () { return curves_1.ecdhP384; } });
+Object.defineProperty(exports, "generateSchnorrKeyPair", { enumerable: true, get: function () { return curves_1.generateSchnorrKeyPair; } });
+Object.defineProperty(exports, "schnorrSign", { enumerable: true, get: function () { return curves_1.schnorrSign; } });
+Object.defineProperty(exports, "schnorrVerify", { enumerable: true, get: function () { return curves_1.schnorrVerify; } });
+var hpke_1 = require("./hpke");
+Object.defineProperty(exports, "hpkeGenerateKeyPair", { enumerable: true, get: function () { return hpke_1.hpkeGenerateKeyPair; } });
+Object.defineProperty(exports, "hpkeSeal", { enumerable: true, get: function () { return hpke_1.hpkeSeal; } });
+Object.defineProperty(exports, "hpkeOpen", { enumerable: true, get: function () { return hpke_1.hpkeOpen; } });
+exports.SUPPORTED_ALGORITHMS = {
+    encryption: [
+        "xchacha20-poly1305",
+        "aes-128-gcm",
+        "aes-256-gcm",
+        "aes-128-gcm-siv",
+        "aes-256-gcm-siv",
+    ],
+    hashing: [
+        "sha256",
+        "sha384",
+        "sha512",
+        "sha3-256",
+        "sha3-512",
+        "blake2b",
+        "blake3",
+    ],
+    kdf: [
+        "scrypt",
+        "hkdf-sha256",
+        "pbkdf2-sha256",
+        "argon2id",
+        "argon2i",
+        "argon2d",
+    ],
+    mac: [
+        "hmac-sha256",
+        "hmac-sha384",
+        "hmac-sha512",
+        "hmac-sha3-256",
+        "hmac-sha3-512",
+        "kmac-128",
+        "kmac-256",
+    ],
+    signing: [
+        "ed25519",
+        "ed448",
+        "ecdsa-p256",
+        "ecdsa-p384",
+        "schnorr",
+        "ml-dsa-44",
+        "ml-dsa-65",
+        "ml-dsa-87",
+        "slh-dsa-sha2-128f",
+        "slh-dsa-sha2-128s",
+        "slh-dsa-sha2-192f",
+        "slh-dsa-sha2-192s",
+        "slh-dsa-sha2-256f",
+        "slh-dsa-sha2-256s",
+        "slh-dsa-shake-128f",
+        "slh-dsa-shake-128s",
+        "slh-dsa-shake-192f",
+        "slh-dsa-shake-192s",
+        "slh-dsa-shake-256f",
+        "slh-dsa-shake-256s",
+        "ed25519-ml-dsa-44",
+        "ed25519-ml-dsa-65",
+        "ed25519-ml-dsa-87",
+        "fn-dsa-512",
+        "fn-dsa-1024",
+    ],
+    keyExchange: [
+        "x25519",
+        "x448",
+        "ecdh-p256",
+        "ecdh-p384",
+        "x25519-ml-kem-512",
+        "x25519-ml-kem-768",
+        "x25519-ml-kem-1024",
+        "p256-ml-kem-768",
+        "x448-ml-kem-1024",
+        "hpke-x25519-chacha20",
+        "hpke-x25519-aes128gcm",
+        "hpke-p256-aes128gcm",
+    ],
+    postQuantum: [
+        "ml-kem-512",
+        "ml-kem-768",
+        "ml-kem-1024",
+        "ml-dsa-44",
+        "ml-dsa-65",
+        "ml-dsa-87",
+        "slh-dsa-sha2-128f",
+        "slh-dsa-sha2-128s",
+        "slh-dsa-sha2-192f",
+        "slh-dsa-sha2-192s",
+        "slh-dsa-sha2-256f",
+        "slh-dsa-sha2-256s",
+        "slh-dsa-shake-128f",
+        "slh-dsa-shake-128s",
+        "slh-dsa-shake-192f",
+        "slh-dsa-shake-192s",
+        "slh-dsa-shake-256f",
+        "slh-dsa-shake-256s",
+        "fn-dsa-512",
+        "fn-dsa-1024",
+    ],
+};
+//# sourceMappingURL=index.js.map

package/dist/modern/kdf.d.ts

@@ -0,0 +1,23 @@
+export declare const KDF_ALGORITHMS: readonly ["scrypt", "hkdf-sha256", "pbkdf2-sha256"];
+export type KdfAlgorithm = (typeof KDF_ALGORITHMS)[number];
+export interface KdfDeriveOptions {
+    algorithm: KdfAlgorithm;
+    password: string | Uint8Array;
+    salt?: string | Uint8Array;
+    keyLength?: number;
+    params?: {
+        N?: number;
+        r?: number;
+        p?: number;
+        iterations?: number;
+        info?: string | Uint8Array;
+    };
+}
+export interface KdfResult {
+    derivedKey: string;
+    salt: string;
+    algorithm: KdfAlgorithm;
+    keyLength: number;
+}
+export declare function kdfDerive(options: KdfDeriveOptions): KdfResult;
+//# sourceMappingURL=kdf.d.ts.map

package/dist/modern/kdf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kdf.d.ts","sourceRoot":"","sources":["../../src/modern/kdf.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,cAAc,qDAIjB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAG3D,MAAM,WAAW,gBAAgB;IAE/B,SAAS,EAAE,YAAY,CAAC;IAExB,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAC;IAE9B,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAE3B,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,MAAM,CAAC,EAAE;QAEP,CAAC,CAAC,EAAE,MAAM,CAAC;QAEX,CAAC,CAAC,EAAE,MAAM,CAAC;QAEX,CAAC,CAAC,EAAE,MAAM,CAAC;QAEX,UAAU,CAAC,EAAE,MAAM,CAAC;QAEpB,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;KAC5B,CAAC;CACH;AAGD,MAAM,WAAW,SAAS;IAExB,UAAU,EAAE,MAAM,CAAC;IAEnB,IAAI,EAAE,MAAM,CAAC;IAEb,SAAS,EAAE,YAAY,CAAC;IAExB,SAAS,EAAE,MAAM,CAAC;CACnB;AAuBD,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAyC9D"}

package/dist/modern/kdf.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KDF_ALGORITHMS = void 0;
+exports.kdfDerive = kdfDerive;
+const scrypt_js_1 = require("@noble/hashes/scrypt.js");
+const hkdf_js_1 = require("@noble/hashes/hkdf.js");
+const pbkdf2_js_1 = require("@noble/hashes/pbkdf2.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+const cost_limits_1 = require("./cost-limits");
+exports.KDF_ALGORITHMS = [
+    "scrypt",
+    "hkdf-sha256",
+    "pbkdf2-sha256",
+];
+const HEX_RE = /^[0-9a-fA-F]*$/;
+function toBytes(input, encoding = "utf8") {
+    if (input instanceof Uint8Array)
+        return input;
+    if (encoding === "hex") {
+        if (!HEX_RE.test(input)) {
+            throw new Error("Invalid hex string");
+        }
+        return Buffer.from(input, "hex");
+    }
+    return Buffer.from(input, "utf8");
+}
+function kdfDerive(options) {
+    const password = toBytes(options.password, "utf8");
+    const salt = options.salt ? toBytes(options.salt, "hex") : (0, utils_js_1.randomBytes)(16);
+    const keyLength = options.keyLength ?? 32;
+    const params = options.params ?? {};
+    let derived;
+    switch (options.algorithm) {
+        case "scrypt": {
+            const N = params.N ?? 131072;
+            const r = params.r ?? 8;
+            const p = params.p ?? 1;
+            (0, cost_limits_1.checkScryptCosts)(N, r, p);
+            derived = (0, scrypt_js_1.scrypt)(password, salt, { N, r, p, dkLen: keyLength });
+            break;
+        }
+        case "hkdf-sha256": {
+            const info = params.info ? toBytes(params.info, "utf8") : undefined;
+            derived = (0, hkdf_js_1.hkdf)(sha2_js_1.sha256, password, salt, info, keyLength);
+            break;
+        }
+        case "pbkdf2-sha256": {
+            const iterations = params.iterations ?? 600000;
+            (0, cost_limits_1.checkPbkdf2Iterations)(iterations);
+            derived = (0, pbkdf2_js_1.pbkdf2)(sha2_js_1.sha256, password, salt, {
+                c: iterations,
+                dkLen: keyLength,
+            });
+            break;
+        }
+        default:
+            throw new Error(`Unsupported KDF algorithm: ${options.algorithm}`);
+    }
+    return {
+        derivedKey: Buffer.from(derived).toString("hex"),
+        salt: Buffer.from(salt).toString("hex"),
+        algorithm: options.algorithm,
+        keyLength,
+    };
+}
+//# sourceMappingURL=kdf.js.map