@sebastienrousseau/crypto-lib 0.0.2 → 0.0.8

package/dist/modern/aead.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aeadEncrypt = aeadEncrypt;
+exports.aeadDecrypt = aeadDecrypt;
+const chacha_js_1 = require("@noble/ciphers/chacha.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+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 NONCE_LENGTH = 24;
+function aeadEncrypt(options) {
+    const key = toBytes(options.key, "hex");
+    if (key.length !== 32) {
+        throw new Error(`Key must be 32 bytes (256 bits), got ${key.length}`);
+    }
+    const plaintext = toBytes(options.plaintext, "utf8");
+    const nonce = (0, utils_js_1.randomBytes)(NONCE_LENGTH);
+    const cipher = (0, chacha_js_1.xchacha20poly1305)(key, nonce, options.aad);
+    const sealed = cipher.encrypt(plaintext);
+    const combined = new Uint8Array(NONCE_LENGTH + sealed.length);
+    combined.set(nonce);
+    combined.set(sealed, NONCE_LENGTH);
+    return {
+        ciphertext: Buffer.from(combined).toString("base64"),
+        algorithm: "xchacha20-poly1305",
+    };
+}
+function aeadDecrypt(options) {
+    const key = toBytes(options.key, "hex");
+    if (key.length !== 32) {
+        throw new Error(`Key must be 32 bytes (256 bits), got ${key.length}`);
+    }
+    const combined = Buffer.from(options.ciphertext, "base64");
+    if (combined.length < NONCE_LENGTH + 16) {
+        throw new Error("Ciphertext too short — missing nonce or auth tag");
+    }
+    const nonce = combined.subarray(0, NONCE_LENGTH);
+    const sealed = combined.subarray(NONCE_LENGTH);
+    const cipher = (0, chacha_js_1.xchacha20poly1305)(key, nonce, options.aad);
+    return cipher.decrypt(sealed);
+}
+//# sourceMappingURL=aead.js.map

package/dist/modern/aes.d.ts

@@ -0,0 +1,35 @@
+export interface AesGcmEncryptOptions {
+    key: string | Uint8Array;
+    plaintext: string | Uint8Array;
+    aad?: Uint8Array;
+}
+export type AesGcmAlgorithm = "aes-256-gcm" | "aes-128-gcm";
+export type AesGcmSivAlgorithm = "aes-256-gcm-siv" | "aes-128-gcm-siv";
+export interface AesGcmEncryptResult {
+    ciphertext: string;
+    algorithm: AesGcmAlgorithm;
+}
+export interface AesGcmSivEncryptOptions {
+    key: string | Uint8Array;
+    plaintext: string | Uint8Array;
+    aad?: Uint8Array;
+}
+export interface AesGcmSivEncryptResult {
+    ciphertext: string;
+    algorithm: AesGcmSivAlgorithm;
+}
+export interface AesGcmSivDecryptOptions {
+    key: string | Uint8Array;
+    ciphertext: string;
+    aad?: Uint8Array;
+}
+export interface AesGcmDecryptOptions {
+    key: string | Uint8Array;
+    ciphertext: string;
+    aad?: Uint8Array;
+}
+export declare function aesGcmEncrypt(options: AesGcmEncryptOptions): AesGcmEncryptResult;
+export declare function aesGcmDecrypt(options: AesGcmDecryptOptions): Uint8Array;
+export declare function aesGcmSivEncrypt(options: AesGcmSivEncryptOptions): AesGcmSivEncryptResult;
+export declare function aesGcmSivDecrypt(options: AesGcmSivDecryptOptions): Uint8Array;
+//# sourceMappingURL=aes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"aes.d.ts","sourceRoot":"","sources":["../../src/modern/aes.ts"],"names":[],"mappings":"AAwBA,MAAM,WAAW,oBAAoB;IAEnC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,SAAS,EAAE,MAAM,GAAG,UAAU,CAAC;IAE/B,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB;AAGD,MAAM,MAAM,eAAe,GAAG,aAAa,GAAG,aAAa,CAAC;AAE5D,MAAM,MAAM,kBAAkB,GAAG,iBAAiB,GAAG,iBAAiB,CAAC;AAGvE,MAAM,WAAW,mBAAmB;IAElC,UAAU,EAAE,MAAM,CAAC;IAEnB,SAAS,EAAE,eAAe,CAAC;CAC5B;AAGD,MAAM,WAAW,uBAAuB;IAEtC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,SAAS,EAAE,MAAM,GAAG,UAAU,CAAC;IAE/B,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB;AAGD,MAAM,WAAW,sBAAsB;IAErC,UAAU,EAAE,MAAM,CAAC;IAEnB,SAAS,EAAE,kBAAkB,CAAC;CAC/B;AAGD,MAAM,WAAW,uBAAuB;IAEtC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,UAAU,EAAE,MAAM,CAAC;IAEnB,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB;AAGD,MAAM,WAAW,oBAAoB;IAEnC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAC;IAEzB,UAAU,EAAE,MAAM,CAAC;IAEnB,GAAG,CAAC,EAAE,UAAU,CAAC;CAClB;AAoED,wBAAgB,aAAa,CAC3B,OAAO,EAAE,oBAAoB,GAC5B,mBAAmB,CAcrB;AAOD,wBAAgB,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,UAAU,CAKvE;AAaD,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,uBAAuB,GAC/B,sBAAsB,CAcxB;AAOD,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,uBAAuB,GAAG,UAAU,CAK7E"}

package/dist/modern/aes.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aesGcmEncrypt = aesGcmEncrypt;
+exports.aesGcmDecrypt = aesGcmDecrypt;
+exports.aesGcmSivEncrypt = aesGcmSivEncrypt;
+exports.aesGcmSivDecrypt = aesGcmSivDecrypt;
+const aes_js_1 = require("@noble/ciphers/aes.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+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 NONCE_LENGTH = 12;
+const TAG_LENGTH = 16;
+function validateAesKey(rawKey) {
+    const key = toBytes(rawKey, "hex");
+    if (key.length !== 16 && key.length !== 32) {
+        throw new Error(`Key must be 16 bytes (128 bits) or 32 bytes (256 bits), got ${key.length}`);
+    }
+    return key;
+}
+function packNonceAndSealed(nonce, sealed) {
+    const combined = new Uint8Array(NONCE_LENGTH + sealed.length);
+    combined.set(nonce);
+    combined.set(sealed, NONCE_LENGTH);
+    return Buffer.from(combined).toString("base64");
+}
+function unpackNonceAndSealed(ciphertext) {
+    const combined = Buffer.from(ciphertext, "base64");
+    if (combined.length < NONCE_LENGTH + TAG_LENGTH) {
+        throw new Error("Ciphertext too short — missing nonce or auth tag");
+    }
+    return {
+        nonce: combined.subarray(0, NONCE_LENGTH),
+        sealed: combined.subarray(NONCE_LENGTH),
+    };
+}
+function aesGcmEncrypt(options) {
+    const key = validateAesKey(options.key);
+    const plaintext = toBytes(options.plaintext, "utf8");
+    const nonce = (0, utils_js_1.randomBytes)(NONCE_LENGTH);
+    const cipher = (0, aes_js_1.gcm)(key, nonce, options.aad);
+    const sealed = cipher.encrypt(plaintext);
+    const algorithm = key.length === 32 ? "aes-256-gcm" : "aes-128-gcm";
+    return {
+        ciphertext: packNonceAndSealed(nonce, sealed),
+        algorithm,
+    };
+}
+function aesGcmDecrypt(options) {
+    const key = validateAesKey(options.key);
+    const { nonce, sealed } = unpackNonceAndSealed(options.ciphertext);
+    const cipher = (0, aes_js_1.gcm)(key, nonce, options.aad);
+    return cipher.decrypt(sealed);
+}
+function aesGcmSivEncrypt(options) {
+    const key = validateAesKey(options.key);
+    const plaintext = toBytes(options.plaintext, "utf8");
+    const nonce = (0, utils_js_1.randomBytes)(NONCE_LENGTH);
+    const cipher = (0, aes_js_1.gcmsiv)(key, nonce, options.aad);
+    const sealed = cipher.encrypt(plaintext);
+    const algorithm = key.length === 32 ? "aes-256-gcm-siv" : "aes-128-gcm-siv";
+    return {
+        ciphertext: packNonceAndSealed(nonce, sealed),
+        algorithm,
+    };
+}
+function aesGcmSivDecrypt(options) {
+    const key = validateAesKey(options.key);
+    const { nonce, sealed } = unpackNonceAndSealed(options.ciphertext);
+    const cipher = (0, aes_js_1.gcmsiv)(key, nonce, options.aad);
+    return cipher.decrypt(sealed);
+}
+//# sourceMappingURL=aes.js.map

package/dist/modern/cost-limits.d.ts

@@ -0,0 +1,11 @@
+export declare const MAX_ARGON2_TIME = 10;
+export declare const MAX_ARGON2_MEMORY = 262144;
+export declare const MAX_ARGON2_PARALLELISM = 8;
+export declare const MAX_SCRYPT_N = 131072;
+export declare const MAX_SCRYPT_R = 8;
+export declare const MAX_SCRYPT_P = 4;
+export declare const MAX_PBKDF2_ITERATIONS = 1000000;
+export declare function checkArgon2Costs(t: number, m: number, p: number): void;
+export declare function checkScryptCosts(N: number, r: number, p: number): void;
+export declare function checkPbkdf2Iterations(iterations: number): void;
+//# sourceMappingURL=cost-limits.d.ts.map

package/dist/modern/cost-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cost-limits.d.ts","sourceRoot":"","sources":["../../src/modern/cost-limits.ts"],"names":[],"mappings":"AAeA,eAAO,MAAM,eAAe,KAAK,CAAC;AAElC,eAAO,MAAM,iBAAiB,SAAS,CAAC;AAExC,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC,eAAO,MAAM,YAAY,SAAS,CAAC;AAEnC,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,eAAO,MAAM,qBAAqB,UAAY,CAAC;AAU/C,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAItE;AAGD,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAOtE;AAGD,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAE9D"}

package/dist/modern/cost-limits.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_PBKDF2_ITERATIONS = exports.MAX_SCRYPT_P = exports.MAX_SCRYPT_R = exports.MAX_SCRYPT_N = exports.MAX_ARGON2_PARALLELISM = exports.MAX_ARGON2_MEMORY = exports.MAX_ARGON2_TIME = void 0;
+exports.checkArgon2Costs = checkArgon2Costs;
+exports.checkScryptCosts = checkScryptCosts;
+exports.checkPbkdf2Iterations = checkPbkdf2Iterations;
+exports.MAX_ARGON2_TIME = 10;
+exports.MAX_ARGON2_MEMORY = 262144;
+exports.MAX_ARGON2_PARALLELISM = 8;
+exports.MAX_SCRYPT_N = 131072;
+exports.MAX_SCRYPT_R = 8;
+exports.MAX_SCRYPT_P = 4;
+exports.MAX_PBKDF2_ITERATIONS = 1_000_000;
+function checkRange(name, value, min, max) {
+    if (!Number.isInteger(value) || value < min || value > max) {
+        throw new Error(`${name} must be an integer ${min}–${max}, got ${value}`);
+    }
+}
+function checkArgon2Costs(t, m, p) {
+    checkRange("Argon2 time cost", t, 1, exports.MAX_ARGON2_TIME);
+    checkRange("Argon2 parallelism", p, 1, exports.MAX_ARGON2_PARALLELISM);
+    checkRange("Argon2 memory cost (KiB)", m, 8 * p, exports.MAX_ARGON2_MEMORY);
+}
+function checkScryptCosts(N, r, p) {
+    checkRange("scrypt N", N, 2, exports.MAX_SCRYPT_N);
+    if ((N & (N - 1)) !== 0) {
+        throw new Error(`scrypt N must be a power of two, got ${N}`);
+    }
+    checkRange("scrypt r", r, 1, exports.MAX_SCRYPT_R);
+    checkRange("scrypt p", p, 1, exports.MAX_SCRYPT_P);
+}
+function checkPbkdf2Iterations(iterations) {
+    checkRange("PBKDF2 iterations", iterations, 1, exports.MAX_PBKDF2_ITERATIONS);
+}
+//# sourceMappingURL=cost-limits.js.map

package/dist/modern/curves.d.ts

@@ -0,0 +1,86 @@
+export interface P256KeyPair {
+    privateKey: string;
+    publicKey: string;
+    algorithm: "ecdsa-p256";
+}
+export interface P256SignResult {
+    signature: string;
+    algorithm: "ecdsa-p256";
+}
+export interface P256VerifyResult {
+    valid: boolean;
+    algorithm: "ecdsa-p256";
+}
+export interface P384KeyPair {
+    privateKey: string;
+    publicKey: string;
+    algorithm: "ecdsa-p384";
+}
+export interface P384SignResult {
+    signature: string;
+    algorithm: "ecdsa-p384";
+}
+export interface P384VerifyResult {
+    valid: boolean;
+    algorithm: "ecdsa-p384";
+}
+export interface Ed448KeyPair {
+    privateKey: string;
+    publicKey: string;
+    algorithm: "ed448";
+}
+export interface Ed448SignResult {
+    signature: string;
+    algorithm: "ed448";
+}
+export interface Ed448VerifyResult {
+    valid: boolean;
+    algorithm: "ed448";
+}
+export interface X448KeyPair {
+    privateKey: string;
+    publicKey: string;
+    algorithm: "x448";
+}
+export interface X448ExchangeResult {
+    sharedSecret: string;
+    algorithm: "x448";
+}
+export interface EcdhP256Result {
+    sharedSecret: string;
+    algorithm: "ecdh-p256";
+}
+export interface EcdhP384Result {
+    sharedSecret: string;
+    algorithm: "ecdh-p384";
+}
+export interface SchnorrKeyPair {
+    privateKey: string;
+    publicKey: string;
+    algorithm: "schnorr";
+}
+export interface SchnorrSignResult {
+    signature: string;
+    algorithm: "schnorr";
+}
+export interface SchnorrVerifyResult {
+    valid: boolean;
+    algorithm: "schnorr";
+}
+export declare function generateP256KeyPair(): P256KeyPair;
+export declare function p256Sign(privateKeyHex: string, message: string | Uint8Array): P256SignResult;
+export declare function p256Verify(publicKeyHex: string, message: string | Uint8Array, signatureHex: string): P256VerifyResult;
+export declare function generateP384KeyPair(): P384KeyPair;
+export declare function p384Sign(privateKeyHex: string, message: string | Uint8Array): P384SignResult;
+export declare function p384Verify(publicKeyHex: string, message: string | Uint8Array, signatureHex: string): P384VerifyResult;
+export declare function generateEd448KeyPair(): Ed448KeyPair;
+export declare function ed448Sign(privateKeyHex: string, message: string | Uint8Array): Ed448SignResult;
+export declare function ed448Verify(publicKeyHex: string, message: string | Uint8Array, signatureHex: string): Ed448VerifyResult;
+export declare function generateX448KeyPair(): X448KeyPair;
+export declare function x448Exchange(privateKeyHex: string, theirPublicKeyHex: string): X448ExchangeResult;
+export declare function ecdhP256(privateKeyHex: string, theirPublicKeyHex: string): EcdhP256Result;
+export declare function ecdhP384(privateKeyHex: string, theirPublicKeyHex: string): EcdhP384Result;
+export declare function generateSchnorrKeyPair(): SchnorrKeyPair;
+export declare function schnorrSign(privateKeyHex: string, message: string | Uint8Array): SchnorrSignResult;
+export declare function schnorrVerify(publicKeyHex: string, message: string | Uint8Array, signatureHex: string): SchnorrVerifyResult;
+//# sourceMappingURL=curves.d.ts.map

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

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

package/dist/modern/curves.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateP256KeyPair = generateP256KeyPair;
+exports.p256Sign = p256Sign;
+exports.p256Verify = p256Verify;
+exports.generateP384KeyPair = generateP384KeyPair;
+exports.p384Sign = p384Sign;
+exports.p384Verify = p384Verify;
+exports.generateEd448KeyPair = generateEd448KeyPair;
+exports.ed448Sign = ed448Sign;
+exports.ed448Verify = ed448Verify;
+exports.generateX448KeyPair = generateX448KeyPair;
+exports.x448Exchange = x448Exchange;
+exports.ecdhP256 = ecdhP256;
+exports.ecdhP384 = ecdhP384;
+exports.generateSchnorrKeyPair = generateSchnorrKeyPair;
+exports.schnorrSign = schnorrSign;
+exports.schnorrVerify = schnorrVerify;
+const nist_js_1 = require("@noble/curves/nist.js");
+const ed448_js_1 = require("@noble/curves/ed448.js");
+const secp256k1_js_1 = require("@noble/curves/secp256k1.js");
+const utils_js_1 = require("@noble/ciphers/utils.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 generateP256KeyPair() {
+    const privateKey = nist_js_1.p256.utils.randomSecretKey();
+    const publicKey = nist_js_1.p256.getPublicKey(privateKey, false);
+    return {
+        privateKey: Buffer.from(privateKey).toString("hex"),
+        publicKey: Buffer.from(publicKey).toString("hex"),
+        algorithm: "ecdsa-p256",
+    };
+}
+function p256Sign(privateKeyHex, message) {
+    const key = assertHex(privateKeyHex, "privateKey");
+    const msg = toBytes(message);
+    const signature = nist_js_1.p256.sign(msg, key);
+    return {
+        signature: Buffer.from(signature).toString("hex"),
+        algorithm: "ecdsa-p256",
+    };
+}
+function p256Verify(publicKeyHex, message, signatureHex) {
+    const key = assertHex(publicKeyHex, "publicKey");
+    const msg = toBytes(message);
+    const sig = assertHex(signatureHex, "signature");
+    const valid = nist_js_1.p256.verify(sig, msg, key);
+    return { valid, algorithm: "ecdsa-p256" };
+}
+function generateP384KeyPair() {
+    const privateKey = nist_js_1.p384.utils.randomSecretKey();
+    const publicKey = nist_js_1.p384.getPublicKey(privateKey, false);
+    return {
+        privateKey: Buffer.from(privateKey).toString("hex"),
+        publicKey: Buffer.from(publicKey).toString("hex"),
+        algorithm: "ecdsa-p384",
+    };
+}
+function p384Sign(privateKeyHex, message) {
+    const key = assertHex(privateKeyHex, "privateKey");
+    const msg = toBytes(message);
+    const signature = nist_js_1.p384.sign(msg, key);
+    return {
+        signature: Buffer.from(signature).toString("hex"),
+        algorithm: "ecdsa-p384",
+    };
+}
+function p384Verify(publicKeyHex, message, signatureHex) {
+    const key = assertHex(publicKeyHex, "publicKey");
+    const msg = toBytes(message);
+    const sig = assertHex(signatureHex, "signature");
+    const valid = nist_js_1.p384.verify(sig, msg, key);
+    return { valid, algorithm: "ecdsa-p384" };
+}
+function generateEd448KeyPair() {
+    const privateKey = (0, utils_js_1.randomBytes)(57);
+    const publicKey = ed448_js_1.ed448.getPublicKey(privateKey);
+    return {
+        privateKey: Buffer.from(privateKey).toString("hex"),
+        publicKey: Buffer.from(publicKey).toString("hex"),
+        algorithm: "ed448",
+    };
+}
+function ed448Sign(privateKeyHex, message) {
+    const key = assertHex(privateKeyHex, "privateKey");
+    const msg = toBytes(message);
+    const signature = ed448_js_1.ed448.sign(msg, key);
+    return {
+        signature: Buffer.from(signature).toString("hex"),
+        algorithm: "ed448",
+    };
+}
+function ed448Verify(publicKeyHex, message, signatureHex) {
+    const key = assertHex(publicKeyHex, "publicKey");
+    const msg = toBytes(message);
+    const sig = assertHex(signatureHex, "signature");
+    const valid = ed448_js_1.ed448.verify(sig, msg, key);
+    return { valid, algorithm: "ed448" };
+}
+function generateX448KeyPair() {
+    const privateKey = ed448_js_1.x448.utils.randomSecretKey();
+    const publicKey = ed448_js_1.x448.getPublicKey(privateKey);
+    return {
+        privateKey: Buffer.from(privateKey).toString("hex"),
+        publicKey: Buffer.from(publicKey).toString("hex"),
+        algorithm: "x448",
+    };
+}
+function x448Exchange(privateKeyHex, theirPublicKeyHex) {
+    const priv = assertHex(privateKeyHex, "privateKey");
+    const pub = assertHex(theirPublicKeyHex, "theirPublicKey");
+    const shared = ed448_js_1.x448.getSharedSecret(priv, pub);
+    return {
+        sharedSecret: Buffer.from(shared).toString("hex"),
+        algorithm: "x448",
+    };
+}
+function ecdhP256(privateKeyHex, theirPublicKeyHex) {
+    const priv = assertHex(privateKeyHex, "privateKey");
+    const pub = assertHex(theirPublicKeyHex, "theirPublicKey");
+    const shared = nist_js_1.p256.getSharedSecret(priv, pub);
+    return {
+        sharedSecret: Buffer.from(shared).toString("hex"),
+        algorithm: "ecdh-p256",
+    };
+}
+function ecdhP384(privateKeyHex, theirPublicKeyHex) {
+    const priv = assertHex(privateKeyHex, "privateKey");
+    const pub = assertHex(theirPublicKeyHex, "theirPublicKey");
+    const shared = nist_js_1.p384.getSharedSecret(priv, pub);
+    return {
+        sharedSecret: Buffer.from(shared).toString("hex"),
+        algorithm: "ecdh-p384",
+    };
+}
+function generateSchnorrKeyPair() {
+    const privateKey = (0, utils_js_1.randomBytes)(32);
+    const publicKey = secp256k1_js_1.schnorr.getPublicKey(privateKey);
+    return {
+        privateKey: Buffer.from(privateKey).toString("hex"),
+        publicKey: Buffer.from(publicKey).toString("hex"),
+        algorithm: "schnorr",
+    };
+}
+function schnorrSign(privateKeyHex, message) {
+    const key = assertHex(privateKeyHex, "privateKey");
+    const msg = toBytes(message);
+    const signature = secp256k1_js_1.schnorr.sign(msg, key);
+    return {
+        signature: Buffer.from(signature).toString("hex"),
+        algorithm: "schnorr",
+    };
+}
+function schnorrVerify(publicKeyHex, message, signatureHex) {
+    const key = assertHex(publicKeyHex, "publicKey");
+    const msg = toBytes(message);
+    const sig = assertHex(signatureHex, "signature");
+    const valid = secp256k1_js_1.schnorr.verify(sig, msg, key);
+    return { valid, algorithm: "schnorr" };
+}
+//# sourceMappingURL=curves.js.map

package/dist/modern/ecdh.d.ts

@@ -0,0 +1,11 @@
+export interface X25519KeyPair {
+    privateKey: string;
+    publicKey: string;
+}
+export interface KeyExchangeResult {
+    sharedSecret: string;
+    algorithm: "x25519";
+}
+export declare function generateX25519KeyPair(): X25519KeyPair;
+export declare function x25519Exchange(privateKey: string | Uint8Array, theirPublicKey: string | Uint8Array): KeyExchangeResult;
+//# sourceMappingURL=ecdh.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ecdh.d.ts","sourceRoot":"","sources":["../../src/modern/ecdh.ts"],"names":[],"mappings":"AAiBA,MAAM,WAAW,aAAa;IAE5B,UAAU,EAAE,MAAM,CAAC;IAEnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAGD,MAAM,WAAW,iBAAiB;IAEhC,YAAY,EAAE,MAAM,CAAC;IAErB,SAAS,EAAE,QAAQ,CAAC;CACrB;AAKD,wBAAgB,qBAAqB,IAAI,aAAa,CAQrD;AASD,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,GAAG,UAAU,EAC/B,cAAc,EAAE,MAAM,GAAG,UAAU,GAClC,iBAAiB,CAgBnB"}

package/dist/modern/ecdh.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateX25519KeyPair = generateX25519KeyPair;
+exports.x25519Exchange = x25519Exchange;
+const ed25519_js_1 = require("@noble/curves/ed25519.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+function generateX25519KeyPair() {
+    const privateKey = (0, utils_js_1.randomBytes)(32);
+    const publicKey = ed25519_js_1.x25519.getPublicKey(privateKey);
+    return {
+        privateKey: Buffer.from(privateKey).toString("hex"),
+        publicKey: Buffer.from(publicKey).toString("hex"),
+    };
+}
+function x25519Exchange(privateKey, theirPublicKey) {
+    const priv = typeof privateKey === "string"
+        ? Buffer.from(privateKey, "hex")
+        : privateKey;
+    const pub = typeof theirPublicKey === "string"
+        ? Buffer.from(theirPublicKey, "hex")
+        : theirPublicKey;
+    const shared = ed25519_js_1.x25519.getSharedSecret(priv, pub);
+    return {
+        sharedSecret: Buffer.from(shared).toString("hex"),
+        algorithm: "x25519",
+    };
+}
+//# sourceMappingURL=ecdh.js.map

package/dist/modern/fn-dsa.d.ts

@@ -0,0 +1,19 @@
+export type FnDsaLevel = 512 | 1024;
+export type FnDsaAlgorithm = "fn-dsa-512" | "fn-dsa-1024";
+export interface FnDsaKeyPairResult {
+    publicKey: string;
+    secretKey: string;
+    algorithm: FnDsaAlgorithm;
+}
+export interface FnDsaSignResult {
+    signature: string;
+    algorithm: FnDsaAlgorithm;
+}
+export interface FnDsaVerifyResult {
+    valid: boolean;
+    algorithm: FnDsaAlgorithm;
+}
+export declare function fnDsaKeygen(level: FnDsaLevel): FnDsaKeyPairResult;
+export declare function fnDsaSign(level: FnDsaLevel, secretKeyHex: string, messageHex: string): FnDsaSignResult;
+export declare function fnDsaVerify(level: FnDsaLevel, publicKeyHex: string, messageHex: string, signatureHex: string): FnDsaVerifyResult;
+//# sourceMappingURL=fn-dsa.d.ts.map

package/dist/modern/fn-dsa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fn-dsa.d.ts","sourceRoot":"","sources":["../../src/modern/fn-dsa.ts"],"names":[],"mappings":"AAyBA,MAAM,MAAM,UAAU,GAAG,GAAG,GAAG,IAAI,CAAC;AAUpC,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,aAAa,CAAC;AAW1D,MAAM,WAAW,kBAAkB;IAEjC,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,cAAc,CAAC;CAC3B;AAWD,MAAM,WAAW,eAAe;IAE9B,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,cAAc,CAAC;CAC3B;AAWD,MAAM,WAAW,iBAAiB;IAEhC,KAAK,EAAE,OAAO,CAAC;IAEf,SAAS,EAAE,cAAc,CAAC;CAC3B;AAkDD,wBAAgB,WAAW,CAAC,KAAK,EAAE,UAAU,GAAG,kBAAkB,CAQjE;AAkBD,wBAAgB,SAAS,CACvB,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,GACjB,eAAe,CASjB;AAoBD,wBAAgB,WAAW,CACzB,KAAK,EAAE,UAAU,EACjB,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,GACnB,iBAAiB,CAUnB"}

package/dist/modern/fn-dsa.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fnDsaKeygen = fnDsaKeygen;
+exports.fnDsaSign = fnDsaSign;
+exports.fnDsaVerify = fnDsaVerify;
+const falcon_js_1 = require("@noble/post-quantum/falcon.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 getFalcon(level) {
+    switch (level) {
+        case 512:
+            return falcon_js_1.falcon512;
+        case 1024:
+            return falcon_js_1.falcon1024;
+        default:
+            throw new Error(`Unsupported FN-DSA level: ${level}. Supported: 512, 1024`);
+    }
+}
+function algorithmName(level) {
+    return `fn-dsa-${level}`;
+}
+function fnDsaKeygen(level) {
+    const falcon = getFalcon(level);
+    const { publicKey, secretKey } = falcon.keygen();
+    return {
+        publicKey: Buffer.from(publicKey).toString("hex"),
+        secretKey: Buffer.from(secretKey).toString("hex"),
+        algorithm: algorithmName(level),
+    };
+}
+function fnDsaSign(level, secretKeyHex, messageHex) {
+    const falcon = getFalcon(level);
+    const secretKey = assertHex(secretKeyHex, "secretKey");
+    const msg = assertHex(messageHex, "message");
+    const signature = falcon.sign(msg, secretKey);
+    return {
+        signature: Buffer.from(signature).toString("hex"),
+        algorithm: algorithmName(level),
+    };
+}
+function fnDsaVerify(level, publicKeyHex, messageHex, signatureHex) {
+    const falcon = getFalcon(level);
+    const publicKey = assertHex(publicKeyHex, "publicKey");
+    const msg = assertHex(messageHex, "message");
+    const signature = assertHex(signatureHex, "signature");
+    const valid = falcon.verify(signature, msg, publicKey);
+    return {
+        valid,
+        algorithm: algorithmName(level),
+    };
+}
+//# sourceMappingURL=fn-dsa.js.map

package/dist/modern/hash.d.ts

@@ -0,0 +1,13 @@
+export declare const HASH_ALGORITHMS: readonly ["sha256", "sha384", "sha512", "sha3-256", "sha3-512", "blake2b", "blake3"];
+export type HashAlgorithm = (typeof HASH_ALGORITHMS)[number];
+export interface HashOptions {
+    algorithm: HashAlgorithm;
+    data: string | Uint8Array;
+}
+export interface HashResult {
+    digest: string;
+    algorithm: HashAlgorithm;
+    length: number;
+}
+export declare function hash(options: HashOptions): HashResult;
+//# sourceMappingURL=hash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/modern/hash.ts"],"names":[],"mappings":"AAiBA,eAAO,MAAM,eAAe,sFAQlB,CAAC;AAGX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,eAAe,CAAC,CAAC,MAAM,CAAC,CAAC;AAG7D,MAAM,WAAW,WAAW;IAE1B,SAAS,EAAE,aAAa,CAAC;IAEzB,IAAI,EAAE,MAAM,GAAG,UAAU,CAAC;CAC3B;AAGD,MAAM,WAAW,UAAU;IAEzB,MAAM,EAAE,MAAM,CAAC;IAEf,SAAS,EAAE,aAAa,CAAC;IAEzB,MAAM,EAAE,MAAM,CAAC;CAChB;AAuBD,wBAAgB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU,CAiBrD"}