@sebastienrousseau/crypto-lib 0.0.3 → 0.0.8

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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"}

package/dist/modern/pq-kem.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RFC10024_CODEPOINTS = exports.RFC10024_SECP256R1_MLKEM768 = exports.RFC10024_X25519_MLKEM768 = void 0;
+exports.normalizeHybridKemAlgorithm = normalizeHybridKemAlgorithm;
+exports.mlKemKeygen = mlKemKeygen;
+exports.mlKemEncapsulate = mlKemEncapsulate;
+exports.mlKemDecapsulate = mlKemDecapsulate;
+exports.hybridKemKeygen = hybridKemKeygen;
+exports.hybridKemEncapsulate = hybridKemEncapsulate;
+exports.hybridKemDecapsulate = hybridKemDecapsulate;
+exports.p256MlKemKeygen = p256MlKemKeygen;
+exports.p256MlKemEncapsulate = p256MlKemEncapsulate;
+exports.p256MlKemDecapsulate = p256MlKemDecapsulate;
+exports.x448MlKemKeygen = x448MlKemKeygen;
+exports.x448MlKemEncapsulate = x448MlKemEncapsulate;
+exports.x448MlKemDecapsulate = x448MlKemDecapsulate;
+const ml_kem_js_1 = require("@noble/post-quantum/ml-kem.js");
+const ed25519_js_1 = require("@noble/curves/ed25519.js");
+const ed448_js_1 = require("@noble/curves/ed448.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 utils_js_1 = require("@noble/ciphers/utils.js");
+exports.RFC10024_X25519_MLKEM768 = "X25519MLKEM768";
+exports.RFC10024_SECP256R1_MLKEM768 = "SecP256r1MLKEM768";
+exports.RFC10024_CODEPOINTS = {
+    [exports.RFC10024_SECP256R1_MLKEM768]: 0x11eb,
+    [exports.RFC10024_X25519_MLKEM768]: 0x11ec,
+};
+function normalizeHybridKemAlgorithm(name) {
+    if (name === exports.RFC10024_X25519_MLKEM768 ||
+        name === exports.RFC10024_SECP256R1_MLKEM768) {
+        throw new Error(`${name} (RFC 10024 TLS group) is not implemented by this library; ` +
+            "its hybrid KEMs use a different combiner and do not interoperate");
+    }
+    return name;
+}
+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 getKem(level) {
+    switch (level) {
+        case 512:
+            return ml_kem_js_1.ml_kem512;
+        case 768:
+            return ml_kem_js_1.ml_kem768;
+        case 1024:
+            return ml_kem_js_1.ml_kem1024;
+        default:
+            throw new Error(`Unsupported ML-KEM level: ${level}. Supported: 512, 768, 1024`);
+    }
+}
+function algorithmName(level) {
+    return `ml-kem-${level}`;
+}
+function lengthPrefixed(bytes) {
+    const out = new Uint8Array(4 + bytes.length);
+    new DataView(out.buffer).setUint32(0, bytes.length, false);
+    out.set(bytes, 4);
+    return out;
+}
+function combineHybrid(t) {
+    const ikm = Buffer.concat([t.ssClassical, t.ssMlKem]);
+    const info = Buffer.concat([
+        lengthPrefixed(Buffer.from(`crypto-service/hybrid-kem/v2/${t.algorithm}`)),
+        lengthPrefixed(t.ctClassical),
+        lengthPrefixed(t.pkClassical),
+        lengthPrefixed(t.ctMlKem),
+        lengthPrefixed(t.pkMlKem),
+    ]);
+    return (0, hkdf_js_1.hkdf)(sha2_js_1.sha256, ikm, undefined, info, 32);
+}
+function toHex(bytes) {
+    return Buffer.from(bytes).toString("hex");
+}
+function hybridAlgorithmName(level) {
+    return `x25519-ml-kem-${level}`;
+}
+function mlKemKeygen(level) {
+    const kem = getKem(level);
+    const { publicKey, secretKey } = kem.keygen();
+    return {
+        publicKey: Buffer.from(publicKey).toString("hex"),
+        secretKey: Buffer.from(secretKey).toString("hex"),
+        algorithm: algorithmName(level),
+    };
+}
+function mlKemEncapsulate(level, publicKeyHex) {
+    const kem = getKem(level);
+    const publicKey = assertHex(publicKeyHex, "publicKey");
+    const { cipherText, sharedSecret } = kem.encapsulate(publicKey);
+    return {
+        ciphertext: Buffer.from(cipherText).toString("hex"),
+        sharedSecret: Buffer.from(sharedSecret).toString("hex"),
+        algorithm: algorithmName(level),
+    };
+}
+function mlKemDecapsulate(level, secretKeyHex, ciphertextHex) {
+    const kem = getKem(level);
+    const secretKey = assertHex(secretKeyHex, "secretKey");
+    const cipherText = assertHex(ciphertextHex, "ciphertext");
+    const sharedSecret = kem.decapsulate(cipherText, secretKey);
+    return {
+        sharedSecret: Buffer.from(sharedSecret).toString("hex"),
+        algorithm: algorithmName(level),
+    };
+}
+function hybridKemKeygen(kemLevel = 768) {
+    const kem = getKem(kemLevel);
+    const x25519Priv = (0, utils_js_1.randomBytes)(32);
+    const x25519Pub = ed25519_js_1.x25519.getPublicKey(x25519Priv);
+    const { publicKey: mlKemPub, secretKey: mlKemSec } = kem.keygen();
+    return {
+        x25519PrivateKey: Buffer.from(x25519Priv).toString("hex"),
+        x25519PublicKey: Buffer.from(x25519Pub).toString("hex"),
+        mlKemPublicKey: Buffer.from(mlKemPub).toString("hex"),
+        mlKemSecretKey: Buffer.from(mlKemSec).toString("hex"),
+        algorithm: hybridAlgorithmName(kemLevel),
+    };
+}
+function hybridKemEncapsulate(kemLevel, theirX25519Public, theirMlKemPublic) {
+    const kem = getKem(kemLevel);
+    const pkClassical = assertHex(theirX25519Public, "theirX25519Public");
+    const pkMlKem = assertHex(theirMlKemPublic, "theirMlKemPublic");
+    const ephemeralPriv = (0, utils_js_1.randomBytes)(32);
+    const ephemeralPub = ed25519_js_1.x25519.getPublicKey(ephemeralPriv);
+    const ssClassical = ed25519_js_1.x25519.getSharedSecret(ephemeralPriv, pkClassical);
+    const { cipherText, sharedSecret: ssMlKem } = kem.encapsulate(pkMlKem);
+    const algorithm = hybridAlgorithmName(kemLevel);
+    const derived = combineHybrid({
+        algorithm,
+        ssClassical,
+        ssMlKem,
+        ctClassical: ephemeralPub,
+        pkClassical,
+        ctMlKem: cipherText,
+        pkMlKem,
+    });
+    return {
+        x25519EphemeralPublic: toHex(ephemeralPub),
+        mlKemCiphertext: toHex(cipherText),
+        sharedSecret: toHex(derived),
+        algorithm,
+    };
+}
+function hybridKemDecapsulate(kemLevel, ourX25519Private, ourMlKemSecret, theirX25519Ephemeral, mlKemCiphertext) {
+    const kem = getKem(kemLevel);
+    const priv = assertHex(ourX25519Private, "ourX25519Private");
+    const ctClassical = assertHex(theirX25519Ephemeral, "theirX25519Ephemeral");
+    const ctMlKem = assertHex(mlKemCiphertext, "mlKemCiphertext");
+    const mlKemSecret = assertHex(ourMlKemSecret, "ourMlKemSecret");
+    const algorithm = hybridAlgorithmName(kemLevel);
+    const derived = combineHybrid({
+        algorithm,
+        ssClassical: ed25519_js_1.x25519.getSharedSecret(priv, ctClassical),
+        ssMlKem: kem.decapsulate(ctMlKem, mlKemSecret),
+        ctClassical,
+        pkClassical: ed25519_js_1.x25519.getPublicKey(priv),
+        ctMlKem,
+        pkMlKem: kem.getPublicKey(mlKemSecret),
+    });
+    return { sharedSecret: toHex(derived), algorithm };
+}
+function p256MlKemKeygen() {
+    const p256Priv = nist_js_1.p256.utils.randomSecretKey();
+    const p256Pub = nist_js_1.p256.getPublicKey(p256Priv, false);
+    const { publicKey: mlKemPub, secretKey: mlKemSec } = ml_kem_js_1.ml_kem768.keygen();
+    return {
+        p256PrivateKey: Buffer.from(p256Priv).toString("hex"),
+        p256PublicKey: Buffer.from(p256Pub).toString("hex"),
+        mlKemPublicKey: Buffer.from(mlKemPub).toString("hex"),
+        mlKemSecretKey: Buffer.from(mlKemSec).toString("hex"),
+        algorithm: "p256-ml-kem-768",
+    };
+}
+function p256MlKemEncapsulate(theirP256Public, theirMlKemPublic) {
+    const pkClassical = nist_js_1.p256.Point.fromBytes(assertHex(theirP256Public, "theirP256Public")).toBytes(false);
+    const pkMlKem = assertHex(theirMlKemPublic, "theirMlKemPublic");
+    const ephemeralPriv = nist_js_1.p256.utils.randomSecretKey();
+    const ephemeralPub = nist_js_1.p256.getPublicKey(ephemeralPriv, false);
+    const ssClassical = nist_js_1.p256.getSharedSecret(ephemeralPriv, pkClassical);
+    const { cipherText, sharedSecret: ssMlKem } = ml_kem_js_1.ml_kem768.encapsulate(pkMlKem);
+    const derived = combineHybrid({
+        algorithm: "p256-ml-kem-768",
+        ssClassical,
+        ssMlKem,
+        ctClassical: ephemeralPub,
+        pkClassical,
+        ctMlKem: cipherText,
+        pkMlKem,
+    });
+    return {
+        p256EphemeralPublic: toHex(ephemeralPub),
+        mlKemCiphertext: toHex(cipherText),
+        sharedSecret: toHex(derived),
+        algorithm: "p256-ml-kem-768",
+    };
+}
+function p256MlKemDecapsulate(ourP256Private, ourMlKemSecret, theirP256Ephemeral, mlKemCiphertext) {
+    const priv = assertHex(ourP256Private, "ourP256Private");
+    const ctClassical = assertHex(theirP256Ephemeral, "theirP256Ephemeral");
+    const ctMlKem = assertHex(mlKemCiphertext, "mlKemCiphertext");
+    const mlKemSecret = assertHex(ourMlKemSecret, "ourMlKemSecret");
+    const derived = combineHybrid({
+        algorithm: "p256-ml-kem-768",
+        ssClassical: nist_js_1.p256.getSharedSecret(priv, ctClassical),
+        ssMlKem: ml_kem_js_1.ml_kem768.decapsulate(ctMlKem, mlKemSecret),
+        ctClassical,
+        pkClassical: nist_js_1.p256.getPublicKey(priv, false),
+        ctMlKem,
+        pkMlKem: ml_kem_js_1.ml_kem768.getPublicKey(mlKemSecret),
+    });
+    return { sharedSecret: toHex(derived), algorithm: "p256-ml-kem-768" };
+}
+function x448MlKemKeygen() {
+    const x448Priv = ed448_js_1.x448.utils.randomSecretKey();
+    const x448Pub = ed448_js_1.x448.getPublicKey(x448Priv);
+    const { publicKey: mlKemPub, secretKey: mlKemSec } = ml_kem_js_1.ml_kem1024.keygen();
+    return {
+        x448PrivateKey: Buffer.from(x448Priv).toString("hex"),
+        x448PublicKey: Buffer.from(x448Pub).toString("hex"),
+        mlKemPublicKey: Buffer.from(mlKemPub).toString("hex"),
+        mlKemSecretKey: Buffer.from(mlKemSec).toString("hex"),
+        algorithm: "x448-ml-kem-1024",
+    };
+}
+function x448MlKemEncapsulate(theirX448Public, theirMlKemPublic) {
+    const pkClassical = assertHex(theirX448Public, "theirX448Public");
+    const pkMlKem = assertHex(theirMlKemPublic, "theirMlKemPublic");
+    const ephemeralPriv = ed448_js_1.x448.utils.randomSecretKey();
+    const ephemeralPub = ed448_js_1.x448.getPublicKey(ephemeralPriv);
+    const ssClassical = ed448_js_1.x448.getSharedSecret(ephemeralPriv, pkClassical);
+    const { cipherText, sharedSecret: ssMlKem } = ml_kem_js_1.ml_kem1024.encapsulate(pkMlKem);
+    const derived = combineHybrid({
+        algorithm: "x448-ml-kem-1024",
+        ssClassical,
+        ssMlKem,
+        ctClassical: ephemeralPub,
+        pkClassical,
+        ctMlKem: cipherText,
+        pkMlKem,
+    });
+    return {
+        x448EphemeralPublic: toHex(ephemeralPub),
+        mlKemCiphertext: toHex(cipherText),
+        sharedSecret: toHex(derived),
+        algorithm: "x448-ml-kem-1024",
+    };
+}
+function x448MlKemDecapsulate(ourX448Private, ourMlKemSecret, theirX448Ephemeral, mlKemCiphertext) {
+    const priv = assertHex(ourX448Private, "ourX448Private");
+    const ctClassical = assertHex(theirX448Ephemeral, "theirX448Ephemeral");
+    const ctMlKem = assertHex(mlKemCiphertext, "mlKemCiphertext");
+    const mlKemSecret = assertHex(ourMlKemSecret, "ourMlKemSecret");
+    const derived = combineHybrid({
+        algorithm: "x448-ml-kem-1024",
+        ssClassical: ed448_js_1.x448.getSharedSecret(priv, ctClassical),
+        ssMlKem: ml_kem_js_1.ml_kem1024.decapsulate(ctMlKem, mlKemSecret),
+        ctClassical,
+        pkClassical: ed448_js_1.x448.getPublicKey(priv),
+        ctMlKem,
+        pkMlKem: ml_kem_js_1.ml_kem1024.getPublicKey(mlKemSecret),
+    });
+    return { sharedSecret: toHex(derived), algorithm: "x448-ml-kem-1024" };
+}
+//# sourceMappingURL=pq-kem.js.map

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

@@ -0,0 +1,30 @@
+export type MlDsaLevel = 44 | 65 | 87;
+export type MlDsaAlgorithm = "ml-dsa-44" | "ml-dsa-65" | "ml-dsa-87";
+export interface MlDsaKeyPairResult {
+    publicKey: string;
+    secretKey: string;
+    algorithm: MlDsaAlgorithm;
+}
+export interface MlDsaSignResult {
+    signature: string;
+    algorithm: MlDsaAlgorithm;
+}
+export interface MlDsaVerifyResult {
+    valid: boolean;
+    algorithm: MlDsaAlgorithm;
+}
+export interface HybridSignResult {
+    ed25519Signature: string;
+    mlDsaSignature: string;
+    algorithm: string;
+}
+export interface HybridVerifyResult {
+    valid: boolean;
+    algorithm: string;
+}
+export declare function mlDsaKeygen(level: MlDsaLevel): MlDsaKeyPairResult;
+export declare function mlDsaSign(level: MlDsaLevel, secretKeyHex: string, message: string | Uint8Array): MlDsaSignResult;
+export declare function mlDsaVerify(level: MlDsaLevel, publicKeyHex: string, message: string | Uint8Array, signatureHex: string): MlDsaVerifyResult;
+export declare function hybridSign(secretKeyEd25519Hex: string, secretKeyMlDsaHex: string, message: string | Uint8Array, mlDsaLevel?: MlDsaLevel): HybridSignResult;
+export declare function hybridVerify(pubKeyEd25519Hex: string, pubKeyMlDsaHex: string, message: string | Uint8Array, sigEd25519Hex: string, sigMlDsaHex: string, mlDsaLevel?: MlDsaLevel): HybridVerifyResult;
+//# sourceMappingURL=pq-sign.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pq-sign.d.ts","sourceRoot":"","sources":["../../src/modern/pq-sign.ts"],"names":[],"mappings":"AAsBA,MAAM,MAAM,UAAU,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;AAGtC,MAAM,MAAM,cAAc,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC;AAGrE,MAAM,WAAW,kBAAkB;IAEjC,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,cAAc,CAAC;CAC3B;AAGD,MAAM,WAAW,eAAe;IAE9B,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,cAAc,CAAC;CAC3B;AAGD,MAAM,WAAW,iBAAiB;IAEhC,KAAK,EAAE,OAAO,CAAC;IAEf,SAAS,EAAE,cAAc,CAAC;CAC3B;AAGD,MAAM,WAAW,gBAAgB;IAE/B,gBAAgB,EAAE,MAAM,CAAC;IAEzB,cAAc,EAAE,MAAM,CAAC;IAEvB,SAAS,EAAE,MAAM,CAAC;CACnB;AAGD,MAAM,WAAW,kBAAkB;IAEjC,KAAK,EAAE,OAAO,CAAC;IAEf,SAAS,EAAE,MAAM,CAAC;CACnB;AA+CD,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,kBAAkB,CAQjE;AAKD,wBAAgB,SAAS,CACvB,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,GAAG,UAAU,GAC3B,eAAe,CASjB;AAKD,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,MAAM,GAAG,UAAU,EAC5B,YAAY,EAAE,MAAM,GACnB,iBAAiB,CAUnB;AAYD,wBAAgB,UAAU,CACxB,mBAAmB,EAAE,MAAM,EAC3B,iBAAiB,EAAE,MAAM,EACzB,OAAO,EAAE,MAAM,GAAG,UAAU,EAC5B,UAAU,GAAE,UAAe,GAC1B,gBAAgB,CAclB;AAaD,wBAAgB,YAAY,CAC1B,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,OAAO,EAAE,MAAM,GAAG,UAAU,EAC5B,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,MAAM,EACnB,UAAU,GAAE,UAAe,GAC1B,kBAAkB,CAepB"}

package/dist/modern/pq-sign.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mlDsaKeygen = mlDsaKeygen;
+exports.mlDsaSign = mlDsaSign;
+exports.mlDsaVerify = mlDsaVerify;
+exports.hybridSign = hybridSign;
+exports.hybridVerify = hybridVerify;
+const ml_dsa_js_1 = require("@noble/post-quantum/ml-dsa.js");
+const ed25519_js_1 = require("@noble/curves/ed25519.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");
+}
+function getDsa(level) {
+    switch (level) {
+        case 44:
+            return ml_dsa_js_1.ml_dsa44;
+        case 65:
+            return ml_dsa_js_1.ml_dsa65;
+        case 87:
+            return ml_dsa_js_1.ml_dsa87;
+        default:
+            throw new Error(`Unsupported ML-DSA level: ${level}. Supported: 44, 65, 87`);
+    }
+}
+function algorithmName(level) {
+    return `ml-dsa-${level}`;
+}
+function mlDsaKeygen(level) {
+    const dsa = getDsa(level);
+    const { publicKey, secretKey } = dsa.keygen();
+    return {
+        publicKey: Buffer.from(publicKey).toString("hex"),
+        secretKey: Buffer.from(secretKey).toString("hex"),
+        algorithm: algorithmName(level),
+    };
+}
+function mlDsaSign(level, secretKeyHex, message) {
+    const dsa = getDsa(level);
+    const secretKey = assertHex(secretKeyHex, "secretKey");
+    const msg = toBytes(message);
+    const signature = dsa.sign(msg, secretKey);
+    return {
+        signature: Buffer.from(signature).toString("hex"),
+        algorithm: algorithmName(level),
+    };
+}
+function mlDsaVerify(level, publicKeyHex, message, signatureHex) {
+    const dsa = getDsa(level);
+    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(level),
+    };
+}
+function hybridSign(secretKeyEd25519Hex, secretKeyMlDsaHex, message, mlDsaLevel = 65) {
+    const dsa = getDsa(mlDsaLevel);
+    const ed25519Key = assertHex(secretKeyEd25519Hex, "secretKeyEd25519");
+    const mlDsaKey = assertHex(secretKeyMlDsaHex, "secretKeyMlDsa");
+    const msg = toBytes(message);
+    const ed25519Sig = ed25519_js_1.ed25519.sign(msg, ed25519Key);
+    const mlDsaSig = dsa.sign(msg, mlDsaKey);
+    return {
+        ed25519Signature: Buffer.from(ed25519Sig).toString("hex"),
+        mlDsaSignature: Buffer.from(mlDsaSig).toString("hex"),
+        algorithm: `ed25519-ml-dsa-${mlDsaLevel}`,
+    };
+}
+function hybridVerify(pubKeyEd25519Hex, pubKeyMlDsaHex, message, sigEd25519Hex, sigMlDsaHex, mlDsaLevel = 65) {
+    const dsa = getDsa(mlDsaLevel);
+    const ed25519Pub = assertHex(pubKeyEd25519Hex, "pubKeyEd25519");
+    const mlDsaPub = assertHex(pubKeyMlDsaHex, "pubKeyMlDsa");
+    const msg = toBytes(message);
+    const ed25519Sig = assertHex(sigEd25519Hex, "sigEd25519");
+    const mlDsaSig = assertHex(sigMlDsaHex, "sigMlDsa");
+    const ed25519Valid = ed25519_js_1.ed25519.verify(ed25519Sig, msg, ed25519Pub);
+    const mlDsaValid = dsa.verify(mlDsaSig, msg, mlDsaPub);
+    return {
+        valid: ed25519Valid && mlDsaValid,
+        algorithm: `ed25519-ml-dsa-${mlDsaLevel}`,
+    };
+}
+//# sourceMappingURL=pq-sign.js.map

