internxt-crypto 1.3.1 → 1.4.0

package/dist/email-crypto-Cr7znO1a.js

@@ -1,401 +0,0 @@
-require("./chunk-C13QxCFV.js");
-const require_constants = require("./constants.js");
-const require_utils = require("./utils.js");
-const require_derive_key = require("./derive-key.js");
-const require_derive_password = require("./derive-password-CbYRDq7V.js");
-const require_symmetric_crypto = require("./symmetric-crypto.js");
-const require_xwing = require("./xwing-7fEqAT7W.js");
-let _noble_ciphers_aes_js = require("@noble/ciphers/aes.js");
-//#region src/key-wrapper/aesWrapper.ts
-/**
-* Unwraps the given wrapped key
-*
-* @param encryptedKey - The wrapped key
-* @param wrappingKey - The secret key used for unwrapping
-* @returns The resulting key
-*/
-async function unwrapKey(encryptedKey, wrappingKey) {
-	return (0, _noble_ciphers_aes_js.aeskw)(wrappingKey).decrypt(encryptedKey);
-}
-/**
-* Wraps the given key
-*
-* @param key - The key to be wrapped
-* @param wrappingKey - The secret key used for wrapping
-* @returns The resulting ciphertext
-*/
-async function wrapKey(key, wrappingKey) {
-	return (0, _noble_ciphers_aes_js.aeskw)(wrappingKey).encrypt(key);
-}
-//#endregion
-//#region src/email-crypto/core.ts
-/**
-* Symmetrically encrypts email body.
-*
-* @param body - The email body to encrypt.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The resulting encrypted email body and symmetric key used for encryption
-*/
-async function encryptEmailBody(body, aux) {
-	try {
-		if (!body.text || !body.subject) throw new Error("Invalid input");
-		const encryptionKey = require_symmetric_crypto.genSymmetricKey();
-		return {
-			encEmailBody: await encryptEmailBodyWithKey(body, encryptionKey, aux),
-			encryptionKey
-		};
-	} catch (error) {
-		throw new Error("Failed to symmetrically encrypt email body", { cause: error });
-	}
-}
-/**
-* Symmetrically encrypts email body with the given key.
-*
-* @param body - The email body to encrypt.
-* @param encryptionKey - The symmetric key to encrypt the email.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The resulting encrypted email body and symmetric key used for encryption
-*/
-async function encryptEmailBodyWithKey(body, encryptionKey, aux) {
-	try {
-		const text = require_utils.UTF8ToUint8(body.text);
-		const subjectEnc = await require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(body.subject), aux);
-		const enc = {
-			encText: require_utils.uint8ArrayToBase64(await require_symmetric_crypto.encryptSymmetrically(encryptionKey, text, aux)),
-			encSubject: require_utils.uint8ArrayToBase64(subjectEnc)
-		};
-		if (body.attachments) {
-			const promises = body.attachments.map((attachment) => {
-				return require_symmetric_crypto.encryptSymmetrically(encryptionKey, require_utils.UTF8ToUint8(attachment), aux);
-			});
-			enc.encAttachments = (await Promise.all(promises))?.map(require_utils.uint8ArrayToBase64);
-		}
-		return enc;
-	} catch (error) {
-		throw new Error("Failed to encrypt email body", { cause: error });
-	}
-}
-/**
-* Decrypts symmetrically encrypted email body.
-*
-* @param encEmailBody - The email body to decrypt.
-* @param encryptionKey - The symmetric key to decrypt the email.
-* @param aux - An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The resulting decrypted email body
-*/
-async function decryptEmailBody(encEmailBody, encryptionKey, aux) {
-	try {
-		const subject = require_utils.uint8ToUTF8(await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(encEmailBody.encSubject), aux));
-		const body = {
-			text: require_utils.uint8ToUTF8(await require_symmetric_crypto.decryptSymmetrically(encryptionKey, require_utils.base64ToUint8Array(encEmailBody.encText), aux)),
-			subject
-		};
-		if (encEmailBody.encAttachments) {
-			const promises = (encEmailBody.encAttachments?.map(require_utils.base64ToUint8Array))?.map((encAtt) => require_symmetric_crypto.decryptSymmetrically(encryptionKey, encAtt, aux));
-			body.attachments = (await Promise.all(promises))?.map((att) => require_utils.uint8ToUTF8(att));
-		}
-		return body;
-	} catch (error) {
-		throw new Error("Failed to symmetrically decrypt email body", { cause: error });
-	}
-}
-/**
-* Encrypts the email symmetric key using hybrid encryption.
-*
-* @param emailEncryptionKey - The symmetric key used for email encryption.
-* @param recipient - The recipient with a public hybrid key.
-* @returns The encrypted email symmetric key
-*/
-async function encryptKeysHybrid(emailEncryptionKey, recipient) {
-	try {
-		const { cipherText, sharedSecret } = require_xwing.encapsulateHybrid(recipient.publicHybridKey);
-		return {
-			encryptedKey: require_utils.uint8ArrayToBase64(await wrapKey(emailEncryptionKey, sharedSecret)),
-			hybridCiphertext: require_utils.uint8ArrayToBase64(cipherText),
-			encryptedForEmail: recipient.email
-		};
-	} 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 recipientPrivateKey - The private key of the recipient.
-* @returns The email encryption key
-*/
-async function decryptKeysHybrid(encryptedKey, recipientPrivateKey) {
-	try {
-		const kyberCiphertext = require_utils.base64ToUint8Array(encryptedKey.hybridCiphertext);
-		return await unwrapKey(require_utils.base64ToUint8Array(encryptedKey.encryptedKey), require_xwing.decapsulateHybrid(kyberCiphertext, recipientPrivateKey));
-	} 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 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_password.getKeyFromPassword(password);
-		const encryptedKey = await wrapKey(emailEncryptionKey, 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 key
-*/
-async function removePasswordProtection(emailEncryptionKey, password) {
-	try {
-		const salt = require_utils.base64ToUint8Array(emailEncryptionKey.salt);
-		return await unwrapKey(require_utils.base64ToUint8Array(emailEncryptionKey.encryptedKey), await require_derive_password.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 body using hybrid encryption.
-*
-* @param body - The email body to encrypt.
-* @param recipientPublicKeys - The public keys of the recipient.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The encrypted email body
-*/
-async function encryptEmailHybrid(body, recipient, aux) {
-	try {
-		const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);
-		return {
-			encEmailBody,
-			encryptedKey: await encryptKeysHybrid(encryptionKey, recipient)
-		};
-	} catch (error) {
-		throw new Error("Failed to encrypt email body with hybrid encryption", { cause: error });
-	}
-}
-/**
-* Encrypts the email body using hybrid encryption for multiple recipients.
-*
-* @param body - The email body to encrypt for multiple recipients.
-* @param recipients - The recipients with corresponding public keys.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The set of encrypted email bodies
-*/
-async function encryptEmailHybridForMultipleRecipients(body, recipients, aux) {
-	try {
-		const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);
-		const encryptedEmails = [];
-		for (const recipient of recipients) {
-			const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);
-			encryptedEmails.push({
-				encEmailBody,
-				encryptedKey
-			});
-		}
-		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 encEmailBody - The encrypted email.
-* @param recipientPrivateHybridKeys - The private key of the recipient.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The decrypted email body
-*/
-async function decryptEmailHybrid(encEmailBody, recipientPrivateHybridKeys, aux) {
-	try {
-		const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);
-		return await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);
-	} 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 aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The password-protected email
-*/
-async function createPwdProtectedEmail(emailBody, password, aux) {
-	try {
-		const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);
-		return {
-			encEmailBody,
-			encryptedKey: await passwordProtectKey(encryptionKey, password)
-		};
-	} 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.
-* @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).
-* @returns The decrypted email body
-*/
-async function decryptPwdProtectedEmail(encryptedEmail, password, aux) {
-	try {
-		const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);
-		return await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);
-	} 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 encryption.
-*
-* @returns The user's private and public keys
-*/
-async function generateEmailKeys() {
-	return require_xwing.genHybridKeys();
-}
-/**
-* Derives database encryption key for the given user
-*
-* @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)
-* @returns The symmetric key for protecting database
-*/
-const deriveDatabaseKey = async (mnemonic) => {
-	return require_derive_key.deriveKeyFromMnemonic(mnemonic, require_constants.CONTEXT_DATABASE);
-};
-/**
-* Derives email draft encryption key for the given user
-*
-* @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)
-* @returns The symmetric key for protecting email drafts
-*/
-const deriveEmailDraftKey = async (mnemonic) => {
-	return require_derive_key.deriveKeyFromMnemonic(mnemonic, require_constants.CONTEXT_DRAFT);
-};
-//#endregion
-Object.defineProperty(exports, "createPwdProtectedEmail", {
-	enumerable: true,
-	get: function() {
-		return createPwdProtectedEmail;
-	}
-});
-Object.defineProperty(exports, "decryptEmailBody", {
-	enumerable: true,
-	get: function() {
-		return decryptEmailBody;
-	}
-});
-Object.defineProperty(exports, "decryptEmailHybrid", {
-	enumerable: true,
-	get: function() {
-		return decryptEmailHybrid;
-	}
-});
-Object.defineProperty(exports, "decryptKeysHybrid", {
-	enumerable: true,
-	get: function() {
-		return decryptKeysHybrid;
-	}
-});
-Object.defineProperty(exports, "decryptPwdProtectedEmail", {
-	enumerable: true,
-	get: function() {
-		return decryptPwdProtectedEmail;
-	}
-});
-Object.defineProperty(exports, "deriveDatabaseKey", {
-	enumerable: true,
-	get: function() {
-		return deriveDatabaseKey;
-	}
-});
-Object.defineProperty(exports, "deriveEmailDraftKey", {
-	enumerable: true,
-	get: function() {
-		return deriveEmailDraftKey;
-	}
-});
-Object.defineProperty(exports, "encryptEmailBody", {
-	enumerable: true,
-	get: function() {
-		return encryptEmailBody;
-	}
-});
-Object.defineProperty(exports, "encryptEmailBodyWithKey", {
-	enumerable: true,
-	get: function() {
-		return encryptEmailBodyWithKey;
-	}
-});
-Object.defineProperty(exports, "encryptEmailHybrid", {
-	enumerable: true,
-	get: function() {
-		return encryptEmailHybrid;
-	}
-});
-Object.defineProperty(exports, "encryptEmailHybridForMultipleRecipients", {
-	enumerable: true,
-	get: function() {
-		return encryptEmailHybridForMultipleRecipients;
-	}
-});
-Object.defineProperty(exports, "encryptKeysHybrid", {
-	enumerable: true,
-	get: function() {
-		return encryptKeysHybrid;
-	}
-});
-Object.defineProperty(exports, "generateEmailKeys", {
-	enumerable: true,
-	get: function() {
-		return generateEmailKeys;
-	}
-});
-Object.defineProperty(exports, "passwordProtectKey", {
-	enumerable: true,
-	get: function() {
-		return passwordProtectKey;
-	}
-});
-Object.defineProperty(exports, "removePasswordProtection", {
-	enumerable: true,
-	get: function() {
-		return removePasswordProtection;
-	}
-});
-Object.defineProperty(exports, "unwrapKey", {
-	enumerable: true,
-	get: function() {
-		return unwrapKey;
-	}
-});
-Object.defineProperty(exports, "wrapKey", {
-	enumerable: true,
-	get: function() {
-		return wrapKey;
-	}
-});
-
-//# sourceMappingURL=email-crypto-Cr7znO1a.js.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"email-crypto-Cr7znO1a.js","names":["genSymmetricKey","UTF8ToUint8","encryptSymmetrically","uint8ArrayToBase64","uint8ToUTF8","decryptSymmetrically","base64ToUint8Array","encapsulateHybrid","decapsulateHybrid","getKeyFromPassword","getKeyFromPasswordAndSalt","genHybridKeys","deriveKeyFromMnemonic","CONTEXT_DATABASE","CONTEXT_DRAFT"],"sources":["../src/key-wrapper/aesWrapper.ts","../src/email-crypto/core.ts","../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"sourcesContent":["import { aeskw } from '@noble/ciphers/aes.js';\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 { HybridEncKey, PwdProtectedKey, EmailBody, EmailBodyEncrypted, RecipientWithPublicKey } from '../types';\nimport { encryptSymmetrically, decryptSymmetrically, genSymmetricKey } from '../symmetric-crypto';\nimport { encapsulateHybrid, decapsulateHybrid } from '../hybrid-crypto';\nimport { wrapKey, unwrapKey } from '../key-wrapper';\nimport { getKeyFromPassword, getKeyFromPasswordAndSalt } from '../derive-password';\nimport { UTF8ToUint8, base64ToUint8Array, uint8ArrayToBase64, uint8ToUTF8 } from '../utils';\n\n/**\n * Symmetrically encrypts email body.\n *\n * @param body - The email body to encrypt.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email body and symmetric key used for encryption\n */\nexport async function encryptEmailBody(\n  body: EmailBody,\n  aux?: Uint8Array,\n): Promise<{\n  encEmailBody: EmailBodyEncrypted;\n  encryptionKey: Uint8Array;\n}> {\n  try {\n    if (!body.text || !body.subject) {\n      throw new Error('Invalid input');\n    }\n    const encryptionKey = genSymmetricKey();\n    const encEmailBody = await encryptEmailBodyWithKey(body, encryptionKey, aux);\n\n    return { encEmailBody, encryptionKey };\n  } catch (error) {\n    throw new Error('Failed to symmetrically encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Symmetrically encrypts email body with the given key.\n *\n * @param body - The email body to encrypt.\n * @param encryptionKey - The symmetric key to encrypt the email.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting encrypted email body and symmetric key used for encryption\n */\nexport async function encryptEmailBodyWithKey(\n  body: EmailBody,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBodyEncrypted> {\n  try {\n    const text = UTF8ToUint8(body.text);\n    const subject = UTF8ToUint8(body.subject);\n    const subjectEnc = await encryptSymmetrically(encryptionKey, subject, aux);\n    const encryptedText = await encryptSymmetrically(encryptionKey, text, aux);\n    const encText = uint8ArrayToBase64(encryptedText);\n    const encSubject = uint8ArrayToBase64(subjectEnc);\n    const enc: EmailBodyEncrypted = { encText, encSubject };\n\n    if (body.attachments) {\n      const promises = body.attachments.map((attachment) => {\n        const binaryAttachment = UTF8ToUint8(attachment);\n        return encryptSymmetrically(encryptionKey, binaryAttachment, aux);\n      });\n      const encryptedAttachments = await Promise.all(promises);\n      enc.encAttachments = encryptedAttachments?.map(uint8ArrayToBase64);\n    }\n\n    return enc;\n  } catch (error) {\n    throw new Error('Failed to encrypt email body', { cause: error });\n  }\n}\n\n/**\n * Decrypts symmetrically encrypted email body.\n *\n * @param encEmailBody - The email body to decrypt.\n * @param encryptionKey - The symmetric key to decrypt the email.\n * @param aux - An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The resulting decrypted email body\n */\nexport async function decryptEmailBody(\n  encEmailBody: EmailBodyEncrypted,\n  encryptionKey: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encSubject = base64ToUint8Array(encEmailBody.encSubject);\n    const subjectArray = await decryptSymmetrically(encryptionKey, encSubject, aux);\n    const subject = uint8ToUTF8(subjectArray);\n    const encText = base64ToUint8Array(encEmailBody.encText);\n    const textArray = await decryptSymmetrically(encryptionKey, encText, aux);\n    const text = uint8ToUTF8(textArray);\n    const body: EmailBody = { text, subject };\n\n    if (encEmailBody.encAttachments) {\n      const encAttachments = encEmailBody.encAttachments?.map(base64ToUint8Array);\n      const promises = encAttachments?.map((encAtt) => decryptSymmetrically(encryptionKey, encAtt, aux));\n      const decryptedAttachments = await Promise.all(promises);\n      body.attachments = decryptedAttachments?.map((att) => uint8ToUTF8(att));\n    }\n\n    return body;\n  } catch (error) {\n    throw new Error('Failed to symmetrically decrypt email body', { 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 recipient - The recipient with a public hybrid key.\n * @returns The encrypted email symmetric key\n */\nexport async function encryptKeysHybrid(\n  emailEncryptionKey: Uint8Array,\n  recipient: RecipientWithPublicKey,\n): Promise<HybridEncKey> {\n  try {\n    const { cipherText, sharedSecret } = encapsulateHybrid(recipient.publicHybridKey);\n    const encryptedKey = await wrapKey(emailEncryptionKey, sharedSecret);\n    const encryptedKeyBase64 = uint8ArrayToBase64(encryptedKey);\n    const kyberCiphertextBase64 = uint8ArrayToBase64(cipherText);\n\n    return {\n      encryptedKey: encryptedKeyBase64,\n      hybridCiphertext: kyberCiphertextBase64,\n      encryptedForEmail: recipient.email,\n    };\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 recipientPrivateKey - The private key of the recipient.\n * @returns The email encryption key\n */\nexport async function decryptKeysHybrid(\n  encryptedKey: HybridEncKey,\n  recipientPrivateKey: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const kyberCiphertext = base64ToUint8Array(encryptedKey.hybridCiphertext);\n    const encKey = base64ToUint8Array(encryptedKey.encryptedKey);\n    const sharedSecret = decapsulateHybrid(kyberCiphertext, recipientPrivateKey);\n    const encryptionKey = await unwrapKey(encKey, sharedSecret);\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 { HybridEncryptedEmail, EmailBody, RecipientWithPublicKey } from '../types';\nimport { decryptEmailBody, encryptKeysHybrid, decryptKeysHybrid, encryptEmailBody } from './core';\n\n/**\n * Encrypts the email body using hybrid encryption.\n *\n * @param body - The email body to encrypt.\n * @param recipientPublicKeys - The public keys of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The encrypted email body\n */\nexport async function encryptEmailHybrid(\n  body: EmailBody,\n  recipient: RecipientWithPublicKey,\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n    const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n    return { encEmailBody, encryptedKey };\n  } catch (error) {\n    throw new Error('Failed to encrypt email body with hybrid encryption', { cause: error });\n  }\n}\n\n/**\n * Encrypts the email body using hybrid encryption for multiple recipients.\n *\n * @param body - The email body to encrypt for multiple recipients.\n * @param recipients - The recipients with corresponding public keys.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The set of encrypted email bodies\n */\nexport async function encryptEmailHybridForMultipleRecipients(\n  body: EmailBody,\n  recipients: RecipientWithPublicKey[],\n  aux?: Uint8Array,\n): Promise<HybridEncryptedEmail[]> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(body, aux);\n\n    const encryptedEmails: HybridEncryptedEmail[] = [];\n    for (const recipient of recipients) {\n      const encryptedKey = await encryptKeysHybrid(encryptionKey, recipient);\n      encryptedEmails.push({\n        encEmailBody: encEmailBody,\n        encryptedKey,\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 encEmailBody - The encrypted email.\n * @param recipientPrivateHybridKeys - The private key of the recipient.\n * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptEmailHybrid(\n  encEmailBody: HybridEncryptedEmail,\n  recipientPrivateHybridKeys: Uint8Array,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await decryptKeysHybrid(encEmailBody.encryptedKey, recipientPrivateHybridKeys);\n    const body = await decryptEmailBody(encEmailBody.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt email with hybrid encryption', { cause: error });\n  }\n}\n","import { PwdProtectedEmail, EmailBody } 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 aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The password-protected email\n */\nexport async function createPwdProtectedEmail(\n  emailBody: EmailBody,\n  password: string,\n  aux?: Uint8Array,\n): Promise<PwdProtectedEmail> {\n  try {\n    const { encryptionKey, encEmailBody } = await encryptEmailBody(emailBody, aux);\n    const encryptedKey = await passwordProtectKey(encryptionKey, password);\n\n    return { encEmailBody, encryptedKey };\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 * @param aux -  An optional auxilary sting for AEAD (e.g., email ID or timestamp).\n * @returns The decrypted email body\n */\nexport async function decryptPwdProtectedEmail(\n  encryptedEmail: PwdProtectedEmail,\n  password: string,\n  aux?: Uint8Array,\n): Promise<EmailBody> {\n  try {\n    const encryptionKey = await removePasswordProtection(encryptedEmail.encryptedKey, password);\n    const body = await decryptEmailBody(encryptedEmail.encEmailBody, encryptionKey, aux);\n    return body;\n  } catch (error) {\n    throw new Error('Failed to decrypt password-protect email', { cause: error });\n  }\n}\n","import { genHybridKeys } from '../hybrid-crypto';\nimport { HybridKeyPair } from '../types';\nimport { deriveKeyFromMnemonic } from '../derive-key';\nimport { CONTEXT_DATABASE, CONTEXT_DRAFT } from '../constants';\n\n/**\n * Generates public and private keys for email encryption.\n *\n * @returns The user's private and public keys\n */\nexport async function generateEmailKeys(): Promise<HybridKeyPair> {\n  return genHybridKeys();\n}\n\n/**\n * Derives database encryption key for the given user\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The symmetric key for protecting database\n */\nexport const deriveDatabaseKey = async (mnemonic: string): Promise<Uint8Array> => {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_DATABASE);\n};\n\n/**\n * Derives email draft encryption key for the given user\n *\n * @param mnemonic - The user's mnemonic (machine-generated with secure PRNG)\n * @returns The symmetric key for protecting email drafts\n */\nexport const deriveEmailDraftKey = async (mnemonic: string): Promise<Uint8Array> => {\n  return deriveKeyFromMnemonic(mnemonic, CONTEXT_DRAFT);\n};\n"],"mappings":"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"}