@sebastienrousseau/crypto-lib 0.0.2 → 0.0.8

package/dist/enums.d.ts

@@ -0,0 +1,81 @@
+declare const _default: {
+    hash: {
+        md5: number;
+        sha1: number;
+        ripemd: number;
+        sha256: number;
+        sha384: number;
+        sha512: number;
+        sha224: number;
+    };
+    size: {
+        keySize512: number;
+        keySize1024: number;
+        keySize2048: number;
+        keySize3072: number;
+        keySize4096: number;
+        keySize6144: number;
+        keySize7680: number;
+        keySize8192: number;
+        keySize15360: number;
+    };
+    curve: {
+        p256: string;
+        "P-256": string;
+        secp256r1: string;
+        prime256v1: string;
+        "1.2.840.10045.3.1.7": string;
+        p384: string;
+        "P-384": string;
+        secp384r1: string;
+        "1.3.132.0.34": string;
+        "2b81040022": string;
+        "2B81040022": string;
+        p521: string;
+        "P-521": string;
+        secp521r1: string;
+        "1.3.132.0.35": string;
+        "2b81040023": string;
+        "2B81040023": string;
+        secp256k1: string;
+        "1.3.132.0.10": string;
+        "2b8104000a": string;
+        "2B8104000A": string;
+        ED25519: string;
+        ed25519: string;
+        Ed25519: string;
+        "1.3.6.1.4.1.11591.15.1": string;
+        "2b06010401da470f01": string;
+        "2B06010401DA470F01": string;
+        X25519: string;
+        cv25519: string;
+        curve25519: string;
+        Curve25519: string;
+        "1.3.6.1.4.1.3029.1.5.1": string;
+        "2b060104019755010501": string;
+        "2B060104019755010501": string;
+        brainpoolP256r1: string;
+        "1.3.36.3.3.2.8.1.1.7": string;
+        "2b2403030208010107": string;
+        "2B2403030208010107": string;
+        brainpoolP384r1: string;
+        "1.3.36.3.3.2.8.1.1.11": string;
+        "2b240303020801010b": string;
+        "2B240303020801010B": string;
+        brainpoolP512r1: string;
+        "1.3.36.3.3.2.8.1.1.13": string;
+        "2b240303020801010d": string;
+        "2B240303020801010D": string;
+    };
+    type: {
+        ecc: string;
+        rsa: string;
+    };
+    format: {
+        armored: string;
+        binary: string;
+        object: string;
+    };
+};
+export default _default;
+//# sourceMappingURL=enums.d.ts.map

package/dist/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../src/enums.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAKA,wBA2OE"}

package/dist/enums.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = {
+    hash: {
+        md5: 1,
+        sha1: 2,
+        ripemd: 3,
+        sha256: 8,
+        sha384: 9,
+        sha512: 10,
+        sha224: 11,
+    },
+    size: {
+        keySize512: 512,
+        keySize1024: 1024,
+        keySize2048: 2048,
+        keySize3072: 3072,
+        keySize4096: 4096,
+        keySize6144: 6144,
+        keySize7680: 7680,
+        keySize8192: 8192,
+        keySize15360: 15360,
+    },
+    curve: {
+        p256: "p256",
+        "P-256": "p256",
+        secp256r1: "p256",
+        prime256v1: "p256",
+        "1.2.840.10045.3.1.7": "p256",
+        p384: "p384",
+        "P-384": "p384",
+        secp384r1: "p384",
+        "1.3.132.0.34": "p384",
+        "2b81040022": "p384",
+        "2B81040022": "p384",
+        p521: "p521",
+        "P-521": "p521",
+        secp521r1: "p521",
+        "1.3.132.0.35": "p521",
+        "2b81040023": "p521",
+        "2B81040023": "p521",
+        secp256k1: "secp256k1",
+        "1.3.132.0.10": "secp256k1",
+        "2b8104000a": "secp256k1",
+        "2B8104000A": "secp256k1",
+        ED25519: "ed25519",
+        ed25519: "ed25519",
+        Ed25519: "ed25519",
+        "1.3.6.1.4.1.11591.15.1": "ed25519",
+        "2b06010401da470f01": "ed25519",
+        "2B06010401DA470F01": "ed25519",
+        X25519: "curve25519",
+        cv25519: "curve25519",
+        curve25519: "curve25519",
+        Curve25519: "curve25519",
+        "1.3.6.1.4.1.3029.1.5.1": "curve25519",
+        "2b060104019755010501": "curve25519",
+        "2B060104019755010501": "curve25519",
+        brainpoolP256r1: "brainpoolP256r1",
+        "1.3.36.3.3.2.8.1.1.7": "brainpoolP256r1",
+        "2b2403030208010107": "brainpoolP256r1",
+        "2B2403030208010107": "brainpoolP256r1",
+        brainpoolP384r1: "brainpoolP384r1",
+        "1.3.36.3.3.2.8.1.1.11": "brainpoolP384r1",
+        "2b240303020801010b": "brainpoolP384r1",
+        "2B240303020801010B": "brainpoolP384r1",
+        brainpoolP512r1: "brainpoolP512r1",
+        "1.3.36.3.3.2.8.1.1.13": "brainpoolP512r1",
+        "2b240303020801010d": "brainpoolP512r1",
+        "2B240303020801010D": "brainpoolP512r1",
+    },
+    type: {
+        ecc: "ecc",
+        rsa: "rsa",
+    },
+    format: {
+        armored: "armored",
+        binary: "binary",
+        object: "object",
+    },
+};
+//# sourceMappingURL=enums.js.map

