internxt-crypto 0.0.11 → 0.0.14

package/dist/{keystore-crypto-B4yCVo9l.js → emailEncryptionKey-CQNe5W_T.js}

@@ -1,12 +1,11 @@
-const require_chunk = require('./chunk-Dt-PWiN7.js');
-const require_constants = require('./constants-Ccp21E03.js');
-const require_asymmetric_crypto = require('./asymmetric-crypto-BORmLhnx.js');
-const require_utils = require('./utils-CNs3cyDj.js');
-const require_hash = require('./hash-BoqwNkcd.js');
-const require_symmetric_crypto = require('./symmetric-crypto-D65zB396.js');
-const require_derive_key = require('./derive-key-CBf2WxJd.js');
-const require_email_crypto = require('./email-crypto-BrT98taw.js');
-const require_types = require('./types-52g887Zi.js');
+const require_constants = require('./constants.js');
+const require_keys = require('./keys-CinT7kEY.js');
+const require_genID = require('./genID-YJSl3YhL.js');
+const require_mac = require('./mac-BMb1F0dN.js');
+const require_aes = require('./aes-DQo1MyCz.js');
+const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-BYaiSGKL.js');
+const require_emailKeys = require('./emailKeys-C0KhtfNP.js');
+const require_types = require('./types.js');
 
 //#region src/keystore-crypto/core.ts
 /**
@@ -20,18 +19,18 @@ const require_types = require('./types-52g887Zi.js');
 */
 async function encryptKeystoreContent(secretKey, keys, userEmail, type) {
 	try {
-		const aux = require_utils.UTF8ToUint8(userEmail + type);
-		const publicKeys = await require_utils.publicKeyToBase64(keys.publicKeys);
-		const kyberPrivateKeyEnc = await require_symmetric_crypto.encryptSymmetrically(secretKey, keys.privateKeys.kyberPrivateKey, aux);
-		const eccPrivateKeyEnc = await require_symmetric_crypto.encryptSymmetrically(secretKey, await require_asymmetric_crypto.exportPrivateKey(keys.privateKeys.eccPrivateKey), aux);
+		const aux = require_genID.UTF8ToUint8(userEmail + type);
+		const publicKeys = await require_genID.publicKeyToBase64(keys.publicKeys);
+		const kyberPrivateKeyEnc = await require_aes.encryptSymmetrically(secretKey, keys.privateKeys.kyberPrivateKey, aux);
+		const eccPrivateKeyEnc = await require_aes.encryptSymmetrically(secretKey, await require_keys.exportPrivateKey(keys.privateKeys.eccPrivateKey), aux);
 		return {
 			userEmail,
 			type,
 			encryptedKeys: {
 				publicKeys,
 				privateKeys: {
-					kyberPrivateKeyBase64: require_utils.uint8ArrayToBase64(kyberPrivateKeyEnc),
-					eccPrivateKeyBase64: require_utils.uint8ArrayToBase64(eccPrivateKeyEnc)
+					kyberPrivateKeyBase64: require_genID.uint8ArrayToBase64(kyberPrivateKeyEnc),
+					eccPrivateKeyBase64: require_genID.uint8ArrayToBase64(eccPrivateKeyEnc)
 				}
 			}
 		};
@@ -50,11 +49,11 @@ async function encryptKeystoreContent(secretKey, keys, userEmail, type) {
 */
 async function decryptKeystoreContent(secretKey, encryptedKeystore) {
 	try {
-		const aux = require_utils.UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);
-		const kyberPublicKey = require_utils.base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.kyberPublicKeyBase64);
-		const eccPublicKey = await require_asymmetric_crypto.importPublicKey(require_utils.base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.eccPublicKeyBase64));
-		const kyberPrivateKey = await require_symmetric_crypto.decryptSymmetrically(secretKey, require_utils.base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.kyberPrivateKeyBase64), aux);
-		const eccPrivateKey = await require_asymmetric_crypto.importPrivateKey(await require_symmetric_crypto.decryptSymmetrically(secretKey, require_utils.base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.eccPrivateKeyBase64), aux));
+		const aux = require_genID.UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);
+		const kyberPublicKey = require_genID.base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.kyberPublicKeyBase64);
+		const eccPublicKey = await require_keys.importPublicKey(require_genID.base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.eccPublicKeyBase64));
+		const kyberPrivateKey = await require_aes.decryptSymmetrically(secretKey, require_genID.base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.kyberPrivateKeyBase64), aux);
+		const eccPrivateKey = await require_keys.importPrivateKey(await require_aes.decryptSymmetrically(secretKey, require_genID.base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.eccPrivateKeyBase64), aux));
 		return {
 			publicKeys: {
 				kyberPublicKey,
@@ -76,8 +75,8 @@ async function decryptKeystoreContent(secretKey, encryptedKeystore) {
 * @returns The derived secret key for protecting the recovery keystore
 */
 async function deriveRecoveryKey(recoveryCodes) {
-	const recoverCodesArray = require_utils.mnemonicToBytes(recoveryCodes);
-	return require_derive_key.deriveSymmetricCryptoKeyFromContext(require_constants.CONTEXT_RECOVERY, require_hash.getBytesFromData(require_constants.AES_KEY_BIT_LENGTH / 8, recoverCodesArray));
+	const recoverCodesArray = require_genID.mnemonicToBytes(recoveryCodes);
+	return require_deriveKeysFromPassword.deriveSymmetricKeyFromContext(require_constants.CONTEXT_RECOVERY, require_mac.getBytesFromData(require_constants.AES_KEY_BIT_LENGTH / 8, recoverCodesArray));
 }
 /**
 * Derives a secret key for protecting the encryption keystore
@@ -86,7 +85,7 @@ async function deriveRecoveryKey(recoveryCodes) {
 * @returns The derived secret key for protecting the encryption keystore
 */
 async function deriveEncryptionKeystoreKey(baseKey) {
-	return require_derive_key.deriveSymmetricCryptoKeyFromContext(require_constants.CONTEXT_ENC_KEYSTORE, baseKey);
+	return require_deriveKeysFromPassword.deriveSymmetricKeyFromContext(require_constants.CONTEXT_ENC_KEYSTORE, baseKey);
 }
 
 //#endregion
@@ -100,9 +99,9 @@ async function deriveEncryptionKeystoreKey(baseKey) {
 */
 async function createEncryptionAndRecoveryKeystores(userEmail, baseKey) {
 	try {
-		const keys = await require_email_crypto.generateEmailKeys();
+		const keys = await require_emailKeys.generateEmailKeys();
 		const encryptionKeystore = await encryptKeystoreContent(await deriveEncryptionKeystoreKey(baseKey), keys, userEmail, require_types.KeystoreType.ENCRYPTION);
-		const recoveryCodes = require_utils.genMnemonic();
+		const recoveryCodes = require_genID.genMnemonic();
 		return {
 			encryptionKeystore,
 			recoveryKeystore: await encryptKeystoreContent(await deriveRecoveryKey(recoveryCodes), keys, userEmail, require_types.KeystoreType.RECOVERY),
@@ -146,14 +145,6 @@ async function openRecoveryKeystore(recoveryCodes, encryptedKeystore) {
 	}
 }
 
-//#endregion
-//#region src/keystore-crypto/index.ts
-var keystore_crypto_exports = /* @__PURE__ */ require_chunk.__exportAll({
-	createEncryptionAndRecoveryKeystores: () => createEncryptionAndRecoveryKeystores,
-	openEncryptionKeystore: () => openEncryptionKeystore,
-	openRecoveryKeystore: () => openRecoveryKeystore
-});
-
 //#endregion
 Object.defineProperty(exports, 'createEncryptionAndRecoveryKeystores', {
   enumerable: true,
@@ -161,12 +152,6 @@ Object.defineProperty(exports, 'createEncryptionAndRecoveryKeystores', {
     return createEncryptionAndRecoveryKeystores;
   }
 });
-Object.defineProperty(exports, 'keystore_crypto_exports', {
-  enumerable: true,
-  get: function () {
-    return keystore_crypto_exports;
-  }
-});
 Object.defineProperty(exports, 'openEncryptionKeystore', {
   enumerable: true,
   get: function () {
@@ -179,4 +164,4 @@ Object.defineProperty(exports, 'openRecoveryKeystore', {
     return openRecoveryKeystore;
   }
 });
-//# sourceMappingURL=keystore-crypto-B4yCVo9l.js.map
+//# sourceMappingURL=emailEncryptionKey-CQNe5W_T.js.map

package/dist/emailEncryptionKey-CQNe5W_T.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emailEncryptionKey-CQNe5W_T.js","names":["UTF8ToUint8","publicKeyToBase64","encryptSymmetrically","exportPrivateKey","uint8ArrayToBase64","base64ToUint8Array","importPublicKey","decryptSymmetrically","importPrivateKey","mnemonicToBytes","deriveSymmetricKeyFromContext","CONTEXT_RECOVERY","getBytesFromData","AES_KEY_BIT_LENGTH","CONTEXT_ENC_KEYSTORE","generateEmailKeys","KeystoreType","genMnemonic"],"sources":["../src/keystore-crypto/core.ts","../src/keystore-crypto/emailEncryptionKey.ts"],"sourcesContent":["import { encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { base64ToUint8Array, uint8ArrayToBase64, UTF8ToUint8, mnemonicToBytes, publicKeyToBase64 } from '../utils';\nimport { deriveSymmetricKeyFromContext } from '../derive-key';\nimport { CONTEXT_ENC_KEYSTORE, AES_KEY_BIT_LENGTH, CONTEXT_RECOVERY } from '../constants';\nimport { getBytesFromData } from '../hash';\nimport { EmailKeys, EncryptedKeystore, KeystoreType } from '../types';\nimport { exportPrivateKey, importPrivateKey, importPublicKey } from '../asymmetric-crypto';\n\n/**\n * Encrypts the keystore content using symmetric encryption\n *\n * @param secretKey - The symmetric key to encrypt the keystore content\n * @param content - The content of the keystore\n * @param userID - The ID of the user\n * @param tag - The keystore type-specific tag string\n * @returns The encrypted keystore content\n */\nexport async function encryptKeystoreContent(\n  secretKey: Uint8Array,\n  keys: EmailKeys,\n  userEmail: string,\n  type: KeystoreType,\n): Promise<EncryptedKeystore> {\n  try {\n    const aux = UTF8ToUint8(userEmail + type);\n    const publicKeys = await publicKeyToBase64(keys.publicKeys);\n    const kyberPrivateKeyEnc = await encryptSymmetrically(secretKey, keys.privateKeys.kyberPrivateKey, aux);\n    const eccPrivateKey = await exportPrivateKey(keys.privateKeys.eccPrivateKey);\n    const eccPrivateKeyEnc = await encryptSymmetrically(secretKey, eccPrivateKey, aux);\n    const encryptedKeys = {\n      publicKeys,\n      privateKeys: {\n        kyberPrivateKeyBase64: uint8ArrayToBase64(kyberPrivateKeyEnc),\n        eccPrivateKeyBase64: uint8ArrayToBase64(eccPrivateKeyEnc),\n      },\n    };\n\n    const keystore: EncryptedKeystore = {\n      userEmail,\n      type,\n      encryptedKeys,\n    };\n    return keystore;\n  } catch (error) {\n    throw new Error('Failed to encrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Decrypts the keystore content using symmetric encryption\n *\n * @param secretKey - The symmetric key to decrypt the keystore content\n * @param encryptedKeys - The encrypted keystore content\n * @param userEmail - The ID of the user\n * @param tag - The keystore type-specific tag string\n * @returns The decrypted keystore content\n */\nexport async function decryptKeystoreContent(\n  secretKey: Uint8Array,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<EmailKeys> {\n  try {\n    const aux = UTF8ToUint8(encryptedKeystore.userEmail + encryptedKeystore.type);\n    const kyberPublicKey = base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.kyberPublicKeyBase64);\n    const eccPublicArray = base64ToUint8Array(encryptedKeystore.encryptedKeys.publicKeys.eccPublicKeyBase64);\n    const eccPublicKey = await importPublicKey(eccPublicArray);\n    const encKyberPrivateKey = base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.kyberPrivateKeyBase64);\n    const kyberPrivateKey = await decryptSymmetrically(secretKey, encKyberPrivateKey, aux);\n    const eccEncArray = base64ToUint8Array(encryptedKeystore.encryptedKeys.privateKeys.eccPrivateKeyBase64);\n    const eccKey = await decryptSymmetrically(secretKey, eccEncArray, aux);\n    const eccPrivateKey = await importPrivateKey(eccKey);\n    const keys = {\n      publicKeys: {\n        kyberPublicKey,\n        eccPublicKey,\n      },\n      privateKeys: {\n        kyberPrivateKey,\n        eccPrivateKey,\n      },\n    };\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to decrypt keystore content', { cause: error });\n  }\n}\n\n/**\n * Derives a secret key for protecting the recovery keystore\n *\n * @param recoveryCodes - The recovery codes\n * @returns The derived secret key for protecting the recovery keystore\n */\nexport async function deriveRecoveryKey(recoveryCodes: string): Promise<Uint8Array> {\n  const recoverCodesArray = mnemonicToBytes(recoveryCodes);\n  const recoveryCodesBuffer = getBytesFromData(AES_KEY_BIT_LENGTH / 8, recoverCodesArray);\n  return deriveSymmetricKeyFromContext(CONTEXT_RECOVERY, recoveryCodesBuffer);\n}\n\n/**\n * Derives a secret key for protecting the encryption keystore\n *\n * @param baseKey - The base secret key from which a new key secret will be derived\n * @returns The derived secret key for protecting the encryption keystore\n */\nexport async function deriveEncryptionKeystoreKey(baseKey: Uint8Array): Promise<Uint8Array> {\n  return deriveSymmetricKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);\n}\n","import { EmailKeys, EncryptedKeystore, KeystoreType } from '../types';\nimport { genMnemonic } from '../utils';\nimport { encryptKeystoreContent, decryptKeystoreContent, deriveEncryptionKeystoreKey, deriveRecoveryKey } from './core';\nimport { generateEmailKeys } from '../email-crypto';\n\n/**\n * Generates email keys and creates encrypted main and recovery keystores\n * The main keystore encryption key is derived from the base key (stored in session storage)\n * The recovery keystore encryption key is derived from the recovery codes\n *\n * @returns The encryption and recovery keystores, recovery codes and email keys\n */\nexport async function createEncryptionAndRecoveryKeystores(\n  userEmail: string,\n  baseKey: Uint8Array,\n): Promise<{\n  encryptionKeystore: EncryptedKeystore;\n  recoveryKeystore: EncryptedKeystore;\n  recoveryCodes: string;\n  keys: EmailKeys;\n}> {\n  try {\n    const keys = await generateEmailKeys();\n\n    const secretKey = await deriveEncryptionKeystoreKey(baseKey);\n    const encryptionKeystore = await encryptKeystoreContent(secretKey, keys, userEmail, KeystoreType.ENCRYPTION);\n\n    const recoveryCodes = genMnemonic();\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const recoveryKeystore = await encryptKeystoreContent(recoveryKey, keys, userEmail, KeystoreType.RECOVERY);\n\n    return { encryptionKeystore, recoveryKeystore, recoveryCodes, keys };\n  } catch (error) {\n    throw new Error('Failed to create encryption and recovery keystores', { cause: error });\n  }\n}\n\n/**\n * Opens the encryption keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\n *\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @param baseKey - The base key from which the decryption key will be derived\n * @returns The encryption keys\n */\nexport async function openEncryptionKeystore(\n  encryptedKeystore: EncryptedKeystore,\n  baseKey: Uint8Array,\n): Promise<EmailKeys> {\n  try {\n    if (encryptedKeystore.type != KeystoreType.ENCRYPTION) {\n      throw new Error('Input is invalid');\n    }\n    const secretKey = await deriveEncryptionKeystoreKey(baseKey);\n    const keys = await decryptKeystoreContent(secretKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to open encryption keystore', { cause: error });\n  }\n}\n\n/**\n * Opens the recovery keystore and returns the email encryption keys\n * The decryption key is derived from the base key (stored in session storage)\n *\n * @param recoveryCodes - The user's recovery codes\n * @param encryptedKeystore - The encrypted keystore containing encryption keys\n * @returns The encryption keys\n */\nexport async function openRecoveryKeystore(\n  recoveryCodes: string,\n  encryptedKeystore: EncryptedKeystore,\n): Promise<EmailKeys> {\n  try {\n    if (encryptedKeystore.type != KeystoreType.RECOVERY) {\n      throw new Error('Input is invalid');\n    }\n    const recoveryKey = await deriveRecoveryKey(recoveryCodes);\n    const keys = await decryptKeystoreContent(recoveryKey, encryptedKeystore);\n    return keys;\n  } catch (error) {\n    throw new Error('Failed to open recovery keystore', { cause: error });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAiBA,eAAsB,uBACpB,WACA,MACA,WACA,MAC4B;AAC5B,KAAI;EACF,MAAM,MAAMA,0BAAY,YAAY,KAAK;EACzC,MAAM,aAAa,MAAMC,gCAAkB,KAAK,WAAW;EAC3D,MAAM,qBAAqB,MAAMC,iCAAqB,WAAW,KAAK,YAAY,iBAAiB,IAAI;EAEvG,MAAM,mBAAmB,MAAMA,iCAAqB,WAD9B,MAAMC,8BAAiB,KAAK,YAAY,cAAc,EACE,IAAI;AAclF,SALoC;GAClC;GACA;GACA,eAXoB;IACpB;IACA,aAAa;KACX,uBAAuBC,iCAAmB,mBAAmB;KAC7D,qBAAqBA,iCAAmB,iBAAiB;KAC1D;IACF;GAMA;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;;AAa3E,eAAsB,uBACpB,WACA,mBACoB;AACpB,KAAI;EACF,MAAM,MAAMJ,0BAAY,kBAAkB,YAAY,kBAAkB,KAAK;EAC7E,MAAM,iBAAiBK,iCAAmB,kBAAkB,cAAc,WAAW,qBAAqB;EAE1G,MAAM,eAAe,MAAMC,6BADJD,iCAAmB,kBAAkB,cAAc,WAAW,mBAAmB,CAC9C;EAE1D,MAAM,kBAAkB,MAAME,iCAAqB,WADxBF,iCAAmB,kBAAkB,cAAc,YAAY,sBAAsB,EAC9B,IAAI;EAGtF,MAAM,gBAAgB,MAAMG,8BADb,MAAMD,iCAAqB,WADtBF,iCAAmB,kBAAkB,cAAc,YAAY,oBAAoB,EACrC,IAAI,CAClB;AAWpD,SAVa;GACX,YAAY;IACV;IACA;IACD;GACD,aAAa;IACX;IACA;IACD;GACF;UAEM,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU3E,eAAsB,kBAAkB,eAA4C;CAClF,MAAM,oBAAoBI,8BAAgB,cAAc;AAExD,QAAOC,6DAA8BC,oCADTC,6BAAiBC,uCAAqB,GAAG,kBAAkB,CACZ;;;;;;;;AAS7E,eAAsB,4BAA4B,SAA0C;AAC1F,QAAOH,6DAA8BI,wCAAsB,QAAQ;;;;;;;;;;;;AC9FrE,eAAsB,qCACpB,WACA,SAMC;AACD,KAAI;EACF,MAAM,OAAO,MAAMC,qCAAmB;EAGtC,MAAM,qBAAqB,MAAM,uBADf,MAAM,4BAA4B,QAAQ,EACO,MAAM,WAAWC,2BAAa,WAAW;EAE5G,MAAM,gBAAgBC,2BAAa;AAInC,SAAO;GAAE;GAAoB,kBAFJ,MAAM,uBADX,MAAM,kBAAkB,cAAc,EACS,MAAM,WAAWD,2BAAa,SAAS;GAE3D;GAAe;GAAM;UAC7D,OAAO;AACd,QAAM,IAAI,MAAM,sDAAsD,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3F,eAAsB,uBACpB,mBACA,SACoB;AACpB,KAAI;AACF,MAAI,kBAAkB,QAAQA,2BAAa,WACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADD,MAAM,4BAA4B,QAAQ,EACP,kBAAkB;UAEhE,OAAO;AACd,QAAM,IAAI,MAAM,sCAAsC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;;AAY3E,eAAsB,qBACpB,eACA,mBACoB;AACpB,KAAI;AACF,MAAI,kBAAkB,QAAQA,2BAAa,SACzC,OAAM,IAAI,MAAM,mBAAmB;AAIrC,SADa,MAAM,uBADC,MAAM,kBAAkB,cAAc,EACH,kBAAkB;UAElE,OAAO;AACd,QAAM,IAAI,MAAM,oCAAoC,EAAE,OAAO,OAAO,CAAC"}

package/dist/{email-crypto-BrT98taw.js → emailKeys-C0KhtfNP.js}

@@ -1,37 +1,25 @@
-const require_chunk = require('./chunk-Dt-PWiN7.js');
-const require_constants = require('./constants-Ccp21E03.js');
-const require_asymmetric_crypto = require('./asymmetric-crypto-BORmLhnx.js');
-const require_utils = require('./utils-CNs3cyDj.js');
-const require_symmetric_crypto = require('./symmetric-crypto-D65zB396.js');
-const require_derive_key = require('./derive-key-CBf2WxJd.js');
-const require_post_quantum_crypto = require('./post-quantum-crypto-CAi-cEkV.js');
+const require_chunk = require('./chunk-EbLFQX5m.js');
+const require_constants = require('./constants.js');
+const require_keys = require('./keys-CinT7kEY.js');
+const require_genID = require('./genID-YJSl3YhL.js');
+const require_aes = require('./aes-DQo1MyCz.js');
+const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-BYaiSGKL.js');
+const require_kyber768 = require('./kyber768-WUVc2fIR.js');
 let _noble_hashes_utils_js = require("@noble/hashes/utils.js");
+let _noble_ciphers_aes_js = require("@noble/ciphers/aes.js");
 
 //#region src/key-wrapper/aesWrapper.ts
 /**
-* Converts wrapping key in Uint8Array into CryptoKey
-*
-* @param key - The wrapping key in Uint8Array representation
-* @returns The resulting CryptoKey
-*/
-async function importWrappingKey(key) {
-	try {
-		return await crypto.subtle.importKey(require_constants.KEY_FORMAT, key, require_constants.KEY_WRAPPING_ALGORITHM, false, ["wrapKey", "unwrapKey"]);
-	} catch (error) {
-		throw new Error("Failed to import wrapping key", { cause: error });
-	}
-}
-/**
 * Derives wrapping key from two secrets
 *
 * @param eccSecret - The secret exchanged via elliptic curves
 * @param kyberSecret - The secret exchanged via Kyber KEM
-* @returns The resulting wrapping CryptoKey
+* @returns The resulting wrapping key
 */
 async function deriveWrappingKey(eccSecret, kyberSecret) {
 	try {
 		if (eccSecret.length !== kyberSecret.length) throw new Error("secrets must have equal length");
-		return await importWrappingKey(await require_derive_key.deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, require_constants.CONTEXT_WRAPPING));
+		return require_deriveKeysFromPassword.deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, require_constants.CONTEXT_WRAPPING);
 	} catch (error) {
 		throw new Error("Failed to derive wrapping key", { cause: error });
 	}
@@ -39,47 +27,29 @@ async function deriveWrappingKey(eccSecret, kyberSecret) {
 /**
 * Unwraps the given wrapped key
 *
-* @param encryptedKey - The encrypted key
-* @param wrappingKey - The secret key used for decryption
-* @returns The resulting wrapping CryptoKey
+* @param encryptedKey - The wrapped key
+* @param wrappingKey - The secret key used for unwrapping
+* @returns The resulting key
 */
 async function unwrapKey(encryptedKey, wrappingKey) {
-	try {
-		return await crypto.subtle.unwrapKey(require_constants.KEY_FORMAT, encryptedKey, wrappingKey, require_constants.KEY_WRAPPING_ALGORITHM, require_constants.AES_ALGORITHM, false, ["encrypt", "decrypt"]);
-	} catch (error) {
-		throw new Error("Failed to unwrap key", { cause: error });
-	}
+	return (0, _noble_ciphers_aes_js.aeskw)(wrappingKey).decrypt(encryptedKey);
 }
 /**
-* Wraps the given CryptoKey
+* Wraps the given key
 *
-* @param encryptionKey - The CryptoKey to be wrapped
+* @param key - The key to be wrapped
 * @param wrappingKey - The secret key used for wrapping
 * @returns The resulting ciphertext
 */
-async function wrapKey(encryptionKey, wrappingKey) {
-	try {
-		const result = await crypto.subtle.wrapKey(require_constants.KEY_FORMAT, encryptionKey, wrappingKey, require_constants.KEY_WRAPPING_ALGORITHM);
-		return new Uint8Array(result);
-	} catch (error) {
-		throw new Error("Failed to wrap key", { cause: error });
-	}
+async function wrapKey(key, wrappingKey) {
+	return (0, _noble_ciphers_aes_js.aeskw)(wrappingKey).encrypt(key);
 }
 
-//#endregion
-//#region src/key-wrapper/index.ts
-var key_wrapper_exports = /* @__PURE__ */ require_chunk.__exportAll({
-	deriveWrappingKey: () => deriveWrappingKey,
-	importWrappingKey: () => importWrappingKey,
-	unwrapKey: () => unwrapKey,
-	wrapKey: () => wrapKey
-});
-
 //#endregion
 //#region src/email-crypto/converters.ts
 function userToBytes(user) {
 	try {
-		return require_utils.UTF8ToUint8(JSON.stringify(user));
+		return require_genID.UTF8ToUint8(JSON.stringify(user));
 	} catch (error) {
 		throw new Error("Failed to convert User to bytes", { cause: error });
 	}
@@ -99,7 +69,7 @@ function recipientsToBytes(recipients) {
 */
 function emailToBinary(email) {
 	try {
-		return require_utils.UTF8ToUint8(JSON.stringify(email));
+		return require_genID.UTF8ToUint8(JSON.stringify(email));
 	} catch (error) {
 		throw new Error("Failed to convert EmailBody to Uint8Array", { cause: error });
 	}
@@ -117,12 +87,12 @@ function emailToBinary(email) {
 function getAux(params, isSubjectEncrypted) {
 	try {
 		const { subject, replyToEmailID, sender, recipient, recipients } = params;
-		const replyBytes = replyToEmailID ? require_utils.uuidToBytes(replyToEmailID) : new Uint8Array();
+		const replyBytes = replyToEmailID ? require_genID.uuidToBytes(replyToEmailID) : new Uint8Array();
 		const senderBytes = userToBytes(sender);
 		const recipientBytes = userToBytes(recipient);
 		const recipientsBytes = recipients ? recipientsToBytes(recipients) : new Uint8Array();
 		if (isSubjectEncrypted) return (0, _noble_hashes_utils_js.concatBytes)(replyBytes, senderBytes, recipientBytes, recipientsBytes);
-		else return (0, _noble_hashes_utils_js.concatBytes)(require_utils.UTF8ToUint8(subject), replyBytes, senderBytes, recipientBytes, recipientsBytes);
+		else return (0, _noble_hashes_utils_js.concatBytes)(require_genID.UTF8ToUint8(subject), replyBytes, senderBytes, recipientBytes, recipientsBytes);
 	} catch (error) {
 		throw new Error("Failed to create aux", { cause: error });
 	}
@@ -190,7 +160,7 @@ async function decryptEmailBody(enc, encParams, encryptionKey, isSubjectEncrypte
 async function encryptEmailContentSymmetrically(email, aux, emailID) {
 	try {
 		if (!email.text) throw new Error("Invalid input");
-		const encryptionKey = await require_symmetric_crypto.genSymmetricCryptoKey();
+		const encryptionKey = require_aes.genSymmetricKey();
 		return {
 			enc: await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID),
 			encryptionKey
@@ -211,10 +181,10 @@ async function encryptEmailContentSymmetrically(email, aux, emailID) {
 async function encryptEmailContentAndSubjectSymmetrically(email, subject, aux, emailID) {
 	try {
 		if (!subject || !email.text) throw new Error("Invalid input");
-		const encryptionKey = await require_symmetric_crypto.genSymmetricCryptoKey();
+		const encryptionKey = require_aes.genSymmetricKey();
 		return {
 			enc: await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID),
-			encSubject: require_utils.uint8ArrayToBase64(await require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(subject), aux)),
+			encSubject: require_genID.uint8ArrayToBase64(await require_aes.encryptSymmetrically(encryptionKey, require_genID.UTF8ToUint8(subject), aux)),
 			encryptionKey
 		};
 	} catch (error) {
@@ -225,15 +195,15 @@ async function encryptEmailContentAndSubjectSymmetrically(email, subject, aux, e
 * Decrypts symmetrically encrypted email.
 *
 * @param encryptedEmail - The email to decrypt.
-* @param encryptionKey - The symmetric CryptoKey.
+* @param encryptionKey - The symmetric key.
 * @returns The decrypted email
 */
 async function decryptEmailAndSubjectSymmetrically(encryptionKey, aux, encSubject, enc) {
 	try {
-		const subjectArray = await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(encSubject), aux);
+		const subjectArray = await require_aes.decryptSymmetrically(encryptionKey, require_genID.base64ToUint8Array(encSubject), aux);
 		return {
 			body: await decryptEmailSymmetrically(encryptionKey, aux, enc),
-			subject: require_utils.uint8ToUTF8(subjectArray)
+			subject: require_genID.uint8ToUTF8(subjectArray)
 		};
 	} catch (error) {
 		throw new Error("Failed to symmetrically decrypt email and subject", { cause: error });
@@ -247,9 +217,9 @@ async function decryptEmailAndSubjectSymmetrically(encryptionKey, aux, encSubjec
 */
 async function encryptEmailContentSymmetricallyWithKey(emailBody, encryptionKey, aux, emailID) {
 	try {
-		const freeField = require_utils.uuidToBytes(emailID);
-		const result = { encText: require_utils.uint8ArrayToBase64(await require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(emailBody.text), aux, freeField)) };
-		if (emailBody.attachments) result.encAttachments = (await encryptEmailAttachements(emailBody.attachments, encryptionKey, aux, emailID))?.map(require_utils.uint8ArrayToBase64);
+		const freeField = require_genID.uuidToBytes(emailID);
+		const result = { encText: require_genID.uint8ArrayToBase64(await require_aes.encryptSymmetrically(encryptionKey, require_genID.UTF8ToUint8(emailBody.text), aux, freeField)) };
+		if (emailBody.attachments) result.encAttachments = (await encryptEmailAttachements(emailBody.attachments, encryptionKey, aux, emailID))?.map(require_genID.uint8ArrayToBase64);
 		return result;
 	} catch (error) {
 		throw new Error("Failed to symmetrically encrypt email with the given key", { cause: error });
@@ -257,9 +227,9 @@ async function encryptEmailContentSymmetricallyWithKey(emailBody, encryptionKey,
 }
 async function encryptEmailAttachements(attachments, encryptionKey, aux, emailID) {
 	try {
-		const freeField = require_utils.uuidToBytes(emailID);
+		const freeField = require_genID.uuidToBytes(emailID);
 		return await Promise.all(attachments.map((attachment) => {
-			return require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(attachment), aux, freeField);
+			return require_aes.encryptSymmetrically(encryptionKey, require_genID.UTF8ToUint8(attachment), aux, freeField);
 		}));
 	} catch (error) {
 		throw new Error("Failed to symmetrically encrypt email attachements", { cause: error });
@@ -268,7 +238,7 @@ async function encryptEmailAttachements(attachments, encryptionKey, aux, emailID
 async function decryptEmailAttachements(encryptedAttachments, encryptionKey, aux) {
 	try {
 		return await Promise.all(encryptedAttachments.map((attachment) => {
-			return require_symmetric_crypto.decryptSymmetrically(encryptionKey, attachment, aux);
+			return require_aes.decryptSymmetrically(encryptionKey, attachment, aux);
 		}));
 	} catch (error) {
 		throw new Error("Failed to symmetrically decrypt email attachements", { cause: error });
@@ -278,15 +248,15 @@ async function decryptEmailAttachements(encryptedAttachments, encryptionKey, aux
 * Decrypts symmetrically encrypted email.
 *
 * @param encryptedEmail - The email to decrypt.
-* @param encryptionKey - The symmetric CryptoKey.
+* @param encryptionKey - The symmetric key.
 * @returns The decrypted email
 */
 async function decryptEmailSymmetrically(encryptionKey, aux, enc) {
 	try {
-		const result = { text: require_utils.uint8ToUTF8(await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(enc.encText), aux)) };
+		const result = { text: require_genID.uint8ToUTF8(await require_aes.decryptSymmetrically(encryptionKey, require_genID.base64ToUint8Array(enc.encText), aux)) };
 		if (enc.encAttachments) {
-			const encAttachements = enc.encAttachments?.map(require_utils.base64ToUint8Array);
-			result.attachments = (await decryptEmailAttachements(encAttachements, encryptionKey, aux))?.map((att) => require_utils.uint8ToUTF8(att));
+			const encAttachements = enc.encAttachments?.map(require_genID.base64ToUint8Array);
+			result.attachments = (await decryptEmailAttachements(encAttachements, encryptionKey, aux))?.map((att) => require_genID.uint8ToUTF8(att));
 		}
 		return result;
 	} catch (error) {
@@ -296,18 +266,18 @@ async function decryptEmailSymmetrically(encryptionKey, aux, enc) {
 /**
 * Encrypts the email symmetric key using hybrid encryption.
 *
-* @param emailEncryptionKey - The symmetric CryptoKey used for email encryption.
+* @param emailEncryptionKey - The symmetric key used for email encryption.
 * @param recipientPublicKey - The public key of the recipient.
 * @param senderPrivateKey - The private key of the sender.
 * @returns The encrypted email symmetric key
 */
 async function encryptKeysHybrid(emailEncryptionKey, recipientPublicKey, senderPrivateKey) {
 	try {
-		const eccSecret = await require_asymmetric_crypto.deriveSecretKey(recipientPublicKey.eccPublicKey, senderPrivateKey.eccPrivateKey);
-		const { cipherText: kyberCiphertext, sharedSecret: kyberSecret } = require_post_quantum_crypto.encapsulateKyber(recipientPublicKey.kyberPublicKey);
+		const eccSecret = await require_keys.deriveSecretKey(recipientPublicKey.eccPublicKey, senderPrivateKey.eccPrivateKey);
+		const { cipherText: kyberCiphertext, sharedSecret: kyberSecret } = require_kyber768.encapsulateKyber(recipientPublicKey.kyberPublicKey);
 		return {
-			encryptedKey: require_utils.uint8ArrayToBase64(await wrapKey(emailEncryptionKey, await deriveWrappingKey(eccSecret, kyberSecret))),
-			kyberCiphertext: require_utils.uint8ArrayToBase64(kyberCiphertext)
+			encryptedKey: require_genID.uint8ArrayToBase64(await wrapKey(emailEncryptionKey, await deriveWrappingKey(eccSecret, kyberSecret))),
+			kyberCiphertext: require_genID.uint8ArrayToBase64(kyberCiphertext)
 		};
 	} catch (error) {
 		throw new Error("Failed to encrypt email key using hybrid encryption", { cause: error });
@@ -319,12 +289,12 @@ async function encryptKeysHybrid(emailEncryptionKey, recipientPublicKey, senderP
 * @param encryptedKey - The encrypted email key.
 * @param senderPublicKey - The public key of the sender.
 * @param recipientPrivateKey - The private key of the recipient.
-* @returns The email encryption CryptoKey
+* @returns The email encryption key
 */
 async function decryptKeysHybrid(encryptedKey, senderPublicKey, recipientPrivateKey) {
 	try {
-		const kyberCiphertext = require_utils.base64ToUint8Array(encryptedKey.kyberCiphertext);
-		return await unwrapKey(require_utils.base64ToUint8Array(encryptedKey.encryptedKey), await deriveWrappingKey(await require_asymmetric_crypto.deriveSecretKey(senderPublicKey.eccPublicKey, recipientPrivateKey.eccPrivateKey), require_post_quantum_crypto.decapsulateKyber(kyberCiphertext, recipientPrivateKey.kyberPrivateKey)));
+		const kyberCiphertext = require_genID.base64ToUint8Array(encryptedKey.kyberCiphertext);
+		return await unwrapKey(require_genID.base64ToUint8Array(encryptedKey.encryptedKey), await deriveWrappingKey(await require_keys.deriveSecretKey(senderPublicKey.eccPublicKey, recipientPrivateKey.eccPrivateKey), require_kyber768.decapsulateKyber(kyberCiphertext, recipientPrivateKey.kyberPrivateKey)));
 	} catch (error) {
 		throw new Error("Failed to decrypt email key encrypted via hybrid encryption", { cause: error });
 	}
@@ -332,17 +302,17 @@ async function decryptKeysHybrid(encryptedKey, senderPublicKey, recipientPrivate
 /**
 * Password-protects the email symmetric key.
 *
-* @param emailEncryptionKey - The symmetric CryptoKey used for email encryption.
+* @param emailEncryptionKey - The symmetric key used for email encryption.
 * @param password - The secret password for key protection.
 * @returns The password-protected email symmetric key
 */
 async function passwordProtectKey(emailEncryptionKey, password) {
 	try {
-		const { key, salt } = await require_derive_key.getKeyFromPassword(password);
-		const encryptedKey = await wrapKey(emailEncryptionKey, await importWrappingKey(key));
-		const saltStr = require_utils.uint8ArrayToBase64(salt);
+		const { key, salt } = await require_deriveKeysFromPassword.getKeyFromPassword(password);
+		const encryptedKey = await wrapKey(emailEncryptionKey, key);
+		const saltStr = require_genID.uint8ArrayToBase64(salt);
 		return {
-			encryptedKey: require_utils.uint8ArrayToBase64(encryptedKey),
+			encryptedKey: require_genID.uint8ArrayToBase64(encryptedKey),
 			salt: saltStr
 		};
 	} catch (error) {
@@ -354,12 +324,12 @@ async function passwordProtectKey(emailEncryptionKey, password) {
 *
 * @param emailEncryptionKey -  The password-protected email key.
 * @param password - The secret password for key protection.
-* @returns The email encryption CryptoKey
+* @returns The email encryption key
 */
 async function removePasswordProtection(emailEncryptionKey, password) {
 	try {
-		const salt = require_utils.base64ToUint8Array(emailEncryptionKey.salt);
-		return await unwrapKey(require_utils.base64ToUint8Array(emailEncryptionKey.encryptedKey), await importWrappingKey(await require_derive_key.getKeyFromPasswordAndSalt(password, salt)));
+		const salt = require_genID.base64ToUint8Array(emailEncryptionKey.salt);
+		return await unwrapKey(require_genID.base64ToUint8Array(emailEncryptionKey.encryptedKey), await require_deriveKeysFromPassword.getKeyFromPasswordAndSalt(password, salt));
 	} catch (error) {
 		throw new Error("Failed to remove password-protection from email key", { cause: error });
 	}
@@ -497,8 +467,8 @@ async function decryptPwdProtectedEmail(encryptedEmail, password) {
 */
 async function generateEmailKeys() {
 	try {
-		const kyberKeys = require_post_quantum_crypto.generateKyberKeys();
-		const keys = await require_asymmetric_crypto.generateEccKeys();
+		const kyberKeys = require_kyber768.generateKyberKeys();
+		const keys = await require_keys.generateEccKeys();
 		return {
 			publicKeys: {
 				eccPublicKey: keys.publicKey,
@@ -514,21 +484,6 @@ async function generateEmailKeys() {
 	}
 }
 
-//#endregion
-//#region src/email-crypto/index.ts
-var email_crypto_exports = /* @__PURE__ */ require_chunk.__exportAll({
-	createPwdProtectedEmail: () => createPwdProtectedEmail,
-	decryptEmailHybrid: () => decryptEmailHybrid,
-	decryptPwdProtectedEmail: () => decryptPwdProtectedEmail,
-	emailToBinary: () => emailToBinary,
-	encryptEmailHybrid: () => encryptEmailHybrid,
-	encryptEmailHybridForMultipleRecipients: () => encryptEmailHybridForMultipleRecipients,
-	generateEmailKeys: () => generateEmailKeys,
-	getAux: () => getAux,
-	recipientsToBytes: () => recipientsToBytes,
-	userToBytes: () => userToBytes
-});
-
 //#endregion
 Object.defineProperty(exports, 'createPwdProtectedEmail', {
   enumerable: true,
@@ -560,12 +515,6 @@ Object.defineProperty(exports, 'emailToBinary', {
     return emailToBinary;
   }
 });
-Object.defineProperty(exports, 'email_crypto_exports', {
-  enumerable: true,
-  get: function () {
-    return email_crypto_exports;
-  }
-});
 Object.defineProperty(exports, 'encryptEmailContentSymmetricallyWithKey', {
   enumerable: true,
   get: function () {
@@ -596,16 +545,16 @@ Object.defineProperty(exports, 'getAux', {
     return getAux;
   }
 });
-Object.defineProperty(exports, 'key_wrapper_exports', {
+Object.defineProperty(exports, 'recipientsToBytes', {
   enumerable: true,
   get: function () {
-    return key_wrapper_exports;
+    return recipientsToBytes;
   }
 });
-Object.defineProperty(exports, 'recipientsToBytes', {
+Object.defineProperty(exports, 'unwrapKey', {
   enumerable: true,
   get: function () {
-    return recipientsToBytes;
+    return unwrapKey;
   }
 });
 Object.defineProperty(exports, 'userToBytes', {
@@ -614,4 +563,10 @@ Object.defineProperty(exports, 'userToBytes', {
     return userToBytes;
   }
 });
-//# sourceMappingURL=email-crypto-BrT98taw.js.map
+Object.defineProperty(exports, 'wrapKey', {
+  enumerable: true,
+  get: function () {
+    return wrapKey;
+  }
+});
+//# sourceMappingURL=emailKeys-C0KhtfNP.js.map

package/dist/emailKeys-C0KhtfNP.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emailKeys-C0KhtfNP.js","names":["deriveSymmetricKeyFromTwoKeysAndContext","CONTEXT_WRAPPING","UTF8ToUint8","uuidToBytes","UTF8ToUint8","genSymmetricKey","uint8ArrayToBase64","encryptSymmetrically","UTF8ToUint8","decryptSymmetrically","base64ToUint8Array","uint8ToUTF8","uuidToBytes","deriveSecretKey","encapsulateKyber","decapsulateKyber","getKeyFromPassword","getKeyFromPasswordAndSalt","generateKyberKeys","generateEccKeys"],"sources":["../src/key-wrapper/aesWrapper.ts","../src/email-crypto/converters.ts","../src/email-crypto/utils.ts","../src/email-crypto/core.ts","../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"sourcesContent":["import { CONTEXT_WRAPPING } from '../constants';\nimport { deriveSymmetricKeyFromTwoKeysAndContext } from '../derive-key';\nimport { aeskw } from '@noble/ciphers/aes.js';\n\n/**\n * Derives wrapping key from two secrets\n *\n * @param eccSecret - The secret exchanged via elliptic curves\n * @param kyberSecret - The secret exchanged via Kyber KEM\n * @returns The resulting wrapping key\n */\nexport async function deriveWrappingKey(eccSecret: Uint8Array, kyberSecret: Uint8Array): Promise<Uint8Array> {\n  try {\n    if (eccSecret.length !== kyberSecret.length) {\n      throw new Error('secrets must have equal length');\n    }\n    return deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, CONTEXT_WRAPPING);\n  } catch (error) {\n    throw new Error('Failed to derive wrapping key', { cause: error });\n  }\n}\n\n/**\n * Unwraps the given wrapped key\n *\n * @param encryptedKey - The wrapped key\n * @param wrappingKey - The secret key used for unwrapping\n * @returns The resulting key\n */\nexport async function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array> {\n  return aeskw(wrappingKey).decrypt(encryptedKey);\n}\n\n/**\n * Wraps the given key\n *\n * @param key - The key to be wrapped\n * @param wrappingKey - The secret key used for wrapping\n * @returns The resulting ciphertext\n */\nexport async function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array> {\n  return aeskw(wrappingKey).encrypt(key);\n}\n","import { UTF8ToUint8 } from '../utils';\nimport { User, Email } from '../types';\nimport { concatBytes } from '@noble/hashes/utils.js';\n\nexport function userToBytes(user: User): Uint8Array {\n  try {\n    const json = JSON.stringify(user);\n    return UTF8ToUint8(json);\n  } catch (error) {\n    throw new Error('Failed to convert User to bytes', { cause: error });\n  }\n}\n\nexport function recipientsToBytes(recipients: User[]): Uint8Array {\n  try {\n    const array = recipients.map((user) => userToBytes(user));\n    return concatBytes(...array);\n  } catch (error) {\n    throw new Error('Failed to convert recipients to bytes', { cause: error });\n  }\n}\n\n/**\n * Converts an Email type into a Uint8Array array.\n *\n * @param email - The email.\n * @returns The Uint8Array array representation of the Email type.\n */\nexport function emailToBinary(email: Email): Uint8Array {\n  try {\n    const json = JSON.stringify(email);\n    return UTF8ToUint8(json);\n  } catch (error) {\n    throw new Error('Failed to convert EmailBody to Uint8Array', { cause: error });\n  }\n}\n","import { concatBytes } from '@noble/hashes/utils.js';\nimport { EmailPublicParameters } from '../types';\nimport { UTF8ToUint8, uuidToBytes } from '../utils';\nimport { userToBytes, recipientsToBytes } from './converters';\n\n/**\n * Creates an auxiliary string from public fields of the email.\n *\n * @param params - The email public parameters.\n * @param isSubjectEncrypted - Indicates if the email subject field should be encrypted\n * @returns The resulting auxiliary string\n */\nexport function getAux(params: EmailPublicParameters, isSubjectEncrypted: boolean): Uint8Array {\n  try {\n    const { subject, replyToEmailID, sender, recipient, recipients } = params;\n    const replyBytes = replyToEmailID ? uuidToBytes(replyToEmailID) : new Uint8Array();\n    const senderBytes = userToBytes(sender);\n    const recipientBytes = userToBytes(recipient);\n    const recipientsBytes = recipients ? recipientsToBytes(recipients) : new Uint8Array();\n\n    if (isSubjectEncrypted) {\n      return concatBytes(replyBytes, senderBytes, recipientBytes, recipientsBytes);\n    } else {\n      const subjectBytes = UTF8ToUint8(subject);\n      return concatBytes(subjectBytes, replyBytes, senderBytes, recipientBytes, recipientsBytes);\n    }\n  } catch (error) {\n    throw new Error('Failed to create aux', { cause: error });\n  }\n}\n","import {\n  HybridEncKey,\n  PwdProtectedKey,\n  PublicKeys,\n  PrivateKeys,\n  EmailBody,\n  EmailBodyEncrypted,\n  Email,\n  EmailPublicParameters,\n} from '../types';\nimport { encryptSymmetrically, decryptSymmetrically, genSymmetricKey } from '../symmetric-crypto';\nimport { encapsulateKyber, decapsulateKyber } from '../post-quantum-crypto';\nimport { deriveWrappingKey, wrapKey, unwrapKey } from '../key-wrapper';\nimport { deriveSecretKey } from '../asymmetric-crypto';\nimport { getKeyFromPassword, getKeyFromPasswordAndSalt } from '../derive-key';\nimport { UTF8ToUint8, base64ToUint8Array, uint8ArrayToBase64, uint8ToUTF8, uuidToBytes } from '../utils';\nimport { getAux } from './utils';\n\nexport async function encryptEmailBody(\n  email: Email,\n  isSubjectEncrypted: boolean,\n): Promise<{\n  enc: EmailBodyEncrypted;\n  params: EmailPublicParameters;\n  encryptionKey: Uint8Array;\n}> {\n  try {\n    const aux = getAux(email.params, isSubjectEncrypted);\n\n    let enc: EmailBodyEncrypted;\n    let encryptionKey: Uint8Array;\n    let params = email.params;\n\n    if (isSubjectEncrypted) {\n      const result = await encryptEmailContentAndSubjectSymmetrically(email.body, email.params.subject, aux, email.id);\n      enc = result.enc;\n      encryptionKey = result.encryptionKey;\n      params = { ...email.params, subject: result.encSubject };\n    } else {\n      const result = await encryptEmailContentSymmetrically(email.body, aux, email.id);\n      enc = result.enc;\n      encryptionKey = result.encryptionKey;\n    }\n\n    return { encryptionKey, enc, params };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body', { cause: error });\n  }\n}\n\nexport async function decryptEmailBody(\n  enc: EmailBodyEncrypted,\n  encParams: EmailPublicParameters,\n  encryptionKey: Uint8Array,\n  isSubjectEncrypted: boolean,\n): Promise<{\n  params: EmailPublicParameters;\n  body: EmailBody;\n}> {\n  try {\n    const aux = getAux(encParams, isSubjectEncrypted);\n    let body: EmailBody;\n    let params = encParams;\n    if (isSubjectEncrypted) {\n      const result = await decryptEmailAndSubjectSymmetrically(encryptionKey, aux, encParams.subject, enc);\n      body = result.body;\n      params = { ...encParams, subject: result.subject };\n    } else {\n      body = await decryptEmailSymmetrically(encryptionKey, aux, enc);\n    }\n\n    return { body, params };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts an email with a randomly sampled key.\n *\n * @param email - The email to encrypt.\n * @param aux - The auxiliary data (e.g., email ID or timestamp) for AEAD.\n * @param emailID - The unique identifier of the email.\n * @returns The resulting ciphertext and the used symmetric key\n */\nexport async function encryptEmailContentSymmetrically(\n  email: EmailBody,\n  aux: Uint8Array,\n  emailID: string,\n): Promise<{ enc: EmailBodyEncrypted; encryptionKey: Uint8Array }> {\n  try {\n    if (!email.text) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = genSymmetricKey();\n    const enc = await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID);\n    return { enc, encryptionKey };\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts an email with a randomly sampled key.\n *\n * @param email - The email to encrypt.\n * @param subject - The email subject to encrypt.\n * @param aux - The auxiliary data (e.g., email ID or timestamp) for AEAD.\n * @param emailID - The unique identifier of the email.\n * @returns The resulting ciphertext and the used symmetric key\n */\nexport async function encryptEmailContentAndSubjectSymmetrically(\n  email: EmailBody,\n  subject: string,\n  aux: Uint8Array,\n  emailID: string,\n): Promise<{ enc: EmailBodyEncrypted; encSubject: string; encryptionKey: Uint8Array }> {\n  try {\n    if (!subject || !email.text) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = genSymmetricKey();\n    const enc = await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID);\n    const subjectBuff = UTF8ToUint8(subject);\n    const subjectEnc = await encryptSymmetrically(encryptionKey, subjectBuff, aux);\n    const encSubject = uint8ArrayToBase64(subjectEnc);\n    return { enc, encSubject, encryptionKey };\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email and subject', { cause: error });\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email.\n *\n * @param encryptedEmail - The email to decrypt.\n * @param encryptionKey - The symmetric key.\n * @returns The decrypted email\n */\nexport async function decryptEmailAndSubjectSymmetrically(\n  encryptionKey: Uint8Array,\n  aux: Uint8Array,\n  encSubject: string,\n  enc: EmailBodyEncrypted,\n): Promise<{ body: EmailBody; subject: string }> {\n  try {\n    const array = base64ToUint8Array(encSubject);\n    const subjectArray = await decryptSymmetrically(encryptionKey, array, aux);\n    const body = await decryptEmailSymmetrically(encryptionKey, aux, enc);\n    const subject = uint8ToUTF8(subjectArray);\n    return { body, subject };\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email and subject', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts an email with a randomly sampled key.\n *\n * @param email - The email to encrypt.\n * @returns The resulting ciphertext and the used symmetric key\n */\nexport async function encryptEmailContentSymmetricallyWithKey(\n  emailBody: EmailBody,\n  encryptionKey: Uint8Array,\n  aux: Uint8Array,\n  emailID: string,\n): Promise<EmailBodyEncrypted> {\n  try {\n    const freeField = uuidToBytes(emailID);\n    const text = UTF8ToUint8(emailBody.text);\n    const encryptedText = await encryptSymmetrically(encryptionKey, text, aux, freeField);\n    const encText = uint8ArrayToBase64(encryptedText);\n    const result: EmailBodyEncrypted = { encText };\n\n    if (emailBody.attachments) {\n      const encryptedAttachements = await encryptEmailAttachements(emailBody.attachments, encryptionKey, aux, emailID);\n      result.encAttachments = encryptedAttachements?.map(uint8ArrayToBase64);\n    }\n    return result;\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email with the given key', { cause: error });\n  }\n}\n\nasync function encryptEmailAttachements(\n  attachments: string[],\n  encryptionKey: Uint8Array,\n  aux: Uint8Array,\n  emailID: string,\n): Promise<Uint8Array[]> {\n  try {\n    const freeField = uuidToBytes(emailID);\n    const encryptedAttachments = await Promise.all(\n      attachments.map((attachment) => {\n        const binaryAttachment = UTF8ToUint8(attachment);\n        return encryptSymmetrically(encryptionKey, binaryAttachment, aux, freeField);\n      }),\n    );\n    return encryptedAttachments;\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email attachements', { cause: error });\n  }\n}\n\nasync function decryptEmailAttachements(\n  encryptedAttachments: Uint8Array[],\n  encryptionKey: Uint8Array,\n  aux: Uint8Array,\n): Promise<Uint8Array[]> {\n  try {\n    const decryptedAttachments = await Promise.all(\n      encryptedAttachments.map((attachment) => {\n        return decryptSymmetrically(encryptionKey, attachment, aux);\n      }),\n    );\n    return decryptedAttachments;\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email attachements', { cause: error });\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email.\n *\n * @param encryptedEmail - The email to decrypt.\n * @param encryptionKey - The symmetric key.\n * @returns The decrypted email\n */\nexport async function decryptEmailSymmetrically(\n  encryptionKey: Uint8Array,\n  aux: Uint8Array,\n  enc: EmailBodyEncrypted,\n): Promise<EmailBody> {\n  try {\n    const cipher = base64ToUint8Array(enc.encText);\n    const textArray = await decryptSymmetrically(encryptionKey, cipher, aux);\n    const text = uint8ToUTF8(textArray);\n    const result: EmailBody = { text };\n\n    if (enc.encAttachments) {\n      const encAttachements = enc.encAttachments?.map(base64ToUint8Array);\n      const attachmentsArray = await decryptEmailAttachements(encAttachements, encryptionKey, aux);\n      result.attachments = attachmentsArray?.map((att) => uint8ToUTF8(att));\n    }\n    return result;\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email symmetric key using hybrid encryption.\n *\n * @param emailEncryptionKey - The symmetric key used for email encryption.\n * @param recipientPublicKey - The public key of the recipient.\n * @param senderPrivateKey - The private key of the sender.\n * @returns The encrypted email symmetric key\n */\nexport async function encryptKeysHybrid(\n  emailEncryptionKey: Uint8Array,\n  recipientPublicKey: PublicKeys,\n  senderPrivateKey: PrivateKeys,\n): Promise<HybridEncKey> {\n  try {\n    const eccSecret = await deriveSecretKey(recipientPublicKey.eccPublicKey, senderPrivateKey.eccPrivateKey);\n    const { cipherText: kyberCiphertext, sharedSecret: kyberSecret } = encapsulateKyber(\n      recipientPublicKey.kyberPublicKey,\n    );\n    const wrappingKey = await deriveWrappingKey(eccSecret, kyberSecret);\n    const encryptedKey = await wrapKey(emailEncryptionKey, wrappingKey);\n    const encryptedKeyBase64 = uint8ArrayToBase64(encryptedKey);\n    const kyberCiphertextBase64 = uint8ArrayToBase64(kyberCiphertext);\n\n    return { encryptedKey: encryptedKeyBase64, kyberCiphertext: kyberCiphertextBase64 };\n  } catch (error) {\n    throw new Error('Failed to encrypt email key using hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email symmetric key encrypted via hybrid encryption.\n *\n * @param encryptedKey - The encrypted email key.\n * @param senderPublicKey - The public key of the sender.\n * @param recipientPrivateKey - The private key of the recipient.\n * @returns The email encryption key\n */\nexport async function decryptKeysHybrid(\n  encryptedKey: HybridEncKey,\n  senderPublicKey: PublicKeys,\n  recipientPrivateKey: PrivateKeys,\n): Promise<Uint8Array> {\n  try {\n    const kyberCiphertext = base64ToUint8Array(encryptedKey.kyberCiphertext);\n    const encKey = base64ToUint8Array(encryptedKey.encryptedKey);\n    const eccSecret = await deriveSecretKey(senderPublicKey.eccPublicKey, recipientPrivateKey.eccPrivateKey);\n    const kyberSecret = decapsulateKyber(kyberCiphertext, recipientPrivateKey.kyberPrivateKey);\n    const wrappingKey = await deriveWrappingKey(eccSecret, kyberSecret);\n    const encryptionKey = await unwrapKey(encKey, wrappingKey);\n    return encryptionKey;\n  } catch (error) {\n    throw new Error('Failed to decrypt email key encrypted via hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Password-protects the email symmetric key.\n *\n * @param emailEncryptionKey - The symmetric key used for email encryption.\n * @param password - The secret password for key protection.\n * @returns The password-protected email symmetric key\n */\nexport async function passwordProtectKey(emailEncryptionKey: Uint8Array, password: string): Promise<PwdProtectedKey> {\n  try {\n    const { key, salt } = await getKeyFromPassword(password);\n    const encryptedKey = await wrapKey(emailEncryptionKey, key);\n    const saltStr = uint8ArrayToBase64(salt);\n    const encryptedKeyStr = uint8ArrayToBase64(encryptedKey);\n    return { encryptedKey: encryptedKeyStr, salt: saltStr };\n  } catch (error) {\n    throw new Error('Failed to password-protect email key', { cause: error });\n  }\n}\n\n/**\n * Removes passoword-protection and exposes the email symmetric key.\n *\n * @param emailEncryptionKey -  The password-protected email key.\n * @param password - The secret password for key protection.\n * @returns The email encryption key\n */\nexport async function removePasswordProtection(\n  emailEncryptionKey: PwdProtectedKey,\n  password: string,\n): Promise<Uint8Array> {\n  try {\n    const salt = base64ToUint8Array(emailEncryptionKey.salt);\n    const encryptedKey = base64ToUint8Array(emailEncryptionKey.encryptedKey);\n    const key = await getKeyFromPasswordAndSalt(password, salt);\n    const encryptionKey = await unwrapKey(encryptedKey, key);\n    return encryptionKey;\n  } catch (error) {\n    throw new Error('Failed to remove password-protection from email key', { cause: error });\n  }\n}\n","import { PublicKeys, PrivateKeys, HybridEncryptedEmail, Email, UserWithPublicKeys } from '../types';\nimport { decryptEmailBody, encryptKeysHybrid, decryptKeysHybrid, encryptEmailBody } from './core';\n\n/**\n * Encrypts the email using hybrid encryption.\n *\n * @param email - The email to encrypt.\n * @param recipientPublicKeys - The public keys of the recipient.\n * @param senderPrivateKey - The private key of the sender.\n * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted\n * @returns The encrypted email\n */\nexport async function encryptEmailHybrid(\n  email: Email,\n  recipient: UserWithPublicKeys,\n  senderPrivateKey: PrivateKeys,\n  isSubjectEncrypted: boolean = false,\n): Promise<HybridEncryptedEmail> {\n  try {\n    const { encryptionKey, params, enc } = await encryptEmailBody(email, isSubjectEncrypted);\n    const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient.publicKeys, senderPrivateKey);\n    return { enc, encryptedKey, recipientEmail: recipient.email, params, isSubjectEncrypted, id: email.id };\n  } catch (error) {\n    throw new Error('Failed to encrypt email with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email using hybrid encryption for multiple recipients.\n *\n * @param email - The email to encrypt.\n * @param recipients - The recipients with corresponding public keys.\n * @param senderPrivateKey - The private key of the sender.\n * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted\n * @returns The set of encrypted email\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  email: Email,\n  recipients: UserWithPublicKeys[],\n  senderPrivateKey: PrivateKeys,\n  isSubjectEncrypted: boolean = false,\n): Promise<HybridEncryptedEmail[]> {\n  try {\n    const { encryptionKey, params, enc } = await encryptEmailBody(email, isSubjectEncrypted);\n\n    const encryptedEmails: HybridEncryptedEmail[] = [];\n    for (const recipient of recipients) {\n      const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient.publicKeys, senderPrivateKey);\n      encryptedEmails.push({\n        enc,\n        encryptedKey,\n        recipientEmail: recipient.email,\n        params,\n        isSubjectEncrypted,\n        id: email.id,\n      });\n    }\n    return encryptedEmails;\n  } catch (error) {\n    throw new Error('Failed to encrypt email to multiple recipients with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Decrypts the email using hybrid encryption.\n *\n * @param encryptedEmail - The encrypted email.\n * @param senderPublicKeys - The public key of the sender.\n * @param recipientPrivateKeys - The private key of the recipient.\n * @returns The decrypted email\n */\nexport async function decryptEmailHybrid(\n  encryptedEmail: HybridEncryptedEmail,\n  senderPublicKeys: PublicKeys,\n  recipientPrivateKeys: PrivateKeys,\n): Promise<Email> {\n  try {\n    const { isSubjectEncrypted, params: encParams, enc, encryptedKey, id } = encryptedEmail;\n    const encryptionKey = await decryptKeysHybrid(encryptedKey, senderPublicKeys, recipientPrivateKeys);\n    const { body, params } = await decryptEmailBody(enc, encParams, encryptionKey, isSubjectEncrypted);\n    return { body, params, id };\n  } catch (error) {\n    throw new Error('Failed to decrypt email with hybrid encryption', { cause: error });\n  }\n}\n","import { PwdProtectedEmail, Email } from '../types';\nimport { decryptEmailBody, passwordProtectKey, removePasswordProtection, encryptEmailBody } from './core';\n\n/**\n * Creates a password-protected email.\n *\n * @param email - The email to password-protect\n * @param password - The secret password shared among recipients\n * @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted\n * @returns The password-protected email\n */\nexport async function createPwdProtectedEmail(\n  email: Email,\n  password: string,\n  isSubjectEncrypted: boolean = false,\n): Promise<PwdProtectedEmail> {\n  try {\n    if (!email?.body || !email.params) {\n      throw new Error('Failed to password-protect email: Invalid email structure');\n    }\n    const { encryptionKey, params, enc } = await encryptEmailBody(email, isSubjectEncrypted);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { enc, encryptedKey, params, id: email.id, isSubjectEncrypted };\n  } catch (error) {\n    throw new Error('Failed to password-protect email', { cause: error });\n  }\n}\n\n/**\n * Opens a password-protected email.\n *\n * @param encryptedEmail - The encrypted email\n * @param password - The secret password shared among recipients.\n * @returns The decrypted email\n */\nexport async function decryptPwdProtectedEmail(encryptedEmail: PwdProtectedEmail, password: string): Promise<Email> {\n  try {\n    const { isSubjectEncrypted, params: encParams, enc, id } = encryptedEmail;\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    const { body, params } = await decryptEmailBody(enc, encParams, encryptionKey, isSubjectEncrypted);\n    return { body, params, id };\n  } catch (error) {\n    throw new Error('Failed to decrypt password-protect email', { cause: error });\n  }\n}\n","import { generateEccKeys } from '../asymmetric-crypto';\nimport { generateKyberKeys } from '../post-quantum-crypto';\nimport { EmailKeys } from '../types';\n\n/**\n * Generates public and private keys for email service.\n *\n * @returns The user's private and public keys\n */\nexport async function generateEmailKeys(): Promise<EmailKeys> {\n  try {\n    const kyberKeys = generateKyberKeys();\n    const keys = await generateEccKeys();\n\n    const emailKeys: EmailKeys = {\n      publicKeys: {\n        eccPublicKey: keys.publicKey,\n        kyberPublicKey: kyberKeys.publicKey,\n      },\n      privateKeys: {\n        eccPrivateKey: keys.privateKey,\n        kyberPrivateKey: kyberKeys.secretKey,\n      },\n    };\n\n    return emailKeys;\n  } catch (error) {\n    throw new Error('Failed to generate keys for email service', { cause: error });\n  }\n}\n"],"mappings":"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"}