@sebastienrousseau/crypto-lib 0.0.2 → 0.0.8

package/dist/modern/mac.d.ts

@@ -0,0 +1,51 @@
+export declare const HMAC_ALGORITHMS: readonly ["sha256", "sha384", "sha512", "sha3-256", "sha3-512"];
+export type HmacAlgorithm = (typeof HMAC_ALGORITHMS)[number];
+export interface HmacComputeOptions {
+    algorithm: HmacAlgorithm;
+    key: string | Uint8Array;
+    data: string | Uint8Array;
+}
+export interface HmacComputeResult {
+    mac: string;
+    algorithm: HmacAlgorithm;
+}
+export interface HmacVerifyOptions {
+    algorithm: HmacAlgorithm;
+    key: string | Uint8Array;
+    data: string | Uint8Array;
+    mac: string;
+}
+export interface HmacVerifyResult {
+    valid: boolean;
+    algorithm: HmacAlgorithm;
+}
+export declare function computeHmac(options: HmacComputeOptions): HmacComputeResult;
+export declare function verifyHmac(options: HmacVerifyOptions): HmacVerifyResult;
+export declare const KMAC_ALGORITHMS: readonly ["kmac-128", "kmac-256"];
+export type KmacAlgorithm = (typeof KMAC_ALGORITHMS)[number];
+export interface KmacComputeOptions {
+    algorithm: KmacAlgorithm;
+    key: string | Uint8Array;
+    data: string | Uint8Array;
+    customization?: string | Uint8Array;
+    outputLength?: number;
+}
+export interface KmacComputeResult {
+    mac: string;
+    algorithm: KmacAlgorithm;
+}
+export interface KmacVerifyOptions {
+    algorithm: KmacAlgorithm;
+    key: string | Uint8Array;
+    data: string | Uint8Array;
+    mac: string;
+    customization?: string | Uint8Array;
+    outputLength?: number;
+}
+export interface KmacVerifyResult {
+    valid: boolean;
+    algorithm: KmacAlgorithm;
+}
+export declare function computeKmac(options: KmacComputeOptions): KmacComputeResult;
+export declare function verifyKmac(options: KmacVerifyOptions): KmacVerifyResult;
+//# sourceMappingURL=mac.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mac.d.ts","sourceRoot":"","sources":["../../src/modern/mac.ts"],"names":[],"mappings":"AAsBA,eAAO,MAAM,eAAe,iEAMlB,CAAC;AAGX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAG7D,MAAM,WAAW,kBAAkB;IAEjC,SAAS,EAAE,aAAa,CAAC;IAEzB,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CAC3B;AAGD,MAAM,WAAW,iBAAiB;IAEhC,GAAG,EAAE,MAAM,CAAC;IAEZ,SAAS,EAAE,aAAa,CAAC;CAC1B;AAGD,MAAM,WAAW,iBAAiB;IAEhC,SAAS,EAAE,aAAa,CAAC;IAEzB,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IAE1B,GAAG,EAAE,MAAM,CAAC;CACb;AAGD,MAAM,WAAW,gBAAgB;IAE/B,KAAK,EAAE,OAAO,CAAC;IAEf,SAAS,EAAE,aAAa,CAAC;CAC1B;AAmDD,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,iBAAiB,CAW1E;AAKD,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,CAavE;AAKD,eAAO,MAAM,eAAe,mCAAoC,CAAC;AAGjE,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAG7D,MAAM,WAAW,kBAAkB;IAEjC,SAAS,EAAE,aAAa,CAAC;IAEzB,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IAE1B,aAAa,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAEpC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAGD,MAAM,WAAW,iBAAiB;IAEhC,GAAG,EAAE,MAAM,CAAC;IAEZ,SAAS,EAAE,aAAa,CAAC;CAC1B;AAGD,MAAM,WAAW,iBAAiB;IAEhC,SAAS,EAAE,aAAa,CAAC;IAEzB,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;IAE1B,GAAG,EAAE,MAAM,CAAC;IAEZ,aAAa,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAEpC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAGD,MAAM,WAAW,gBAAgB;IAE/B,KAAK,EAAE,OAAO,CAAC;IAEf,SAAS,EAAE,aAAa,CAAC;CAC1B;AAoBD,wBAAgB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,iBAAiB,CA0B1E;AAKD,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,CA4BvE"}

