@sebastienrousseau/crypto-lib 0.0.3 → 0.0.7

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

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

package/dist/modern/index.js

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

package/dist/modern/kdf.d.ts

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

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

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

package/dist/modern/kdf.js

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

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