@sebastienrousseau/crypto-lib 0.0.3 → 0.0.8

package/dist/accel/webcrypto-modern.js

@@ -0,0 +1,213 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectModernWebCrypto = detectModernWebCrypto;
+exports._resetModernWebCryptoDetection = _resetModernWebCryptoDetection;
+exports.modernChaCha20Encrypt = modernChaCha20Encrypt;
+exports.modernChaCha20Decrypt = modernChaCha20Decrypt;
+exports.modernSha3Hash = modernSha3Hash;
+const chacha_js_1 = require("@noble/ciphers/chacha.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const nodeCrypto = __importStar(require("node:crypto"));
+function asBufferSource(view) {
+    return view;
+}
+const HEX_RE = /^[0-9a-fA-F]*$/;
+const NONCE_LENGTH = 12;
+const TAG_LENGTH = 16;
+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 getSubtle() {
+    try {
+        if (nodeCrypto.webcrypto &&
+            nodeCrypto.webcrypto.subtle &&
+            typeof nodeCrypto.webcrypto.subtle.encrypt === "function") {
+            return nodeCrypto.webcrypto.subtle;
+        }
+    }
+    catch {
+    }
+    return null;
+}
+let _modernDetectionCache;
+function checkSupport(supports, subtle, op, alg) {
+    try {
+        return !!supports.call(subtle, op, alg);
+    }
+    catch {
+        return false;
+    }
+}
+function detectModernWebCrypto() {
+    if (_modernDetectionCache !== undefined)
+        return _modernDetectionCache;
+    const subtle = getSubtle();
+    const result = {
+        chacha20poly1305: false,
+        sha3: false,
+        mlKem: false,
+        argon2: false,
+        kmac: false,
+    };
+    if (subtle) {
+        const supports = subtle["supports"];
+        if (typeof supports === "function") {
+            const fn = supports;
+            result.chacha20poly1305 = checkSupport(fn, subtle, "encrypt", "ChaCha20-Poly1305");
+            result.sha3 = checkSupport(fn, subtle, "digest", "SHA3-256");
+            result.mlKem = checkSupport(fn, subtle, "deriveBits", "ML-KEM-768");
+            result.argon2 = checkSupport(fn, subtle, "deriveBits", "Argon2id");
+            result.kmac = checkSupport(fn, subtle, "sign", "KMAC256");
+        }
+    }
+    _modernDetectionCache = result;
+    return result;
+}
+function _resetModernWebCryptoDetection() {
+    _modernDetectionCache = undefined;
+}
+async function modernChaCha20Encrypt(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 support = detectModernWebCrypto();
+    if (support.chacha20poly1305) {
+        const subtle = getSubtle();
+        const cryptoKey = await subtle.importKey("raw", asBufferSource(key), { name: "ChaCha20-Poly1305" }, false, ["encrypt"]);
+        const algParams = {
+            name: "ChaCha20-Poly1305",
+            iv: asBufferSource(nonce),
+            tagLength: TAG_LENGTH * 8,
+        };
+        if (options.aad) {
+            algParams["additionalData"] = options.aad;
+        }
+        const encrypted = await subtle.encrypt(algParams, cryptoKey, asBufferSource(plaintext));
+        const sealed = new Uint8Array(encrypted);
+        const combined = new Uint8Array(NONCE_LENGTH + sealed.length);
+        combined.set(nonce);
+        combined.set(sealed, NONCE_LENGTH);
+        return {
+            ciphertext: Buffer.from(combined).toString("base64"),
+            accelerated: true,
+        };
+    }
+    const cipher = (0, chacha_js_1.chacha20poly1305)(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"),
+        accelerated: false,
+    };
+}
+async function modernChaCha20Decrypt(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 + TAG_LENGTH) {
+        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 support = detectModernWebCrypto();
+    if (support.chacha20poly1305) {
+        const subtle = getSubtle();
+        const cryptoKey = await subtle.importKey("raw", asBufferSource(key), { name: "ChaCha20-Poly1305" }, false, ["decrypt"]);
+        const algParams = {
+            name: "ChaCha20-Poly1305",
+            iv: asBufferSource(nonce),
+            tagLength: TAG_LENGTH * 8,
+        };
+        if (options.aad) {
+            algParams["additionalData"] = options.aad;
+        }
+        const decrypted = await subtle.decrypt(algParams, cryptoKey, asBufferSource(sealed));
+        return {
+            plaintext: new Uint8Array(decrypted),
+            accelerated: true,
+        };
+    }
+    const cipher = (0, chacha_js_1.chacha20poly1305)(key, nonce, options.aad);
+    const plaintext = cipher.decrypt(sealed);
+    return {
+        plaintext,
+        accelerated: false,
+    };
+}
+async function modernSha3Hash(options) {
+    const data = toBytes(options.data, "utf8");
+    const support = detectModernWebCrypto();
+    if (support.sha3) {
+        const subtle = getSubtle();
+        const digest = await subtle.digest(options.algorithm, asBufferSource(data));
+        return {
+            digest: Buffer.from(digest).toString("hex"),
+            accelerated: true,
+        };
+    }
+    let digest;
+    switch (options.algorithm) {
+        case "SHA3-256":
+            digest = (0, sha3_js_1.sha3_256)(data);
+            break;
+        case "SHA3-512":
+            digest = (0, sha3_js_1.sha3_512)(data);
+            break;
+        default:
+            throw new Error(`Unsupported SHA-3 algorithm: ${options.algorithm}`);
+    }
+    return {
+        digest: Buffer.from(digest).toString("hex"),
+        accelerated: false,
+    };
+}
+//# sourceMappingURL=webcrypto-modern.js.map

package/dist/accel/worker-pool.d.ts

@@ -0,0 +1,23 @@
+export interface WorkerPoolOptions {
+    size?: number;
+    workerScript?: string;
+}
+export interface WorkerTask {
+    modulePath: string;
+    functionName: string;
+    args: unknown[];
+}
+export declare class WorkerPool {
+    private workers;
+    private queue;
+    private terminated;
+    readonly size: number;
+    constructor(options?: WorkerPoolOptions);
+    execute<T = unknown>(task: WorkerTask): Promise<T>;
+    shutdown(): Promise<void>;
+    get pending(): number;
+    get active(): number;
+    private dispatch;
+    private processQueue;
+}
+//# sourceMappingURL=worker-pool.d.ts.map

package/dist/accel/worker-pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-pool.d.ts","sourceRoot":"","sources":["../../src/accel/worker-pool.ts"],"names":[],"mappings":"AAuBA,MAAM,WAAW,iBAAiB;IAEhC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAGD,MAAM,WAAW,UAAU;IAEzB,UAAU,EAAE,MAAM,CAAC;IAEnB,YAAY,EAAE,MAAM,CAAC;IAErB,IAAI,EAAE,OAAO,EAAE,CAAC;CACjB;AAiED,qBAAa,UAAU;IACrB,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,UAAU,CAAS;IAE3B,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAEjB,OAAO,GAAE,iBAAsB;IA6B3C,OAAO,CAAC,CAAC,GAAG,OAAO,EAAE,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,CAAC,CAAC;IA2B5C,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAkB/B,IAAI,OAAO,IAAI,MAAM,CAEpB;IAKD,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,OAAO,CAAC,QAAQ;IAsChB,OAAO,CAAC,YAAY;CAMrB"}

package/dist/accel/worker-pool.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerPool = void 0;
+const node_worker_threads_1 = require("node:worker_threads");
+const node_os_1 = require("node:os");
+const WORKER_SCRIPT = `
+const { parentPort } = require("node:worker_threads");
+const { isAbsolute } = require("node:path");
+const { pathToFileURL } = require("node:url");
+
+parentPort.on("message", async (msg) => {
+  try {
+    // import() needs a file:// URL for absolute paths on Windows
+    // ("D:\\..." is read as a URL with scheme "d:").
+    const specifier = isAbsolute(msg.modulePath)
+      ? pathToFileURL(msg.modulePath).href
+      : msg.modulePath;
+    const mod = await import(specifier);
+    const fn = mod[msg.functionName];
+    if (typeof fn !== "function") {
+      throw new Error(\`"\${msg.functionName}" is not a function in \${msg.modulePath}\`);
+    }
+    const result = await fn(...msg.args);
+    parentPort.postMessage({ success: true, result });
+  } catch (err) {
+    parentPort.postMessage({
+      success: false,
+      error: err instanceof Error ? err.message : String(err),
+    });
+  }
+});
+`;
+class WorkerPool {
+    workers = [];
+    queue = [];
+    terminated = false;
+    size;
+    constructor(options = {}) {
+        if (!node_worker_threads_1.isMainThread) {
+            throw new Error("WorkerPool must be created from the main thread");
+        }
+        this.size = Math.max(1, options.size ?? Math.floor((0, node_os_1.cpus)().length / 2));
+        const script = options.workerScript ?? undefined;
+        for (let i = 0; i < this.size; i++) {
+            const worker = script
+                ? new node_worker_threads_1.Worker(script)
+                : new node_worker_threads_1.Worker(WORKER_SCRIPT, { eval: true });
+            this.workers.push({ worker, busy: false });
+        }
+    }
+    execute(task) {
+        if (this.terminated) {
+            return Promise.reject(new Error("WorkerPool has been shut down"));
+        }
+        return new Promise((resolve, reject) => {
+            const pending = {
+                task,
+                resolve: resolve,
+                reject,
+            };
+            const available = this.workers.find((w) => !w.busy);
+            if (available) {
+                this.dispatch(available, pending);
+            }
+            else {
+                this.queue.push(pending);
+            }
+        });
+    }
+    async shutdown() {
+        this.terminated = true;
+        for (const pending of this.queue) {
+            pending.reject(new Error("WorkerPool is shutting down"));
+        }
+        this.queue = [];
+        const terminations = this.workers.map((entry) => entry.worker.terminate());
+        await Promise.all(terminations);
+        this.workers = [];
+    }
+    get pending() {
+        return this.queue.length;
+    }
+    get active() {
+        return this.workers.filter((w) => w.busy).length;
+    }
+    dispatch(entry, pending) {
+        entry.busy = true;
+        const handler = (msg) => {
+            entry.worker.off("message", handler);
+            entry.worker.off("error", errorHandler);
+            entry.busy = false;
+            if (msg.success) {
+                pending.resolve(msg.result);
+            }
+            else {
+                pending.reject(new Error(msg.error ?? "Worker task failed"));
+            }
+            this.processQueue(entry);
+        };
+        const errorHandler = (err) => {
+            entry.worker.off("message", handler);
+            entry.worker.off("error", errorHandler);
+            entry.busy = false;
+            pending.reject(err);
+            this.processQueue(entry);
+        };
+        entry.worker.on("message", handler);
+        entry.worker.on("error", errorHandler);
+        entry.worker.postMessage(pending.task);
+    }
+    processQueue(entry) {
+        if (this.queue.length > 0) {
+            const next = this.queue.shift();
+            this.dispatch(entry, next);
+        }
+    }
+}
+exports.WorkerPool = WorkerPool;
+//# sourceMappingURL=worker-pool.js.map

package/dist/bin/cryptolib.d.ts

@@ -1,14 +1,16 @@
 import { dataDecrypt, dataEncrypt, dataGenerate, dataReformat, dataRevoke, dataSessionKey, dataSign, dataVerify } from "../types/types";
-export declare function decrypt(data: dataDecrypt): Promise<object>;
-export declare function encrypt(data: dataEncrypt): Promise<object>;
+import type { ArmoredKeyResult } from "../lib/reformat.js";
+export declare function decrypt(data: dataDecrypt): Promise<{
+    data: string;
+    signatureValid: boolean;
+}>;
+export declare function encrypt(data: dataEncrypt): Promise<string>;
 export declare function generate(data: dataGenerate): Promise<object>;
-export declare function reformat(data: dataReformat): Promise<object>;
+export declare function reformat(data: dataReformat): Promise<ArmoredKeyResult>;
 export declare function session(data: dataSessionKey): Promise<import("openpgp").SessionKey>;
-export declare function revoke(data: dataRevoke): Promise<import("openpgp").SerializedKeyPair<string>>;
+export declare function revoke(data: dataRevoke): Promise<ArmoredKeyResult>;
 export declare function sign(data: dataSign): Promise<string>;
-export declare function verify(data: dataVerify): Promise<import("openpgp").VerifyMessageResult & {
-    data: import("openpgp").WebStream<string>;
-}>;
+export declare function verify(data: dataVerify): Promise<import("openpgp").VerifyMessageResult<GenericWebStream<T>>>;
 declare const _default: {
     decrypt: typeof decrypt;
     encrypt: typeof encrypt;

package/dist/bin/cryptolib.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cryptolib.d.ts","sourceRoot":"","sources":["../../src/bin/cryptolib.ts"],"names":[],"mappings":"AACA,OAAO,EACL,WAAW,EACX,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,cAAc,EACd,QAAQ,EACR,UAAU,EACX,MAAM,gBAAgB,CAAC;AAqBxB,wBAAsB,OAAO,CAAC,IAAI,EAAE,WAAW,mBAG9C;AAqBD,wBAAsB,OAAO,CAAC,IAAI,EAAE,WAAW,mBAG9C;AA2BD,wBAAsB,QAAQ,CAAC,IAAI,EAAE,YAAY,mBAGhD;AAED,wBAAsB,QAAQ,CAAC,IAAI,EAAE,YAAY,mBAGhD;AAuBD,wBAAsB,OAAO,CAAC,IAAI,EAAE,cAAc,yCAGjD;AAmBD,wBAAsB,MAAM,CAAC,IAAI,EAAE,UAAU,wDAG5C;AAoBD,wBAAsB,IAAI,CAAC,IAAI,EAAE,QAAQ,mBAGxC;AAoBD,wBAAsB,MAAM,CAAC,IAAI,EAAE,UAAU;;GAG5C;;;;;;;;;;;AAUD,wBASE"}
+{"version":3,"file":"cryptolib.d.ts","sourceRoot":"","sources":["../../src/bin/cryptolib.ts"],"names":[],"mappings":"AACA,OAAO,EACL,WAAW,EACX,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,cAAc,EACd,QAAQ,EACR,UAAU,EACX,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAkB3D,wBAAsB,OAAO,CAAC,IAAI,EAAE,WAAW;;;GAG9C;AAkBD,wBAAsB,OAAO,CAAC,IAAI,EAAE,WAAW,mBAG9C;AAwBD,wBAAsB,QAAQ,CAAC,IAAI,EAAE,YAAY,mBAGhD;AAGD,wBAAsB,QAAQ,CAAC,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAG5E;AAoBD,wBAAsB,OAAO,CAAC,IAAI,EAAE,cAAc,yCAGjD;AAgBD,wBAAsB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAGxE;AAiBD,wBAAsB,IAAI,CAAC,IAAI,EAAE,QAAQ,mBAGxC;AAiBD,wBAAsB,MAAM,CAAC,IAAI,EAAE,UAAU,uEAG5C;;;;;;;;;;;AAOD,wBAiBE"}

package/dist/bin/cryptolib.js

@@ -15,56 +15,65 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verify = exports.sign = exports.revoke = exports.session = exports.reformat = exports.generate = exports.encrypt = exports.decrypt = void 0;
+exports.decrypt = decrypt;
+exports.encrypt = encrypt;
+exports.generate = generate;
+exports.reformat = reformat;
+exports.session = session;
+exports.revoke = revoke;
+exports.sign = sign;
+exports.verify = verify;
 const key = __importStar(require("../lib"));
 async function decrypt(data) {
     const decrypt = await key.decrypt.default(data);
     return decrypt;
 }
-exports.decrypt = decrypt;
 async function encrypt(data) {
     const encrypt = await key.encrypt.default(data);
     return encrypt;
 }
-exports.encrypt = encrypt;
 async function generate(data) {
     const generate = await key.generate.default(data);
     return generate;
 }
-exports.generate = generate;
 async function reformat(data) {
     const reformat = await key.reformat.default(data);
     return reformat;
 }
-exports.reformat = reformat;
 async function session(data) {
     const verify = await key.session.default(data);
     return verify;
 }
-exports.session = session;
 async function revoke(data) {
     const revoke = await key.revoke.default(data);
     return revoke;
 }
-exports.revoke = revoke;
 async function sign(data) {
     const sign = await key.sign.default(data);
     return sign;
 }
-exports.sign = sign;
 async function verify(data) {
     const verify = await key.verify.default(data);
     return verify;
 }
-exports.verify = verify;
 exports.default = {
     decrypt,
     encrypt,

package/dist/config/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":";;;;;;AAEA,wBAoFE"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config/config.ts"],"names":[],"mappings":";;;;;;AAGA,wBAgEE"}

package/dist/crypto.d.ts

@@ -0,0 +1,43 @@
+import { type HashAlgorithm } from "./modern/hash";
+import { type KeyAlgorithm, type KeyMetadata, type GeneratedKeyPair } from "./keys/keygen";
+import { type HashPasswordResult, type VerifyPasswordResult } from "./modern/password";
+import { getAlgorithm, isDeprecated, recommended, listAlgorithms } from "./registry";
+import { type HmacAlgorithm } from "./modern/mac";
+export type SignAlgorithm = "ed25519" | "ed448" | "ecdsa-p256" | "ecdsa-p384" | "schnorr" | "ml-dsa-44" | "ml-dsa-65" | "ml-dsa-87";
+export interface VerifyPasswordOptions {
+    password: string | Uint8Array;
+    hash: string;
+    salt: string;
+    params: {
+        t: number;
+        m: number;
+        p: number;
+    };
+}
+export interface HmacVerifyOptions {
+    algorithm: HmacAlgorithm;
+    key: string | Uint8Array;
+    data: string | Uint8Array;
+    mac: string;
+}
+export declare const crypto: {
+    readonly randomKey: () => string;
+    readonly encrypt: (key: string | Uint8Array, plaintext: string | Uint8Array) => string;
+    readonly decrypt: (key: string | Uint8Array, ciphertext: string) => Uint8Array;
+    readonly hash: (algorithm: HashAlgorithm, data: string | Uint8Array) => string;
+    readonly generateKeyPair: (algorithm: KeyAlgorithm, metadata?: KeyMetadata) => GeneratedKeyPair;
+    readonly sign: (algorithm: SignAlgorithm, privateKeyHex: string, message: string | Uint8Array) => string;
+    readonly verify: (algorithm: SignAlgorithm, publicKeyHex: string, message: string | Uint8Array, signatureHex: string) => boolean;
+    readonly hashPassword: (password: string | Uint8Array) => HashPasswordResult;
+    readonly verifyPassword: (options: VerifyPasswordOptions) => VerifyPasswordResult;
+    readonly verifyPasswordPhc: (password: string | Uint8Array, phc: string) => VerifyPasswordResult;
+    readonly hmac: (algorithm: HmacAlgorithm, key: string | Uint8Array, data: string | Uint8Array) => string;
+    readonly hmacVerify: (options: HmacVerifyOptions) => boolean;
+    readonly registry: {
+        readonly get: typeof getAlgorithm;
+        readonly list: typeof listAlgorithms;
+        readonly recommended: typeof recommended;
+        readonly isDeprecated: typeof isDeprecated;
+    };
+};
+//# sourceMappingURL=crypto.d.ts.map

package/dist/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AA0BA,OAAO,EAAsB,KAAK,aAAa,EAAE,MAAM,eAAe,CAAC;AACvE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACtB,MAAM,eAAe,CAAC;AAavB,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EAC1B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,WAAW,EACX,cAAc,EACf,MAAM,YAAY,CAAC;AACpB,OAAO,EAA2B,KAAK,aAAa,EAAE,MAAM,cAAc,CAAC;AAI3E,MAAM,MAAM,aAAa,GACrB,SAAS,GACT,OAAO,GACP,YAAY,GACZ,YAAY,GACZ,SAAS,GACT,WAAW,GACX,WAAW,GACX,WAAW,CAAC;AAGhB,MAAM,WAAW,qBAAqB;IAEpC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAC;IAE9B,IAAI,EAAE,MAAM,CAAC;IAEb,IAAI,EAAE,MAAM,CAAC;IAEb,MAAM,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC7C;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;AAKD,eAAO,MAAM,MAAM;8BAWJ,MAAM;4BAgBN,MAAM,GAAG,UAAU,aAAa,MAAM,GAAG,UAAU,KAAG,MAAM;4BAiB5D,MAAM,GAAG,UAAU,cAAc,MAAM,KAAG,UAAU;+BAgBjD,aAAa,QAAQ,MAAM,GAAG,UAAU,KAAG,MAAM;0CAkBpD,YAAY,aACZ,WAAW,KACrB,gBAAgB;+BAmBN,aAAa,iBACT,MAAM,WACZ,MAAM,GAAG,UAAU,KAC3B,MAAM;iCA0CI,aAAa,gBACV,MAAM,WACX,MAAM,GAAG,UAAU,gBACd,MAAM,KACnB,OAAO;sCAsCa,MAAM,GAAG,UAAU,KAAG,kBAAkB;uCAoBvC,qBAAqB,KAAG,oBAAoB;2CAsBxD,MAAM,GAAG,UAAU,OACxB,MAAM,KACV,oBAAoB;+BAkBV,aAAa,OACnB,MAAM,GAAG,UAAU,QAClB,MAAM,GAAG,UAAU,KACxB,MAAM;mCAoBW,iBAAiB,KAAG,OAAO;;;;;;;CAoBvC,CAAC"}

package/dist/crypto.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crypto = void 0;
+const secretbox_1 = require("./high-level/secretbox");
+const hash_1 = require("./modern/hash");
+const keygen_1 = require("./keys/keygen");
+const signing_1 = require("./modern/signing");
+const curves_1 = require("./modern/curves");
+const pq_sign_1 = require("./modern/pq-sign");
+const password_1 = require("./modern/password");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+const registry_1 = require("./registry");
+const mac_1 = require("./modern/mac");
+const errors_1 = require("./errors");
+exports.crypto = {
+    randomKey() {
+        return Buffer.from((0, utils_js_1.randomBytes)(32)).toString("hex");
+    },
+    encrypt(key, plaintext) {
+        return (0, secretbox_1.seal)(key, plaintext).sealed;
+    },
+    decrypt(key, ciphertext) {
+        return (0, secretbox_1.open)(key, ciphertext);
+    },
+    hash(algorithm, data) {
+        return (0, hash_1.hash)({ algorithm, data }).digest;
+    },
+    generateKeyPair(algorithm, metadata) {
+        return (0, keygen_1.generateKeyPair)(algorithm, metadata);
+    },
+    sign(algorithm, privateKeyHex, message) {
+        switch (algorithm) {
+            case "ed25519":
+                return (0, signing_1.ed25519Sign)(privateKeyHex, message).signature;
+            case "ed448":
+                return (0, curves_1.ed448Sign)(privateKeyHex, message).signature;
+            case "ecdsa-p256":
+                return (0, curves_1.p256Sign)(privateKeyHex, message).signature;
+            case "ecdsa-p384":
+                return (0, curves_1.p384Sign)(privateKeyHex, message).signature;
+            case "schnorr":
+                return (0, curves_1.schnorrSign)(privateKeyHex, message).signature;
+            case "ml-dsa-44":
+                return (0, pq_sign_1.mlDsaSign)(44, privateKeyHex, message).signature;
+            case "ml-dsa-65":
+                return (0, pq_sign_1.mlDsaSign)(65, privateKeyHex, message).signature;
+            case "ml-dsa-87":
+                return (0, pq_sign_1.mlDsaSign)(87, privateKeyHex, message).signature;
+            default:
+                throw new errors_1.CryptoError(`Unsupported signing algorithm: ${algorithm}`, errors_1.CryptoErrorCode.UNSUPPORTED_ALGORITHM);
+        }
+    },
+    verify(algorithm, publicKeyHex, message, signatureHex) {
+        switch (algorithm) {
+            case "ed25519":
+                return (0, signing_1.ed25519Verify)(publicKeyHex, message, signatureHex).valid;
+            case "ed448":
+                return (0, curves_1.ed448Verify)(publicKeyHex, message, signatureHex).valid;
+            case "ecdsa-p256":
+                return (0, curves_1.p256Verify)(publicKeyHex, message, signatureHex).valid;
+            case "ecdsa-p384":
+                return (0, curves_1.p384Verify)(publicKeyHex, message, signatureHex).valid;
+            case "schnorr":
+                return (0, curves_1.schnorrVerify)(publicKeyHex, message, signatureHex).valid;
+            case "ml-dsa-44":
+                return (0, pq_sign_1.mlDsaVerify)(44, publicKeyHex, message, signatureHex).valid;
+            case "ml-dsa-65":
+                return (0, pq_sign_1.mlDsaVerify)(65, publicKeyHex, message, signatureHex).valid;
+            case "ml-dsa-87":
+                return (0, pq_sign_1.mlDsaVerify)(87, publicKeyHex, message, signatureHex).valid;
+            default:
+                throw new errors_1.CryptoError(`Unsupported verify algorithm: ${algorithm}`, errors_1.CryptoErrorCode.UNSUPPORTED_ALGORITHM);
+        }
+    },
+    hashPassword(password) {
+        return (0, password_1.hashPassword)({ password });
+    },
+    verifyPassword(options) {
+        return (0, password_1.verifyPassword)({
+            password: options.password,
+            hash: options.hash,
+            salt: options.salt,
+            params: options.params,
+        });
+    },
+    verifyPasswordPhc(password, phc) {
+        return (0, password_1.verifyPasswordPhc)({ password, phc });
+    },
+    hmac(algorithm, key, data) {
+        return (0, mac_1.computeHmac)({ algorithm, key, data }).mac;
+    },
+    hmacVerify(options) {
+        return (0, mac_1.verifyHmac)({
+            algorithm: options.algorithm,
+            key: options.key,
+            data: options.data,
+            mac: options.mac,
+        }).valid;
+    },
+    registry: {
+        get: registry_1.getAlgorithm,
+        list: registry_1.listAlgorithms,
+        recommended: registry_1.recommended,
+        isDeprecated: registry_1.isDeprecated,
+    },
+};
+//# sourceMappingURL=crypto.js.map