package/dist/modern/mac.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KMAC_ALGORITHMS = exports.HMAC_ALGORITHMS = void 0;
+exports.computeHmac = computeHmac;
+exports.verifyHmac = verifyHmac;
+exports.computeKmac = computeKmac;
+exports.verifyKmac = verifyKmac;
+const hmac_js_1 = require("@noble/hashes/hmac.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const sha3_addons_js_1 = require("@noble/hashes/sha3-addons.js");
+const utils_1 = require("../utils");
+exports.HMAC_ALGORITHMS = [
+    "sha256",
+    "sha384",
+    "sha512",
+    "sha3-256",
+    "sha3-512",
+];
+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");
+}
+const hashFunctions = {
+    sha256: sha2_js_1.sha256,
+    sha384: sha2_js_1.sha384,
+    sha512: sha2_js_1.sha512,
+    "sha3-256": sha3_js_1.sha3_256,
+    "sha3-512": sha3_js_1.sha3_512,
+};
+function getHashFn(algorithm) {
+    const fn = hashFunctions[algorithm];
+    if (!fn) {
+        throw new Error(`Unsupported HMAC algorithm: ${algorithm}. Supported: ${exports.HMAC_ALGORITHMS.join(", ")}`);
+    }
+    return fn;
+}
+function computeHmac(options) {
+    const hashFn = getHashFn(options.algorithm);
+    const key = toBytes(options.key, "hex");
+    const data = toBytes(options.data, "utf8");
+    const mac = (0, hmac_js_1.hmac)(hashFn, key, data);
+    return {
+        mac: Buffer.from(mac).toString("hex"),
+        algorithm: options.algorithm,
+    };
+}
+function verifyHmac(options) {
+    const hashFn = getHashFn(options.algorithm);
+    const key = toBytes(options.key, "hex");
+    const data = toBytes(options.data, "utf8");
+    const expectedMac = toBytes(options.mac, "hex");
+    const computedMac = (0, hmac_js_1.hmac)(hashFn, key, data);
+    const valid = (0, utils_1.timingSafeEqual)(computedMac, expectedMac);
+    return {
+        valid,
+        algorithm: options.algorithm,
+    };
+}
+exports.KMAC_ALGORITHMS = ["kmac-128", "kmac-256"];
+const kmacFunctions = {
+    "kmac-128": sha3_addons_js_1.kmac128,
+    "kmac-256": sha3_addons_js_1.kmac256,
+};
+const kmacDefaultLength = {
+    "kmac-128": 32,
+    "kmac-256": 64,
+};
+function computeKmac(options) {
+    const fn = kmacFunctions[options.algorithm];
+    if (!fn) {
+        throw new Error(`Unsupported KMAC algorithm: ${options.algorithm}. Supported: ${exports.KMAC_ALGORITHMS.join(", ")}`);
+    }
+    const key = toBytes(options.key, "hex");
+    const data = toBytes(options.data, "utf8");
+    const outputLength = options.outputLength ?? kmacDefaultLength[options.algorithm];
+    const opts = {
+        dkLen: outputLength,
+    };
+    if (options.customization) {
+        opts.personalization = toBytes(options.customization, "utf8");
+    }
+    const mac = fn(key, data, opts);
+    return {
+        mac: Buffer.from(mac).toString("hex"),
+        algorithm: options.algorithm,
+    };
+}
+function verifyKmac(options) {
+    const fn = kmacFunctions[options.algorithm];
+    if (!fn) {
+        throw new Error(`Unsupported KMAC algorithm: ${options.algorithm}. Supported: ${exports.KMAC_ALGORITHMS.join(", ")}`);
+    }
+    const key = toBytes(options.key, "hex");
+    const data = toBytes(options.data, "utf8");
+    const expectedMac = toBytes(options.mac, "hex");
+    const outputLength = options.outputLength ?? kmacDefaultLength[options.algorithm];
+    const verifyOpts = {
+        dkLen: outputLength,
+    };
+    if (options.customization) {
+        verifyOpts.personalization = toBytes(options.customization, "utf8");
+    }
+    const computedMac = fn(key, data, verifyOpts);
+    const valid = (0, utils_1.timingSafeEqual)(computedMac, expectedMac);
+    return {
+        valid,
+        algorithm: options.algorithm,
+    };
+}
+//# sourceMappingURL=mac.js.map