package/dist/errors.d.ts

@@ -0,0 +1,14 @@
+export declare class CryptoError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+export declare const CryptoErrorCode: {
+    readonly INVALID_KEY: "INVALID_KEY";
+    readonly UNSUPPORTED_ALGORITHM: "UNSUPPORTED_ALGORITHM";
+    readonly INVALID_HEX: "INVALID_HEX";
+    readonly INVALID_CIPHERTEXT: "INVALID_CIPHERTEXT";
+    readonly AUTH_FAILED: "AUTH_FAILED";
+    readonly BUFFER_DESTROYED: "BUFFER_DESTROYED";
+    readonly INVALID_INPUT: "INVALID_INPUT";
+};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAwBA,qBAAa,WAAY,SAAQ,KAAK;IAEpC,SAAgB,IAAI,EAAE,MAAM,CAAC;gBAajB,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;CAK1C;AAGD,eAAO,MAAM,eAAe;;;;;;;;CAelB,CAAC"}

package/dist/errors.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoErrorCode = exports.CryptoError = void 0;
+class CryptoError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = "CryptoError";
+        this.code = code;
+    }
+}
+exports.CryptoError = CryptoError;
+exports.CryptoErrorCode = {
+    INVALID_KEY: "INVALID_KEY",
+    UNSUPPORTED_ALGORITHM: "UNSUPPORTED_ALGORITHM",
+    INVALID_HEX: "INVALID_HEX",
+    INVALID_CIPHERTEXT: "INVALID_CIPHERTEXT",
+    AUTH_FAILED: "AUTH_FAILED",
+    BUFFER_DESTROYED: "BUFFER_DESTROYED",
+    INVALID_INPUT: "INVALID_INPUT",
+};
+//# sourceMappingURL=errors.js.map

package/dist/high-level/index.d.ts

@@ -0,0 +1,11 @@
+export * as secretbox from "./secretbox";
+export type { SecretboxResult } from "./secretbox";
+export * as sealedbox from "./sealedbox";
+export type { SealedBoxResult, PqSealedBoxResult } from "./sealedbox";
+export { passwordEncrypt, passwordDecrypt } from "./password-encrypt";
+export type { PasswordEncryptOptions, PasswordEncryptResult, } from "./password-encrypt";
+export { aesKwWrap, aesKwUnwrap, aesKwpWrap, aesKwpUnwrap, x25519AesKwWrap, x25519AesKwUnwrap, } from "./key-wrap";
+export type { AesKwWrapResult, X25519AesKwWrapResult } from "./key-wrap";
+export { multiEncrypt, multiDecryptClassical, multiDecryptPQ, } from "./multi-recipient";
+export type { ClassicalRecipient, PqRecipient, Recipient, WrappedKey, MultiRecipientEncryptResult, } from "./multi-recipient";
+//# sourceMappingURL=index.d.ts.map

