internxt-crypto 1.3.1 → 1.4.0

package/dist/email-crypto-cHDsjSb5.mjs

@@ -1,299 +0,0 @@
-import { CONTEXT_DATABASE, CONTEXT_DRAFT } from "./constants.mjs";
-import { UTF8ToUint8, base64ToUint8Array, uint8ArrayToBase64, uint8ToUTF8 } from "./utils.mjs";
-import { deriveKeyFromMnemonic } from "./derive-key.mjs";
-import { n as getKeyFromPassword, r as getKeyFromPasswordAndSalt } from "./derive-password-PED-YfwE.mjs";
-import { decryptSymmetrically, encryptSymmetrically, genSymmetricKey } from "./symmetric-crypto.mjs";
-import { n as encapsulateHybrid, r as genHybridKeys, t as decapsulateHybrid } from "./xwing-B34h5e3Z.mjs";
-import { aeskw } from "@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 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 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 = 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 = UTF8ToUint8(body.text);
-		const subjectEnc = await encryptSymmetrically(encryptionKey, UTF8ToUint8(body.subject), aux);
-		const enc = {
-			encText: uint8ArrayToBase64(await encryptSymmetrically(encryptionKey, text, aux)),
-			encSubject: uint8ArrayToBase64(subjectEnc)
-		};
-		if (body.attachments) {
-			const promises = body.attachments.map((attachment) => {
-				return encryptSymmetrically(encryptionKey, UTF8ToUint8(attachment), aux);
-			});
-			enc.encAttachments = (await Promise.all(promises))?.map(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 = uint8ToUTF8(await decryptSymmetrically(encryptionKey, base64ToUint8Array(encEmailBody.encSubject), aux));
-		const body = {
-			text: uint8ToUTF8(await decryptSymmetrically(encryptionKey, base64ToUint8Array(encEmailBody.encText), aux)),
-			subject
-		};
-		if (encEmailBody.encAttachments) {
-			const promises = (encEmailBody.encAttachments?.map(base64ToUint8Array))?.map((encAtt) => decryptSymmetrically(encryptionKey, encAtt, aux));
-			body.attachments = (await Promise.all(promises))?.map((att) => 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 } = encapsulateHybrid(recipient.publicHybridKey);
-		return {
-			encryptedKey: uint8ArrayToBase64(await wrapKey(emailEncryptionKey, sharedSecret)),
-			hybridCiphertext: 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 = base64ToUint8Array(encryptedKey.hybridCiphertext);
-		return await unwrapKey(base64ToUint8Array(encryptedKey.encryptedKey), 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 getKeyFromPassword(password);
-		const encryptedKey = await wrapKey(emailEncryptionKey, key);
-		const saltStr = uint8ArrayToBase64(salt);
-		return {
-			encryptedKey: 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 = base64ToUint8Array(emailEncryptionKey.salt);
-		return await unwrapKey(base64ToUint8Array(emailEncryptionKey.encryptedKey), await 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 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 deriveKeyFromMnemonic(mnemonic, 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 deriveKeyFromMnemonic(mnemonic, CONTEXT_DRAFT);
-};
-//#endregion
-export { wrapKey as _, decryptPwdProtectedEmail as a, encryptEmailHybridForMultipleRecipients as c, encryptEmailBody as d, encryptEmailBodyWithKey as f, unwrapKey as g, removePasswordProtection as h, createPwdProtectedEmail as i, decryptEmailBody as l, passwordProtectKey as m, deriveEmailDraftKey as n, decryptEmailHybrid as o, encryptKeysHybrid as p, generateEmailKeys as r, encryptEmailHybrid as s, deriveDatabaseKey as t, decryptKeysHybrid as u };
-
-//# sourceMappingURL=email-crypto-cHDsjSb5.mjs.map

package/dist/email-crypto-cHDsjSb5.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"email-crypto-cHDsjSb5.mjs","names":[],"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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"}

package/dist/types-4P0WII1D.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-4P0WII1D.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,SAAA;EACA,mBAAA;AAAA;AAAA,KAGU,sBAAA;EACV,KAAA;EACA,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,aAAA;EACV,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;AAAA,KAGD,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,YAAA;EACV,gBAAA;EACA,YAAA;EACA,iBAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,UAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,OAAA;EACA,WAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}

package/dist/types-DAPJQG8U.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-DAPJQG8U.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,SAAA;EACA,mBAAA;AAAA;AAAA,KAGU,sBAAA;EACV,KAAA;EACA,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,aAAA;EACV,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;AAAA,KAGD,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,YAAA,EAAc,kBAAA;AAAA;AAAA,KAGJ,YAAA;EACV,gBAAA;EACA,YAAA;EACA,iBAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,UAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,OAAA;EACA,WAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}