internxt-crypto 0.0.9-alpha → 0.0.11

package/dist/email-crypto-BrT98taw.js

@@ -0,0 +1,617 @@
+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');
+let _noble_hashes_utils_js = require("@noble/hashes/utils.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
+*/
+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));
+	} catch (error) {
+		throw new Error("Failed to derive wrapping key", { cause: error });
+	}
+}
+/**
+* Unwraps the given wrapped key
+*
+* @param encryptedKey - The encrypted key
+* @param wrappingKey - The secret key used for decryption
+* @returns The resulting wrapping CryptoKey
+*/
+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 });
+	}
+}
+/**
+* Wraps the given CryptoKey
+*
+* @param encryptionKey - The CryptoKey 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 });
+	}
+}
+
+//#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));
+	} catch (error) {
+		throw new Error("Failed to convert User to bytes", { cause: error });
+	}
+}
+function recipientsToBytes(recipients) {
+	try {
+		return (0, _noble_hashes_utils_js.concatBytes)(...recipients.map((user) => userToBytes(user)));
+	} catch (error) {
+		throw new Error("Failed to convert recipients to bytes", { cause: error });
+	}
+}
+/**
+* Converts an Email type into a Uint8Array array.
+*
+* @param email - The email.
+* @returns The Uint8Array array representation of the Email type.
+*/
+function emailToBinary(email) {
+	try {
+		return require_utils.UTF8ToUint8(JSON.stringify(email));
+	} catch (error) {
+		throw new Error("Failed to convert EmailBody to Uint8Array", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/email-crypto/utils.ts
+/**
+* Creates an auxiliary string from public fields of the email.
+*
+* @param params - The email public parameters.
+* @param isSubjectEncrypted - Indicates if the email subject field should be encrypted
+* @returns The resulting auxiliary string
+*/
+function getAux(params, isSubjectEncrypted) {
+	try {
+		const { subject, replyToEmailID, sender, recipient, recipients } = params;
+		const replyBytes = replyToEmailID ? require_utils.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);
+	} catch (error) {
+		throw new Error("Failed to create aux", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/email-crypto/core.ts
+async function encryptEmailBody(email, isSubjectEncrypted) {
+	try {
+		const aux = getAux(email.params, isSubjectEncrypted);
+		let enc;
+		let encryptionKey;
+		let params = email.params;
+		if (isSubjectEncrypted) {
+			const result = await encryptEmailContentAndSubjectSymmetrically(email.body, email.params.subject, aux, email.id);
+			enc = result.enc;
+			encryptionKey = result.encryptionKey;
+			params = {
+				...email.params,
+				subject: result.encSubject
+			};
+		} else {
+			const result = await encryptEmailContentSymmetrically(email.body, aux, email.id);
+			enc = result.enc;
+			encryptionKey = result.encryptionKey;
+		}
+		return {
+			encryptionKey,
+			enc,
+			params
+		};
+	} catch (error) {
+		throw new Error("Failed to encrypt email body", { cause: error });
+	}
+}
+async function decryptEmailBody(enc, encParams, encryptionKey, isSubjectEncrypted) {
+	try {
+		const aux = getAux(encParams, isSubjectEncrypted);
+		let body;
+		let params = encParams;
+		if (isSubjectEncrypted) {
+			const result = await decryptEmailAndSubjectSymmetrically(encryptionKey, aux, encParams.subject, enc);
+			body = result.body;
+			params = {
+				...encParams,
+				subject: result.subject
+			};
+		} else body = await decryptEmailSymmetrically(encryptionKey, aux, enc);
+		return {
+			body,
+			params
+		};
+	} catch (error) {
+		throw new Error("Failed to encrypt email body", { cause: error });
+	}
+}
+/**
+* Symmetrically encrypts an email with a randomly sampled key.
+*
+* @param email - The email to encrypt.
+* @param aux - The auxiliary data (e.g., email ID or timestamp) for AEAD.
+* @param emailID - The unique identifier of the email.
+* @returns The resulting ciphertext and the used symmetric key
+*/
+async function encryptEmailContentSymmetrically(email, aux, emailID) {
+	try {
+		if (!email.text) throw new Error("Invalid input");
+		const encryptionKey = await require_symmetric_crypto.genSymmetricCryptoKey();
+		return {
+			enc: await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID),
+			encryptionKey
+		};
+	} catch (error) {
+		throw new Error("Failed to symmetrically encrypt email", { cause: error });
+	}
+}
+/**
+* Symmetrically encrypts an email with a randomly sampled key.
+*
+* @param email - The email to encrypt.
+* @param subject - The email subject to encrypt.
+* @param aux - The auxiliary data (e.g., email ID or timestamp) for AEAD.
+* @param emailID - The unique identifier of the email.
+* @returns The resulting ciphertext and the used symmetric key
+*/
+async function encryptEmailContentAndSubjectSymmetrically(email, subject, aux, emailID) {
+	try {
+		if (!subject || !email.text) throw new Error("Invalid input");
+		const encryptionKey = await require_symmetric_crypto.genSymmetricCryptoKey();
+		return {
+			enc: await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID),
+			encSubject: require_utils.uint8ArrayToBase64(await require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(subject), aux)),
+			encryptionKey
+		};
+	} catch (error) {
+		throw new Error("Failed to symmetrically encrypt email and subject", { cause: error });
+	}
+}
+/**
+* Decrypts symmetrically encrypted email.
+*
+* @param encryptedEmail - The email to decrypt.
+* @param encryptionKey - The symmetric CryptoKey.
+* @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);
+		return {
+			body: await decryptEmailSymmetrically(encryptionKey, aux, enc),
+			subject: require_utils.uint8ToUTF8(subjectArray)
+		};
+	} catch (error) {
+		throw new Error("Failed to symmetrically decrypt email and subject", { cause: error });
+	}
+}
+/**
+* Symmetrically encrypts an email with a randomly sampled key.
+*
+* @param email - The email to encrypt.
+* @returns The resulting ciphertext and the used symmetric key
+*/
+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);
+		return result;
+	} catch (error) {
+		throw new Error("Failed to symmetrically encrypt email with the given key", { cause: error });
+	}
+}
+async function encryptEmailAttachements(attachments, encryptionKey, aux, emailID) {
+	try {
+		const freeField = require_utils.uuidToBytes(emailID);
+		return await Promise.all(attachments.map((attachment) => {
+			return require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(attachment), aux, freeField);
+		}));
+	} catch (error) {
+		throw new Error("Failed to symmetrically encrypt email attachements", { cause: error });
+	}
+}
+async function decryptEmailAttachements(encryptedAttachments, encryptionKey, aux) {
+	try {
+		return await Promise.all(encryptedAttachments.map((attachment) => {
+			return require_symmetric_crypto.decryptSymmetrically(encryptionKey, attachment, aux);
+		}));
+	} catch (error) {
+		throw new Error("Failed to symmetrically decrypt email attachements", { cause: error });
+	}
+}
+/**
+* Decrypts symmetrically encrypted email.
+*
+* @param encryptedEmail - The email to decrypt.
+* @param encryptionKey - The symmetric CryptoKey.
+* @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)) };
+		if (enc.encAttachments) {
+			const encAttachements = enc.encAttachments?.map(require_utils.base64ToUint8Array);
+			result.attachments = (await decryptEmailAttachements(encAttachements, encryptionKey, aux))?.map((att) => require_utils.uint8ToUTF8(att));
+		}
+		return result;
+	} catch (error) {
+		throw new Error("Failed to symmetrically decrypt email", { cause: error });
+	}
+}
+/**
+* Encrypts the email symmetric key using hybrid encryption.
+*
+* @param emailEncryptionKey - The symmetric CryptoKey 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);
+		return {
+			encryptedKey: require_utils.uint8ArrayToBase64(await wrapKey(emailEncryptionKey, await deriveWrappingKey(eccSecret, kyberSecret))),
+			kyberCiphertext: require_utils.uint8ArrayToBase64(kyberCiphertext)
+		};
+	} catch (error) {
+		throw new Error("Failed to encrypt email key using hybrid encryption", { cause: error });
+	}
+}
+/**
+* Decrypts the email symmetric key encrypted via hybrid encryption.
+*
+* @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
+*/
+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)));
+	} catch (error) {
+		throw new Error("Failed to decrypt email key encrypted via hybrid encryption", { cause: error });
+	}
+}
+/**
+* Password-protects the email symmetric key.
+*
+* @param emailEncryptionKey - The symmetric CryptoKey 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);
+		return {
+			encryptedKey: require_utils.uint8ArrayToBase64(encryptedKey),
+			salt: saltStr
+		};
+	} catch (error) {
+		throw new Error("Failed to password-protect email key", { cause: error });
+	}
+}
+/**
+* Removes passoword-protection and exposes the email symmetric key.
+*
+* @param emailEncryptionKey -  The password-protected email key.
+* @param password - The secret password for key protection.
+* @returns The email encryption CryptoKey
+*/
+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)));
+	} catch (error) {
+		throw new Error("Failed to remove password-protection from email key", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/email-crypto/hybridEncyptedEmail.ts
+/**
+* Encrypts the email using hybrid encryption.
+*
+* @param email - The email to encrypt.
+* @param recipientPublicKeys - The public keys of the recipient.
+* @param senderPrivateKey - The private key of the sender.
+* @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted
+* @returns The encrypted email
+*/
+async function encryptEmailHybrid(email, recipient, senderPrivateKey, isSubjectEncrypted = false) {
+	try {
+		const { encryptionKey, params, enc } = await encryptEmailBody(email, isSubjectEncrypted);
+		return {
+			enc,
+			encryptedKey: await encryptKeysHybrid(encryptionKey, recipient.publicKeys, senderPrivateKey),
+			recipientEmail: recipient.email,
+			params,
+			isSubjectEncrypted,
+			id: email.id
+		};
+	} catch (error) {
+		throw new Error("Failed to encrypt email with hybrid encryption", { cause: error });
+	}
+}
+/**
+* Encrypts the email using hybrid encryption for multiple recipients.
+*
+* @param email - The email to encrypt.
+* @param recipients - The recipients with corresponding public keys.
+* @param senderPrivateKey - The private key of the sender.
+* @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted
+* @returns The set of encrypted email
+*/
+async function encryptEmailHybridForMultipleRecipients(email, recipients, senderPrivateKey, isSubjectEncrypted = false) {
+	try {
+		const { encryptionKey, params, enc } = await encryptEmailBody(email, isSubjectEncrypted);
+		const encryptedEmails = [];
+		for (const recipient of recipients) {
+			const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient.publicKeys, senderPrivateKey);
+			encryptedEmails.push({
+				enc,
+				encryptedKey,
+				recipientEmail: recipient.email,
+				params,
+				isSubjectEncrypted,
+				id: email.id
+			});
+		}
+		return encryptedEmails;
+	} catch (error) {
+		throw new Error("Failed to encrypt email to multiple recipients with hybrid encryption", { cause: error });
+	}
+}
+/**
+* Decrypts the email using hybrid encryption.
+*
+* @param encryptedEmail - The encrypted email.
+* @param senderPublicKeys - The public key of the sender.
+* @param recipientPrivateKeys - The private key of the recipient.
+* @returns The decrypted email
+*/
+async function decryptEmailHybrid(encryptedEmail, senderPublicKeys, recipientPrivateKeys) {
+	try {
+		const { isSubjectEncrypted, params: encParams, enc, encryptedKey, id } = encryptedEmail;
+		const { body, params } = await decryptEmailBody(enc, encParams, await decryptKeysHybrid(encryptedKey, senderPublicKeys, recipientPrivateKeys), isSubjectEncrypted);
+		return {
+			body,
+			params,
+			id
+		};
+	} catch (error) {
+		throw new Error("Failed to decrypt email with hybrid encryption", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/email-crypto/pwdProtectedEmail.ts
+/**
+* Creates a password-protected email.
+*
+* @param email - The email to password-protect
+* @param password - The secret password shared among recipients
+* @param isSubjectEncrypted -  Indicates if the email subject field should be encrypted
+* @returns The password-protected email
+*/
+async function createPwdProtectedEmail(email, password, isSubjectEncrypted = false) {
+	try {
+		if (!email?.body || !email.params) throw new Error("Failed to password-protect email: Invalid email structure");
+		const { encryptionKey, params, enc } = await encryptEmailBody(email, isSubjectEncrypted);
+		return {
+			enc,
+			encryptedKey: await passwordProtectKey(encryptionKey, password),
+			params,
+			id: email.id,
+			isSubjectEncrypted
+		};
+	} catch (error) {
+		throw new Error("Failed to password-protect email", { cause: error });
+	}
+}
+/**
+* Opens a password-protected email.
+*
+* @param encryptedEmail - The encrypted email
+* @param password - The secret password shared among recipients.
+* @returns The decrypted email
+*/
+async function decryptPwdProtectedEmail(encryptedEmail, password) {
+	try {
+		const { isSubjectEncrypted, params: encParams, enc, id } = encryptedEmail;
+		const { body, params } = await decryptEmailBody(enc, encParams, await removePasswordProtection(encryptedEmail.encryptedKey, password), isSubjectEncrypted);
+		return {
+			body,
+			params,
+			id
+		};
+	} catch (error) {
+		throw new Error("Failed to decrypt password-protect email", { cause: error });
+	}
+}
+
+//#endregion
+//#region src/email-crypto/emailKeys.ts
+/**
+* Generates public and private keys for email service.
+*
+* @returns The user's private and public keys
+*/
+async function generateEmailKeys() {
+	try {
+		const kyberKeys = require_post_quantum_crypto.generateKyberKeys();
+		const keys = await require_asymmetric_crypto.generateEccKeys();
+		return {
+			publicKeys: {
+				eccPublicKey: keys.publicKey,
+				kyberPublicKey: kyberKeys.publicKey
+			},
+			privateKeys: {
+				eccPrivateKey: keys.privateKey,
+				kyberPrivateKey: kyberKeys.secretKey
+			}
+		};
+	} catch (error) {
+		throw new Error("Failed to generate keys for email service", { cause: error });
+	}
+}
+
+//#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,
+  get: function () {
+    return createPwdProtectedEmail;
+  }
+});
+Object.defineProperty(exports, 'decryptEmailHybrid', {
+  enumerable: true,
+  get: function () {
+    return decryptEmailHybrid;
+  }
+});
+Object.defineProperty(exports, 'decryptEmailSymmetrically', {
+  enumerable: true,
+  get: function () {
+    return decryptEmailSymmetrically;
+  }
+});
+Object.defineProperty(exports, 'decryptPwdProtectedEmail', {
+  enumerable: true,
+  get: function () {
+    return decryptPwdProtectedEmail;
+  }
+});
+Object.defineProperty(exports, 'emailToBinary', {
+  enumerable: true,
+  get: function () {
+    return emailToBinary;
+  }
+});
+Object.defineProperty(exports, 'email_crypto_exports', {
+  enumerable: true,
+  get: function () {
+    return email_crypto_exports;
+  }
+});
+Object.defineProperty(exports, 'encryptEmailContentSymmetricallyWithKey', {
+  enumerable: true,
+  get: function () {
+    return encryptEmailContentSymmetricallyWithKey;
+  }
+});
+Object.defineProperty(exports, 'encryptEmailHybrid', {
+  enumerable: true,
+  get: function () {
+    return encryptEmailHybrid;
+  }
+});
+Object.defineProperty(exports, 'encryptEmailHybridForMultipleRecipients', {
+  enumerable: true,
+  get: function () {
+    return encryptEmailHybridForMultipleRecipients;
+  }
+});
+Object.defineProperty(exports, 'generateEmailKeys', {
+  enumerable: true,
+  get: function () {
+    return generateEmailKeys;
+  }
+});
+Object.defineProperty(exports, 'getAux', {
+  enumerable: true,
+  get: function () {
+    return getAux;
+  }
+});
+Object.defineProperty(exports, 'key_wrapper_exports', {
+  enumerable: true,
+  get: function () {
+    return key_wrapper_exports;
+  }
+});
+Object.defineProperty(exports, 'recipientsToBytes', {
+  enumerable: true,
+  get: function () {
+    return recipientsToBytes;
+  }
+});
+Object.defineProperty(exports, 'userToBytes', {
+  enumerable: true,
+  get: function () {
+    return userToBytes;
+  }
+});
+//# sourceMappingURL=email-crypto-BrT98taw.js.map

package/dist/email-crypto-BrT98taw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"email-crypto-BrT98taw.js","names":["KEY_FORMAT","KEY_WRAPPING_ALGORITHM","deriveSymmetricKeyFromTwoKeysAndContext","CONTEXT_WRAPPING","AES_ALGORITHM","UTF8ToUint8","uuidToBytes","UTF8ToUint8","genSymmetricCryptoKey","uint8ArrayToBase64","encryptSymmetrically","UTF8ToUint8","decryptSymmetrically","base64ToUint8Array","uint8ToUTF8","uuidToBytes","deriveSecretKey","encapsulateKyber","decapsulateKyber","getKeyFromPassword","getKeyFromPasswordAndSalt","generateKyberKeys","generateEccKeys"],"sources":["../src/key-wrapper/aesWrapper.ts","../src/key-wrapper/index.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","../src/email-crypto/index.ts"],"sourcesContent":["import { KEY_WRAPPING_ALGORITHM, KEY_FORMAT, CONTEXT_WRAPPING, AES_ALGORITHM } from '../constants';\nimport { deriveSymmetricKeyFromTwoKeysAndContext } from '../derive-key';\n\n/**\n * Converts wrapping key in Uint8Array into CryptoKey\n *\n * @param key - The wrapping key in Uint8Array representation\n * @returns The resulting CryptoKey\n */\nexport async function importWrappingKey(key: Uint8Array): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.importKey(KEY_FORMAT, key as BufferSource, KEY_WRAPPING_ALGORITHM, false, [\n      'wrapKey',\n      'unwrapKey',\n    ]);\n  } catch (error) {\n    throw new Error('Failed to import wrapping key', { cause: error });\n  }\n}\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 CryptoKey\n */\nexport async function deriveWrappingKey(eccSecret: Uint8Array, kyberSecret: Uint8Array): Promise<CryptoKey> {\n  try {\n    if (eccSecret.length !== kyberSecret.length) {\n      throw new Error('secrets must have equal length');\n    }\n    const key = await deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, CONTEXT_WRAPPING);\n    return await importWrappingKey(key);\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 encrypted key\n * @param wrappingKey - The secret key used for decryption\n * @returns The resulting wrapping CryptoKey\n */\nexport async function unwrapKey(encryptedKey: Uint8Array, wrappingKey: CryptoKey): Promise<CryptoKey> {\n  try {\n    return await crypto.subtle.unwrapKey(\n      KEY_FORMAT,\n      encryptedKey as BufferSource,\n      wrappingKey,\n      KEY_WRAPPING_ALGORITHM,\n      AES_ALGORITHM,\n      false,\n      ['encrypt', 'decrypt'],\n    );\n  } catch (error) {\n    throw new Error('Failed to unwrap key', { cause: error });\n  }\n}\n\n/**\n * Wraps the given CryptoKey\n *\n * @param encryptionKey - The CryptoKey to be wrapped\n * @param wrappingKey - The secret key used for wrapping\n * @returns The resulting ciphertext\n */\nexport async function wrapKey(encryptionKey: CryptoKey, wrappingKey: CryptoKey): Promise<Uint8Array> {\n  try {\n    const result = await crypto.subtle.wrapKey(KEY_FORMAT, encryptionKey, wrappingKey, KEY_WRAPPING_ALGORITHM);\n    return new Uint8Array(result);\n  } catch (error) {\n    throw new Error('Failed to wrap key', { cause: error });\n  }\n}\n","export * from './aesWrapper';\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 { genSymmetricCryptoKey, encryptSymmetrically, decryptSymmetrically } from '../symmetric-crypto';\nimport { encapsulateKyber, decapsulateKyber } from '../post-quantum-crypto';\nimport { deriveWrappingKey, wrapKey, unwrapKey, importWrappingKey } 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: CryptoKey;\n}> {\n  try {\n    const aux = getAux(email.params, isSubjectEncrypted);\n\n    let enc: EmailBodyEncrypted;\n    let encryptionKey: CryptoKey;\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: CryptoKey,\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: CryptoKey }> {\n  try {\n    if (!email.text) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = await genSymmetricCryptoKey();\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: CryptoKey }> {\n  try {\n    if (!subject || !email.text) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = await genSymmetricCryptoKey();\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 CryptoKey.\n * @returns The decrypted email\n */\nexport async function decryptEmailAndSubjectSymmetrically(\n  encryptionKey: CryptoKey,\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: CryptoKey,\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: CryptoKey,\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: CryptoKey,\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 CryptoKey.\n * @returns The decrypted email\n */\nexport async function decryptEmailSymmetrically(\n  encryptionKey: CryptoKey,\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 CryptoKey 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: CryptoKey,\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 CryptoKey\n */\nexport async function decryptKeysHybrid(\n  encryptedKey: HybridEncKey,\n  senderPublicKey: PublicKeys,\n  recipientPrivateKey: PrivateKeys,\n): Promise<CryptoKey> {\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 CryptoKey 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: CryptoKey, password: string): Promise<PwdProtectedKey> {\n  try {\n    const { key, salt } = await getKeyFromPassword(password);\n    const wrappingKey = await importWrappingKey(key);\n    const encryptedKey = await wrapKey(emailEncryptionKey, wrappingKey);\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 CryptoKey\n */\nexport async function removePasswordProtection(\n  emailEncryptionKey: PwdProtectedKey,\n  password: string,\n): Promise<CryptoKey> {\n  try {\n    const salt = base64ToUint8Array(emailEncryptionKey.salt);\n    const encryptedKey = base64ToUint8Array(emailEncryptionKey.encryptedKey);\n    const key = await getKeyFromPasswordAndSalt(password, salt);\n    const wrappingKey = await importWrappingKey(key);\n    const encryptionKey = await unwrapKey(encryptedKey, wrappingKey);\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","export * from './hybridEncyptedEmail';\nexport * from './pwdProtectedEmail';\nexport * from './converters';\nexport * from './emailKeys';\nexport * from './utils';\n"],"mappings":"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"}