package/dist/modern/password.d.ts

@@ -0,0 +1,40 @@
+export type Argon2Variant = "argon2id" | "argon2i" | "argon2d";
+export interface Argon2Params {
+    t: number;
+    m: number;
+    p: number;
+}
+export interface HashPasswordOptions {
+    password: string | Uint8Array;
+    salt?: string | Uint8Array;
+    timeCost?: number;
+    memoryCost?: number;
+    parallelism?: number;
+    hashLength?: number;
+    variant?: Argon2Variant;
+}
+export interface HashPasswordResult {
+    hash: string;
+    salt: string;
+    params: Argon2Params;
+    algorithm: Argon2Variant;
+    phc: string;
+}
+export interface VerifyPasswordOptions {
+    password: string | Uint8Array;
+    hash: string;
+    salt: string;
+    params: Argon2Params;
+    variant?: Argon2Variant;
+}
+export interface VerifyPasswordResult {
+    valid: boolean;
+}
+export interface VerifyPhcOptions {
+    password: string | Uint8Array;
+    phc: string;
+}
+export declare function hashPassword(options: HashPasswordOptions): HashPasswordResult;
+export declare function verifyPassword(options: VerifyPasswordOptions): VerifyPasswordResult;
+export declare function verifyPasswordPhc(options: VerifyPhcOptions): VerifyPasswordResult;
+//# sourceMappingURL=password.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"password.d.ts","sourceRoot":"","sources":["../../src/modern/password.ts"],"names":[],"mappings":"AA2BA,MAAM,MAAM,aAAa,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,CAAC;AAG/D,MAAM,WAAW,YAAY;IAE3B,CAAC,EAAE,MAAM,CAAC;IAEV,CAAC,EAAE,MAAM,CAAC;IAEV,CAAC,EAAE,MAAM,CAAC;CACX;AAGD,MAAM,WAAW,mBAAmB;IAElC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAC;IAE9B,IAAI,CAAC,EAAE,MAAM,GAAG,UAAU,CAAC;IAE3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAGD,MAAM,WAAW,kBAAkB;IAEjC,IAAI,EAAE,MAAM,CAAC;IAEb,IAAI,EAAE,MAAM,CAAC;IAEb,MAAM,EAAE,YAAY,CAAC;IAErB,SAAS,EAAE,aAAa,CAAC;IAEzB,GAAG,EAAE,MAAM,CAAC;CACb;AAGD,MAAM,WAAW,qBAAqB;IAEpC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAC;IAE9B,IAAI,EAAE,MAAM,CAAC;IAEb,IAAI,EAAE,MAAM,CAAC;IAEb,MAAM,EAAE,YAAY,CAAC;IAErB,OAAO,CAAC,EAAE,aAAa,CAAC;CACzB;AAGD,MAAM,WAAW,oBAAoB;IAEnC,KAAK,EAAE,OAAO,CAAC;CAChB;AAGD,MAAM,WAAW,gBAAgB;IAE/B,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAC;IAE9B,GAAG,EAAE,MAAM,CAAC;CACb;AAuGD,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,kBAAkB,CAuB7E;AAKD,wBAAgB,cAAc,CAC5B,OAAO,EAAE,qBAAqB,GAC7B,oBAAoB,CActB;AAWD,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,gBAAgB,GACxB,oBAAoB,CAgBtB"}

