internxt-crypto 0.0.10-alpha → 0.0.13

package/dist/keystore-crypto.mjs

@@ -1,501 +1,3 @@
-import { utf8ToBytes } from '@noble/hashes/utils.js';
-import * as bip39 from '@scure/bip39';
-import { wordlist } from '@scure/bip39/wordlists/english';
-import { blake3 } from '@noble/hashes/blake3.js';
-import { randomBytes } from '@noble/post-quantum/utils.js';
-import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';
+import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-27mIHh18.mjs";
 
-// src/utils/converters.ts
-function UTF8ToUint8(str) {
-  return new TextEncoder().encode(str);
-}
-function uint8ArrayToBase64(buffer) {
-  const array = Uint16Array.from(buffer);
-  const binaryString = new TextDecoder("UTF-16").decode(array);
-  return btoa(binaryString);
-}
-function base64ToUint8Array(str) {
-  const binaryString = atob(str);
-  const len = binaryString.length;
-  const array = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    array[i] = binaryString.charCodeAt(i);
-  }
-  return new Uint8Array(array.buffer);
-}
-
-// src/constants.ts
-var AES_ALGORITHM = "AES-GCM";
-var AES_KEY_BIT_LENGTH = 256;
-var AUX_LEN = 128;
-var IV_LEN_BYTES = 16;
-var KEY_FORMAT = "raw";
-var ECC_ALGORITHM = "X25519";
-var CONTEXT_LOGIN = "CRYPTO library 2025-07-26 16:18:03 key for opening identity keystore";
-var CONTEXT_ENC_KEYSTORE = "CRYPTO library 2025-07-30 16:18:03 key for opening encryption keys keystore";
-var CONTEXT_RECOVERY = "CRYPTO library 2025-07-30 16:20:00 key for account recovery";
-var IDENTITY_KEYSTORE_TAG = "Identity keystore";
-var ENCRYPTION_KEYSTORE_TAG = "Encryption keystore";
-var RECOVERY_KEYSTORE_TAG = "Key recovery keystroe";
-
-// src/asymmetric-crypto/keys.ts
-async function generateEccKeys() {
-  try {
-    return await crypto.subtle.generateKey(
-      {
-        name: ECC_ALGORITHM
-      },
-      true,
-      ["deriveBits"]
-    );
-  } catch (error) {
-    throw new Error("Failed to generate elliptic curve key pair", { cause: error });
-  }
-}
-async function exportPublicKey(key) {
-  try {
-    const result = await crypto.subtle.exportKey("spki", key);
-    return new Uint8Array(result);
-  } catch (error) {
-    throw new Error("Failed to export public key", { cause: error });
-  }
-}
-async function importPublicKey(spkiKeyData) {
-  try {
-    return await crypto.subtle.importKey(
-      "spki",
-      spkiKeyData,
-      {
-        name: ECC_ALGORITHM
-      },
-      true,
-      []
-    );
-  } catch (error) {
-    throw new Error("Failed to import public key", { cause: error });
-  }
-}
-async function exportPrivateKey(key) {
-  try {
-    const result = await crypto.subtle.exportKey("pkcs8", key);
-    return new Uint8Array(result);
-  } catch (error) {
-    throw new Error("Failed to export private key", { cause: error });
-  }
-}
-async function importPrivateKey(pkcs8KeyData) {
-  try {
-    return await crypto.subtle.importKey(
-      "pkcs8",
-      pkcs8KeyData,
-      {
-        name: ECC_ALGORITHM
-      },
-      true,
-      ["deriveBits"]
-    );
-  } catch (error) {
-    throw new Error("Failed to import private key", { cause: error });
-  }
-}
-
-// src/utils/keyConverters.ts
-async function identityKeysToBase64(keys) {
-  try {
-    const pkArray = await exportPublicKey(keys.userPublicKey);
-    const skArray = await exportPrivateKey(keys.userPrivateKey);
-    const json = JSON.stringify({
-      userPublicKey: uint8ArrayToBase64(pkArray),
-      userPrivateKey: uint8ArrayToBase64(skArray)
-    });
-    const base64 = btoa(json);
-    return base64;
-  } catch (error) {
-    throw new Error("Failed to convert identity keys to base64", { cause: error });
-  }
-}
-async function encryptionKeysToBase64(keys) {
-  try {
-    const pkArray = await exportPublicKey(keys.userPublicKey);
-    const skArray = await exportPrivateKey(keys.userPrivateKey);
-    const json = JSON.stringify({
-      userPublicKey: uint8ArrayToBase64(pkArray),
-      userPrivateKey: uint8ArrayToBase64(skArray),
-      userPublicKyberKey: uint8ArrayToBase64(keys.userPublicKyberKey),
-      userPrivateKyberKey: uint8ArrayToBase64(keys.userPrivateKyberKey)
-    });
-    const base64 = btoa(json);
-    return base64;
-  } catch (error) {
-    throw new Error("Failed to convert identity keys to base64", { cause: error });
-  }
-}
-async function base64ToIdentityKeys(base64) {
-  try {
-    const json = atob(base64);
-    const obj = JSON.parse(json);
-    const pkArray = base64ToUint8Array(obj.userPublicKey);
-    const skArray = base64ToUint8Array(obj.userPrivateKey);
-    const pkCryptoKey = await importPublicKey(pkArray);
-    const skCryptoKey = await importPrivateKey(skArray);
-    const result = {
-      userPublicKey: pkCryptoKey,
-      userPrivateKey: skCryptoKey
-    };
-    return result;
-  } catch (error) {
-    throw new Error("Failed convert base64 to idenity key", { cause: error });
-  }
-}
-async function base64ToEncryptionKeys(base64) {
-  try {
-    const json = atob(base64);
-    const obj = JSON.parse(json);
-    const pkArray = base64ToUint8Array(obj.userPublicKey);
-    const skArray = base64ToUint8Array(obj.userPrivateKey);
-    const pkCryptoKey = await importPublicKey(pkArray);
-    const skCryptoKey = await importPrivateKey(skArray);
-    const pkKyber = base64ToUint8Array(obj.userPublicKyberKey);
-    const skKyber = base64ToUint8Array(obj.userPrivateKyberKey);
-    const result = {
-      userPublicKey: pkCryptoKey,
-      userPrivateKey: skCryptoKey,
-      userPublicKyberKey: pkKyber,
-      userPrivateKyberKey: skKyber
-    };
-    return result;
-  } catch (error) {
-    throw new Error("Failed to convert base64 to encryption key", { cause: error });
-  }
-}
-function genMnemonic(bits) {
-  return bip39.generateMnemonic(wordlist, bits);
-}
-function getBytesFromString(bytes, value) {
-  return blake3(utf8ToBytes(value), { dkLen: bytes });
-}
-
-// src/symmetric-crypto/keys.ts
-async function importSymmetricCryptoKey(keyData) {
-  return crypto.subtle.importKey(
-    KEY_FORMAT,
-    new Uint8Array(keyData),
-    {
-      name: AES_ALGORITHM,
-      length: AES_KEY_BIT_LENGTH
-    },
-    true,
-    ["encrypt", "decrypt"]
-  );
-}
-async function createNISTbasedIV(freeField) {
-  try {
-    if (!freeField) {
-      return randomBytes(IV_LEN_BYTES);
-    }
-    const iv = new Uint8Array(16);
-    const randFiled = randomBytes(12);
-    iv.set(randFiled, 0);
-    const freeFiledFixedLength = await getBytesFromString(4, freeField);
-    iv.set(freeFiledFixedLength, 12);
-    return iv;
-  } catch (error) {
-    throw new Error("Failed to create IV", { cause: error });
-  }
-}
-async function makeAuxFixedLength(aux) {
-  return getBytesFromString(AUX_LEN / 8, aux);
-}
-async function encryptMessage(message, encryptionKey, iv, additionalData) {
-  try {
-    const encrypted = await crypto.subtle.encrypt(
-      { name: AES_ALGORITHM, iv, additionalData },
-      encryptionKey,
-      message
-    );
-    return new Uint8Array(encrypted);
-  } catch (error) {
-    throw new Error("Failed to encrypt symmetrically", { cause: error });
-  }
-}
-async function decryptMessage(ciphertext, iv, encryptionKey, additionalData) {
-  try {
-    const decrypted = await crypto.subtle.decrypt(
-      { name: AES_ALGORITHM, iv, additionalData },
-      encryptionKey,
-      ciphertext
-    );
-    return new Uint8Array(decrypted);
-  } catch (error) {
-    throw new Error("Failed to decrypt symmetrically", { cause: error });
-  }
-}
-
-// src/symmetric-crypto/aes.ts
-async function encryptSymmetrically(encryptionKey, message, aux, freeField) {
-  try {
-    const iv = await createNISTbasedIV(freeField);
-    const additionalData = await makeAuxFixedLength(aux);
-    const ciphertext = await encryptMessage(message, encryptionKey, iv, additionalData);
-    return { ciphertext, iv };
-  } catch (error) {
-    throw new Error("Failed to encrypt symmetrically", { cause: error });
-  }
-}
-async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
-  try {
-    const additionalData = await makeAuxFixedLength(aux);
-    const result = await decryptMessage(
-      encryptedMessage.ciphertext,
-      encryptedMessage.iv,
-      encryptionKey,
-      additionalData
-    );
-    return result;
-  } catch (error) {
-    throw new Error("Failed to decrypt symmetrically", { cause: error });
-  }
-}
-
-// src/storage-service/sessionStorageService.ts
-function get(key) {
-  return sessionStorage.getItem(key);
-}
-function set(key, value) {
-  return sessionStorage.setItem(key, value);
-}
-function removeItem(key) {
-  sessionStorage.removeItem(key);
-}
-function exists(key) {
-  return !!sessionStorage.getItem(key);
-}
-function clear() {
-  sessionStorage.clear();
-}
-var sessionStorageService = {
-  set,
-  get,
-  removeItem,
-  exists,
-  clear
-};
-var sessionStorageService_default = sessionStorageService;
-function deriveSymmetricKeyFromContext(context, baseKey) {
-  return blake3(baseKey, { context: UTF8ToUint8(context) });
-}
-async function deriveSymmetricCryptoKeyFromContext(context, baseKey) {
-  try {
-    if (baseKey.length != AES_KEY_BIT_LENGTH / 8) {
-      throw new Error(`Base key length must be exactly ${AES_KEY_BIT_LENGTH / 8} bytes`);
-    }
-    if (!context) {
-      throw new Error("Context is empry");
-    }
-    const keyBytes = deriveSymmetricKeyFromContext(context, baseKey);
-    const key = await importSymmetricCryptoKey(keyBytes);
-    return key;
-  } catch (error) {
-    throw new Error("Failed to derive CryptoKey from base key and context", { cause: error });
-  }
-}
-
-// src/keystore-crypto/core.ts
-async function encryptKeystoreContent(secretKey, content, userID, tag) {
-  try {
-    const aux = userID + tag;
-    const message = base64ToUint8Array(content);
-    const result = await encryptSymmetrically(secretKey, message, aux);
-    return result;
-  } catch (error) {
-    throw new Error("Failed to encrypt keystore content", { cause: error });
-  }
-}
-async function decryptKeystoreContent(secretKey, encryptedKeys, userID, tag) {
-  try {
-    const aux = userID + tag;
-    const content = await decryptSymmetrically(secretKey, encryptedKeys, aux);
-    const result = uint8ArrayToBase64(content);
-    return result;
-  } catch (error) {
-    throw new Error("Failed to decrypt keystore content", { cause: error });
-  }
-}
-function getUserID() {
-  try {
-    const userID = sessionStorageService_default.get("userID");
-    if (!userID) {
-      throw new Error("No UserID");
-    }
-    return userID;
-  } catch (error) {
-    throw new Error("Failed to get UserID from session storage", { cause: error });
-  }
-}
-function getBaseKey() {
-  try {
-    const baseKeyBase64 = sessionStorageService_default.get("baseKey");
-    if (!baseKeyBase64) {
-      throw new Error("No base key");
-    }
-    return base64ToUint8Array(baseKeyBase64);
-  } catch (error) {
-    throw new Error("Failed to get base key from session storage", { cause: error });
-  }
-}
-async function deriveIdentityKeystoreKey(baseKey) {
-  return deriveSymmetricCryptoKeyFromContext(CONTEXT_LOGIN, baseKey);
-}
-async function deriveRecoveryKey(recoveryCodes) {
-  const recoveryCodesBuffer = await getBytesFromString(AES_KEY_BIT_LENGTH / 8, recoveryCodes);
-  return deriveSymmetricCryptoKeyFromContext(CONTEXT_RECOVERY, recoveryCodesBuffer);
-}
-async function deriveEncryptionKeystoreKey(baseKey) {
-  return deriveSymmetricCryptoKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);
-}
-function generateKyberKeys(seed) {
-  try {
-    return ml_kem768.keygen(seed);
-  } catch (error) {
-    throw new Error("Failed to generate Kyber keys", { cause: error });
-  }
-}
-
-// src/keystore-crypto/emailEncryptionKey.ts
-function generateRecoveryCodes() {
-  return genMnemonic(AES_KEY_BIT_LENGTH);
-}
-async function generateEncryptionKeys() {
-  try {
-    const keyPair = await generateEccKeys();
-    const keyPairKyber = generateKyberKeys();
-    const result = {
-      userPrivateKey: keyPair.privateKey,
-      userPublicKey: keyPair.publicKey,
-      userPublicKyberKey: keyPairKyber.publicKey,
-      userPrivateKyberKey: keyPairKyber.secretKey
-    };
-    return result;
-  } catch (error) {
-    throw new Error("Failed to generate encryption keys", { cause: error });
-  }
-}
-async function createEncryptionAndRecoveryKeystores() {
-  try {
-    const userID = getUserID();
-    const baseKey = getBaseKey();
-    const keys = await generateEncryptionKeys();
-    const content = await encryptionKeysToBase64(keys);
-    const secretKey = await deriveEncryptionKeystoreKey(baseKey);
-    const ciphertext = await encryptKeystoreContent(secretKey, content, userID, ENCRYPTION_KEYSTORE_TAG);
-    const encryptionKeystore = {
-      userID,
-      type: "encryption" /* ENCRYPTION */,
-      encryptedKeys: ciphertext
-    };
-    const recoveryCodes = generateRecoveryCodes();
-    const recoveryKey = await deriveRecoveryKey(recoveryCodes);
-    const encKeys = await encryptKeystoreContent(recoveryKey, content, userID, RECOVERY_KEYSTORE_TAG);
-    const recoveryKeystore = {
-      userID,
-      type: "recovery" /* RECOVERY */,
-      encryptedKeys: encKeys
-    };
-    return { encryptionKeystore, recoveryKeystore, recoveryCodes };
-  } catch (error) {
-    throw new Error("Failed to create encryption and recovery keystores", { cause: error });
-  }
-}
-async function openEncryptionKeystore(encryptedKeystore) {
-  try {
-    if (encryptedKeystore.type != "encryption" /* ENCRYPTION */) {
-      throw new Error("Input is invalid");
-    }
-    const baseKey = getBaseKey();
-    const secretKey = await deriveEncryptionKeystoreKey(baseKey);
-    const json = await decryptKeystoreContent(
-      secretKey,
-      encryptedKeystore.encryptedKeys,
-      encryptedKeystore.userID,
-      ENCRYPTION_KEYSTORE_TAG
-    );
-    const keys = await base64ToEncryptionKeys(json);
-    return keys;
-  } catch (error) {
-    throw new Error("Failed to open encryption keystore", { cause: error });
-  }
-}
-async function openRecoveryKeystore(recoveryCodes, encryptedKeystore) {
-  try {
-    if (encryptedKeystore.type != "recovery" /* RECOVERY */) {
-      throw new Error("Input is invalid");
-    }
-    const recoveryKey = await deriveRecoveryKey(recoveryCodes);
-    const json = await decryptKeystoreContent(
-      recoveryKey,
-      encryptedKeystore.encryptedKeys,
-      encryptedKeystore.userID,
-      RECOVERY_KEYSTORE_TAG
-    );
-    const keys = await base64ToEncryptionKeys(json);
-    return keys;
-  } catch (error) {
-    throw new Error("Failed to open recovery keystore", { cause: error });
-  }
-}
-
-// src/keystore-crypto/userIdenityKey.ts
-async function generateIdentityKeys() {
-  try {
-    const keyPair = await generateEccKeys();
-    const result = {
-      userPrivateKey: keyPair.privateKey,
-      userPublicKey: keyPair.publicKey
-    };
-    return result;
-  } catch (error) {
-    throw new Error("Failed to generate idenity keys", { cause: error });
-  }
-}
-async function createIdentityKeystore() {
-  try {
-    const type = "identity" /* IDENTITY */;
-    const userID = getUserID();
-    const baseKey = getBaseKey();
-    const keys = await generateIdentityKeys();
-    const content = await identityKeysToBase64(keys);
-    const secretKey = await deriveIdentityKeystoreKey(baseKey);
-    const encryptedKeys = await encryptKeystoreContent(secretKey, content, userID, IDENTITY_KEYSTORE_TAG);
-    const result = {
-      userID,
-      type,
-      encryptedKeys
-    };
-    return result;
-  } catch (error) {
-    throw new Error("Failed to create identity keystore", { cause: error });
-  }
-}
-async function openIdentityKeystore(encryptedKeystore) {
-  try {
-    if (encryptedKeystore.type != "identity" /* IDENTITY */) {
-      throw new Error("Input is invalid");
-    }
-    const baseKey = getBaseKey();
-    const secretKey = await deriveIdentityKeystoreKey(baseKey);
-    const json = await decryptKeystoreContent(
-      secretKey,
-      encryptedKeystore.encryptedKeys,
-      encryptedKeystore.userID,
-      IDENTITY_KEYSTORE_TAG
-    );
-    const keys = await base64ToIdentityKeys(json);
-    return keys;
-  } catch (error) {
-    throw new Error("Failed to open identity keystore", { cause: error });
-  }
-}
-
-export { createEncryptionAndRecoveryKeystores, createIdentityKeystore, generateEncryptionKeys, generateIdentityKeys, generateRecoveryCodes, openEncryptionKeystore, openIdentityKeystore, openRecoveryKeystore };
-//# sourceMappingURL=keystore-crypto.mjs.map
-//# sourceMappingURL=keystore-crypto.mjs.map
+export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };

