internxt-crypto 0.0.13 → 0.0.14

package/dist/{emailKeys-Fp9WR3wl.mjs → emailKeys-D4lp9NRv.mjs}

@@ -1,36 +1,24 @@
-import { AES_ALGORITHM, CONTEXT_WRAPPING, KEY_FORMAT, KEY_WRAPPING_ALGORITHM } from "./constants.mjs";
+import { CONTEXT_WRAPPING } from "./constants.mjs";
 import { o as deriveSecretKey, r as generateEccKeys } from "./keys-BfcaiAOv.mjs";
 import { f as uint8ArrayToBase64, l as UTF8ToUint8, m as uint8ToUTF8, r as uuidToBytes, u as base64ToUint8Array } from "./genID-3Er5IowC.mjs";
-import { a as genSymmetricCryptoKey, n as encryptSymmetrically, t as decryptSymmetrically } from "./aes-DSDxP8uF.mjs";
-import { n as getKeyFromPasswordAndSalt, t as getKeyFromPassword, u as deriveSymmetricKeyFromTwoKeysAndContext } from "./deriveKeysFromPassword-DJRWZ8Rw.mjs";
-import { a as generateKyberKeys, i as encapsulateKyber, r as decapsulateKyber } from "./kyber1024-PpwE1rki.mjs";
+import { n as encryptSymmetrically, o as genSymmetricKey, t as decryptSymmetrically } from "./aes-DCb9dJqb.mjs";
+import { n as getKeyFromPasswordAndSalt, t as getKeyFromPassword, u as deriveSymmetricKeyFromTwoKeysAndContext } from "./deriveKeysFromPassword-XIwzErlL.mjs";
+import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-SXnIo-Nw.mjs";
 import { concatBytes } from "@noble/hashes/utils.js";
+import { aeskw } from "@noble/ciphers/aes.js";
 
 //#region src/key-wrapper/aesWrapper.ts
 /**
-* Converts wrapping key in Uint8Array into CryptoKey
-*
-* @param key - The wrapping key in Uint8Array representation
-* @returns The resulting CryptoKey
-*/
-async function importWrappingKey(key) {
-	try {
-		return await crypto.subtle.importKey(KEY_FORMAT, key, KEY_WRAPPING_ALGORITHM, false, ["wrapKey", "unwrapKey"]);
-	} catch (error) {
-		throw new Error("Failed to import wrapping key", { cause: error });
-	}
-}
-/**
 * Derives wrapping key from two secrets
 *
 * @param eccSecret - The secret exchanged via elliptic curves
 * @param kyberSecret - The secret exchanged via Kyber KEM
-* @returns The resulting wrapping CryptoKey
+* @returns The resulting wrapping key
 */
 async function deriveWrappingKey(eccSecret, kyberSecret) {
 	try {
 		if (eccSecret.length !== kyberSecret.length) throw new Error("secrets must have equal length");
-		return await importWrappingKey(await deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, CONTEXT_WRAPPING));
+		return deriveSymmetricKeyFromTwoKeysAndContext(eccSecret, kyberSecret, CONTEXT_WRAPPING);
 	} catch (error) {
 		throw new Error("Failed to derive wrapping key", { cause: error });
 	}