package/dist/high-level/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/high-level/index.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAEzC,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAEzC,YAAY,EAAE,eAAe,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEtE,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAEtE,YAAY,EACV,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,SAAS,EACT,WAAW,EACX,UAAU,EACV,YAAY,EACZ,eAAe,EACf,iBAAiB,GAClB,MAAM,YAAY,CAAC;AAEpB,YAAY,EAAE,eAAe,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAEzE,OAAO,EACL,YAAY,EACZ,qBAAqB,EACrB,cAAc,GACf,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,kBAAkB,EAClB,WAAW,EACX,SAAS,EACT,UAAU,EACV,2BAA2B,GAC5B,MAAM,mBAAmB,CAAC"}

package/dist/high-level/index.js

@@ -0,0 +1,53 @@
+"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.multiDecryptPQ = exports.multiDecryptClassical = exports.multiEncrypt = exports.x25519AesKwUnwrap = exports.x25519AesKwWrap = exports.aesKwpUnwrap = exports.aesKwpWrap = exports.aesKwUnwrap = exports.aesKwWrap = exports.passwordDecrypt = exports.passwordEncrypt = exports.sealedbox = exports.secretbox = void 0;
+exports.secretbox = __importStar(require("./secretbox"));
+exports.sealedbox = __importStar(require("./sealedbox"));
+var password_encrypt_1 = require("./password-encrypt");
+Object.defineProperty(exports, "passwordEncrypt", { enumerable: true, get: function () { return password_encrypt_1.passwordEncrypt; } });
+Object.defineProperty(exports, "passwordDecrypt", { enumerable: true, get: function () { return password_encrypt_1.passwordDecrypt; } });
+var key_wrap_1 = require("./key-wrap");
+Object.defineProperty(exports, "aesKwWrap", { enumerable: true, get: function () { return key_wrap_1.aesKwWrap; } });
+Object.defineProperty(exports, "aesKwUnwrap", { enumerable: true, get: function () { return key_wrap_1.aesKwUnwrap; } });
+Object.defineProperty(exports, "aesKwpWrap", { enumerable: true, get: function () { return key_wrap_1.aesKwpWrap; } });
+Object.defineProperty(exports, "aesKwpUnwrap", { enumerable: true, get: function () { return key_wrap_1.aesKwpUnwrap; } });
+Object.defineProperty(exports, "x25519AesKwWrap", { enumerable: true, get: function () { return key_wrap_1.x25519AesKwWrap; } });
+Object.defineProperty(exports, "x25519AesKwUnwrap", { enumerable: true, get: function () { return key_wrap_1.x25519AesKwUnwrap; } });
+var multi_recipient_1 = require("./multi-recipient");
+Object.defineProperty(exports, "multiEncrypt", { enumerable: true, get: function () { return multi_recipient_1.multiEncrypt; } });
+Object.defineProperty(exports, "multiDecryptClassical", { enumerable: true, get: function () { return multi_recipient_1.multiDecryptClassical; } });
+Object.defineProperty(exports, "multiDecryptPQ", { enumerable: true, get: function () { return multi_recipient_1.multiDecryptPQ; } });
+//# sourceMappingURL=index.js.map

package/dist/high-level/key-wrap.d.ts

@@ -0,0 +1,16 @@
+export interface AesKwWrapResult {
+    wrapped: string;
+    algorithm: "aes-kw" | "aes-kwp";
+}
+export interface X25519AesKwWrapResult {
+    wrapped: string;
+    ephemeralPublicKey: string;
+    algorithm: "x25519-aes-kw";
+}
+export declare function aesKwWrap(kek: string | Uint8Array, keyToWrap: string | Uint8Array): AesKwWrapResult;
+export declare function aesKwUnwrap(kek: string | Uint8Array, wrappedKey: string | Uint8Array): Uint8Array;
+export declare function aesKwpWrap(kek: string | Uint8Array, data: string | Uint8Array): AesKwWrapResult;
+export declare function aesKwpUnwrap(kek: string | Uint8Array, wrappedData: string | Uint8Array): Uint8Array;
+export declare function x25519AesKwWrap(recipientPublicKey: string | Uint8Array, keyToWrap: string | Uint8Array): X25519AesKwWrapResult;
+export declare function x25519AesKwUnwrap(recipientSecretKey: string | Uint8Array, ephemeralPublicKey: string | Uint8Array, wrappedKey: string | Uint8Array): Uint8Array;
+//# sourceMappingURL=key-wrap.d.ts.map

