@sebastienrousseau/crypto-lib 0.0.3 → 0.0.7

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

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