internxt-crypto 0.0.11 → 0.0.13

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

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

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

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

package/dist/hash-BoqwNkcd.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash-BoqwNkcd.js","names":["blake3","AES_KEY_BIT_LENGTH"],"sources":["../src/hash/blake3.ts","../src/hash/mac.ts","../src/hash/index.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\nimport { bytesToHex } from '@noble/hashes/utils.js';\n\n/**\n * Hashes the given array of data\n *\n * @param data - The data to hash\n * @returns The resulting hash array\n */\nexport function hashDataArray(data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create();\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data\n *\n * @param data - The data to hash\n * @returns The resulting hash hex string\n */\nexport function hashDataArrayHex(data: Uint8Array[]): string {\n  return bytesToHex(hashDataArray(data));\n}\n\nexport function hashDataArrayWithKeyHex(hashKey: Uint8Array, data: Uint8Array[]): string {\n  try {\n    const hash = hashDataArrayWithKey(hashKey, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to compute hash hex', { cause: error });\n  }\n}\n\nexport function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ key: hashKey });\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataArray(bytes: number, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ dkLen: bytes });\n    for (const chunk of data) {\n      hasher.update(chunk);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataArrayHex(bytes: number, data: Uint8Array[]): string {\n  try {\n    const hash = getBytesFromDataArray(bytes, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given string using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromData(bytes: number, data: Uint8Array): Uint8Array {\n  return blake3(data, { dkLen: bytes });\n}\n\n/**\n * Hashes the given data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataHex(bytes: number, data: Uint8Array): string {\n  return bytesToHex(getBytesFromData(bytes, data));\n}\n","import { bytesToHex } from '@noble/hashes/utils.js';\nimport { AES_KEY_BIT_LENGTH } from '../constants';\nimport { getBytesFromData, hashDataArrayWithKey } from './blake3';\n\n/**\n * Computes mac for the given key material and data\n *\n * @param keyMaterial - The key material\n * @param data - The data to hash\n * @returns The resulting hash hex string\n */\nexport function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string {\n  try {\n    const key = getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial);\n    const hash = hashDataArrayWithKey(key, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to compute mac', { cause: error });\n  }\n}\n","export * from './blake3';\nexport * from './mac';\n"],"mappings":";;;;;;;;;;;;AASA,SAAgB,cAAc,MAAgC;AAC5D,KAAI;EACF,MAAM,SAASA,+BAAO,QAAQ;AAC9B,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU/D,SAAgB,iBAAiB,MAA4B;AAC3D,+CAAkB,cAAc,KAAK,CAAC;;AAGxC,SAAgB,wBAAwB,SAAqB,MAA4B;AACvF,KAAI;AAEF,gDADa,qBAAqB,SAAS,KAAK,CACzB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,8BAA8B,EAAE,OAAO,OAAO,CAAC;;;AAInE,SAAgB,qBAAqB,SAAqB,MAAgC;AACxF,KAAI;EACF,MAAM,SAASA,+BAAO,OAAO,EAAE,KAAK,SAAS,CAAC;AAC9C,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW/D,SAAgB,sBAAsB,OAAe,MAAgC;AACnF,KAAI;EACF,MAAM,SAASA,+BAAO,OAAO,EAAE,OAAO,OAAO,CAAC;AAC9C,OAAK,MAAM,SAAS,KAClB,QAAO,OAAO,MAAM;AAEtB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,SAAgB,yBAAyB,OAAe,MAA4B;AAClF,KAAI;AAEF,gDADa,sBAAsB,OAAO,KAAK,CACxB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,SAAgB,iBAAiB,OAAe,MAA8B;AAC5E,4CAAc,MAAM,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUvC,SAAgB,oBAAoB,OAAe,MAA0B;AAC3E,+CAAkB,iBAAiB,OAAO,KAAK,CAAC;;;;;;;;;;;;AC/FlD,SAAgB,WAAW,aAAyB,MAA4B;AAC9E,KAAI;AAGF,gDADa,qBADD,iBAAiBC,uCAAqB,GAAG,YAAY,EAC1B,KAAK,CACrB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}