package/dist/high-level/key-wrap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-wrap.d.ts","sourceRoot":"","sources":["../../src/high-level/key-wrap.ts"],"names":[],"mappings":"AAuCA,MAAM,WAAW,eAAe;IAE9B,OAAO,EAAE,MAAM,CAAC;IAEhB,SAAS,EAAE,QAAQ,GAAG,SAAS,CAAC;CACjC;AAGD,MAAM,WAAW,qBAAqB;IAEpC,OAAO,EAAE,MAAM,CAAC;IAEhB,kBAAkB,EAAE,MAAM,CAAC;IAE3B,SAAS,EAAE,eAAe,CAAC;CAC5B;AAUD,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,GAAG,UAAU,EACxB,SAAS,EAAE,MAAM,GAAG,UAAU,GAC7B,eAAe,CASjB;AAQD,wBAAgB,WAAW,CACzB,GAAG,EAAE,MAAM,GAAG,UAAU,EACxB,UAAU,EAAE,MAAM,GAAG,UAAU,GAC9B,UAAU,CAQZ;AAUD,wBAAgB,UAAU,CACxB,GAAG,EAAE,MAAM,GAAG,UAAU,EACxB,IAAI,EAAE,MAAM,GAAG,UAAU,GACxB,eAAe,CASjB;AAQD,wBAAgB,YAAY,CAC1B,GAAG,EAAE,MAAM,GAAG,UAAU,EACxB,WAAW,EAAE,MAAM,GAAG,UAAU,GAC/B,UAAU,CAQZ;AAcD,wBAAgB,eAAe,CAC7B,kBAAkB,EAAE,MAAM,GAAG,UAAU,EACvC,SAAS,EAAE,MAAM,GAAG,UAAU,GAC7B,qBAAqB,CA0BvB;AASD,wBAAgB,iBAAiB,CAC/B,kBAAkB,EAAE,MAAM,GAAG,UAAU,EACvC,kBAAkB,EAAE,MAAM,GAAG,UAAU,EACvC,UAAU,EAAE,MAAM,GAAG,UAAU,GAC9B,UAAU,CA0BZ"}