package/dist/modern/password.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashPassword = hashPassword;
+exports.verifyPassword = verifyPassword;
+exports.verifyPasswordPhc = verifyPasswordPhc;
+const argon2_js_1 = require("@noble/hashes/argon2.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+const utils_1 = require("../utils");
+const cost_limits_1 = require("./cost-limits");
+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 getArgon2Fn(variant) {
+    switch (variant) {
+        case "argon2id":
+            return argon2_js_1.argon2id;
+        case "argon2i":
+            return argon2_js_1.argon2i;
+        case "argon2d":
+            return argon2_js_1.argon2d;
+        default:
+            throw new Error(`Unsupported Argon2 variant: ${variant}. Supported: argon2id, argon2i, argon2d`);
+    }
+}
+function toPhcString(variant, params, salt, hash) {
+    let saltB64 = Buffer.from(salt).toString("base64");
+    while (saltB64.endsWith("="))
+        saltB64 = saltB64.slice(0, -1);
+    let hashB64 = Buffer.from(hash).toString("base64");
+    while (hashB64.endsWith("="))
+        hashB64 = hashB64.slice(0, -1);
+    return `$${variant}$v=19$m=${params.m},t=${params.t},p=${params.p}$${saltB64}$${hashB64}`;
+}
+function parsePhcString(phc) {
+    const parts = phc.split("$").filter(Boolean);
+    if (parts.length < 5) {
+        throw new Error("Invalid PHC string format");
+    }
+    const variant = parts[0];
+    if (!["argon2id", "argon2i", "argon2d"].includes(variant)) {
+        throw new Error(`Unsupported variant in PHC string: ${variant}`);
+    }
+    const paramStr = parts[2];
+    const paramParts = paramStr.split(",");
+    const paramMap = {};
+    for (const p of paramParts) {
+        const [k, v] = p.split("=");
+        paramMap[k] = parseInt(v, 10);
+    }
+    const params = {
+        m: paramMap["m"],
+        t: paramMap["t"],
+        p: paramMap["p"],
+    };
+    const salt = Buffer.from(parts[3], "base64");
+    const hash = Buffer.from(parts[4], "base64");
+    return { variant, params, salt, hash };
+}
+const DEFAULT_TIME_COST = 3;
+const DEFAULT_MEMORY_COST = 65536;
+const DEFAULT_PARALLELISM = 4;
+const DEFAULT_HASH_LENGTH = 32;
+const DEFAULT_SALT_LENGTH = 16;
+function hashPassword(options) {
+    const variant = options.variant ?? "argon2id";
+    const argon2Fn = getArgon2Fn(variant);
+    const password = toBytes(options.password, "utf8");
+    const salt = options.salt
+        ? toBytes(options.salt, "hex")
+        : (0, utils_js_1.randomBytes)(DEFAULT_SALT_LENGTH);
+    const t = options.timeCost ?? DEFAULT_TIME_COST;
+    const m = options.memoryCost ?? DEFAULT_MEMORY_COST;
+    const p = options.parallelism ?? DEFAULT_PARALLELISM;
+    const dkLen = options.hashLength ?? DEFAULT_HASH_LENGTH;
+    (0, cost_limits_1.checkArgon2Costs)(t, m, p);
+    const hash = argon2Fn(password, salt, { t, m, p, dkLen });
+    const params = { t, m, p };
+    return {
+        hash: Buffer.from(hash).toString("hex"),
+        salt: Buffer.from(salt).toString("hex"),
+        params,
+        algorithm: variant,
+        phc: toPhcString(variant, params, salt, hash),
+    };
+}
+function verifyPassword(options) {
+    const variant = options.variant ?? "argon2id";
+    const argon2Fn = getArgon2Fn(variant);
+    const password = toBytes(options.password, "utf8");
+    const salt = toBytes(options.salt, "hex");
+    const expectedHash = toBytes(options.hash, "hex");
+    const { t, m, p } = options.params;
+    (0, cost_limits_1.checkArgon2Costs)(t, m, p);
+    const dkLen = expectedHash.length;
+    const computedHash = argon2Fn(password, salt, { t, m, p, dkLen });
+    const valid = (0, utils_1.timingSafeEqual)(computedHash, expectedHash);
+    return { valid };
+}
+function verifyPasswordPhc(options) {
+    const { variant, params, salt, hash } = parsePhcString(options.phc);
+    const argon2Fn = getArgon2Fn(variant);
+    const password = toBytes(options.password, "utf8");
+    const dkLen = hash.length;
+    (0, cost_limits_1.checkArgon2Costs)(params.t, params.m, params.p);
+    const computedHash = argon2Fn(password, salt, {
+        t: params.t,
+        m: params.m,
+        p: params.p,
+        dkLen,
+    });
+    const valid = (0, utils_1.timingSafeEqual)(computedHash, hash);
+    return { valid };
+}
+//# sourceMappingURL=password.js.map

package/dist/modern/pq-hash-sign.d.ts

@@ -0,0 +1,18 @@
+export type SlhDsaVariant = "sha2-128f" | "sha2-128s" | "sha2-192f" | "sha2-192s" | "sha2-256f" | "sha2-256s" | "shake-128f" | "shake-128s" | "shake-192f" | "shake-192s" | "shake-256f" | "shake-256s";
+export interface SlhDsaKeyPairResult {
+    publicKey: string;
+    secretKey: string;
+    algorithm: string;
+}
+export interface SlhDsaSignResult {
+    signature: string;
+    algorithm: string;
+}
+export interface SlhDsaVerifyResult {
+    valid: boolean;
+    algorithm: string;
+}
+export declare function slhDsaKeygen(variant: SlhDsaVariant): SlhDsaKeyPairResult;
+export declare function slhDsaSign(variant: SlhDsaVariant, secretKeyHex: string, message: string | Uint8Array): SlhDsaSignResult;
+export declare function slhDsaVerify(variant: SlhDsaVariant, publicKeyHex: string, message: string | Uint8Array, signatureHex: string): SlhDsaVerifyResult;
+//# sourceMappingURL=pq-hash-sign.d.ts.map

package/dist/modern/pq-hash-sign.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pq-hash-sign.d.ts","sourceRoot":"","sources":["../../src/modern/pq-hash-sign.ts"],"names":[],"mappings":"AAqCA,MAAM,MAAM,aAAa,GACrB,WAAW,GACX,WAAW,GACX,WAAW,GACX,WAAW,GACX,WAAW,GACX,WAAW,GACX,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,YAAY,GACZ,YAAY,CAAC;AAGjB,MAAM,WAAW,mBAAmB;IAElC,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,MAAM,CAAC;CACnB;AAGD,MAAM,WAAW,gBAAgB;IAE/B,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,MAAM,CAAC;CACnB;AAGD,MAAM,WAAW,kBAAkB;IAEjC,KAAK,EAAE,OAAO,CAAC;IAEf,SAAS,EAAE,MAAM,CAAC;CACnB;AA0DD,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,mBAAmB,CAQxE;AAKD,wBAAgB,UAAU,CACxB,OAAO,EAAE,aAAa,EACtB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,GAAG,UAAU,GAC3B,gBAAgB,CASlB;AAKD,wBAAgB,YAAY,CAC1B,OAAO,EAAE,aAAa,EACtB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,GAAG,UAAU,EAC5B,YAAY,EAAE,MAAM,GACnB,kBAAkB,CAUpB"}

package/dist/modern/pq-hash-sign.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slhDsaKeygen = slhDsaKeygen;
+exports.slhDsaSign = slhDsaSign;
+exports.slhDsaVerify = slhDsaVerify;
+const slh_dsa_js_1 = require("@noble/post-quantum/slh-dsa.js");
+const HEX_RE = /^[0-9a-fA-F]*$/;
+function assertHex(input, label) {
+    if (!HEX_RE.test(input)) {
+        throw new Error(`Invalid hex string for ${label}`);
+    }
+    return Buffer.from(input, "hex");
+}
+function toBytes(input) {
+    if (input instanceof Uint8Array)
+        return input;
+    return Buffer.from(input, "utf8");
+}
+const SLH_DSA_VARIANTS = {
+    "sha2-128f": slh_dsa_js_1.slh_dsa_sha2_128f,
+    "sha2-128s": slh_dsa_js_1.slh_dsa_sha2_128s,
+    "sha2-192f": slh_dsa_js_1.slh_dsa_sha2_192f,
+    "sha2-192s": slh_dsa_js_1.slh_dsa_sha2_192s,
+    "sha2-256f": slh_dsa_js_1.slh_dsa_sha2_256f,
+    "sha2-256s": slh_dsa_js_1.slh_dsa_sha2_256s,
+    "shake-128f": slh_dsa_js_1.slh_dsa_shake_128f,
+    "shake-128s": slh_dsa_js_1.slh_dsa_shake_128s,
+    "shake-192f": slh_dsa_js_1.slh_dsa_shake_192f,
+    "shake-192s": slh_dsa_js_1.slh_dsa_shake_192s,
+    "shake-256f": slh_dsa_js_1.slh_dsa_shake_256f,
+    "shake-256s": slh_dsa_js_1.slh_dsa_shake_256s,
+};
+function getVariant(variant) {
+    const impl = SLH_DSA_VARIANTS[variant];
+    if (!impl) {
+        throw new Error(`Unsupported SLH-DSA variant: ${variant}. Supported: ${Object.keys(SLH_DSA_VARIANTS).join(", ")}`);
+    }
+    return impl;
+}
+function algorithmName(variant) {
+    return `slh-dsa-${variant}`;
+}
+function slhDsaKeygen(variant) {
+    const dsa = getVariant(variant);
+    const { publicKey, secretKey } = dsa.keygen();
+    return {
+        publicKey: Buffer.from(publicKey).toString("hex"),
+        secretKey: Buffer.from(secretKey).toString("hex"),
+        algorithm: algorithmName(variant),
+    };
+}
+function slhDsaSign(variant, secretKeyHex, message) {
+    const dsa = getVariant(variant);
+    const secretKey = assertHex(secretKeyHex, "secretKey");
+    const msg = toBytes(message);
+    const signature = dsa.sign(msg, secretKey);
+    return {
+        signature: Buffer.from(signature).toString("hex"),
+        algorithm: algorithmName(variant),
+    };
+}
+function slhDsaVerify(variant, publicKeyHex, message, signatureHex) {
+    const dsa = getVariant(variant);
+    const publicKey = assertHex(publicKeyHex, "publicKey");
+    const msg = toBytes(message);
+    const signature = assertHex(signatureHex, "signature");
+    const valid = dsa.verify(signature, msg, publicKey);
+    return {
+        valid,
+        algorithm: algorithmName(variant),
+    };
+}
+//# sourceMappingURL=pq-hash-sign.js.map

package/dist/modern/pq-kem.d.ts

@@ -0,0 +1,88 @@
+export type MlKemLevel = 512 | 768 | 1024;
+export type MlKemAlgorithm = "ml-kem-512" | "ml-kem-768" | "ml-kem-1024";
+export declare const RFC10024_X25519_MLKEM768: "X25519MLKEM768";
+export declare const RFC10024_SECP256R1_MLKEM768: "SecP256r1MLKEM768";
+export declare const RFC10024_CODEPOINTS: {
+    readonly SecP256r1MLKEM768: 4587;
+    readonly X25519MLKEM768: 4588;
+};
+export type HybridKemAlgorithm = "x25519-ml-kem-512" | "x25519-ml-kem-768" | "x25519-ml-kem-1024" | "p256-ml-kem-768" | "x448-ml-kem-1024";
+export declare function normalizeHybridKemAlgorithm(name: HybridKemAlgorithm | string): string;
+export interface MlKemKeyPairResult {
+    publicKey: string;
+    secretKey: string;
+    algorithm: MlKemAlgorithm;
+}
+export interface MlKemEncapsulateResult {
+    ciphertext: string;
+    sharedSecret: string;
+    algorithm: MlKemAlgorithm;
+}
+export interface MlKemDecapsulateResult {
+    sharedSecret: string;
+    algorithm: MlKemAlgorithm;
+}
+export interface HybridKemKeyPair {
+    x25519PrivateKey: string;
+    x25519PublicKey: string;
+    mlKemPublicKey: string;
+    mlKemSecretKey: string;
+    algorithm: HybridKemAlgorithm;
+}
+export interface HybridKemEncapsulateResult {
+    x25519EphemeralPublic: string;
+    mlKemCiphertext: string;
+    sharedSecret: string;
+    algorithm: HybridKemAlgorithm;
+}
+export interface HybridKemDecapsulateResult {
+    sharedSecret: string;
+    algorithm: HybridKemAlgorithm;
+}
+export declare function mlKemKeygen(level: MlKemLevel): MlKemKeyPairResult;
+export declare function mlKemEncapsulate(level: MlKemLevel, publicKeyHex: string): MlKemEncapsulateResult;
+export declare function mlKemDecapsulate(level: MlKemLevel, secretKeyHex: string, ciphertextHex: string): MlKemDecapsulateResult;
+export declare function hybridKemKeygen(kemLevel?: MlKemLevel): HybridKemKeyPair;
+export declare function hybridKemEncapsulate(kemLevel: MlKemLevel, theirX25519Public: string, theirMlKemPublic: string): HybridKemEncapsulateResult;
+export declare function hybridKemDecapsulate(kemLevel: MlKemLevel, ourX25519Private: string, ourMlKemSecret: string, theirX25519Ephemeral: string, mlKemCiphertext: string): HybridKemDecapsulateResult;
+export interface P256MlKemKeyPair {
+    p256PrivateKey: string;
+    p256PublicKey: string;
+    mlKemPublicKey: string;
+    mlKemSecretKey: string;
+    algorithm: "p256-ml-kem-768";
+}
+export interface P256MlKemEncapsulateResult {
+    p256EphemeralPublic: string;
+    mlKemCiphertext: string;
+    sharedSecret: string;
+    algorithm: "p256-ml-kem-768";
+}
+export interface P256MlKemDecapsulateResult {
+    sharedSecret: string;
+    algorithm: "p256-ml-kem-768";
+}
+export declare function p256MlKemKeygen(): P256MlKemKeyPair;
+export declare function p256MlKemEncapsulate(theirP256Public: string, theirMlKemPublic: string): P256MlKemEncapsulateResult;
+export declare function p256MlKemDecapsulate(ourP256Private: string, ourMlKemSecret: string, theirP256Ephemeral: string, mlKemCiphertext: string): P256MlKemDecapsulateResult;
+export interface X448MlKemKeyPair {
+    x448PrivateKey: string;
+    x448PublicKey: string;
+    mlKemPublicKey: string;
+    mlKemSecretKey: string;
+    algorithm: "x448-ml-kem-1024";
+}
+export interface X448MlKemEncapsulateResult {
+    x448EphemeralPublic: string;
+    mlKemCiphertext: string;
+    sharedSecret: string;
+    algorithm: "x448-ml-kem-1024";
+}
+export interface X448MlKemDecapsulateResult {
+    sharedSecret: string;
+    algorithm: "x448-ml-kem-1024";
+}
+export declare function x448MlKemKeygen(): X448MlKemKeyPair;
+export declare function x448MlKemEncapsulate(theirX448Public: string, theirMlKemPublic: string): X448MlKemEncapsulateResult;
+export declare function x448MlKemDecapsulate(ourX448Private: string, ourMlKemSecret: string, theirX448Ephemeral: string, mlKemCiphertext: string): X448MlKemDecapsulateResult;
+//# sourceMappingURL=pq-kem.d.ts.map

package/dist/modern/pq-kem.d.ts.map

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