package/dist/modern/pq.d.ts

@@ -0,0 +1,38 @@
+export interface MlKemKeyPair {
+    publicKey: string;
+    secretKey: string;
+    algorithm: "ml-kem-768";
+}
+export interface MlKemEncapsulateResult {
+    ciphertext: string;
+    sharedSecret: string;
+    algorithm: "ml-kem-768";
+}
+export interface MlKemDecapsulateResult {
+    sharedSecret: string;
+    algorithm: "ml-kem-768";
+}
+export declare function mlKemGenerateKeyPair(): MlKemKeyPair;
+export declare function mlKemEncapsulate(publicKeyHex: string): MlKemEncapsulateResult;
+export declare function mlKemDecapsulate(secretKeyHex: string, ciphertextHex: string): MlKemDecapsulateResult;
+export interface HybridKeyPair {
+    x25519PrivateKey: string;
+    x25519PublicKey: string;
+    mlKemPublicKey: string;
+    mlKemSecretKey: string;
+    algorithm: "x25519-ml-kem-768";
+}
+export interface HybridEncapsulateResult {
+    x25519EphemeralPublic: string;
+    mlKemCiphertext: string;
+    sharedSecret: string;
+    algorithm: "x25519-ml-kem-768";
+}
+export interface HybridDecapsulateResult {
+    sharedSecret: string;
+    algorithm: "x25519-ml-kem-768";
+}
+export declare function hybridGenerateKeyPair(): HybridKeyPair;
+export declare function hybridEncapsulate(theirX25519Public: string, theirMlKemPublic: string): HybridEncapsulateResult;
+export declare function hybridDecapsulate(ourX25519Private: string, ourMlKemSecret: string, theirX25519Ephemeral: string, mlKemCiphertext: string): HybridDecapsulateResult;
+//# sourceMappingURL=pq.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pq.d.ts","sourceRoot":"","sources":["../../src/modern/pq.ts"],"names":[],"mappings":"AA2BA,MAAM,WAAW,YAAY;IAE3B,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,YAAY,CAAC;CACzB;AAGD,MAAM,WAAW,sBAAsB;IAErC,UAAU,EAAE,MAAM,CAAC;IAEnB,YAAY,EAAE,MAAM,CAAC;IAErB,SAAS,EAAE,YAAY,CAAC;CACzB;AAGD,MAAM,WAAW,sBAAsB;IAErC,YAAY,EAAE,MAAM,CAAC;IAErB,SAAS,EAAE,YAAY,CAAC;CACzB;AAKD,wBAAgB,oBAAoB,IAAI,YAAY,CAOnD;AAKD,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,sBAAsB,CAQ7E;AAKD,wBAAgB,gBAAgB,CAC9B,YAAY,EAAE,MAAM,EACpB,aAAa,EAAE,MAAM,GACpB,sBAAsB,CAQxB;AAKD,MAAM,WAAW,aAAa;IAE5B,gBAAgB,EAAE,MAAM,CAAC;IAEzB,eAAe,EAAE,MAAM,CAAC;IAExB,cAAc,EAAE,MAAM,CAAC;IAEvB,cAAc,EAAE,MAAM,CAAC;IAEvB,SAAS,EAAE,mBAAmB,CAAC;CAChC;AAGD,MAAM,WAAW,uBAAuB;IAEtC,qBAAqB,EAAE,MAAM,CAAC;IAE9B,eAAe,EAAE,MAAM,CAAC;IAExB,YAAY,EAAE,MAAM,CAAC;IAErB,SAAS,EAAE,mBAAmB,CAAC;CAChC;AAGD,MAAM,WAAW,uBAAuB;IAEtC,YAAY,EAAE,MAAM,CAAC;IAErB,SAAS,EAAE,mBAAmB,CAAC;CAChC;AAKD,wBAAgB,qBAAqB,IAAI,aAAa,CAYrD;AASD,wBAAgB,iBAAiB,CAC/B,iBAAiB,EAAE,MAAM,EACzB,gBAAgB,EAAE,MAAM,GACvB,uBAAuB,CAiCzB;AAWD,wBAAgB,iBAAiB,CAC/B,gBAAgB,EAAE,MAAM,EACxB,cAAc,EAAE,MAAM,EACtB,oBAAoB,EAAE,MAAM,EAC5B,eAAe,EAAE,MAAM,GACtB,uBAAuB,CA8BzB"}