internxt-crypto 0.0.13 → 0.0.14

package/dist/kyber768-WUVc2fIR.js.map

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

package/dist/post-quantum-crypto.d.mts

@@ -1,16 +1,11 @@
-import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-DzIcGg1i.mjs";
-
-//#region src/post-quantum-crypto/kyber512.d.ts
-declare namespace kyber512_d_exports {
-  export { decapsulateKyber$2 as decapsulateKyber, encapsulateKyber$2 as encapsulateKyber, generateKyberKeys$2 as generateKyberKeys };
-}
+//#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): {
+declare function generateKyberKeys(seed?: Uint8Array): {
   publicKey: Uint8Array;
   secretKey: Uint8Array;
 };
@@ -20,7 +15,7 @@ declare function generateKyberKeys$2(seed?: Uint8Array): {
  * @param publicKey - The public Kyber key
  * @returns The resulting encapsulation and the generated shared secret.
  */
-declare function encapsulateKyber$2(publicKey: Uint8Array): {
+declare function encapsulateKyber(publicKey: Uint8Array): {
   cipherText: Uint8Array;
   sharedSecret: Uint8Array;
 };
@@ -31,38 +26,7 @@ declare function encapsulateKyber$2(publicKey: Uint8Array): {
  * @param secretKey - The private Kyber key
  * @returns The resulting decapsulated shared secret.
  */
-declare function decapsulateKyber$2(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-declare namespace kyber1024_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 function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
 //#endregion
-export { decapsulateKyber, encapsulateKyber, generateKyberKeys, kyber1024_d_exports as kyber1024, kyber512_d_exports as kyber512 };
+export { decapsulateKyber, encapsulateKyber, generateKyberKeys };
 //# sourceMappingURL=post-quantum-crypto.d.mts.map

package/dist/post-quantum-crypto.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"post-quantum-crypto.d.mts","names":[],"sources":["../src/post-quantum-crypto/kyber512.ts","../src/post-quantum-crypto/kyber1024.ts"],"mappings":";;;;;;;;;;;;iBAQgB,mBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,kBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;AAFhB;;iBAkBgB,kBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA;AAAA;;;;;;;;;iBCnCjE,mBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,kBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;ADFhB;;iBCkBgB,kBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA"}
+{"version":3,"file":"post-quantum-crypto.d.mts","names":[],"sources":["../src/post-quantum-crypto/kyber768.ts"],"mappings":";;AAQA;;;;;iBAAgB,iBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,gBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;;;iBAgBA,gBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA"}

package/dist/post-quantum-crypto.d.ts

@@ -1,16 +1,11 @@
-import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-DGBB_RS7.js";
-
-//#region src/post-quantum-crypto/kyber512.d.ts
-declare namespace kyber512_d_exports {
-  export { decapsulateKyber$2 as decapsulateKyber, encapsulateKyber$2 as encapsulateKyber, generateKyberKeys$2 as generateKyberKeys };
-}
+//#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): {
+declare function generateKyberKeys(seed?: Uint8Array): {
   publicKey: Uint8Array;
   secretKey: Uint8Array;
 };
@@ -20,7 +15,7 @@ declare function generateKyberKeys$2(seed?: Uint8Array): {
  * @param publicKey - The public Kyber key
  * @returns The resulting encapsulation and the generated shared secret.
  */
-declare function encapsulateKyber$2(publicKey: Uint8Array): {
+declare function encapsulateKyber(publicKey: Uint8Array): {
   cipherText: Uint8Array;
   sharedSecret: Uint8Array;
 };
@@ -31,38 +26,7 @@ declare function encapsulateKyber$2(publicKey: Uint8Array): {
  * @param secretKey - The private Kyber key
  * @returns The resulting decapsulated shared secret.
  */
-declare function decapsulateKyber$2(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
-declare namespace kyber1024_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 function decapsulateKyber(cipherText: Uint8Array, secretKey: Uint8Array): Uint8Array;
 //#endregion
-export { decapsulateKyber, encapsulateKyber, generateKyberKeys, kyber1024_d_exports as kyber1024, kyber512_d_exports as kyber512 };
+export { decapsulateKyber, encapsulateKyber, generateKyberKeys };
 //# sourceMappingURL=post-quantum-crypto.d.ts.map

package/dist/post-quantum-crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"post-quantum-crypto.d.ts","names":[],"sources":["../src/post-quantum-crypto/kyber512.ts","../src/post-quantum-crypto/kyber1024.ts"],"mappings":";;;;;;;;;;;;iBAQgB,mBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,kBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;AAFhB;;iBAkBgB,kBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA;AAAA;;;;;;;;;iBCnCjE,mBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,kBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;ADFhB;;iBCkBgB,kBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA"}
+{"version":3,"file":"post-quantum-crypto.d.ts","names":[],"sources":["../src/post-quantum-crypto/kyber768.ts"],"mappings":";;AAQA;;;;;iBAAgB,iBAAA,CAAkB,IAAA,GAAO,UAAA;EACvC,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;;;;;;;iBAeG,gBAAA,CAAiB,SAAA,EAAW,UAAA;EAC1C,UAAA,EAAY,UAAA;EACZ,YAAA,EAAc,UAAA;AAAA;;;;;;;;iBAgBA,gBAAA,CAAiB,UAAA,EAAY,UAAA,EAAY,SAAA,EAAW,UAAA,GAAa,UAAA"}

package/dist/post-quantum-crypto.js

@@ -1,18 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_kyber1024 = require('./kyber1024-jeKS8CXf.js');
+const require_kyber768 = require('./kyber768-WUVc2fIR.js');
 
-exports.decapsulateKyber = require_kyber1024.decapsulateKyber;
-exports.encapsulateKyber = require_kyber1024.encapsulateKyber;
-exports.generateKyberKeys = require_kyber1024.generateKyberKeys;
-Object.defineProperty(exports, 'kyber1024', {
-  enumerable: true,
-  get: function () {
-    return require_kyber1024.kyber1024_exports;
-  }
-});
-Object.defineProperty(exports, 'kyber512', {
-  enumerable: true,
-  get: function () {
-    return require_kyber1024.kyber512_exports;
-  }
-});
+exports.decapsulateKyber = require_kyber768.decapsulateKyber;
+exports.encapsulateKyber = require_kyber768.encapsulateKyber;
+exports.generateKyberKeys = require_kyber768.generateKyberKeys;

package/dist/post-quantum-crypto.mjs

@@ -1,3 +1,3 @@
-import { a as generateKyberKeys, i as encapsulateKyber, n as kyber512_exports, r as decapsulateKyber, t as kyber1024_exports } from "./kyber1024-PpwE1rki.mjs";
+import { n as encapsulateKyber, r as generateKyberKeys, t as decapsulateKyber } from "./kyber768-SXnIo-Nw.mjs";
 
-export { decapsulateKyber, encapsulateKyber, generateKyberKeys, kyber1024_exports as kyber1024, kyber512_exports as kyber512 };
+export { decapsulateKyber, encapsulateKyber, generateKyberKeys };

package/dist/symmetric-crypto.d.mts

@@ -36,22 +36,22 @@ declare function deriveSymmetricCryptoKey(keyMaterial: Uint8Array): Promise<Cryp
 /**
  * Symmetrically encrypts the message
  *
- * @param encryptionKey - The symmetric CryptoKey used for message encryption
+ * @param encryptionKey - The symmetric key used for message encryption
  * @param message - The message to encrypt
  * @param freeField - The context of the message (required for IV generation)
  * @param aux - The auxilary string
  * @returns The resulting ciphertext.
  */
-declare function encryptSymmetrically(encryptionKey: CryptoKey, message: Uint8Array, aux: Uint8Array, freeField?: Uint8Array): Promise<Uint8Array>;
+declare function encryptSymmetrically(encryptionKey: Uint8Array, message: Uint8Array, aux: Uint8Array, freeField?: Uint8Array): Promise<Uint8Array>;
 /**
  * Decryps symmetrically encrypted message
  *
- * @param encryptionKey - The symmetric CryptoKey used for message encryption
+ * @param encryptionKey - The symmetric key used for message encryption
  * @param encryptedMessage - The ciphertext
  * @param aux - The auxilary string
  * @returns The resulting ciphertext.
  */
-declare function decryptSymmetrically(encryptionKey: CryptoKey, encryptedMessage: Uint8Array, aux: Uint8Array): Promise<Uint8Array>;
+declare function decryptSymmetrically(encryptionKey: Uint8Array, encryptedMessage: Uint8Array, aux: Uint8Array): Promise<Uint8Array>;
 //#endregion
 export { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey };
 //# sourceMappingURL=symmetric-crypto.d.mts.map

package/dist/symmetric-crypto.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"symmetric-crypto.d.mts","names":[],"sources":["../src/symmetric-crypto/keys.ts","../src/symmetric-crypto/aes.ts"],"mappings":";;AASA;;;;;iBAAsB,wBAAA,CAAyB,OAAA,EAAS,UAAA,GAAa,WAAA,GAAc,OAAA,CAAQ,SAAA;;;;;;;iBAmBrE,wBAAA,CAAyB,GAAA,EAAK,SAAA,GAAY,OAAA,CAAQ,UAAA;;;;AAAxE;;iBAcsB,qBAAA,CAAA,GAAyB,OAAA,CAAQ,SAAA;;;;;;iBAgBvC,eAAA,CAAA,GAAmB,UAAA;;;;;;iBAeb,wBAAA,CAAyB,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,SAAA;;;;AAhEjF;;;;;;;;iBCIsB,oBAAA,CACpB,aAAA,EAAe,SAAA,EACf,OAAA,EAAS,UAAA,EACT,GAAA,EAAK,UAAA,EACL,SAAA,GAAY,UAAA,GACX,OAAA,CAAQ,UAAA;;;;;;;;ADUX;iBCSsB,oBAAA,CACpB,aAAA,EAAe,SAAA,EACf,gBAAA,EAAkB,UAAA,EAClB,GAAA,EAAK,UAAA,GACJ,OAAA,CAAQ,UAAA"}
+{"version":3,"file":"symmetric-crypto.d.mts","names":[],"sources":["../src/symmetric-crypto/keys.ts","../src/symmetric-crypto/aes.ts"],"mappings":";;AAUA;;;;;iBAAsB,wBAAA,CAAyB,OAAA,EAAS,UAAA,GAAa,WAAA,GAAc,OAAA,CAAQ,SAAA;;;;;;;iBAmBrE,wBAAA,CAAyB,GAAA,EAAK,SAAA,GAAY,OAAA,CAAQ,UAAA;;;;AAAxE;;iBAcsB,qBAAA,CAAA,GAAyB,OAAA,CAAQ,SAAA;;;;;;iBAgBvC,eAAA,CAAA,GAAmB,UAAA;;;;;;iBASb,wBAAA,CAAyB,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,SAAA;;;;AA1DjF;;;;;;;;iBCGsB,oBAAA,CACpB,aAAA,EAAe,UAAA,EACf,OAAA,EAAS,UAAA,EACT,GAAA,EAAK,UAAA,EACL,SAAA,GAAY,UAAA,GACX,OAAA,CAAQ,UAAA;;;;;;;;ADWX;iBCQsB,oBAAA,CACpB,aAAA,EAAe,UAAA,EACf,gBAAA,EAAkB,UAAA,EAClB,GAAA,EAAK,UAAA,GACJ,OAAA,CAAQ,UAAA"}

package/dist/symmetric-crypto.d.ts

@@ -36,22 +36,22 @@ declare function deriveSymmetricCryptoKey(keyMaterial: Uint8Array): Promise<Cryp
 /**
  * Symmetrically encrypts the message
  *
- * @param encryptionKey - The symmetric CryptoKey used for message encryption
+ * @param encryptionKey - The symmetric key used for message encryption
  * @param message - The message to encrypt
  * @param freeField - The context of the message (required for IV generation)
  * @param aux - The auxilary string
  * @returns The resulting ciphertext.
  */
-declare function encryptSymmetrically(encryptionKey: CryptoKey, message: Uint8Array, aux: Uint8Array, freeField?: Uint8Array): Promise<Uint8Array>;
+declare function encryptSymmetrically(encryptionKey: Uint8Array, message: Uint8Array, aux: Uint8Array, freeField?: Uint8Array): Promise<Uint8Array>;
 /**
  * Decryps symmetrically encrypted message
  *
- * @param encryptionKey - The symmetric CryptoKey used for message encryption
+ * @param encryptionKey - The symmetric key used for message encryption
  * @param encryptedMessage - The ciphertext
  * @param aux - The auxilary string
  * @returns The resulting ciphertext.
  */
-declare function decryptSymmetrically(encryptionKey: CryptoKey, encryptedMessage: Uint8Array, aux: Uint8Array): Promise<Uint8Array>;
+declare function decryptSymmetrically(encryptionKey: Uint8Array, encryptedMessage: Uint8Array, aux: Uint8Array): Promise<Uint8Array>;
 //#endregion
 export { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey };
 //# sourceMappingURL=symmetric-crypto.d.ts.map

package/dist/symmetric-crypto.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symmetric-crypto.d.ts","names":[],"sources":["../src/symmetric-crypto/keys.ts","../src/symmetric-crypto/aes.ts"],"mappings":";;AASA;;;;;iBAAsB,wBAAA,CAAyB,OAAA,EAAS,UAAA,GAAa,WAAA,GAAc,OAAA,CAAQ,SAAA;;;;;;;iBAmBrE,wBAAA,CAAyB,GAAA,EAAK,SAAA,GAAY,OAAA,CAAQ,UAAA;;;;AAAxE;;iBAcsB,qBAAA,CAAA,GAAyB,OAAA,CAAQ,SAAA;;;;;;iBAgBvC,eAAA,CAAA,GAAmB,UAAA;;;;;;iBAeb,wBAAA,CAAyB,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,SAAA;;;;AAhEjF;;;;;;;;iBCIsB,oBAAA,CACpB,aAAA,EAAe,SAAA,EACf,OAAA,EAAS,UAAA,EACT,GAAA,EAAK,UAAA,EACL,SAAA,GAAY,UAAA,GACX,OAAA,CAAQ,UAAA;;;;;;;;ADUX;iBCSsB,oBAAA,CACpB,aAAA,EAAe,SAAA,EACf,gBAAA,EAAkB,UAAA,EAClB,GAAA,EAAK,UAAA,GACJ,OAAA,CAAQ,UAAA"}
+{"version":3,"file":"symmetric-crypto.d.ts","names":[],"sources":["../src/symmetric-crypto/keys.ts","../src/symmetric-crypto/aes.ts"],"mappings":";;AAUA;;;;;iBAAsB,wBAAA,CAAyB,OAAA,EAAS,UAAA,GAAa,WAAA,GAAc,OAAA,CAAQ,SAAA;;;;;;;iBAmBrE,wBAAA,CAAyB,GAAA,EAAK,SAAA,GAAY,OAAA,CAAQ,UAAA;;;;AAAxE;;iBAcsB,qBAAA,CAAA,GAAyB,OAAA,CAAQ,SAAA;;;;;;iBAgBvC,eAAA,CAAA,GAAmB,UAAA;;;;;;iBASb,wBAAA,CAAyB,WAAA,EAAa,UAAA,GAAa,OAAA,CAAQ,SAAA;;;;AA1DjF;;;;;;;;iBCGsB,oBAAA,CACpB,aAAA,EAAe,UAAA,EACf,OAAA,EAAS,UAAA,EACT,GAAA,EAAK,UAAA,EACL,SAAA,GAAY,UAAA,GACX,OAAA,CAAQ,UAAA;;;;;;;;ADWX;iBCQsB,oBAAA,CACpB,aAAA,EAAe,UAAA,EACf,gBAAA,EAAkB,UAAA,EAClB,GAAA,EAAK,UAAA,GACJ,OAAA,CAAQ,UAAA"}

package/dist/symmetric-crypto.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_aes = require('./aes-bOrKZuUC.js');
+const require_aes = require('./aes-DQo1MyCz.js');
 
 exports.decryptSymmetrically = require_aes.decryptSymmetrically;
 exports.deriveSymmetricCryptoKey = require_aes.deriveSymmetricCryptoKey;

package/dist/symmetric-crypto.mjs

@@ -1,3 +1,3 @@
-import { a as genSymmetricCryptoKey, i as exportSymmetricCryptoKey, n as encryptSymmetrically, o as genSymmetricKey, r as deriveSymmetricCryptoKey, s as importSymmetricCryptoKey, t as decryptSymmetrically } from "./aes-DSDxP8uF.mjs";
+import { a as genSymmetricCryptoKey, i as exportSymmetricCryptoKey, n as encryptSymmetrically, o as genSymmetricKey, r as deriveSymmetricCryptoKey, s as importSymmetricCryptoKey, t as decryptSymmetrically } from "./aes-DCb9dJqb.mjs";
 
 export { decryptSymmetrically, deriveSymmetricCryptoKey, encryptSymmetrically, exportSymmetricCryptoKey, genSymmetricCryptoKey, genSymmetricKey, importSymmetricCryptoKey };

package/dist/types.d.mts

@@ -19,6 +19,10 @@ type PublicKeysBase64 = {
   eccPublicKeyBase64: string;
   kyberPublicKeyBase64: string;
 };
+type HybridKeyPair = {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+};
 type PrivateKeys = {
   eccPrivateKey: CryptoKey;
   kyberPrivateKey: Uint8Array;
@@ -100,5 +104,5 @@ declare enum KeystoreType {
   RECOVERY = "Recovery"
 }
 //#endregion
-export { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys };
+export { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys };
 //# sourceMappingURL=types.d.mts.map

package/dist/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,aAAA,EAAe,kBAAA;AAAA;AAAA,KAGL,IAAA;EACV,KAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA,GAAqB,IAAA;EAC/B,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,UAAA;EACV,YAAA,EAAc,SAAA;EACd,cAAA,EAAgB,UAAA;AAAA;AAAA,KAGN,gBAAA;EACV,kBAAA;EACA,oBAAA;AAAA;AAAA,KAGU,WAAA;EACV,aAAA,EAAe,SAAA;EACf,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,oBAAA;EACV,mBAAA;EACA,qBAAA;AAAA;AAAA,KAGU,SAAA;EACV,UAAA,EAAY,UAAA;EACZ,WAAA,EAAa,WAAA;AAAA;AAAA,KAGH,kBAAA;EACV,UAAA,EAAY,gBAAA;EACZ,WAAA,EAAa,oBAAA;AAAA;AAAA,KAGH,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,GAAA,EAAK,kBAAA;EACL,cAAA;EACA,MAAA,EAAQ,qBAAA;EACR,EAAA;EACA,kBAAA;AAAA;AAAA,KAGU,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,GAAA,EAAK,kBAAA;EACL,MAAA,EAAQ,qBAAA;EACR,EAAA;EACA,kBAAA;AAAA;AAAA,KAGU,WAAA;EACV,MAAA,EAAQ,qBAAA;EACR,GAAA,EAAK,kBAAA;EACL,EAAA;AAAA;AAAA,KAGU,YAAA;EACV,eAAA;EACA,YAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,WAAA;AAAA;AAAA,KAGU,qBAAA;EACV,OAAA;EACA,SAAA;EACA,MAAA,EAAQ,IAAA;EACR,SAAA,EAAW,IAAA;EACX,UAAA,GAAa,IAAA;EACb,cAAA;EACA,MAAA;AAAA;AAAA,KAGU,KAAA;EACV,EAAA;EACA,IAAA,EAAM,SAAA;EACN,MAAA,EAAQ,qBAAA;AAAA;AAAA,UAGO,SAAA;EACf,OAAA,EAAS,GAAA,SAAY,KAAA;EACrB,SAAA;EACA,cAAA;EACA,YAAA;AAAA;AAAA,UAEe,iBAAA;EACf,KAAA,EAAO,KAAA;EACP,KAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,aAAA,EAAe,kBAAA;AAAA;AAAA,KAGL,IAAA;EACV,KAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA,GAAqB,IAAA;EAC/B,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,UAAA;EACV,YAAA,EAAc,SAAA;EACd,cAAA,EAAgB,UAAA;AAAA;AAAA,KAGN,gBAAA;EACV,kBAAA;EACA,oBAAA;AAAA;AAAA,KAGU,aAAA;EACV,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;AAAA,KAGD,WAAA;EACV,aAAA,EAAe,SAAA;EACf,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,oBAAA;EACV,mBAAA;EACA,qBAAA;AAAA;AAAA,KAGU,SAAA;EACV,UAAA,EAAY,UAAA;EACZ,WAAA,EAAa,WAAA;AAAA;AAAA,KAGH,kBAAA;EACV,UAAA,EAAY,gBAAA;EACZ,WAAA,EAAa,oBAAA;AAAA;AAAA,KAGH,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,GAAA,EAAK,kBAAA;EACL,cAAA;EACA,MAAA,EAAQ,qBAAA;EACR,EAAA;EACA,kBAAA;AAAA;AAAA,KAGU,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,GAAA,EAAK,kBAAA;EACL,MAAA,EAAQ,qBAAA;EACR,EAAA;EACA,kBAAA;AAAA;AAAA,KAGU,WAAA;EACV,MAAA,EAAQ,qBAAA;EACR,GAAA,EAAK,kBAAA;EACL,EAAA;AAAA;AAAA,KAGU,YAAA;EACV,eAAA;EACA,YAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,WAAA;AAAA;AAAA,KAGU,qBAAA;EACV,OAAA;EACA,SAAA;EACA,MAAA,EAAQ,IAAA;EACR,SAAA,EAAW,IAAA;EACX,UAAA,GAAa,IAAA;EACb,cAAA;EACA,MAAA;AAAA;AAAA,KAGU,KAAA;EACV,EAAA;EACA,IAAA,EAAM,SAAA;EACN,MAAA,EAAQ,qBAAA;AAAA;AAAA,UAGO,SAAA;EACf,OAAA,EAAS,GAAA,SAAY,KAAA;EACrB,SAAA;EACA,cAAA;EACA,YAAA;AAAA;AAAA,UAEe,iBAAA;EACf,KAAA,EAAO,KAAA;EACP,KAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}

package/dist/types.d.ts

@@ -19,6 +19,10 @@ type PublicKeysBase64 = {
   eccPublicKeyBase64: string;
   kyberPublicKeyBase64: string;
 };
+type HybridKeyPair = {
+  publicKey: Uint8Array;
+  secretKey: Uint8Array;
+};
 type PrivateKeys = {
   eccPrivateKey: CryptoKey;
   kyberPrivateKey: Uint8Array;
@@ -100,5 +104,5 @@ declare enum KeystoreType {
   RECOVERY = "Recovery"
 }
 //#endregion
-export { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys };
+export { Email, EmailBody, EmailBodyEncrypted, EmailKeys, EmailKeysEncrypted, EmailPublicParameters, EmailSearchResult, EncryptedKeystore, HybridEncKey, HybridEncryptedEmail, HybridKeyPair, KeystoreType, MailCache, PrivateKeys, PrivateKeysEncrypted, PublicKeys, PublicKeysBase64, PwdProtectedEmail, PwdProtectedKey, StoredEmail, User, UserWithPublicKeys };
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,aAAA,EAAe,kBAAA;AAAA;AAAA,KAGL,IAAA;EACV,KAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA,GAAqB,IAAA;EAC/B,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,UAAA;EACV,YAAA,EAAc,SAAA;EACd,cAAA,EAAgB,UAAA;AAAA;AAAA,KAGN,gBAAA;EACV,kBAAA;EACA,oBAAA;AAAA;AAAA,KAGU,WAAA;EACV,aAAA,EAAe,SAAA;EACf,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,oBAAA;EACV,mBAAA;EACA,qBAAA;AAAA;AAAA,KAGU,SAAA;EACV,UAAA,EAAY,UAAA;EACZ,WAAA,EAAa,WAAA;AAAA;AAAA,KAGH,kBAAA;EACV,UAAA,EAAY,gBAAA;EACZ,WAAA,EAAa,oBAAA;AAAA;AAAA,KAGH,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,GAAA,EAAK,kBAAA;EACL,cAAA;EACA,MAAA,EAAQ,qBAAA;EACR,EAAA;EACA,kBAAA;AAAA;AAAA,KAGU,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,GAAA,EAAK,kBAAA;EACL,MAAA,EAAQ,qBAAA;EACR,EAAA;EACA,kBAAA;AAAA;AAAA,KAGU,WAAA;EACV,MAAA,EAAQ,qBAAA;EACR,GAAA,EAAK,kBAAA;EACL,EAAA;AAAA;AAAA,KAGU,YAAA;EACV,eAAA;EACA,YAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,WAAA;AAAA;AAAA,KAGU,qBAAA;EACV,OAAA;EACA,SAAA;EACA,MAAA,EAAQ,IAAA;EACR,SAAA,EAAW,IAAA;EACX,UAAA,GAAa,IAAA;EACb,cAAA;EACA,MAAA;AAAA;AAAA,KAGU,KAAA;EACV,EAAA;EACA,IAAA,EAAM,SAAA;EACN,MAAA,EAAQ,qBAAA;AAAA;AAAA,UAGO,SAAA;EACf,OAAA,EAAS,GAAA,SAAY,KAAA;EACrB,SAAA;EACA,cAAA;EACA,YAAA;AAAA;AAAA,UAEe,iBAAA;EACf,KAAA,EAAO,KAAA;EACP,KAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../src/types.ts"],"mappings":";KAAY,iBAAA;EACV,SAAA;EACA,IAAA,EAAM,YAAA;EACN,aAAA,EAAe,kBAAA;AAAA;AAAA,KAGL,IAAA;EACV,KAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA,GAAqB,IAAA;EAC/B,UAAA,EAAY,UAAA;AAAA;AAAA,KAGF,UAAA;EACV,YAAA,EAAc,SAAA;EACd,cAAA,EAAgB,UAAA;AAAA;AAAA,KAGN,gBAAA;EACV,kBAAA;EACA,oBAAA;AAAA;AAAA,KAGU,aAAA;EACV,SAAA,EAAW,UAAA;EACX,SAAA,EAAW,UAAA;AAAA;AAAA,KAGD,WAAA;EACV,aAAA,EAAe,SAAA;EACf,eAAA,EAAiB,UAAA;AAAA;AAAA,KAGP,oBAAA;EACV,mBAAA;EACA,qBAAA;AAAA;AAAA,KAGU,SAAA;EACV,UAAA,EAAY,UAAA;EACZ,WAAA,EAAa,WAAA;AAAA;AAAA,KAGH,kBAAA;EACV,UAAA,EAAY,gBAAA;EACZ,WAAA,EAAa,oBAAA;AAAA;AAAA,KAGH,oBAAA;EACV,YAAA,EAAc,YAAA;EACd,GAAA,EAAK,kBAAA;EACL,cAAA;EACA,MAAA,EAAQ,qBAAA;EACR,EAAA;EACA,kBAAA;AAAA;AAAA,KAGU,iBAAA;EACV,YAAA,EAAc,eAAA;EACd,GAAA,EAAK,kBAAA;EACL,MAAA,EAAQ,qBAAA;EACR,EAAA;EACA,kBAAA;AAAA;AAAA,KAGU,WAAA;EACV,MAAA,EAAQ,qBAAA;EACR,GAAA,EAAK,kBAAA;EACL,EAAA;AAAA;AAAA,KAGU,YAAA;EACV,eAAA;EACA,YAAA;AAAA;AAAA,KAGU,eAAA;EACV,YAAA;EACA,IAAA;AAAA;AAAA,KAGU,kBAAA;EACV,OAAA;EACA,cAAA;AAAA;AAAA,KAGU,SAAA;EACV,IAAA;EACA,WAAA;AAAA;AAAA,KAGU,qBAAA;EACV,OAAA;EACA,SAAA;EACA,MAAA,EAAQ,IAAA;EACR,SAAA,EAAW,IAAA;EACX,UAAA,GAAa,IAAA;EACb,cAAA;EACA,MAAA;AAAA;AAAA,KAGU,KAAA;EACV,EAAA;EACA,IAAA,EAAM,SAAA;EACN,MAAA,EAAQ,qBAAA;AAAA;AAAA,UAGO,SAAA;EACf,OAAA,EAAS,GAAA,SAAY,KAAA;EACrB,SAAA;EACA,cAAA;EACA,YAAA;AAAA;AAAA,UAEe,iBAAA;EACf,KAAA,EAAO,KAAA;EACP,KAAA;AAAA;AAAA,aAGU,YAAA;EACV,UAAA;EACA,QAAA;AAAA"}

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  encryptedKeys: EmailKeysEncrypted;\n};\n\nexport type User = {\n  email: string;\n  name: string;\n};\n\nexport type UserWithPublicKeys = User & {\n  publicKeys: PublicKeys;\n};\n\nexport type PublicKeys = {\n  eccPublicKey: CryptoKey;\n  kyberPublicKey: Uint8Array;\n};\n\nexport type PublicKeysBase64 = {\n  eccPublicKeyBase64: string;\n  kyberPublicKeyBase64: string;\n};\n\nexport type PrivateKeys = {\n  eccPrivateKey: CryptoKey;\n  kyberPrivateKey: Uint8Array;\n};\n\nexport type PrivateKeysEncrypted = {\n  eccPrivateKeyBase64: string;\n  kyberPrivateKeyBase64: string;\n};\n\nexport type EmailKeys = {\n  publicKeys: PublicKeys;\n  privateKeys: PrivateKeys;\n};\n\nexport type EmailKeysEncrypted = {\n  publicKeys: PublicKeysBase64;\n  privateKeys: PrivateKeysEncrypted;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  enc: EmailBodyEncrypted;\n  recipientEmail: string;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  enc: EmailBodyEncrypted;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type StoredEmail = {\n  params: EmailPublicParameters;\n  enc: EmailBodyEncrypted;\n  id: string;\n};\n\nexport type HybridEncKey = {\n  kyberCiphertext: string;\n  encryptedKey: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  attachments?: string[];\n};\n\nexport type EmailPublicParameters = {\n  subject: string;\n  createdAt: string;\n  sender: User;\n  recipient: User;\n  recipients?: User[];\n  replyToEmailID?: string;\n  labels?: string[];\n};\n\nexport type Email = {\n  id: string;\n  body: EmailBody;\n  params: EmailPublicParameters;\n};\n\nexport interface MailCache<Email> {\n  esCache: Map<string, Email>;\n  cacheSize: number;\n  isCacheLimited: boolean;\n  isCacheReady: boolean;\n}\nexport interface EmailSearchResult {\n  email: Email;\n  score?: number;\n}\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";;;AAmHA,IAAY,sDAAL;AACL;AACA"}
+{"version":3,"file":"types.js","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  encryptedKeys: EmailKeysEncrypted;\n};\n\nexport type User = {\n  email: string;\n  name: string;\n};\n\nexport type UserWithPublicKeys = User & {\n  publicKeys: PublicKeys;\n};\n\nexport type PublicKeys = {\n  eccPublicKey: CryptoKey;\n  kyberPublicKey: Uint8Array;\n};\n\nexport type PublicKeysBase64 = {\n  eccPublicKeyBase64: string;\n  kyberPublicKeyBase64: string;\n};\n\nexport type HybridKeyPair = {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n};\n\nexport type PrivateKeys = {\n  eccPrivateKey: CryptoKey;\n  kyberPrivateKey: Uint8Array;\n};\n\nexport type PrivateKeysEncrypted = {\n  eccPrivateKeyBase64: string;\n  kyberPrivateKeyBase64: string;\n};\n\nexport type EmailKeys = {\n  publicKeys: PublicKeys;\n  privateKeys: PrivateKeys;\n};\n\nexport type EmailKeysEncrypted = {\n  publicKeys: PublicKeysBase64;\n  privateKeys: PrivateKeysEncrypted;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  enc: EmailBodyEncrypted;\n  recipientEmail: string;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  enc: EmailBodyEncrypted;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type StoredEmail = {\n  params: EmailPublicParameters;\n  enc: EmailBodyEncrypted;\n  id: string;\n};\n\nexport type HybridEncKey = {\n  kyberCiphertext: string;\n  encryptedKey: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  attachments?: string[];\n};\n\nexport type EmailPublicParameters = {\n  subject: string;\n  createdAt: string;\n  sender: User;\n  recipient: User;\n  recipients?: User[];\n  replyToEmailID?: string;\n  labels?: string[];\n};\n\nexport type Email = {\n  id: string;\n  body: EmailBody;\n  params: EmailPublicParameters;\n};\n\nexport interface MailCache<Email> {\n  esCache: Map<string, Email>;\n  cacheSize: number;\n  isCacheLimited: boolean;\n  isCacheReady: boolean;\n}\nexport interface EmailSearchResult {\n  email: Email;\n  score?: number;\n}\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";;;AAwHA,IAAY,sDAAL;AACL;AACA"}

package/dist/types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  encryptedKeys: EmailKeysEncrypted;\n};\n\nexport type User = {\n  email: string;\n  name: string;\n};\n\nexport type UserWithPublicKeys = User & {\n  publicKeys: PublicKeys;\n};\n\nexport type PublicKeys = {\n  eccPublicKey: CryptoKey;\n  kyberPublicKey: Uint8Array;\n};\n\nexport type PublicKeysBase64 = {\n  eccPublicKeyBase64: string;\n  kyberPublicKeyBase64: string;\n};\n\nexport type PrivateKeys = {\n  eccPrivateKey: CryptoKey;\n  kyberPrivateKey: Uint8Array;\n};\n\nexport type PrivateKeysEncrypted = {\n  eccPrivateKeyBase64: string;\n  kyberPrivateKeyBase64: string;\n};\n\nexport type EmailKeys = {\n  publicKeys: PublicKeys;\n  privateKeys: PrivateKeys;\n};\n\nexport type EmailKeysEncrypted = {\n  publicKeys: PublicKeysBase64;\n  privateKeys: PrivateKeysEncrypted;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  enc: EmailBodyEncrypted;\n  recipientEmail: string;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  enc: EmailBodyEncrypted;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type StoredEmail = {\n  params: EmailPublicParameters;\n  enc: EmailBodyEncrypted;\n  id: string;\n};\n\nexport type HybridEncKey = {\n  kyberCiphertext: string;\n  encryptedKey: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  attachments?: string[];\n};\n\nexport type EmailPublicParameters = {\n  subject: string;\n  createdAt: string;\n  sender: User;\n  recipient: User;\n  recipients?: User[];\n  replyToEmailID?: string;\n  labels?: string[];\n};\n\nexport type Email = {\n  id: string;\n  body: EmailBody;\n  params: EmailPublicParameters;\n};\n\nexport interface MailCache<Email> {\n  esCache: Map<string, Email>;\n  cacheSize: number;\n  isCacheLimited: boolean;\n  isCacheReady: boolean;\n}\nexport interface EmailSearchResult {\n  email: Email;\n  score?: number;\n}\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";AAmHA,IAAY,sDAAL;AACL;AACA"}
+{"version":3,"file":"types.mjs","names":[],"sources":["../src/types.ts"],"sourcesContent":["export type EncryptedKeystore = {\n  userEmail: string;\n  type: KeystoreType;\n  encryptedKeys: EmailKeysEncrypted;\n};\n\nexport type User = {\n  email: string;\n  name: string;\n};\n\nexport type UserWithPublicKeys = User & {\n  publicKeys: PublicKeys;\n};\n\nexport type PublicKeys = {\n  eccPublicKey: CryptoKey;\n  kyberPublicKey: Uint8Array;\n};\n\nexport type PublicKeysBase64 = {\n  eccPublicKeyBase64: string;\n  kyberPublicKeyBase64: string;\n};\n\nexport type HybridKeyPair = {\n  publicKey: Uint8Array;\n  secretKey: Uint8Array;\n};\n\nexport type PrivateKeys = {\n  eccPrivateKey: CryptoKey;\n  kyberPrivateKey: Uint8Array;\n};\n\nexport type PrivateKeysEncrypted = {\n  eccPrivateKeyBase64: string;\n  kyberPrivateKeyBase64: string;\n};\n\nexport type EmailKeys = {\n  publicKeys: PublicKeys;\n  privateKeys: PrivateKeys;\n};\n\nexport type EmailKeysEncrypted = {\n  publicKeys: PublicKeysBase64;\n  privateKeys: PrivateKeysEncrypted;\n};\n\nexport type HybridEncryptedEmail = {\n  encryptedKey: HybridEncKey;\n  enc: EmailBodyEncrypted;\n  recipientEmail: string;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type PwdProtectedEmail = {\n  encryptedKey: PwdProtectedKey;\n  enc: EmailBodyEncrypted;\n  params: EmailPublicParameters;\n  id: string;\n  isSubjectEncrypted: boolean;\n};\n\nexport type StoredEmail = {\n  params: EmailPublicParameters;\n  enc: EmailBodyEncrypted;\n  id: string;\n};\n\nexport type HybridEncKey = {\n  kyberCiphertext: string;\n  encryptedKey: string;\n};\n\nexport type PwdProtectedKey = {\n  encryptedKey: string;\n  salt: string;\n};\n\nexport type EmailBodyEncrypted = {\n  encText: string;\n  encAttachments?: string[];\n};\n\nexport type EmailBody = {\n  text: string;\n  attachments?: string[];\n};\n\nexport type EmailPublicParameters = {\n  subject: string;\n  createdAt: string;\n  sender: User;\n  recipient: User;\n  recipients?: User[];\n  replyToEmailID?: string;\n  labels?: string[];\n};\n\nexport type Email = {\n  id: string;\n  body: EmailBody;\n  params: EmailPublicParameters;\n};\n\nexport interface MailCache<Email> {\n  esCache: Map<string, Email>;\n  cacheSize: number;\n  isCacheLimited: boolean;\n  isCacheReady: boolean;\n}\nexport interface EmailSearchResult {\n  email: Email;\n  score?: number;\n}\n\nexport enum KeystoreType {\n  ENCRYPTION = 'Encryption',\n  RECOVERY = 'Recovery',\n}\n"],"mappings":";AAwHA,IAAY,sDAAL;AACL;AACA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "internxt-crypto",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/index.js",
@@ -36,6 +36,7 @@
     "vitest": "^4.0.0"
   },
   "dependencies": {
+    "@noble/ciphers": "^2.1.1",
     "@noble/hashes": "^2.0.1",
     "@noble/post-quantum": "^0.5.2",
     "@scure/bip39": "^2.0.1",

package/dist/aes-DSDxP8uF.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"aes-DSDxP8uF.mjs","names":[],"sources":["../src/symmetric-crypto/keys.ts","../src/symmetric-crypto/core.ts","../src/symmetric-crypto/aes.ts"],"sourcesContent":["import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, KEY_FORMAT } from '../constants';\nimport { getBytesFromData } from '../hash';\n\n/**\n * Converts Uint8Array into CryptoKey\n *\n * @param keyData - The Uint8Array representation of the symmetric key\n * @returns The resulting symmetric CryptoKey.\n */\nexport async function importSymmetricCryptoKey(keyData: Uint8Array | ArrayBuffer): Promise<CryptoKey> {\n  return crypto.subtle.importKey(\n    KEY_FORMAT,\n    new Uint8Array(keyData),\n    {\n      name: AES_ALGORITHM,\n      length: AES_KEY_BIT_LENGTH,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  );\n}\n\n/**\n * Converts CryptoKey into Uint8Array\n *\n * @param key - The symmetric CryptoKey\n * @returns The resulting Uint8Array.\n */\nexport async function exportSymmetricCryptoKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const rawKey = await crypto.subtle.exportKey(KEY_FORMAT, key);\n    return new Uint8Array(rawKey);\n  } catch (error) {\n    throw new Error('Failed to export symmetric CryptoKey', { cause: error });\n  }\n}\n\n/**\n * Generates symmetric CryptoKey\n *\n * @returns The generated CryptoKey.\n */\nexport async function genSymmetricCryptoKey(): Promise<CryptoKey> {\n  return crypto.subtle.generateKey(\n    {\n      name: AES_ALGORITHM,\n      length: AES_KEY_BIT_LENGTH,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  );\n}\n\n/**\n * Generates symmetric key as Uint8Array\n *\n * @returns The generated Uint8Array.\n */\nexport function genSymmetricKey(): Uint8Array {\n  try {\n    const key = new Uint8Array(AES_KEY_BIT_LENGTH / 8);\n    crypto.getRandomValues(key);\n    return key;\n  } catch (error) {\n    throw new Error('Failed to generate symmetric key', { cause: error });\n  }\n}\n\n/**\n * Derives CryptoKey from the given key material\n *\n * @returns The derived CryptoKey.\n */\nexport async function deriveSymmetricCryptoKey(keyMaterial: Uint8Array): Promise<CryptoKey> {\n  try {\n    const hashBuffer = getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial);\n    return importSymmetricCryptoKey(hashBuffer);\n  } catch (error) {\n    throw new Error('Failed to derive CryptoKey from the given key material', { cause: error });\n  }\n}\n","import { randomBytes } from '@noble/post-quantum/utils.js';\nimport { getBytesFromData } from '../hash';\nimport { AUX_BYTE_LEN, AES_ALGORITHM, IV_LEN_BYTES } from '../constants';\n\n/**\n * Creates an initialization vector (IV) using RGB-based construction (8.2.2 NIST Special Publication 800-38D)\n * Constructs a 128-bits IV from 2 fileds: the random field (at least 96 bits) and the free field (32 bits).\n * If free filed is empty, then the entier 128-bit IV is sampled randomly.\n *\n * @param freeFiled - The string with an unrestricted content. Can be a device identifier, etc.\n * @returns The resulting 128-bits initialization vector.\n */\nexport function createNISTbasedIV(freeField?: Uint8Array): Uint8Array {\n  try {\n    if (!freeField) {\n      return randomBytes(IV_LEN_BYTES);\n    }\n\n    const iv = new Uint8Array(16);\n\n    const randFiled = randomBytes(12);\n    iv.set(randFiled, 0);\n\n    const freeFiledFixedLength = getBytesFromData(4, freeField);\n    iv.set(freeFiledFixedLength, 12);\n\n    return iv;\n  } catch (error) {\n    throw new Error('Failed to create IV', { cause: error });\n  }\n}\n\n/**\n * Hashes aux string to make it fixed-length\n *\n * @param aux - The auxilay string of arbitrary length\n * @returns The resulting fixed-length auxilary string.\n */\nexport async function makeAuxFixedLength(aux: Uint8Array): Promise<Uint8Array> {\n  return getBytesFromData(AUX_BYTE_LEN, aux);\n}\n\n/**\n * Symmetrically encrypts message\n *\n * @param message - The message to encrypt\n * @param encryptionKey - The encryption key\n * @param iv - The initialization vector\n * @param additionalData - The auxilary data\n * @returns The resulting ciphertext\n */\nexport async function encryptMessage(\n  message: Uint8Array,\n  encryptionKey: CryptoKey,\n  iv: Uint8Array,\n  additionalData: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const encrypted = await crypto.subtle.encrypt(\n      { name: AES_ALGORITHM, iv: iv as BufferSource, additionalData: additionalData as BufferSource },\n      encryptionKey,\n      message as BufferSource,\n    );\n    return new Uint8Array(encrypted);\n  } catch (error) {\n    throw new Error('Failed to encrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Symmetrically decrypts message\n *\n * @param ciphertext - The encrypted message\n * @param ciphertext - The initialization vector\n * @param encryptionKey - The encryption key\n * @param additionalData - The auxilary data\n * @returns The resulting decrypted message\n */\nexport async function decryptMessage(\n  ciphertext: Uint8Array,\n  iv: Uint8Array,\n  encryptionKey: CryptoKey,\n  additionalData: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const decrypted = await crypto.subtle.decrypt(\n      { name: AES_ALGORITHM, iv: iv as BufferSource, additionalData: additionalData as BufferSource },\n      encryptionKey,\n      ciphertext as BufferSource,\n    );\n    return new Uint8Array(decrypted);\n  } catch (error) {\n    throw new Error('Failed to decrypt symmetrically', { cause: error });\n  }\n}\n","import { createNISTbasedIV, makeAuxFixedLength, encryptMessage, decryptMessage } from './core';\nimport { concatBytes } from '@noble/hashes/utils.js';\nimport { IV_LEN_BYTES } from '../constants';\n\n/**\n * Symmetrically encrypts the message\n *\n * @param encryptionKey - The symmetric CryptoKey used for message encryption\n * @param message - The message to encrypt\n * @param freeField - The context of the message (required for IV generation)\n * @param aux - The auxilary string\n * @returns The resulting ciphertext.\n */\nexport async function encryptSymmetrically(\n  encryptionKey: CryptoKey,\n  message: Uint8Array,\n  aux: Uint8Array,\n  freeField?: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const iv = createNISTbasedIV(freeField);\n    const additionalData = await makeAuxFixedLength(aux);\n    const ciphertext = await encryptMessage(message, encryptionKey, iv, additionalData);\n    return concatBytes(ciphertext, iv);\n  } catch (error) {\n    throw new Error('Failed to encrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Decryps symmetrically encrypted message\n *\n * @param encryptionKey - The symmetric CryptoKey used for message encryption\n * @param encryptedMessage - The ciphertext\n * @param aux - The auxilary string\n * @returns The resulting ciphertext.\n */\nexport async function decryptSymmetrically(\n  encryptionKey: CryptoKey,\n  encryptedMessage: Uint8Array,\n  aux: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const additionalData = await makeAuxFixedLength(aux);\n    const ciphertext = encryptedMessage.slice(0, encryptedMessage.length - IV_LEN_BYTES);\n    const iv = encryptedMessage.slice(encryptedMessage.length - IV_LEN_BYTES);\n    const result = await decryptMessage(ciphertext, iv, encryptionKey, additionalData);\n    return result;\n  } catch (error) {\n    throw new Error('Failed to decrypt symmetrically', { cause: error });\n  }\n}\n"],"mappings":"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"}

package/dist/aes-bOrKZuUC.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"aes-bOrKZuUC.js","names":["KEY_FORMAT","AES_ALGORITHM","AES_KEY_BIT_LENGTH","getBytesFromData","IV_LEN_BYTES","getBytesFromData","AUX_BYTE_LEN","AES_ALGORITHM","IV_LEN_BYTES"],"sources":["../src/symmetric-crypto/keys.ts","../src/symmetric-crypto/core.ts","../src/symmetric-crypto/aes.ts"],"sourcesContent":["import { AES_ALGORITHM, AES_KEY_BIT_LENGTH, KEY_FORMAT } from '../constants';\nimport { getBytesFromData } from '../hash';\n\n/**\n * Converts Uint8Array into CryptoKey\n *\n * @param keyData - The Uint8Array representation of the symmetric key\n * @returns The resulting symmetric CryptoKey.\n */\nexport async function importSymmetricCryptoKey(keyData: Uint8Array | ArrayBuffer): Promise<CryptoKey> {\n  return crypto.subtle.importKey(\n    KEY_FORMAT,\n    new Uint8Array(keyData),\n    {\n      name: AES_ALGORITHM,\n      length: AES_KEY_BIT_LENGTH,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  );\n}\n\n/**\n * Converts CryptoKey into Uint8Array\n *\n * @param key - The symmetric CryptoKey\n * @returns The resulting Uint8Array.\n */\nexport async function exportSymmetricCryptoKey(key: CryptoKey): Promise<Uint8Array> {\n  try {\n    const rawKey = await crypto.subtle.exportKey(KEY_FORMAT, key);\n    return new Uint8Array(rawKey);\n  } catch (error) {\n    throw new Error('Failed to export symmetric CryptoKey', { cause: error });\n  }\n}\n\n/**\n * Generates symmetric CryptoKey\n *\n * @returns The generated CryptoKey.\n */\nexport async function genSymmetricCryptoKey(): Promise<CryptoKey> {\n  return crypto.subtle.generateKey(\n    {\n      name: AES_ALGORITHM,\n      length: AES_KEY_BIT_LENGTH,\n    },\n    true,\n    ['encrypt', 'decrypt'],\n  );\n}\n\n/**\n * Generates symmetric key as Uint8Array\n *\n * @returns The generated Uint8Array.\n */\nexport function genSymmetricKey(): Uint8Array {\n  try {\n    const key = new Uint8Array(AES_KEY_BIT_LENGTH / 8);\n    crypto.getRandomValues(key);\n    return key;\n  } catch (error) {\n    throw new Error('Failed to generate symmetric key', { cause: error });\n  }\n}\n\n/**\n * Derives CryptoKey from the given key material\n *\n * @returns The derived CryptoKey.\n */\nexport async function deriveSymmetricCryptoKey(keyMaterial: Uint8Array): Promise<CryptoKey> {\n  try {\n    const hashBuffer = getBytesFromData(AES_KEY_BIT_LENGTH / 8, keyMaterial);\n    return importSymmetricCryptoKey(hashBuffer);\n  } catch (error) {\n    throw new Error('Failed to derive CryptoKey from the given key material', { cause: error });\n  }\n}\n","import { randomBytes } from '@noble/post-quantum/utils.js';\nimport { getBytesFromData } from '../hash';\nimport { AUX_BYTE_LEN, AES_ALGORITHM, IV_LEN_BYTES } from '../constants';\n\n/**\n * Creates an initialization vector (IV) using RGB-based construction (8.2.2 NIST Special Publication 800-38D)\n * Constructs a 128-bits IV from 2 fileds: the random field (at least 96 bits) and the free field (32 bits).\n * If free filed is empty, then the entier 128-bit IV is sampled randomly.\n *\n * @param freeFiled - The string with an unrestricted content. Can be a device identifier, etc.\n * @returns The resulting 128-bits initialization vector.\n */\nexport function createNISTbasedIV(freeField?: Uint8Array): Uint8Array {\n  try {\n    if (!freeField) {\n      return randomBytes(IV_LEN_BYTES);\n    }\n\n    const iv = new Uint8Array(16);\n\n    const randFiled = randomBytes(12);\n    iv.set(randFiled, 0);\n\n    const freeFiledFixedLength = getBytesFromData(4, freeField);\n    iv.set(freeFiledFixedLength, 12);\n\n    return iv;\n  } catch (error) {\n    throw new Error('Failed to create IV', { cause: error });\n  }\n}\n\n/**\n * Hashes aux string to make it fixed-length\n *\n * @param aux - The auxilay string of arbitrary length\n * @returns The resulting fixed-length auxilary string.\n */\nexport async function makeAuxFixedLength(aux: Uint8Array): Promise<Uint8Array> {\n  return getBytesFromData(AUX_BYTE_LEN, aux);\n}\n\n/**\n * Symmetrically encrypts message\n *\n * @param message - The message to encrypt\n * @param encryptionKey - The encryption key\n * @param iv - The initialization vector\n * @param additionalData - The auxilary data\n * @returns The resulting ciphertext\n */\nexport async function encryptMessage(\n  message: Uint8Array,\n  encryptionKey: CryptoKey,\n  iv: Uint8Array,\n  additionalData: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const encrypted = await crypto.subtle.encrypt(\n      { name: AES_ALGORITHM, iv: iv as BufferSource, additionalData: additionalData as BufferSource },\n      encryptionKey,\n      message as BufferSource,\n    );\n    return new Uint8Array(encrypted);\n  } catch (error) {\n    throw new Error('Failed to encrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Symmetrically decrypts message\n *\n * @param ciphertext - The encrypted message\n * @param ciphertext - The initialization vector\n * @param encryptionKey - The encryption key\n * @param additionalData - The auxilary data\n * @returns The resulting decrypted message\n */\nexport async function decryptMessage(\n  ciphertext: Uint8Array,\n  iv: Uint8Array,\n  encryptionKey: CryptoKey,\n  additionalData: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const decrypted = await crypto.subtle.decrypt(\n      { name: AES_ALGORITHM, iv: iv as BufferSource, additionalData: additionalData as BufferSource },\n      encryptionKey,\n      ciphertext as BufferSource,\n    );\n    return new Uint8Array(decrypted);\n  } catch (error) {\n    throw new Error('Failed to decrypt symmetrically', { cause: error });\n  }\n}\n","import { createNISTbasedIV, makeAuxFixedLength, encryptMessage, decryptMessage } from './core';\nimport { concatBytes } from '@noble/hashes/utils.js';\nimport { IV_LEN_BYTES } from '../constants';\n\n/**\n * Symmetrically encrypts the message\n *\n * @param encryptionKey - The symmetric CryptoKey used for message encryption\n * @param message - The message to encrypt\n * @param freeField - The context of the message (required for IV generation)\n * @param aux - The auxilary string\n * @returns The resulting ciphertext.\n */\nexport async function encryptSymmetrically(\n  encryptionKey: CryptoKey,\n  message: Uint8Array,\n  aux: Uint8Array,\n  freeField?: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const iv = createNISTbasedIV(freeField);\n    const additionalData = await makeAuxFixedLength(aux);\n    const ciphertext = await encryptMessage(message, encryptionKey, iv, additionalData);\n    return concatBytes(ciphertext, iv);\n  } catch (error) {\n    throw new Error('Failed to encrypt symmetrically', { cause: error });\n  }\n}\n\n/**\n * Decryps symmetrically encrypted message\n *\n * @param encryptionKey - The symmetric CryptoKey used for message encryption\n * @param encryptedMessage - The ciphertext\n * @param aux - The auxilary string\n * @returns The resulting ciphertext.\n */\nexport async function decryptSymmetrically(\n  encryptionKey: CryptoKey,\n  encryptedMessage: Uint8Array,\n  aux: Uint8Array,\n): Promise<Uint8Array> {\n  try {\n    const additionalData = await makeAuxFixedLength(aux);\n    const ciphertext = encryptedMessage.slice(0, encryptedMessage.length - IV_LEN_BYTES);\n    const iv = encryptedMessage.slice(encryptedMessage.length - IV_LEN_BYTES);\n    const result = await decryptMessage(ciphertext, iv, encryptionKey, additionalData);\n    return result;\n  } catch (error) {\n    throw new Error('Failed to decrypt symmetrically', { cause: error });\n  }\n}\n"],"mappings":"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"}

package/dist/emailEncryptionKey-27mIHh18.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"emailEncryptionKey-27mIHh18.mjs","names":[],"sources":["../src/keystore-crypto/core.ts","../src/keystore-crypto/emailEncryptionKey.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"],"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/emailEncryptionKey-DbaDAdoW.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"emailEncryptionKey-DbaDAdoW.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"],"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"],"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,iCAAqB,WAAW,KAAK,YAAY,iBAAiB,IAAI;EAEvG,MAAM,mBAAmB,MAAMA,iCAAqB,WAD9B,MAAMC,8BAAiB,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,6BADJD,iCAAmB,kBAAkB,cAAc,WAAW,mBAAmB,CAC9C;EAE1D,MAAM,kBAAkB,MAAME,iCAAqB,WADxBF,iCAAmB,kBAAkB,cAAc,YAAY,sBAAsB,EAC9B,IAAI;EAGtF,MAAM,gBAAgB,MAAMG,8BADb,MAAMD,iCAAqB,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,mEAAoCC,oCADfC,6BAAiBC,uCAAqB,GAAG,kBAAkB,CACN;;;;;;;;AASnF,eAAsB,4BAA4B,SAAyC;AACzF,QAAOH,mEAAoCI,wCAAsB,QAAQ;;;;;;;;;;;;AC9F3E,eAAsB,qCACpB,WACA,SAMC;AACD,KAAI;EACF,MAAM,OAAO,MAAMC,qCAAmB;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/emailKeys-BJGdkLrg.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"emailKeys-BJGdkLrg.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/email-crypto/converters.ts","../src/email-crypto/utils.ts","../src/email-crypto/core.ts","../src/email-crypto/hybridEncyptedEmail.ts","../src/email-crypto/pwdProtectedEmail.ts","../src/email-crypto/emailKeys.ts"],"sourcesContent":["import { 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","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"],"mappings":"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"}