package/dist/hash-CXeGAwai.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash-CXeGAwai.mjs","names":[],"sources":["../src/hash/blake3.ts","../src/hash/mac.ts","../src/hash/index.ts"],"sourcesContent":["import { blake3 } from '@noble/hashes/blake3.js';\nimport { bytesToHex } from '@noble/hashes/utils.js';\n\n/**\n * Hashes the given array of data\n *\n * @param data - The data to hash\n * @returns The resulting hash array\n */\nexport function hashDataArray(data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create();\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data\n *\n * @param data - The data to hash\n * @returns The resulting hash hex string\n */\nexport function hashDataArrayHex(data: Uint8Array[]): string {\n  return bytesToHex(hashDataArray(data));\n}\n\nexport function hashDataArrayWithKeyHex(hashKey: Uint8Array, data: Uint8Array[]): string {\n  try {\n    const hash = hashDataArrayWithKey(hashKey, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to compute hash hex', { cause: error });\n  }\n}\n\nexport function hashDataArrayWithKey(hashKey: Uint8Array, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ key: hashKey });\n    for (const d of data) {\n      hasher.update(d);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to compute hash', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataArray(bytes: number, data: Uint8Array[]): Uint8Array {\n  try {\n    const hasher = blake3.create({ dkLen: bytes });\n    for (const chunk of data) {\n      hasher.update(chunk);\n    }\n    return hasher.digest();\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given array of data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataArrayHex(bytes: number, data: Uint8Array[]): string {\n  try {\n    const hash = getBytesFromDataArray(bytes, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to get bytes from data', { cause: error });\n  }\n}\n\n/**\n * Hashes the given string using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromData(bytes: number, data: Uint8Array): Uint8Array {\n  return blake3(data, { dkLen: bytes });\n}\n\n/**\n * Hashes the given data using blake3 algorithm\n *\n * @param bytes - The desired output byte-length\n * @param data - The data to hash\n * @returns The resulting hash value\n */\nexport function getBytesFromDataHex(bytes: number, data: Uint8Array): string {\n  return bytesToHex(getBytesFromData(bytes, data));\n}\n","import { bytesToHex } from '@noble/hashes/utils.js';\nimport { AES_KEY_BIT_LENGTH } from '../constants';\nimport { getBytesFromData, hashDataArrayWithKey } from './blake3';\n\n/**\n * Computes mac for the given key material and data\n *\n * @param keyMaterial - The key material\n * @param data - The data to hash\n * @returns The resulting hash hex string\n */\nexport function computeMac(keyMaterial: Uint8Array, data: Uint8Array[]): string {\n  try {\n    const key = getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial);\n    const hash = hashDataArrayWithKey(key, data);\n    return bytesToHex(hash);\n  } catch (error) {\n    throw new Error('Failed to compute mac', { cause: error });\n  }\n}\n","export * from './blake3';\nexport * from './mac';\n"],"mappings":";;;;;;;;;;;;AASA,SAAgB,cAAc,MAAgC;AAC5D,KAAI;EACF,MAAM,SAAS,OAAO,QAAQ;AAC9B,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAU/D,SAAgB,iBAAiB,MAA4B;AAC3D,QAAO,WAAW,cAAc,KAAK,CAAC;;AAGxC,SAAgB,wBAAwB,SAAqB,MAA4B;AACvF,KAAI;AAEF,SAAO,WADM,qBAAqB,SAAS,KAAK,CACzB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,8BAA8B,EAAE,OAAO,OAAO,CAAC;;;AAInE,SAAgB,qBAAqB,SAAqB,MAAgC;AACxF,KAAI;EACF,MAAM,SAAS,OAAO,OAAO,EAAE,KAAK,SAAS,CAAC;AAC9C,OAAK,MAAM,KAAK,KACd,QAAO,OAAO,EAAE;AAElB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,0BAA0B,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAW/D,SAAgB,sBAAsB,OAAe,MAAgC;AACnF,KAAI;EACF,MAAM,SAAS,OAAO,OAAO,EAAE,OAAO,OAAO,CAAC;AAC9C,OAAK,MAAM,SAAS,KAClB,QAAO,OAAO,MAAM;AAEtB,SAAO,OAAO,QAAQ;UACf,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,SAAgB,yBAAyB,OAAe,MAA4B;AAClF,KAAI;AAEF,SAAO,WADM,sBAAsB,OAAO,KAAK,CACxB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,iCAAiC,EAAE,OAAO,OAAO,CAAC;;;;;;;;;;AAWtE,SAAgB,iBAAiB,OAAe,MAA8B;AAC5E,QAAO,OAAO,MAAM,EAAE,OAAO,OAAO,CAAC;;;;;;;;;AAUvC,SAAgB,oBAAoB,OAAe,MAA0B;AAC3E,QAAO,WAAW,iBAAiB,OAAO,KAAK,CAAC;;;;;;;;;;;;AC/FlD,SAAgB,WAAW,aAAyB,MAA4B;AAC9E,KAAI;AAGF,SAAO,WADM,qBADD,iBAAiB,qBAAqB,GAAG,YAAY,EAC1B,KAAK,CACrB;UAChB,OAAO;AACd,QAAM,IAAI,MAAM,yBAAyB,EAAE,OAAO,OAAO,CAAC"}

package/dist/index-CQqgKsbX.d.ts

@@ -1,50 +0,0 @@
-declare namespace localStorageService_d_exports {
-  export { LocalStorageService, localStorageService as default };
-}
-declare function get$1(key: string): string | null;
-declare function set$1(key: string, value: string): void;
-declare function removeItem$1(key: string): void;
-declare function exists$1(key: string): boolean;
-declare function clear$1(): void;
-declare const localStorageService: {
-  set: typeof set$1;
-  get: typeof get$1;
-  removeItem: typeof removeItem$1;
-  exists: typeof exists$1;
-  clear: typeof clear$1;
-};
-interface LocalStorageService {
-  set: (key: string, value: string) => void;
-  get: (key: string) => string | null;
-  removeItem: (key: string) => void;
-  exists: (key: string) => boolean;
-  clear: () => void;
-}
-declare namespace sessionStorageService_d_exports {
-  export { SessionStorageService, sessionStorageService as default };
-}
-declare function get(key: string): string | null;
-declare function set(key: string, value: string): void;
-declare function removeItem(key: string): void;
-declare function exists(key: string): boolean;
-declare function clear(): void;
-declare const sessionStorageService: {
-  set: typeof set;
-  get: typeof get;
-  removeItem: typeof removeItem;
-  exists: typeof exists;
-  clear: typeof clear;
-};
-interface SessionStorageService {
-  set: (key: string, value: string) => void;
-  get: (key: string) => string | null;
-  removeItem: (key: string) => void;
-  exists: (key: string) => boolean;
-  clear: () => void;
-}
-declare namespace index_d_exports {
-  export { localStorageService_d_exports as localStorageService, sessionStorageService_d_exports as sessionStorageService };
-}
-//#endregion
-export { sessionStorageService_d_exports as n, localStorageService_d_exports as r, index_d_exports as t };
-//# sourceMappingURL=index-CQqgKsbX.d.ts.map

package/dist/index-CintVUbp.d.ts

@@ -1,97 +0,0 @@
-//#region src/post-quantum-crypto/kyber768.d.ts
-/**
- * Generates public and secret Kyber keys
- *
- * @param seed - The optional seed
- * @returns The generated Kyber key pair.
- */
-declare function generateKyberKeys$2(seed?: Uint8Array): {
-  publicKey: Uint8Array;
-  secretKey: Uint8Array;
-};
-/**
- * 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.
- */
-declare function encapsulateKyber$2(publicKey: Uint8Array): {
-  cipherText: Uint8Array;
-  sharedSecret: Uint8Array;
-};
-/**
- * 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.
- */
-declare function decapsulateKyber$2(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-declare namespace kyber512_d_exports {
-  export { decapsulateKyber$1 as decapsulateKyber, encapsulateKyber$1 as encapsulateKyber, generateKyberKeys$1 as generateKyberKeys };
-}
-/**
- * Generates public and secret Kyber keys
- *
- * @param seed - The optional seed
- * @returns The generated Kyber key pair.
- */
-declare function generateKyberKeys$1(seed?: Uint8Array): {
-  publicKey: Uint8Array;
-  secretKey: Uint8Array;
-};
-/**
- * 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.
- */
-declare function encapsulateKyber$1(publicKey: Uint8Array): {
-  cipherText: Uint8Array;
-  sharedSecret: Uint8Array;
-};
-/**
- * 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.
- */
-declare function decapsulateKyber$1(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-declare namespace kyber1024_d_exports {
-  export { decapsulateKyber, encapsulateKyber, generateKyberKeys };
-}
-/**
- * Generates public and secret Kyber keys
- *
- * @param seed - The optional seed
- * @returns The generated Kyber key pair.
- */
-declare function generateKyberKeys(seed?: Uint8Array): {
-  publicKey: Uint8Array;
-  secretKey: Uint8Array;
-};
-/**
- * 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.
- */
-declare function encapsulateKyber(publicKey: Uint8Array): {
-  cipherText: Uint8Array;
-  sharedSecret: Uint8Array;
-};
-/**
- * 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.
- */
-declare function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-declare namespace index_d_exports {
-  export { decapsulateKyber$2 as decapsulateKyber, encapsulateKyber$2 as encapsulateKyber, generateKyberKeys$2 as generateKyberKeys, kyber1024_d_exports as kyber1024, kyber512_d_exports as kyber512 };
-}
-//#endregion
-export { encapsulateKyber$2 as a, decapsulateKyber$2 as i, kyber1024_d_exports as n, generateKyberKeys$2 as o, kyber512_d_exports as r, index_d_exports as t };
-//# sourceMappingURL=index-CintVUbp.d.ts.map

package/dist/index-D5pBU_A5.d.mts

@@ -1,50 +0,0 @@
-declare namespace localStorageService_d_exports {
-  export { LocalStorageService, localStorageService as default };
-}
-declare function get$1(key: string): string | null;
-declare function set$1(key: string, value: string): void;
-declare function removeItem$1(key: string): void;
-declare function exists$1(key: string): boolean;
-declare function clear$1(): void;
-declare const localStorageService: {
-  set: typeof set$1;
-  get: typeof get$1;
-  removeItem: typeof removeItem$1;
-  exists: typeof exists$1;
-  clear: typeof clear$1;
-};
-interface LocalStorageService {
-  set: (key: string, value: string) => void;
-  get: (key: string) => string | null;
-  removeItem: (key: string) => void;
-  exists: (key: string) => boolean;
-  clear: () => void;
-}
-declare namespace sessionStorageService_d_exports {
-  export { SessionStorageService, sessionStorageService as default };
-}
-declare function get(key: string): string | null;
-declare function set(key: string, value: string): void;
-declare function removeItem(key: string): void;
-declare function exists(key: string): boolean;
-declare function clear(): void;
-declare const sessionStorageService: {
-  set: typeof set;
-  get: typeof get;
-  removeItem: typeof removeItem;
-  exists: typeof exists;
-  clear: typeof clear;
-};
-interface SessionStorageService {
-  set: (key: string, value: string) => void;
-  get: (key: string) => string | null;
-  removeItem: (key: string) => void;
-  exists: (key: string) => boolean;
-  clear: () => void;
-}
-declare namespace index_d_exports {
-  export { localStorageService_d_exports as localStorageService, sessionStorageService_d_exports as sessionStorageService };
-}
-//#endregion
-export { sessionStorageService_d_exports as n, localStorageService_d_exports as r, index_d_exports as t };
-//# sourceMappingURL=index-D5pBU_A5.d.mts.map

package/dist/index-MaOov-ag.d.mts

@@ -1,97 +0,0 @@
-//#region src/post-quantum-crypto/kyber768.d.ts
-/**
- * Generates public and secret Kyber keys
- *
- * @param seed - The optional seed
- * @returns The generated Kyber key pair.
- */
-declare function generateKyberKeys$2(seed?: Uint8Array): {
-  publicKey: Uint8Array;
-  secretKey: Uint8Array;
-};
-/**
- * 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.
- */
-declare function encapsulateKyber$2(publicKey: Uint8Array): {
-  cipherText: Uint8Array;
-  sharedSecret: Uint8Array;
-};
-/**
- * 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.
- */
-declare function decapsulateKyber$2(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-declare namespace kyber512_d_exports {
-  export { decapsulateKyber$1 as decapsulateKyber, encapsulateKyber$1 as encapsulateKyber, generateKyberKeys$1 as generateKyberKeys };
-}
-/**
- * Generates public and secret Kyber keys
- *
- * @param seed - The optional seed
- * @returns The generated Kyber key pair.
- */
-declare function generateKyberKeys$1(seed?: Uint8Array): {
-  publicKey: Uint8Array;
-  secretKey: Uint8Array;
-};
-/**
- * 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.
- */
-declare function encapsulateKyber$1(publicKey: Uint8Array): {
-  cipherText: Uint8Array;
-  sharedSecret: Uint8Array;
-};
-/**
- * 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.
- */
-declare function decapsulateKyber$1(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-declare namespace kyber1024_d_exports {
-  export { decapsulateKyber, encapsulateKyber, generateKyberKeys };
-}
-/**
- * Generates public and secret Kyber keys
- *
- * @param seed - The optional seed
- * @returns The generated Kyber key pair.
- */
-declare function generateKyberKeys(seed?: Uint8Array): {
-  publicKey: Uint8Array;
-  secretKey: Uint8Array;
-};
-/**
- * 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.
- */
-declare function encapsulateKyber(publicKey: Uint8Array): {
-  cipherText: Uint8Array;
-  sharedSecret: Uint8Array;
-};
-/**
- * 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.
- */
-declare function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-declare namespace index_d_exports {
-  export { decapsulateKyber$2 as decapsulateKyber, encapsulateKyber$2 as encapsulateKyber, generateKyberKeys$2 as generateKyberKeys, kyber1024_d_exports as kyber1024, kyber512_d_exports as kyber512 };
-}
-//#endregion
-export { encapsulateKyber$2 as a, decapsulateKyber$2 as i, kyber1024_d_exports as n, generateKyberKeys$2 as o, kyber512_d_exports as r, index_d_exports as t };
-//# sourceMappingURL=index-MaOov-ag.d.mts.map

package/dist/keystore-crypto-B4yCVo9l.js.map

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

package/dist/keystore-crypto-Bjgriq9h.mjs.map

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

package/dist/keystore-service.d.mts

@@ -1,48 +0,0 @@
-import { c as EncryptedKeystore, d as KeystoreType, g as PublicKeysBase64, h as PublicKeys } from "./types-DwQJtrTx.mjs";
-import { AxiosResponse } from "axios";
-
-//#region src/keystore-service/api.d.ts
-declare class KeyServiceAPI {
-  private readonly baseUrl;
-  constructor(baseUrl: string);
-  /**
-   * Converts the specific client error into a proprietary error for our apps
-   * @param error
-   * @private
-   */
-  private normalizeError;
-  /**
-   * Sends a user's encrypted keystore to the server
-   * @param keystore - The encrypted keystore
-   * @param url - The user specific part of the url
-   * @returns Server response
-   */
-  uploadKeystoreToServer(encryptedKeystore: EncryptedKeystore): Promise<AxiosResponse>;
-  /**
-   * Requests a user's encrypted keystore from the server
-   * @param url - The user-specific part of the url
-   * @returns The user's encrypted keystore as base64 string
-   */
-  getKeystoreFromServer(userID: string, keystoreType: KeystoreType): Promise<EncryptedKeystore>;
-  /**
-   * Obtains recipients public keys from the server
-   *
-   * @param emails - The recipients' emails
-   * @returns The list of recipients' public keys
-   */
-  getRecipientsPublicKeysFromServer(emails: string[]): Promise<PublicKeysBase64[]>;
-  /**
-   * Obtains the recipient public keys from the server
-   *
-   * @param email - The recipients' emails
-   * @returns The list of recipients' public keys
-   */
-  getRecipientsPublicKeys(emails: string[]): Promise<PublicKeys[]>;
-}
-declare function getKeyServiceAPI(baseUrl: string): KeyServiceAPI;
-declare namespace index_d_exports {
-  export { KeyServiceAPI, getKeyServiceAPI };
-}
-//#endregion
-export { KeyServiceAPI, getKeyServiceAPI, index_d_exports as t };
-//# sourceMappingURL=keystore-service.d.mts.map

package/dist/keystore-service.d.ts

@@ -1,48 +0,0 @@
-import { c as EncryptedKeystore, d as KeystoreType, g as PublicKeysBase64, h as PublicKeys } from "./types-Ds3ivE9W.js";
-import { AxiosResponse } from "axios";
-
-//#region src/keystore-service/api.d.ts
-declare class KeyServiceAPI {
-  private readonly baseUrl;
-  constructor(baseUrl: string);
-  /**
-   * Converts the specific client error into a proprietary error for our apps
-   * @param error
-   * @private
-   */
-  private normalizeError;
-  /**
-   * Sends a user's encrypted keystore to the server
-   * @param keystore - The encrypted keystore
-   * @param url - The user specific part of the url
-   * @returns Server response
-   */
-  uploadKeystoreToServer(encryptedKeystore: EncryptedKeystore): Promise<AxiosResponse>;
-  /**
-   * Requests a user's encrypted keystore from the server
-   * @param url - The user-specific part of the url
-   * @returns The user's encrypted keystore as base64 string
-   */
-  getKeystoreFromServer(userID: string, keystoreType: KeystoreType): Promise<EncryptedKeystore>;
-  /**
-   * Obtains recipients public keys from the server
-   *
-   * @param emails - The recipients' emails
-   * @returns The list of recipients' public keys
-   */
-  getRecipientsPublicKeysFromServer(emails: string[]): Promise<PublicKeysBase64[]>;
-  /**
-   * Obtains the recipient public keys from the server
-   *
-   * @param email - The recipients' emails
-   * @returns The list of recipients' public keys
-   */
-  getRecipientsPublicKeys(emails: string[]): Promise<PublicKeys[]>;
-}
-declare function getKeyServiceAPI(baseUrl: string): KeyServiceAPI;
-declare namespace index_d_exports {
-  export { KeyServiceAPI, getKeyServiceAPI };
-}
-//#endregion
-export { KeyServiceAPI, getKeyServiceAPI, index_d_exports as t };
-//# sourceMappingURL=keystore-service.d.ts.map