package/dist/kyber1024-PpwE1rki.mjs

@@ -0,0 +1,144 @@
+import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
+import { ml_kem1024, ml_kem512, ml_kem768 } from "@noble/post-quantum/ml-kem.js";
+
+//#region src/post-quantum-crypto/kyber768.ts
+/**
+* Generates public and secret Kyber keys
+*
+* @param seed - The optional seed
+* @returns The generated Kyber key pair.
+*/
+function generateKyberKeys$2(seed) {
+	try {
+		return ml_kem768.keygen(seed);
+	} catch (error) {
+		throw new Error("Failed to generate Kyber keys", { cause: error });
+	}
+}
+/**
+* Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+*
+* @param publicKey - The public Kyber key
+* @returns The resulting encapsulation and the generated shared secret.
+*/
+function encapsulateKyber$2(publicKey) {
+	try {
+		return ml_kem768.encapsulate(publicKey);
+	} catch (error) {
+		throw new Error("Failed to encapsulate", { cause: error });
+	}
+}
+/**
+* Decapsulates the encapsulated shared secret using Kyber algorithms
+*
+* @param cipherText - The encapsulated key
+* @param secretKey - The private Kyber key
+* @returns The resulting decapsulated shared secret.
+*/
+function decapsulateKyber$2(cipherText, secretKey) {
+	try {
+		return ml_kem768.decapsulate(cipherText, secretKey);
+	} catch (error) {
+		throw new Error("Failed to decapsulate", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/post-quantum-crypto/kyber512.ts
+var kyber512_exports = /* @__PURE__ */ __exportAll({
+	decapsulateKyber: () => decapsulateKyber$1,
+	encapsulateKyber: () => encapsulateKyber$1,
+	generateKyberKeys: () => generateKyberKeys$1
+});
+/**
+* Generates public and secret Kyber keys
+*
+* @param seed - The optional seed
+* @returns The generated Kyber key pair.
+*/
+function generateKyberKeys$1(seed) {
+	try {
+		return ml_kem512.keygen(seed);
+	} catch (error) {
+		throw new Error("Failed to generate Kyber keys", { cause: error });
+	}
+}
+/**
+* Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+*
+* @param publicKey - The public Kyber key
+* @returns The resulting encapsulation and the generated shared secret.
+*/
+function encapsulateKyber$1(publicKey) {
+	try {
+		return ml_kem512.encapsulate(publicKey);
+	} catch (error) {
+		throw new Error("Failed to encapsulate", { cause: error });
+	}
+}
+/**
+* Decapsulates the encapsulated shared secret using Kyber algorithms
+*
+* @param cipherText - The encapsulated key
+* @param secretKey - The private Kyber key
+* @returns The resulting decapsulated shared secret.
+*/
+function decapsulateKyber$1(cipherText, secretKey) {
+	try {
+		return ml_kem512.decapsulate(cipherText, secretKey);
+	} catch (error) {
+		throw new Error("Failed to decapsulate", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/post-quantum-crypto/kyber1024.ts
+var kyber1024_exports = /* @__PURE__ */ __exportAll({
+	decapsulateKyber: () => decapsulateKyber,
+	encapsulateKyber: () => encapsulateKyber,
+	generateKyberKeys: () => generateKyberKeys
+});
+/**
+* Generates public and secret Kyber keys
+*
+* @param seed - The optional seed
+* @returns The generated Kyber key pair.
+*/
+function generateKyberKeys(seed) {
+	try {
+		return ml_kem1024.keygen(seed);
+	} catch (error) {
+		throw new Error("Failed to generate Kyber keys", { cause: error });
+	}
+}
+/**
+* Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+*
+* @param publicKey - The public Kyber key
+* @returns The resulting encapsulation and the generated shared secret.
+*/
+function encapsulateKyber(publicKey) {
+	try {
+		return ml_kem1024.encapsulate(publicKey);
+	} catch (error) {
+		throw new Error("Failed to encapsulate", { cause: error });
+	}
+}
+/**
+* Decapsulates the encapsulated shared secret using Kyber algorithms
+*
+* @param cipherText - The encapsulated key
+* @param secretKey - The private Kyber key
+* @returns The resulting decapsulated shared secret.
+*/
+function decapsulateKyber(cipherText, secretKey) {
+	try {
+		return ml_kem1024.decapsulate(cipherText, secretKey);
+	} catch (error) {
+		throw new Error("Failed to decapsulate", { cause: error });
+	}
+}
+
+//#endregion
+export { generateKyberKeys$2 as a, encapsulateKyber$2 as i, kyber512_exports as n, decapsulateKyber$2 as r, kyber1024_exports as t };
+//# sourceMappingURL=kyber1024-PpwE1rki.mjs.map

package/dist/kyber1024-PpwE1rki.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"kyber1024-PpwE1rki.mjs","names":["generateKyberKeys","encapsulateKyber","decapsulateKyber","generateKyberKeys","encapsulateKyber","decapsulateKyber"],"sources":["../src/post-quantum-crypto/kyber768.ts","../src/post-quantum-crypto/kyber512.ts","../src/post-quantum-crypto/kyber1024.ts"],"sourcesContent":["import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';\n\n/**\n * Generates public and secret Kyber keys\n *\n * @param seed - The optional seed\n * @returns The generated Kyber key pair.\n */\nexport function generateKyberKeys(seed?: Uint8Array): {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n} {\n  try {\n    return ml_kem768.keygen(seed);\n  } catch (error) {\n    throw new Error('Failed to generate Kyber keys', { cause: error });\n  }\n}\n\n/**\n * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms\n *\n * @param publicKey - The public Kyber key\n * @returns The resulting encapsulation and the generated shared secret.\n */\nexport function encapsulateKyber(publicKey: Uint8Array): {\n  cipherText: Uint8Array;\n  sharedSecret: Uint8Array;\n} {\n  try {\n    return ml_kem768.encapsulate(publicKey);\n  } catch (error) {\n    throw new Error('Failed to encapsulate', { cause: error });\n  }\n}\n\n/**\n * Decapsulates the encapsulated shared secret using Kyber algorithms\n *\n * @param cipherText - The encapsulated key\n * @param secretKey - The private Kyber key\n * @returns The resulting decapsulated shared secret.\n */\nexport function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  try {\n    return ml_kem768.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n","import { ml_kem512 } from '@noble/post-quantum/ml-kem.js';\n\n/**\n * Generates public and secret Kyber keys\n *\n * @param seed - The optional seed\n * @returns The generated Kyber key pair.\n */\nexport function generateKyberKeys(seed?: Uint8Array): {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n} {\n  try {\n    return ml_kem512.keygen(seed);\n  } catch (error) {\n    throw new Error('Failed to generate Kyber keys', { cause: error });\n  }\n}\n\n/**\n * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms\n *\n * @param publicKey - The public Kyber key\n * @returns The resulting encapsulation and the generated shared secret.\n */\nexport function encapsulateKyber(publicKey: Uint8Array): {\n  cipherText: Uint8Array;\n  sharedSecret: Uint8Array;\n} {\n  try {\n    return ml_kem512.encapsulate(publicKey);\n  } catch (error) {\n    throw new Error('Failed to encapsulate', { cause: error });\n  }\n}\n\n/**\n * Decapsulates the encapsulated shared secret using Kyber algorithms\n *\n * @param cipherText - The encapsulated key\n * @param secretKey - The private Kyber key\n * @returns The resulting decapsulated shared secret.\n */\nexport function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  try {\n    return ml_kem512.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n","import { ml_kem1024 } from '@noble/post-quantum/ml-kem.js';\n\n/**\n * Generates public and secret Kyber keys\n *\n * @param seed - The optional seed\n * @returns The generated Kyber key pair.\n */\nexport function generateKyberKeys(seed?: Uint8Array): {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n} {\n  try {\n    return ml_kem1024.keygen(seed);\n  } catch (error) {\n    throw new Error('Failed to generate Kyber keys', { cause: error });\n  }\n}\n\n/**\n * Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms\n *\n * @param publicKey - The public Kyber key\n * @returns The resulting encapsulation and the generated shared secret.\n */\nexport function encapsulateKyber(publicKey: Uint8Array): {\n  cipherText: Uint8Array;\n  sharedSecret: Uint8Array;\n} {\n  try {\n    return ml_kem1024.encapsulate(publicKey);\n  } catch (error) {\n    throw new Error('Failed to encapsulate', { cause: error });\n  }\n}\n\n/**\n * Decapsulates the encapsulated shared secret using Kyber algorithms\n *\n * @param cipherText - The encapsulated key\n * @param secretKey - The private Kyber key\n * @returns The resulting decapsulated shared secret.\n */\nexport function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array {\n  try {\n    return ml_kem1024.decapsulate(cipherText, secretKey);\n  } catch (error) {\n    throw new Error('Failed to decapsulate', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;AAQA,SAAgBA,oBAAkB,MAGhC;AACA,KAAI;AACF,SAAO,UAAU,OAAO,KAAK;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgBC,mBAAiB,WAG/B;AACA,KAAI;AACF,SAAO,UAAU,YAAY,UAAU;UAChC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgBC,mBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAO,UAAU,YAAY,YAAY,UAAU;UAC5C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;;;;ACvC9D,SAAgBC,oBAAkB,MAGhC;AACA,KAAI;AACF,SAAO,UAAU,OAAO,KAAK;UACtB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgBC,mBAAiB,WAG/B;AACA,KAAI;AACF,SAAO,UAAU,YAAY,UAAU;UAChC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgBC,mBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAO,UAAU,YAAY,YAAY,UAAU;UAC5C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;;;;;;ACvC9D,SAAgB,kBAAkB,MAGhC;AACA,KAAI;AACF,SAAO,WAAW,OAAO,KAAK;UACvB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUtE,SAAgB,iBAAiB,WAG/B;AACA,KAAI;AACF,SAAO,WAAW,YAAY,UAAU;UACjC,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW9D,SAAgB,iBAAiB,YAAwB,WAAmC;AAC1F,KAAI;AACF,SAAO,WAAW,YAAY,YAAY,UAAU;UAC7C,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}