package/dist/high-level/key-wrap.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aesKwWrap = aesKwWrap;
+exports.aesKwUnwrap = aesKwUnwrap;
+exports.aesKwpWrap = aesKwpWrap;
+exports.aesKwpUnwrap = aesKwpUnwrap;
+exports.x25519AesKwWrap = x25519AesKwWrap;
+exports.x25519AesKwUnwrap = x25519AesKwUnwrap;
+const aes_js_1 = require("@noble/ciphers/aes.js");
+const ed25519_js_1 = require("@noble/curves/ed25519.js");
+const hkdf_js_1 = require("@noble/hashes/hkdf.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+const HEX_RE = /^[0-9a-fA-F]*$/;
+function hexToBytes(hex) {
+    if (!HEX_RE.test(hex))
+        throw new Error("Invalid hex string");
+    return Buffer.from(hex, "hex");
+}
+function toKey(key) {
+    if (key instanceof Uint8Array)
+        return key;
+    return hexToBytes(key);
+}
+function aesKwWrap(kek, keyToWrap) {
+    const kekBytes = toKey(kek);
+    const keyBytes = toKey(keyToWrap);
+    const cipher = (0, aes_js_1.aeskw)(kekBytes);
+    const wrapped = cipher.encrypt(keyBytes);
+    return {
+        wrapped: Buffer.from(wrapped).toString("base64"),
+        algorithm: "aes-kw",
+    };
+}
+function aesKwUnwrap(kek, wrappedKey) {
+    const kekBytes = toKey(kek);
+    const wrapped = wrappedKey instanceof Uint8Array
+        ? wrappedKey
+        : Buffer.from(wrappedKey, "base64");
+    const cipher = (0, aes_js_1.aeskw)(kekBytes);
+    return cipher.decrypt(wrapped);
+}
+function aesKwpWrap(kek, data) {
+    const kekBytes = toKey(kek);
+    const dataBytes = toKey(data);
+    const cipher = (0, aes_js_1.aeskwp)(kekBytes);
+    const wrapped = cipher.encrypt(dataBytes);
+    return {
+        wrapped: Buffer.from(wrapped).toString("base64"),
+        algorithm: "aes-kwp",
+    };
+}
+function aesKwpUnwrap(kek, wrappedData) {
+    const kekBytes = toKey(kek);
+    const wrapped = wrappedData instanceof Uint8Array
+        ? wrappedData
+        : Buffer.from(wrappedData, "base64");
+    const cipher = (0, aes_js_1.aeskwp)(kekBytes);
+    return cipher.decrypt(wrapped);
+}
+function x25519AesKwWrap(recipientPublicKey, keyToWrap) {
+    const recipPub = typeof recipientPublicKey === "string"
+        ? hexToBytes(recipientPublicKey)
+        : recipientPublicKey;
+    const keyBytes = toKey(keyToWrap);
+    const ephPriv = (0, utils_js_1.randomBytes)(32);
+    const ephPub = ed25519_js_1.x25519.getPublicKey(ephPriv);
+    const raw = ed25519_js_1.x25519.getSharedSecret(ephPriv, recipPub);
+    const kek = (0, hkdf_js_1.hkdf)(sha2_js_1.sha256, raw, ephPub, new TextEncoder().encode("x25519-aes-kw-v1"), 32);
+    const cipher = (0, aes_js_1.aeskw)(kek);
+    const wrapped = cipher.encrypt(keyBytes);
+    return {
+        wrapped: Buffer.from(wrapped).toString("base64"),
+        ephemeralPublicKey: Buffer.from(ephPub).toString("hex"),
+        algorithm: "x25519-aes-kw",
+    };
+}
+function x25519AesKwUnwrap(recipientSecretKey, ephemeralPublicKey, wrappedKey) {
+    const secKey = typeof recipientSecretKey === "string"
+        ? hexToBytes(recipientSecretKey)
+        : recipientSecretKey;
+    const ephPub = typeof ephemeralPublicKey === "string"
+        ? hexToBytes(ephemeralPublicKey)
+        : ephemeralPublicKey;
+    const wrapped = wrappedKey instanceof Uint8Array
+        ? wrappedKey
+        : Buffer.from(wrappedKey, "base64");
+    const raw = ed25519_js_1.x25519.getSharedSecret(secKey, ephPub);
+    const kek = (0, hkdf_js_1.hkdf)(sha2_js_1.sha256, raw, ephPub, new TextEncoder().encode("x25519-aes-kw-v1"), 32);
+    const cipher = (0, aes_js_1.aeskw)(kek);
+    return cipher.decrypt(wrapped);
+}
+//# sourceMappingURL=key-wrap.js.map

package/dist/high-level/multi-recipient.d.ts

@@ -0,0 +1,25 @@
+export interface ClassicalRecipient {
+    type: "x25519";
+    publicKey: string;
+}
+export interface PqRecipient {
+    type: "x25519-ml-kem-768";
+    x25519PublicKey: string;
+    mlKemPublicKey: string;
+}
+export type Recipient = ClassicalRecipient | PqRecipient;
+export interface WrappedKey {
+    type: "x25519" | "x25519-ml-kem-768";
+    wrappedKey: string;
+    ephemeralPublicKey: string;
+    mlKemCiphertext?: string;
+}
+export interface MultiRecipientEncryptResult {
+    ciphertext: string;
+    recipients: WrappedKey[];
+    algorithm: "multi-recipient-secretbox";
+}
+export declare function multiEncrypt(recipients: Recipient[], plaintext: string | Uint8Array): MultiRecipientEncryptResult;
+export declare function multiDecryptClassical(secretKey: string | Uint8Array, wrappedKey: WrappedKey, ciphertext: string): Uint8Array;
+export declare function multiDecryptPQ(x25519SecretKey: string | Uint8Array, mlKemSecretKey: string | Uint8Array, wrappedKey: WrappedKey, ciphertext: string): Uint8Array;
+//# sourceMappingURL=multi-recipient.d.ts.map

package/dist/high-level/multi-recipient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multi-recipient.d.ts","sourceRoot":"","sources":["../../src/high-level/multi-recipient.ts"],"names":[],"mappings":"AAwCA,MAAM,WAAW,kBAAkB;IAEjC,IAAI,EAAE,QAAQ,CAAC;IAEf,SAAS,EAAE,MAAM,CAAC;CACnB;AAGD,MAAM,WAAW,WAAW;IAE1B,IAAI,EAAE,mBAAmB,CAAC;IAE1B,eAAe,EAAE,MAAM,CAAC;IAExB,cAAc,EAAE,MAAM,CAAC;CACxB;AAGD,MAAM,MAAM,SAAS,GAAG,kBAAkB,GAAG,WAAW,CAAC;AAGzD,MAAM,WAAW,UAAU;IAEzB,IAAI,EAAE,QAAQ,GAAG,mBAAmB,CAAC;IAErC,UAAU,EAAE,MAAM,CAAC;IAEnB,kBAAkB,EAAE,MAAM,CAAC;IAE3B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAGD,MAAM,WAAW,2BAA2B;IAE1C,UAAU,EAAE,MAAM,CAAC;IAEnB,UAAU,EAAE,UAAU,EAAE,CAAC;IAEzB,SAAS,EAAE,2BAA2B,CAAC;CACxC;AAQD,wBAAgB,YAAY,CAC1B,UAAU,EAAE,SAAS,EAAE,EACvB,SAAS,EAAE,MAAM,GAAG,UAAU,GAC7B,2BAA2B,CAgE7B;AASD,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,MAAM,GAAG,UAAU,EAC9B,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,GACjB,UAAU,CAOZ;AAUD,wBAAgB,cAAc,CAC5B,eAAe,EAAE,MAAM,GAAG,UAAU,EACpC,cAAc,EAAE,MAAM,GAAG,UAAU,EACnC,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,MAAM,GACjB,UAAU,CAuCZ"}

package/dist/high-level/multi-recipient.js

@@ -0,0 +1,122 @@
+"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.multiEncrypt = multiEncrypt;
+exports.multiDecryptClassical = multiDecryptClassical;
+exports.multiDecryptPQ = multiDecryptPQ;
+const utils_js_1 = require("@noble/ciphers/utils.js");
+const secretbox = __importStar(require("./secretbox"));
+const key_wrap_1 = require("./key-wrap");
+const ed25519_js_1 = require("@noble/curves/ed25519.js");
+const ml_kem_js_1 = require("@noble/post-quantum/ml-kem.js");
+const aes_js_1 = require("@noble/ciphers/aes.js");
+const hkdf_js_1 = require("@noble/hashes/hkdf.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const HEX_RE = /^[0-9a-fA-F]*$/;
+function hexToBytes(hex) {
+    if (!HEX_RE.test(hex))
+        throw new Error("Invalid hex string");
+    return Buffer.from(hex, "hex");
+}
+function multiEncrypt(recipients, plaintext) {
+    if (recipients.length === 0) {
+        throw new Error("At least one recipient is required");
+    }
+    const dek = (0, utils_js_1.randomBytes)(32);
+    const sealed = secretbox.seal(dek, plaintext);
+    const wrappedKeys = recipients.map((r) => {
+        if (r.type === "x25519") {
+            const result = (0, key_wrap_1.x25519AesKwWrap)(r.publicKey, dek);
+            return {
+                type: "x25519",
+                wrappedKey: result.wrapped,
+                ephemeralPublicKey: result.ephemeralPublicKey,
+            };
+        }
+        else {
+            const x25519Pub = hexToBytes(r.x25519PublicKey);
+            const mlKemPub = hexToBytes(r.mlKemPublicKey);
+            const ephPriv = (0, utils_js_1.randomBytes)(32);
+            const ephPub = ed25519_js_1.x25519.getPublicKey(ephPriv);
+            const x25519Shared = ed25519_js_1.x25519.getSharedSecret(ephPriv, x25519Pub);
+            const { cipherText: mlKemCt, sharedSecret: mlKemShared } = ml_kem_js_1.ml_kem768.encapsulate(mlKemPub);
+            const combined = new Uint8Array(x25519Shared.length + mlKemShared.length);
+            combined.set(x25519Shared);
+            combined.set(mlKemShared, x25519Shared.length);
+            const kek = (0, hkdf_js_1.hkdf)(sha2_js_1.sha256, combined, ephPub, new TextEncoder().encode("multi-recipient-pq-v1"), 32);
+            const cipher = (0, aes_js_1.aeskw)(kek);
+            const wrapped = cipher.encrypt(dek);
+            return {
+                type: "x25519-ml-kem-768",
+                wrappedKey: Buffer.from(wrapped).toString("base64"),
+                ephemeralPublicKey: Buffer.from(ephPub).toString("hex"),
+                mlKemCiphertext: Buffer.from(mlKemCt).toString("hex"),
+            };
+        }
+    });
+    return {
+        ciphertext: sealed.sealed,
+        recipients: wrappedKeys,
+        algorithm: "multi-recipient-secretbox",
+    };
+}
+function multiDecryptClassical(secretKey, wrappedKey, ciphertext) {
+    const dek = (0, key_wrap_1.x25519AesKwUnwrap)(secretKey, wrappedKey.ephemeralPublicKey, wrappedKey.wrappedKey);
+    return secretbox.open(dek, ciphertext);
+}
+function multiDecryptPQ(x25519SecretKey, mlKemSecretKey, wrappedKey, ciphertext) {
+    const x25519Sec = typeof x25519SecretKey === "string"
+        ? hexToBytes(x25519SecretKey)
+        : x25519SecretKey;
+    const mlKemSec = typeof mlKemSecretKey === "string"
+        ? hexToBytes(mlKemSecretKey)
+        : mlKemSecretKey;
+    if (!wrappedKey.mlKemCiphertext) {
+        throw new Error("Missing ML-KEM ciphertext in wrapped key");
+    }
+    const ephPub = hexToBytes(wrappedKey.ephemeralPublicKey);
+    const mlKemCt = hexToBytes(wrappedKey.mlKemCiphertext);
+    const x25519Shared = ed25519_js_1.x25519.getSharedSecret(x25519Sec, ephPub);
+    const mlKemShared = ml_kem_js_1.ml_kem768.decapsulate(mlKemCt, mlKemSec);
+    const combined = new Uint8Array(x25519Shared.length + mlKemShared.length);
+    combined.set(x25519Shared);
+    combined.set(mlKemShared, x25519Shared.length);
+    const kek = (0, hkdf_js_1.hkdf)(sha2_js_1.sha256, combined, ephPub, new TextEncoder().encode("multi-recipient-pq-v1"), 32);
+    const wrapped = Buffer.from(wrappedKey.wrappedKey, "base64");
+    const cipher = (0, aes_js_1.aeskw)(kek);
+    const dek = cipher.decrypt(wrapped);
+    return secretbox.open(dek, ciphertext);
+}
+//# sourceMappingURL=multi-recipient.js.map

package/dist/high-level/password-encrypt.d.ts

@@ -0,0 +1,14 @@
+export interface PasswordEncryptOptions {
+    password: string | Uint8Array;
+    plaintext: string | Uint8Array;
+    timeCost?: number;
+    memoryCost?: number;
+    parallelism?: number;
+}
+export interface PasswordEncryptResult {
+    encrypted: string;
+    algorithm: "argon2id-xchacha20-poly1305";
+}
+export declare function passwordEncrypt(options: PasswordEncryptOptions): PasswordEncryptResult;
+export declare function passwordDecrypt(password: string | Uint8Array, encrypted: string | Uint8Array): Uint8Array;
+//# sourceMappingURL=password-encrypt.d.ts.map

package/dist/high-level/password-encrypt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password-encrypt.d.ts","sourceRoot":"","sources":["../../src/high-level/password-encrypt.ts"],"names":[],"mappings":"AAoDA,MAAM,WAAW,sBAAsB;IAErC,QAAQ,EAAE,MAAM,GAAG,UAAU,CAAC;IAE9B,SAAS,EAAE,MAAM,GAAG,UAAU,CAAC;IAE/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,UAAU,CAAC,EAAE,MAAM,CAAC;IAEpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAGD,MAAM,WAAW,qBAAqB;IAEpC,SAAS,EAAE,MAAM,CAAC;IAElB,SAAS,EAAE,6BAA6B,CAAC;CAC1C;AAsDD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,sBAAsB,GAC9B,qBAAqB,CAwBvB;AAQD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,GAAG,UAAU,EAC7B,SAAS,EAAE,MAAM,GAAG,UAAU,GAC7B,UAAU,CA+BZ"}

package/dist/high-level/password-encrypt.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.passwordEncrypt = passwordEncrypt;
+exports.passwordDecrypt = passwordDecrypt;
+const argon2_js_1 = require("@noble/hashes/argon2.js");
+const chacha_js_1 = require("@noble/ciphers/chacha.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+const cost_limits_1 = require("../modern/cost-limits");
+const VERSION_V1 = 0x01;
+const VERSION_V2 = 0x02;
+const SALT_LEN = 16;
+const NONCE_LEN = 24;
+const KEY_LEN = 32;
+const TAG_LEN = 16;
+const HEADER_LEN = 1 + 4 + 4 + 4 + 4 + SALT_LEN + NONCE_LEN;
+const DEFAULT_TIME = 3;
+const DEFAULT_MEMORY = 65536;
+const DEFAULT_PARALLELISM = 4;
+function toBytes(input) {
+    return input instanceof Uint8Array ? input : Buffer.from(input, "utf8");
+}
+function writeU32LE(buf, value, offset) {
+    buf[offset] = value & 0xff;
+    buf[offset + 1] = (value >>> 8) & 0xff;
+    buf[offset + 2] = (value >>> 16) & 0xff;
+    buf[offset + 3] = (value >>> 24) & 0xff;
+}
+function readU32LE(buf, offset) {
+    return ((buf[offset] |
+        (buf[offset + 1] << 8) |
+        (buf[offset + 2] << 16) |
+        (buf[offset + 3] << 24)) >>>
+        0);
+}
+function buildHeader(t, m, p, salt, nonce) {
+    const header = new Uint8Array(HEADER_LEN);
+    header[0] = VERSION_V2;
+    writeU32LE(header, t, 1);
+    writeU32LE(header, m, 5);
+    writeU32LE(header, p, 9);
+    writeU32LE(header, KEY_LEN, 13);
+    header.set(salt, 17);
+    header.set(nonce, 17 + SALT_LEN);
+    return header;
+}
+function passwordEncrypt(options) {
+    const pwd = toBytes(options.password);
+    const pt = toBytes(options.plaintext);
+    const t = options.timeCost ?? DEFAULT_TIME;
+    const m = options.memoryCost ?? DEFAULT_MEMORY;
+    const p = options.parallelism ?? DEFAULT_PARALLELISM;
+    (0, cost_limits_1.checkArgon2Costs)(t, m, p);
+    const salt = (0, utils_js_1.randomBytes)(SALT_LEN);
+    const key = (0, argon2_js_1.argon2id)(pwd, salt, { t, m, p, dkLen: KEY_LEN });
+    const nonce = (0, utils_js_1.randomBytes)(NONCE_LEN);
+    const header = buildHeader(t, m, p, salt, nonce);
+    const ct = (0, chacha_js_1.xchacha20poly1305)(key, nonce, header).encrypt(pt);
+    const out = new Uint8Array(HEADER_LEN + ct.length);
+    out.set(header, 0);
+    out.set(ct, HEADER_LEN);
+    return {
+        encrypted: Buffer.from(out).toString("base64"),
+        algorithm: "argon2id-xchacha20-poly1305",
+    };
+}
+function passwordDecrypt(password, encrypted) {
+    const pwd = toBytes(password);
+    const raw = encrypted instanceof Uint8Array
+        ? encrypted
+        : Buffer.from(encrypted, "base64");
+    if (raw.length < HEADER_LEN + TAG_LEN) {
+        throw new Error("Encrypted payload too short");
+    }
+    const version = raw[0];
+    if (version !== VERSION_V1 && version !== VERSION_V2) {
+        throw new Error(`Unsupported format version: ${version}`);
+    }
+    const t = readU32LE(raw, 1);
+    const m = readU32LE(raw, 5);
+    const p = readU32LE(raw, 9);
+    const dkLen = readU32LE(raw, 13);
+    const salt = raw.subarray(17, 17 + SALT_LEN);
+    const nonce = raw.subarray(17 + SALT_LEN, HEADER_LEN);
+    const ct = raw.subarray(HEADER_LEN);
+    (0, cost_limits_1.checkArgon2Costs)(t, m, p);
+    if (dkLen !== KEY_LEN) {
+        throw new Error(`Unsupported key length in header: ${dkLen}`);
+    }
+    const key = (0, argon2_js_1.argon2id)(pwd, salt, { t, m, p, dkLen });
+    const aad = version === VERSION_V2 ? raw.subarray(0, HEADER_LEN) : undefined;
+    return (0, chacha_js_1.xchacha20poly1305)(key, nonce, aad).decrypt(ct);
+}
+//# sourceMappingURL=password-encrypt.js.map