@@ -38,31 +26,22 @@ async function deriveWrappingKey(eccSecret, kyberSecret) {
 /**
 * Unwraps the given wrapped key
 *
-* @param encryptedKey - The encrypted key
-* @param wrappingKey - The secret key used for decryption
-* @returns The resulting wrapping CryptoKey
+* @param encryptedKey - The wrapped key
+* @param wrappingKey - The secret key used for unwrapping
+* @returns The resulting key
 */
 async function unwrapKey(encryptedKey, wrappingKey) {
-	try {
-		return await crypto.subtle.unwrapKey(KEY_FORMAT, encryptedKey, wrappingKey, KEY_WRAPPING_ALGORITHM, AES_ALGORITHM, false, ["encrypt", "decrypt"]);
-	} catch (error) {
-		throw new Error("Failed to unwrap key", { cause: error });
-	}
+	return aeskw(wrappingKey).decrypt(encryptedKey);
 }
 /**
-* Wraps the given CryptoKey
+* Wraps the given key
 *
-* @param encryptionKey - The CryptoKey to be wrapped
+* @param key - The key to be wrapped
 * @param wrappingKey - The secret key used for wrapping
 * @returns The resulting ciphertext
 */
-async function wrapKey(encryptionKey, wrappingKey) {
-	try {
-		const result = await crypto.subtle.wrapKey(KEY_FORMAT, encryptionKey, wrappingKey, KEY_WRAPPING_ALGORITHM);
-		return new Uint8Array(result);
-	} catch (error) {
-		throw new Error("Failed to wrap key", { cause: error });
-	}
+async function wrapKey(key, wrappingKey) {
+	return aeskw(wrappingKey).encrypt(key);
 }
 
 //#endregion
@@ -180,7 +159,7 @@ async function decryptEmailBody(enc, encParams, encryptionKey, isSubjectEncrypte
 async function encryptEmailContentSymmetrically(email, aux, emailID) {
 	try {
 		if (!email.text) throw new Error("Invalid input");
-		const encryptionKey = await genSymmetricCryptoKey();
+		const encryptionKey = genSymmetricKey();
 		return {
 			enc: await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID),
 			encryptionKey
@@ -201,7 +180,7 @@ async function encryptEmailContentSymmetrically(email, aux, emailID) {
 async function encryptEmailContentAndSubjectSymmetrically(email, subject, aux, emailID) {
 	try {
 		if (!subject || !email.text) throw new Error("Invalid input");
-		const encryptionKey = await genSymmetricCryptoKey();
+		const encryptionKey = genSymmetricKey();
 		return {
 			enc: await encryptEmailContentSymmetricallyWithKey(email, encryptionKey, aux, emailID),
 			encSubject: uint8ArrayToBase64(await encryptSymmetrically(encryptionKey, UTF8ToUint8(subject), aux)),
@@ -215,7 +194,7 @@ async function encryptEmailContentAndSubjectSymmetrically(email, subject, aux, e
 * Decrypts symmetrically encrypted email.
 *
 * @param encryptedEmail - The email to decrypt.
-* @param encryptionKey - The symmetric CryptoKey.
+* @param encryptionKey - The symmetric key.
 * @returns The decrypted email
 */
 async function decryptEmailAndSubjectSymmetrically(encryptionKey, aux, encSubject, enc) {
@@ -268,7 +247,7 @@ async function decryptEmailAttachements(encryptedAttachments, encryptionKey, aux
 * Decrypts symmetrically encrypted email.
 *
 * @param encryptedEmail - The email to decrypt.
-* @param encryptionKey - The symmetric CryptoKey.
+* @param encryptionKey - The symmetric key.
 * @returns The decrypted email
 */
 async function decryptEmailSymmetrically(encryptionKey, aux, enc) {
@@ -286,7 +265,7 @@ async function decryptEmailSymmetrically(encryptionKey, aux, enc) {
 /**
 * Encrypts the email symmetric key using hybrid encryption.
 *
-* @param emailEncryptionKey - The symmetric CryptoKey used for email encryption.
+* @param emailEncryptionKey - The symmetric key used for email encryption.
 * @param recipientPublicKey - The public key of the recipient.
 * @param senderPrivateKey - The private key of the sender.
 * @returns The encrypted email symmetric key
@@ -309,7 +288,7 @@ async function encryptKeysHybrid(emailEncryptionKey, recipientPublicKey, senderP
 * @param encryptedKey - The encrypted email key.
 * @param senderPublicKey - The public key of the sender.
 * @param recipientPrivateKey - The private key of the recipient.
-* @returns The email encryption CryptoKey
+* @returns The email encryption key
 */
 async function decryptKeysHybrid(encryptedKey, senderPublicKey, recipientPrivateKey) {
 	try {
@@ -322,14 +301,14 @@ async function decryptKeysHybrid(encryptedKey, senderPublicKey, recipientPrivate
 /**
 * Password-protects the email symmetric key.
 *
-* @param emailEncryptionKey - The symmetric CryptoKey used for email encryption.
+* @param emailEncryptionKey - The symmetric key used for email encryption.
 * @param password - The secret password for key protection.
 * @returns The password-protected email symmetric key
 */
 async function passwordProtectKey(emailEncryptionKey, password) {
 	try {
 		const { key, salt } = await getKeyFromPassword(password);
-		const encryptedKey = await wrapKey(emailEncryptionKey, await importWrappingKey(key));
+		const encryptedKey = await wrapKey(emailEncryptionKey, key);
 		const saltStr = uint8ArrayToBase64(salt);
 		return {
 			encryptedKey: uint8ArrayToBase64(encryptedKey),
@@ -344,12 +323,12 @@ async function passwordProtectKey(emailEncryptionKey, password) {
 *
 * @param emailEncryptionKey -  The password-protected email key.
 * @param password - The secret password for key protection.
-* @returns The email encryption CryptoKey
+* @returns The email encryption key
 */
 async function removePasswordProtection(emailEncryptionKey, password) {
 	try {
 		const salt = base64ToUint8Array(emailEncryptionKey.salt);
-		return await unwrapKey(base64ToUint8Array(emailEncryptionKey.encryptedKey), await importWrappingKey(await getKeyFromPasswordAndSalt(password, 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 });
 	}
@@ -506,4 +485,4 @@ async function generateEmailKeys() {
 
 //#endregion
 export { encryptEmailHybrid as a, encryptEmailContentSymmetricallyWithKey as c, recipientsToBytes as d, userToBytes as f, decryptEmailHybrid as i, getAux as l, wrapKey as m, createPwdProtectedEmail as n, encryptEmailHybridForMultipleRecipients as o, unwrapKey as p, decryptPwdProtectedEmail as r, decryptEmailSymmetrically as s, generateEmailKeys as t, emailToBinary as u };
-//# sourceMappingURL=emailKeys-Fp9WR3wl.mjs.map
+//# sourceMappingURL=emailKeys-D4lp9NRv.mjs.map

package/dist/emailKeys-D4lp9NRv.mjs.map

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

package/dist/index.d.mts

@@ -1,12 +1,12 @@
 import { deriveSecretKey, exportPrivateKey, exportPublicKey, generateEccKeys, importPrivateKey, importPublicKey } from "./asymmetric-crypto.mjs";
-import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH } from "./constants.mjs";
+import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH } from "./constants.mjs";
 import { deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, verifyKeyFromPasswordHex } from "./derive-key.mjs";
-import { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys } from "./types.mjs";
+import { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys } from "./types.mjs";
 import { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys } from "./email-crypto.mjs";
 import { addEmailToCache, addEmailToSearchIndex, addEmailsToCache, buildSearchIndexFromCache, closeDatabase, createCacheFromDB, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, encryptAndStoreEmail, encryptAndStoreManyEmail, enforceMaxEmailNumber, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getEmailBatch, getEmailCount, getEmailFromCache, openDatabase, removeEmailFromSearchIndex, searchEmails } from "./email-search.mjs";
 import { computeMac, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex } from "./hash.mjs";
 import { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore } from "./keystore-crypto.mjs";
-import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-DzIcGg1i.mjs";
+import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.mjs";
 import { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey } from "./symmetric-crypto.mjs";
 import { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes } from "./utils.mjs";
 
@@ -14,19 +14,19 @@ import { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, by
 /**
  * Unwraps the given wrapped key
  *
- * @param encryptedKey - The encrypted key
- * @param wrappingKey - The secret key used for decryption
- * @returns The resulting wrapping CryptoKey
+ * @param encryptedKey - The wrapped key
+ * @param wrappingKey - The secret key used for unwrapping
+ * @returns The resulting key
  */
-declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: CryptoKey): Promise<CryptoKey>;
+declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
 /**
- * Wraps the given CryptoKey
+ * Wraps the given key
  *
- * @param encryptionKey - The CryptoKey to be wrapped
+ * @param key - The key to be wrapped
  * @param wrappingKey - The secret key used for wrapping
  * @returns The resulting ciphertext
  */
-declare function wrapKey(encryptionKey: CryptoKey, wrappingKey: CryptoKey): Promise<Uint8Array>;
+declare function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
 //#endregion
-export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HASH_BIT_LEN, HybridEncKey, HybridEncryptedEmail, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, UTF8ToUint8, User, UserWithPublicKeys, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToPublicKey, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, computeMac, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricCryptoKey, deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, exportPrivateKey, exportPublicKey, exportSymmetricCryptoKey, genMnemonic, genSymmetricCryptoKey, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, hexToUint8Array, importPrivateKey, importPublicKey, importSymmetricCryptoKey, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, publicKeyToBase64, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, verifyKeyFromPasswordHex, wrapKey };
+export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HASH_BIT_LEN, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, UTF8ToUint8, User, UserWithPublicKeys, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToPublicKey, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, computeMac, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricCryptoKey, deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, exportPrivateKey, exportPublicKey, exportSymmetricCryptoKey, genMnemonic, genSymmetricCryptoKey, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, hexToUint8Array, importPrivateKey, importPublicKey, importSymmetricCryptoKey, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, publicKeyToBase64, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, verifyKeyFromPasswordHex, wrapKey };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/key-wrapper/aesWrapper.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBA8CsB,SAAA,CAAU,YAAA,EAAc,UAAA,EAAY,WAAA,EAAa,SAAA,GAAY,OAAA,CAAQ,SAAA;;;;;;;;iBAuBrE,OAAA,CAAQ,aAAA,EAAe,SAAA,EAAW,WAAA,EAAa,SAAA,GAAY,OAAA,CAAQ,UAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/key-wrapper/aesWrapper.ts"],"mappings":";;;;;;;;;;;;;;;;;;AA6BA;;iBAAsB,SAAA,CAAU,YAAA,EAAc,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;;;iBAWtE,OAAA,CAAQ,GAAA,EAAK,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA"}

package/dist/index.d.ts

@@ -1,12 +1,12 @@
 import { deriveSecretKey, exportPrivateKey, exportPublicKey, generateEccKeys, importPrivateKey, importPublicKey } from "./asymmetric-crypto.js";
-import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH } from "./constants.js";
+import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH } from "./constants.js";
 import { deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, verifyKeyFromPasswordHex } from "./derive-key.js";
-import { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys } from "./types.js";
+import { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys } from "./types.js";
 import { createPwdProtectedEmail, decryptEmailHybrid, decryptPwdProtectedEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, generateEmailKeys } from "./email-crypto.js";
 import { addEmailToCache, addEmailToSearchIndex, addEmailsToCache, buildSearchIndexFromCache, closeDatabase, createCacheFromDB, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, encryptAndStoreEmail, encryptAndStoreManyEmail, enforceMaxEmailNumber, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getEmailBatch, getEmailCount, getEmailFromCache, openDatabase, removeEmailFromSearchIndex, searchEmails } from "./email-search.js";
 import { computeMac, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex } from "./hash.js";
 import { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore } from "./keystore-crypto.js";
-import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-DGBB_RS7.js";
+import { decapsulateKyber, encapsulateKyber, generateKyberKeys } from "./post-quantum-crypto.js";
 import { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey } from "./symmetric-crypto.js";
 import { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, bytesToUuid, genMnemonic, generateUuid, hexToUint8Array, mnemonicToBytes, publicKeyToBase64, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, uuidToBytes } from "./utils.js";
 
@@ -14,19 +14,19 @@ import { UTF8ToUint8, base64ToPublicKey, base64ToUint8Array, bytesToMnemonic, by
 /**
  * Unwraps the given wrapped key
  *
- * @param encryptedKey - The encrypted key
- * @param wrappingKey - The secret key used for decryption
- * @returns The resulting wrapping CryptoKey
+ * @param encryptedKey - The wrapped key
+ * @param wrappingKey - The secret key used for unwrapping
+ * @returns The resulting key
  */
-declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: CryptoKey): Promise<CryptoKey>;
+declare function unwrapKey(encryptedKey: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
 /**
- * Wraps the given CryptoKey
+ * Wraps the given key
  *
- * @param encryptionKey - The CryptoKey to be wrapped
+ * @param key - The key to be wrapped
  * @param wrappingKey - The secret key used for wrapping
  * @returns The resulting ciphertext
  */
-declare function wrapKey(encryptionKey: CryptoKey, wrappingKey: CryptoKey): Promise<Uint8Array>;
+declare function wrapKey(key: Uint8Array, wrappingKey: Uint8Array): Promise<Uint8Array>;
 //#endregion
-export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HASH_BIT_LEN, HybridEncKey, HybridEncryptedEmail, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, UTF8ToUint8, User, UserWithPublicKeys, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToPublicKey, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, computeMac, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricCryptoKey, deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, exportPrivateKey, exportPublicKey, exportSymmetricCryptoKey, genMnemonic, genSymmetricCryptoKey, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, hexToUint8Array, importPrivateKey, importPublicKey, importSymmetricCryptoKey, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, publicKeyToBase64, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, verifyKeyFromPasswordHex, wrapKey };
+export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HASH_BIT_LEN, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, UTF8ToUint8, User, UserWithPublicKeys, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToPublicKey, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, computeMac, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricCryptoKey, deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, exportPrivateKey, exportPublicKey, exportSymmetricCryptoKey, genMnemonic, genSymmetricCryptoKey, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, hexToUint8Array, importPrivateKey, importPublicKey, importSymmetricCryptoKey, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, publicKeyToBase64, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, verifyKeyFromPasswordHex, wrapKey };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/key-wrapper/aesWrapper.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;iBA8CsB,SAAA,CAAU,YAAA,EAAc,UAAA,EAAY,WAAA,EAAa,SAAA,GAAY,OAAA,CAAQ,SAAA;;;;;;;;iBAuBrE,OAAA,CAAQ,aAAA,EAAe,SAAA,EAAW,WAAA,EAAa,SAAA,GAAY,OAAA,CAAQ,UAAA"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/key-wrapper/aesWrapper.ts"],"mappings":";;;;;;;;;;;;;;;;;;AA6BA;;iBAAsB,SAAA,CAAU,YAAA,EAAc,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA;;;;;;;;iBAWtE,OAAA,CAAQ,GAAA,EAAK,UAAA,EAAY,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,UAAA"}

package/dist/index.js

@@ -3,13 +3,13 @@ const require_constants = require('./constants.js');
 const require_keys = require('./keys-CinT7kEY.js');
 const require_genID = require('./genID-YJSl3YhL.js');
 const require_mac = require('./mac-BMb1F0dN.js');
-const require_aes = require('./aes-bOrKZuUC.js');
-const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-Ko7NxkHM.js');
-const require_kyber1024 = require('./kyber1024-jeKS8CXf.js');
-const require_emailKeys = require('./emailKeys-BJGdkLrg.js');
+const require_aes = require('./aes-DQo1MyCz.js');
+const require_deriveKeysFromPassword = require('./deriveKeysFromPassword-BYaiSGKL.js');
+const require_kyber768 = require('./kyber768-WUVc2fIR.js');
+const require_emailKeys = require('./emailKeys-C0KhtfNP.js');
 const require_email_search = require('./email-search.js');
 const require_types = require('./types.js');
-const require_emailEncryptionKey = require('./emailEncryptionKey-DbaDAdoW.js');
+const require_emailEncryptionKey = require('./emailEncryptionKey-CQNe5W_T.js');
 
 exports.AES_ALGORITHM = require_constants.AES_ALGORITHM;
 exports.AES_KEY_BIT_LENGTH = require_constants.AES_KEY_BIT_LENGTH;
@@ -31,10 +31,6 @@ exports.HASH_BIT_LEN = require_constants.HASH_BIT_LEN;
 exports.IV_LEN_BYTES = require_constants.IV_LEN_BYTES;
 exports.KEY_FORMAT = require_constants.KEY_FORMAT;
 exports.KEY_WRAPPING_ALGORITHM = require_constants.KEY_WRAPPING_ALGORITHM;
-exports.KYBER1024_PUBLIC_KEY_LENGTH = require_constants.KYBER1024_PUBLIC_KEY_LENGTH;
-exports.KYBER1024_SECRET_KEY_LENGTH = require_constants.KYBER1024_SECRET_KEY_LENGTH;
-exports.KYBER512_PUBLIC_KEY_LENGTH = require_constants.KYBER512_PUBLIC_KEY_LENGTH;
-exports.KYBER512_SECRET_KEY_LENGTH = require_constants.KYBER512_SECRET_KEY_LENGTH;
 exports.KYBER768_PUBLIC_KEY_LENGTH = require_constants.KYBER768_PUBLIC_KEY_LENGTH;
 exports.KYBER768_SECRET_KEY_LENGTH = require_constants.KYBER768_SECRET_KEY_LENGTH;
 exports.KYBER_SEED_LENGTH = require_constants.KYBER_SEED_LENGTH;
@@ -42,6 +38,10 @@ exports.KeystoreType = require_types.KeystoreType;
 exports.MAX_CACHE_SIZE = require_constants.MAX_CACHE_SIZE;
 exports.MAX_EMAIL_PER_BATCH = require_constants.MAX_EMAIL_PER_BATCH;
 exports.UTF8ToUint8 = require_genID.UTF8ToUint8;
+exports.XWING_CIPHERTEXT_BYTE_LENGTH = require_constants.XWING_CIPHERTEXT_BYTE_LENGTH;
+exports.XWING_PUBLIC_KEY_LENGTH = require_constants.XWING_PUBLIC_KEY_LENGTH;
+exports.XWING_SECRET_KEY_LENGTH = require_constants.XWING_SECRET_KEY_LENGTH;
+exports.XWING_SEED_BYTE_LENGTH = require_constants.XWING_SEED_BYTE_LENGTH;
 exports.addEmailToCache = require_email_search.addEmailToCache;
 exports.addEmailToSearchIndex = require_email_search.addEmailToSearchIndex;
 exports.addEmailsToCache = require_email_search.addEmailsToCache;
@@ -55,7 +55,7 @@ exports.computeMac = require_mac.computeMac;
 exports.createCacheFromDB = require_email_search.createCacheFromDB;
 exports.createEncryptionAndRecoveryKeystores = require_emailEncryptionKey.createEncryptionAndRecoveryKeystores;
 exports.createPwdProtectedEmail = require_emailKeys.createPwdProtectedEmail;
-exports.decapsulateKyber = require_kyber1024.decapsulateKyber;
+exports.decapsulateKyber = require_kyber768.decapsulateKyber;
 exports.decryptEmailHybrid = require_emailKeys.decryptEmailHybrid;
 exports.decryptPwdProtectedEmail = require_emailKeys.decryptPwdProtectedEmail;
 exports.decryptSymmetrically = require_aes.decryptSymmetrically;
@@ -70,7 +70,7 @@ exports.deriveSymmetricCryptoKeyFromTwoKeys = require_deriveKeysFromPassword.der
 exports.deriveSymmetricKeyFromContext = require_deriveKeysFromPassword.deriveSymmetricKeyFromContext;
 exports.deriveSymmetricKeyFromTwoKeys = require_deriveKeysFromPassword.deriveSymmetricKeyFromTwoKeys;
 exports.deriveSymmetricKeyFromTwoKeysAndContext = require_deriveKeysFromPassword.deriveSymmetricKeyFromTwoKeysAndContext;
-exports.encapsulateKyber = require_kyber1024.encapsulateKyber;
+exports.encapsulateKyber = require_kyber768.encapsulateKyber;
 exports.encryptAndStoreEmail = require_email_search.encryptAndStoreEmail;
 exports.encryptAndStoreManyEmail = require_email_search.encryptAndStoreManyEmail;
 exports.encryptEmailHybrid = require_emailKeys.encryptEmailHybrid;
@@ -85,7 +85,7 @@ exports.genSymmetricCryptoKey = require_aes.genSymmetricCryptoKey;
 exports.genSymmetricKey = require_aes.genSymmetricKey;
 exports.generateEccKeys = require_keys.generateEccKeys;
 exports.generateEmailKeys = require_emailKeys.generateEmailKeys;
-exports.generateKyberKeys = require_kyber1024.generateKyberKeys;
+exports.generateKyberKeys = require_kyber768.generateKyberKeys;
 exports.generateUuid = require_genID.generateUuid;
 exports.getAllEmailsSortedNewestFirst = require_email_search.getAllEmailsSortedNewestFirst;
 exports.getAllEmailsSortedOldestFirst = require_email_search.getAllEmailsSortedOldestFirst;

package/dist/index.mjs

@@ -1,13 +1,13 @@
-import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH } from "./constants.mjs";
+import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH } from "./constants.mjs";
 import { a as importPublicKey, i as importPrivateKey, n as exportPublicKey, o as deriveSecretKey, r as generateEccKeys, t as exportPrivateKey } from "./keys-BfcaiAOv.mjs";
 import { a as genMnemonic, c as publicKeyToBase64, d as hexToUint8Array, f as uint8ArrayToBase64, i as bytesToMnemonic, l as UTF8ToUint8, m as uint8ToUTF8, n as generateUuid, o as mnemonicToBytes, p as uint8ArrayToHex, r as uuidToBytes, s as base64ToPublicKey, t as bytesToUuid, u as base64ToUint8Array } from "./genID-3Er5IowC.mjs";
 import { a as getBytesFromDataHex, c as hashDataArrayWithKey, i as getBytesFromDataArrayHex, l as hashDataArrayWithKeyHex, n as getBytesFromData, o as hashDataArray, s as hashDataArrayHex, t as computeMac } from "./mac-ZpRlx8Fs.mjs";
-import { a as genSymmetricCryptoKey, i as exportSymmetricCryptoKey, n as encryptSymmetrically, o as genSymmetricKey, r as deriveSymmetricCryptoKey, s as importSymmetricCryptoKey, t as decryptSymmetrically } from "./aes-DSDxP8uF.mjs";
-import { a as verifyKeyFromPasswordHex, c as deriveSymmetricKeyFromContext, i as getKeyFromPasswordHex, l as deriveSymmetricKeyFromTwoKeys, n as getKeyFromPasswordAndSalt, o as deriveSymmetricCryptoKeyFromContext, r as getKeyFromPasswordAndSaltHex, s as deriveSymmetricCryptoKeyFromTwoKeys, t as getKeyFromPassword, u as deriveSymmetricKeyFromTwoKeysAndContext } from "./deriveKeysFromPassword-DJRWZ8Rw.mjs";
-import { a as generateKyberKeys, i as encapsulateKyber, r as decapsulateKyber } from "./kyber1024-PpwE1rki.mjs";
-import { a as encryptEmailHybrid, i as decryptEmailHybrid, m as wrapKey, n as createPwdProtectedEmail, o as encryptEmailHybridForMultipleRecipients, p as unwrapKey, r as decryptPwdProtectedEmail, t as generateEmailKeys } from "./emailKeys-Fp9WR3wl.mjs";
+import { a as genSymmetricCryptoKey, i as exportSymmetricCryptoKey, n as encryptSymmetrically, o as genSymmetricKey, r as deriveSymmetricCryptoKey, s as importSymmetricCryptoKey, t as decryptSymmetrically } from "./aes-DCb9dJqb.mjs";
+import { a as verifyKeyFromPasswordHex, c as deriveSymmetricKeyFromContext, i as getKeyFromPasswordHex, l as deriveSymmetricKeyFromTwoKeys, n as getKeyFromPasswordAndSalt, o as deriveSymmetricCryptoKeyFromContext, r as getKeyFromPasswordAndSaltHex, s as deriveSymmetricCryptoKeyFromTwoKeys, t as getKeyFromPassword, u as deriveSymmetricKeyFromTwoKeysAndContext } from "./deriveKeysFromPassword-XIwzErlL.mjs";
+import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-SXnIo-Nw.mjs";
+import { a as encryptEmailHybrid, i as decryptEmailHybrid, m as wrapKey, n as createPwdProtectedEmail, o as encryptEmailHybridForMultipleRecipients, p as unwrapKey, r as decryptPwdProtectedEmail, t as generateEmailKeys } from "./emailKeys-D4lp9NRv.mjs";
 import { addEmailToCache, addEmailToSearchIndex, addEmailsToCache, buildSearchIndexFromCache, closeDatabase, createCacheFromDB, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, encryptAndStoreEmail, encryptAndStoreManyEmail, enforceMaxEmailNumber, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getEmailBatch, getEmailCount, getEmailFromCache, openDatabase, removeEmailFromSearchIndex, searchEmails } from "./email-search.mjs";
 import { KeystoreType } from "./types.mjs";
-import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-27mIHh18.mjs";
+import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-B9xHw1h_.mjs";
 
-export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER1024_PUBLIC_KEY_LENGTH, KYBER1024_SECRET_KEY_LENGTH, KYBER512_PUBLIC_KEY_LENGTH, KYBER512_SECRET_KEY_LENGTH, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, UTF8ToUint8, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToPublicKey, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, computeMac, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricCryptoKey, deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, exportPrivateKey, exportPublicKey, exportSymmetricCryptoKey, genMnemonic, genSymmetricCryptoKey, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, hexToUint8Array, importPrivateKey, importPublicKey, importSymmetricCryptoKey, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, publicKeyToBase64, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, verifyKeyFromPasswordHex, wrapKey };
+export { AES_ALGORITHM, AES_KEY_BIT_LENGTH, ARGON2ID_ITERATIONS, ARGON2ID_MEMORY_SIZE, ARGON2ID_OUTPUT_BYTE_LENGTH, ARGON2ID_PARALLELISM, ARGON2ID_SALT_BYTE_LENGTH, AUX_BYTE_LEN, CONTEXT_DERIVE, CONTEXT_ENC_KEYSTORE, CONTEXT_INDEX, CONTEXT_RECOVERY, CONTEXT_WRAPPING, DB_LABEL, DB_VERSION, ECC_ALGORITHM, HASH_BIT_LEN, IV_LEN_BYTES, KEY_FORMAT, KEY_WRAPPING_ALGORITHM, KYBER768_PUBLIC_KEY_LENGTH, KYBER768_SECRET_KEY_LENGTH, KYBER_SEED_LENGTH, KeystoreType, MAX_CACHE_SIZE, MAX_EMAIL_PER_BATCH, UTF8ToUint8, XWING_CIPHERTEXT_BYTE_LENGTH, XWING_PUBLIC_KEY_LENGTH, XWING_SECRET_KEY_LENGTH, XWING_SEED_BYTE_LENGTH, addEmailToCache, addEmailToSearchIndex, addEmailsToCache, base64ToPublicKey, base64ToUint8Array, buildSearchIndexFromCache, bytesToMnemonic, bytesToUuid, closeDatabase, computeMac, createCacheFromDB, createEncryptionAndRecoveryKeystores, createPwdProtectedEmail, decapsulateKyber, decryptEmailHybrid, decryptPwdProtectedEmail, decryptSymmetrically, deleteEmail, deleteEmailFromCache, deleteOldestEmails, deriveIndexKey, deriveSecretKey, deriveSymmetricCryptoKey, deriveSymmetricCryptoKeyFromContext, deriveSymmetricCryptoKeyFromTwoKeys, deriveSymmetricKeyFromContext, deriveSymmetricKeyFromTwoKeys, deriveSymmetricKeyFromTwoKeysAndContext, encapsulateKyber, encryptAndStoreEmail, encryptAndStoreManyEmail, encryptEmailHybrid, encryptEmailHybridForMultipleRecipients, encryptSymmetrically, enforceMaxEmailNumber, exportPrivateKey, exportPublicKey, exportSymmetricCryptoKey, genMnemonic, genSymmetricCryptoKey, genSymmetricKey, generateEccKeys, generateEmailKeys, generateKyberKeys, generateUuid, getAllEmailsSortedNewestFirst, getAllEmailsSortedOldestFirst, getAndDecryptAllEmails, getAndDecryptEmail, getBytesFromData, getBytesFromDataArrayHex, getBytesFromDataHex, getEmailBatch, getEmailCount, getEmailFromCache, getKeyFromPassword, getKeyFromPasswordAndSalt, getKeyFromPasswordAndSaltHex, getKeyFromPasswordHex, hashDataArray, hashDataArrayHex, hashDataArrayWithKey, hashDataArrayWithKeyHex, hexToUint8Array, importPrivateKey, importPublicKey, importSymmetricCryptoKey, mnemonicToBytes, openDatabase, openEncryptionKeystore, openRecoveryKeystore, publicKeyToBase64, removeEmailFromSearchIndex, searchEmails, uint8ArrayToBase64, uint8ArrayToHex, uint8ToUTF8, unwrapKey, uuidToBytes, verifyKeyFromPasswordHex, wrapKey };

package/dist/keystore-crypto.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_emailEncryptionKey = require('./emailEncryptionKey-DbaDAdoW.js');
+const require_emailEncryptionKey = require('./emailEncryptionKey-CQNe5W_T.js');
 
 exports.createEncryptionAndRecoveryKeystores = require_emailEncryptionKey.createEncryptionAndRecoveryKeystores;
 exports.openEncryptionKeystore = require_emailEncryptionKey.openEncryptionKeystore;

package/dist/keystore-crypto.mjs

@@ -1,3 +1,3 @@
-import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-27mIHh18.mjs";
+import { n as openEncryptionKeystore, r as openRecoveryKeystore, t as createEncryptionAndRecoveryKeystores } from "./emailEncryptionKey-B9xHw1h_.mjs";
 
 export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };

package/dist/kyber768-SXnIo-Nw.mjs

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

package/dist/kyber768-SXnIo-Nw.mjs.map

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

package/dist/kyber768-WUVc2fIR.js

@@ -0,0 +1,65 @@
+const require_chunk = require('./chunk-EbLFQX5m.js');
+let _noble_post_quantum_ml_kem_js = require("@noble/post-quantum/ml-kem.js");
+
+//#region src/post-quantum-crypto/kyber768.ts
+/**
+* Generates public and secret Kyber keys
+*
+* @param seed - The optional seed
+* @returns The generated Kyber key pair.
+*/
+function generateKyberKeys(seed) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem768.keygen(seed);
+	} catch (error) {
+		throw new Error("Failed to generate Kyber keys", { cause: error });
+	}
+}
+/**
+* Generates a shared secret of 256-bits and encapsulates it to the given public key using Kyber algorithms
+*
+* @param publicKey - The public Kyber key
+* @returns The resulting encapsulation and the generated shared secret.
+*/
+function encapsulateKyber(publicKey) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem768.encapsulate(publicKey);
+	} catch (error) {
+		throw new Error("Failed to encapsulate", { cause: error });
+	}
+}
+/**
+* Decapsulates the encapsulated shared secret using Kyber algorithms
+*
+* @param cipherText - The encapsulated key
+* @param secretKey - The private Kyber key
+* @returns The resulting decapsulated shared secret.
+*/
+function decapsulateKyber(cipherText, secretKey) {
+	try {
+		return _noble_post_quantum_ml_kem_js.ml_kem768.decapsulate(cipherText, secretKey);
+	} catch (error) {
+		throw new Error("Failed to decapsulate", { cause: error });
+	}
+}
+
+//#endregion
+Object.defineProperty(exports, 'decapsulateKyber', {
+  enumerable: true,
+  get: function () {
+    return decapsulateKyber;
+  }
+});
+Object.defineProperty(exports, 'encapsulateKyber', {
+  enumerable: true,
+  get: function () {
+    return encapsulateKyber;
+  }
+});
+Object.defineProperty(exports, 'generateKyberKeys', {
+  enumerable: true,
+  get: function () {
+    return generateKyberKeys;
+  }
+});
+//# sourceMappingURL=kyber768-WUVc2fIR.js.map