internxt-crypto 0.0.10-alpha → 0.0.11

package/dist/keystore-crypto.mjs

@@ -1,501 +1,9 @@
-import { utf8ToBytes } from '@noble/hashes/utils.js';
-import * as bip39 from '@scure/bip39';
-import { wordlist } from '@scure/bip39/wordlists/english';
-import { blake3 } from '@noble/hashes/blake3.js';
-import { randomBytes } from '@noble/post-quantum/utils.js';
-import { ml_kem768 } from '@noble/post-quantum/ml-kem.js';
-
-// src/utils/converters.ts
-function UTF8ToUint8(str) {
-  return new TextEncoder().encode(str);
-}
-function uint8ArrayToBase64(buffer) {
-  const array = Uint16Array.from(buffer);
-  const binaryString = new TextDecoder("UTF-16").decode(array);
-  return btoa(binaryString);
-}
-function base64ToUint8Array(str) {
-  const binaryString = atob(str);
-  const len = binaryString.length;
-  const array = new Uint8Array(len);
-  for (let i = 0; i < len; i++) {
-    array[i] = binaryString.charCodeAt(i);
-  }
-  return new Uint8Array(array.buffer);
-}
-
-// src/constants.ts
-var AES_ALGORITHM = "AES-GCM";
-var AES_KEY_BIT_LENGTH = 256;
-var AUX_LEN = 128;
-var IV_LEN_BYTES = 16;
-var KEY_FORMAT = "raw";
-var ECC_ALGORITHM = "X25519";
-var CONTEXT_LOGIN = "CRYPTO library 2025-07-26 16:18:03 key for opening identity keystore";
-var CONTEXT_ENC_KEYSTORE = "CRYPTO library 2025-07-30 16:18:03 key for opening encryption keys keystore";
-var CONTEXT_RECOVERY = "CRYPTO library 2025-07-30 16:20:00 key for account recovery";
-var IDENTITY_KEYSTORE_TAG = "Identity keystore";
-var ENCRYPTION_KEYSTORE_TAG = "Encryption keystore";
-var RECOVERY_KEYSTORE_TAG = "Key recovery keystroe";
-
-// src/asymmetric-crypto/keys.ts
-async function generateEccKeys() {
-  try {
-    return await crypto.subtle.generateKey(
-      {
-        name: ECC_ALGORITHM
-      },
-      true,
-      ["deriveBits"]
-    );
-  } catch (error) {
-    throw new Error("Failed to generate elliptic curve key pair", { cause: error });
-  }
-}
-async function exportPublicKey(key) {
-  try {
-    const result = await crypto.subtle.exportKey("spki", key);
-    return new Uint8Array(result);
-  } catch (error) {
-    throw new Error("Failed to export public key", { cause: error });
-  }
-}
-async function importPublicKey(spkiKeyData) {
-  try {
-    return await crypto.subtle.importKey(
-      "spki",
-      spkiKeyData,
-      {
-        name: ECC_ALGORITHM
-      },
-      true,
-      []
-    );
-  } catch (error) {
-    throw new Error("Failed to import public key", { cause: error });
-  }
-}
-async function exportPrivateKey(key) {
-  try {
-    const result = await crypto.subtle.exportKey("pkcs8", key);
-    return new Uint8Array(result);
-  } catch (error) {
-    throw new Error("Failed to export private key", { cause: error });
-  }
-}
-async function importPrivateKey(pkcs8KeyData) {
-  try {
-    return await crypto.subtle.importKey(
-      "pkcs8",
-      pkcs8KeyData,
-      {
-        name: ECC_ALGORITHM
-      },
-      true,
-      ["deriveBits"]
-    );
-  } catch (error) {
-    throw new Error("Failed to import private key", { cause: error });
-  }
-}
-
-// src/utils/keyConverters.ts
-async function identityKeysToBase64(keys) {
-  try {
-    const pkArray = await exportPublicKey(keys.userPublicKey);
-    const skArray = await exportPrivateKey(keys.userPrivateKey);
-    const json = JSON.stringify({
-      userPublicKey: uint8ArrayToBase64(pkArray),
-      userPrivateKey: uint8ArrayToBase64(skArray)
-    });
-    const base64 = btoa(json);
-    return base64;
-  } catch (error) {
-    throw new Error("Failed to convert identity keys to base64", { cause: error });
-  }
-}
-async function encryptionKeysToBase64(keys) {
-  try {
-    const pkArray = await exportPublicKey(keys.userPublicKey);
-    const skArray = await exportPrivateKey(keys.userPrivateKey);
-    const json = JSON.stringify({
-      userPublicKey: uint8ArrayToBase64(pkArray),
-      userPrivateKey: uint8ArrayToBase64(skArray),
-      userPublicKyberKey: uint8ArrayToBase64(keys.userPublicKyberKey),
-      userPrivateKyberKey: uint8ArrayToBase64(keys.userPrivateKyberKey)
-    });
-    const base64 = btoa(json);
-    return base64;
-  } catch (error) {
-    throw new Error("Failed to convert identity keys to base64", { cause: error });
-  }
-}
-async function base64ToIdentityKeys(base64) {
-  try {
-    const json = atob(base64);
-    const obj = JSON.parse(json);
-    const pkArray = base64ToUint8Array(obj.userPublicKey);
-    const skArray = base64ToUint8Array(obj.userPrivateKey);
-    const pkCryptoKey = await importPublicKey(pkArray);
-    const skCryptoKey = await importPrivateKey(skArray);
-    const result = {
-      userPublicKey: pkCryptoKey,
-      userPrivateKey: skCryptoKey
-    };
-    return result;
-  } catch (error) {
-    throw new Error("Failed convert base64 to idenity key", { cause: error });
-  }
-}
-async function base64ToEncryptionKeys(base64) {
-  try {
-    const json = atob(base64);
-    const obj = JSON.parse(json);
-    const pkArray = base64ToUint8Array(obj.userPublicKey);
-    const skArray = base64ToUint8Array(obj.userPrivateKey);
-    const pkCryptoKey = await importPublicKey(pkArray);
-    const skCryptoKey = await importPrivateKey(skArray);
-    const pkKyber = base64ToUint8Array(obj.userPublicKyberKey);
-    const skKyber = base64ToUint8Array(obj.userPrivateKyberKey);
-    const result = {
-      userPublicKey: pkCryptoKey,
-      userPrivateKey: skCryptoKey,
-      userPublicKyberKey: pkKyber,
-      userPrivateKyberKey: skKyber
-    };
-    return result;
-  } catch (error) {
-    throw new Error("Failed to convert base64 to encryption key", { cause: error });
-  }
-}
-function genMnemonic(bits) {
-  return bip39.generateMnemonic(wordlist, bits);
-}
-function getBytesFromString(bytes, value) {
-  return blake3(utf8ToBytes(value), { dkLen: bytes });
-}
-
-// src/symmetric-crypto/keys.ts
-async function importSymmetricCryptoKey(keyData) {
-  return crypto.subtle.importKey(
-    KEY_FORMAT,
-    new Uint8Array(keyData),
-    {
-      name: AES_ALGORITHM,
-      length: AES_KEY_BIT_LENGTH
-    },
-    true,
-    ["encrypt", "decrypt"]
-  );
-}
-async function createNISTbasedIV(freeField) {
-  try {
-    if (!freeField) {
-      return randomBytes(IV_LEN_BYTES);
-    }
-    const iv = new Uint8Array(16);
-    const randFiled = randomBytes(12);
-    iv.set(randFiled, 0);
-    const freeFiledFixedLength = await getBytesFromString(4, freeField);
-    iv.set(freeFiledFixedLength, 12);
-    return iv;
-  } catch (error) {
-    throw new Error("Failed to create IV", { cause: error });
-  }
-}
-async function makeAuxFixedLength(aux) {
-  return getBytesFromString(AUX_LEN / 8, aux);
-}
-async function encryptMessage(message, encryptionKey, iv, additionalData) {
-  try {
-    const encrypted = await crypto.subtle.encrypt(
-      { name: AES_ALGORITHM, iv, additionalData },
-      encryptionKey,
-      message
-    );
-    return new Uint8Array(encrypted);
-  } catch (error) {
-    throw new Error("Failed to encrypt symmetrically", { cause: error });
-  }
-}
-async function decryptMessage(ciphertext, iv, encryptionKey, additionalData) {
-  try {
-    const decrypted = await crypto.subtle.decrypt(
-      { name: AES_ALGORITHM, iv, additionalData },
-      encryptionKey,
-      ciphertext
-    );
-    return new Uint8Array(decrypted);
-  } catch (error) {
-    throw new Error("Failed to decrypt symmetrically", { cause: error });
-  }
-}
-
-// src/symmetric-crypto/aes.ts
-async function encryptSymmetrically(encryptionKey, message, aux, freeField) {
-  try {
-    const iv = await createNISTbasedIV(freeField);
-    const additionalData = await makeAuxFixedLength(aux);
-    const ciphertext = await encryptMessage(message, encryptionKey, iv, additionalData);
-    return { ciphertext, iv };
-  } catch (error) {
-    throw new Error("Failed to encrypt symmetrically", { cause: error });
-  }
-}
-async function decryptSymmetrically(encryptionKey, encryptedMessage, aux) {
-  try {
-    const additionalData = await makeAuxFixedLength(aux);
-    const result = await decryptMessage(
-      encryptedMessage.ciphertext,
-      encryptedMessage.iv,
-      encryptionKey,
-      additionalData
-    );
-    return result;
-  } catch (error) {
-    throw new Error("Failed to decrypt symmetrically", { cause: error });
-  }
-}
-
-// src/storage-service/sessionStorageService.ts
-function get(key) {
-  return sessionStorage.getItem(key);
-}
-function set(key, value) {
-  return sessionStorage.setItem(key, value);
-}
-function removeItem(key) {
-  sessionStorage.removeItem(key);
-}
-function exists(key) {
-  return !!sessionStorage.getItem(key);
-}
-function clear() {
-  sessionStorage.clear();
-}
-var sessionStorageService = {
-  set,
-  get,
-  removeItem,
-  exists,
-  clear
-};
-var sessionStorageService_default = sessionStorageService;
-function deriveSymmetricKeyFromContext(context, baseKey) {
-  return blake3(baseKey, { context: UTF8ToUint8(context) });
-}
-async function deriveSymmetricCryptoKeyFromContext(context, baseKey) {
-  try {
-    if (baseKey.length != AES_KEY_BIT_LENGTH / 8) {
-      throw new Error(`Base key length must be exactly ${AES_KEY_BIT_LENGTH / 8} bytes`);
-    }
-    if (!context) {
-      throw new Error("Context is empry");
-    }
-    const keyBytes = deriveSymmetricKeyFromContext(context, baseKey);
-    const key = await importSymmetricCryptoKey(keyBytes);
-    return key;
-  } catch (error) {
-    throw new Error("Failed to derive CryptoKey from base key and context", { cause: error });
-  }
-}
-
-// src/keystore-crypto/core.ts
-async function encryptKeystoreContent(secretKey, content, userID, tag) {
-  try {
-    const aux = userID + tag;
-    const message = base64ToUint8Array(content);
-    const result = await encryptSymmetrically(secretKey, message, aux);
-    return result;
-  } catch (error) {
-    throw new Error("Failed to encrypt keystore content", { cause: error });
-  }
-}
-async function decryptKeystoreContent(secretKey, encryptedKeys, userID, tag) {
-  try {
-    const aux = userID + tag;
-    const content = await decryptSymmetrically(secretKey, encryptedKeys, aux);
-    const result = uint8ArrayToBase64(content);
-    return result;
-  } catch (error) {
-    throw new Error("Failed to decrypt keystore content", { cause: error });
-  }
-}
-function getUserID() {
-  try {
-    const userID = sessionStorageService_default.get("userID");
-    if (!userID) {
-      throw new Error("No UserID");
-    }
-    return userID;
-  } catch (error) {
-    throw new Error("Failed to get UserID from session storage", { cause: error });
-  }
-}
-function getBaseKey() {
-  try {
-    const baseKeyBase64 = sessionStorageService_default.get("baseKey");
-    if (!baseKeyBase64) {
-      throw new Error("No base key");
-    }
-    return base64ToUint8Array(baseKeyBase64);
-  } catch (error) {
-    throw new Error("Failed to get base key from session storage", { cause: error });
-  }
-}
-async function deriveIdentityKeystoreKey(baseKey) {
-  return deriveSymmetricCryptoKeyFromContext(CONTEXT_LOGIN, baseKey);
-}
-async function deriveRecoveryKey(recoveryCodes) {
-  const recoveryCodesBuffer = await getBytesFromString(AES_KEY_BIT_LENGTH / 8, recoveryCodes);
-  return deriveSymmetricCryptoKeyFromContext(CONTEXT_RECOVERY, recoveryCodesBuffer);
-}
-async function deriveEncryptionKeystoreKey(baseKey) {
-  return deriveSymmetricCryptoKeyFromContext(CONTEXT_ENC_KEYSTORE, baseKey);
-}
-function generateKyberKeys(seed) {
-  try {
-    return ml_kem768.keygen(seed);
-  } catch (error) {
-    throw new Error("Failed to generate Kyber keys", { cause: error });
-  }
-}
-
-// src/keystore-crypto/emailEncryptionKey.ts
-function generateRecoveryCodes() {
-  return genMnemonic(AES_KEY_BIT_LENGTH);
-}
-async function generateEncryptionKeys() {
-  try {
-    const keyPair = await generateEccKeys();
-    const keyPairKyber = generateKyberKeys();
-    const result = {
-      userPrivateKey: keyPair.privateKey,
-      userPublicKey: keyPair.publicKey,
-      userPublicKyberKey: keyPairKyber.publicKey,
-      userPrivateKyberKey: keyPairKyber.secretKey
-    };
-    return result;
-  } catch (error) {
-    throw new Error("Failed to generate encryption keys", { cause: error });
-  }
-}
-async function createEncryptionAndRecoveryKeystores() {
-  try {
-    const userID = getUserID();
-    const baseKey = getBaseKey();
-    const keys = await generateEncryptionKeys();
-    const content = await encryptionKeysToBase64(keys);
-    const secretKey = await deriveEncryptionKeystoreKey(baseKey);
-    const ciphertext = await encryptKeystoreContent(secretKey, content, userID, ENCRYPTION_KEYSTORE_TAG);
-    const encryptionKeystore = {
-      userID,
-      type: "encryption" /* ENCRYPTION */,
-      encryptedKeys: ciphertext
-    };
-    const recoveryCodes = generateRecoveryCodes();
-    const recoveryKey = await deriveRecoveryKey(recoveryCodes);
-    const encKeys = await encryptKeystoreContent(recoveryKey, content, userID, RECOVERY_KEYSTORE_TAG);
-    const recoveryKeystore = {
-      userID,
-      type: "recovery" /* RECOVERY */,
-      encryptedKeys: encKeys
-    };
-    return { encryptionKeystore, recoveryKeystore, recoveryCodes };
-  } catch (error) {
-    throw new Error("Failed to create encryption and recovery keystores", { cause: error });
-  }
-}
-async function openEncryptionKeystore(encryptedKeystore) {
-  try {
-    if (encryptedKeystore.type != "encryption" /* ENCRYPTION */) {
-      throw new Error("Input is invalid");
-    }
-    const baseKey = getBaseKey();
-    const secretKey = await deriveEncryptionKeystoreKey(baseKey);
-    const json = await decryptKeystoreContent(
-      secretKey,
-      encryptedKeystore.encryptedKeys,
-      encryptedKeystore.userID,
-      ENCRYPTION_KEYSTORE_TAG
-    );
-    const keys = await base64ToEncryptionKeys(json);
-    return keys;
-  } catch (error) {
-    throw new Error("Failed to open encryption keystore", { cause: error });
-  }
-}
-async function openRecoveryKeystore(recoveryCodes, encryptedKeystore) {
-  try {
-    if (encryptedKeystore.type != "recovery" /* RECOVERY */) {
-      throw new Error("Input is invalid");
-    }
-    const recoveryKey = await deriveRecoveryKey(recoveryCodes);
-    const json = await decryptKeystoreContent(
-      recoveryKey,
-      encryptedKeystore.encryptedKeys,
-      encryptedKeystore.userID,
-      RECOVERY_KEYSTORE_TAG
-    );
-    const keys = await base64ToEncryptionKeys(json);
-    return keys;
-  } catch (error) {
-    throw new Error("Failed to open recovery keystore", { cause: error });
-  }
-}
-
-// src/keystore-crypto/userIdenityKey.ts
-async function generateIdentityKeys() {
-  try {
-    const keyPair = await generateEccKeys();
-    const result = {
-      userPrivateKey: keyPair.privateKey,
-      userPublicKey: keyPair.publicKey
-    };
-    return result;
-  } catch (error) {
-    throw new Error("Failed to generate idenity keys", { cause: error });
-  }
-}
-async function createIdentityKeystore() {
-  try {
-    const type = "identity" /* IDENTITY */;
-    const userID = getUserID();
-    const baseKey = getBaseKey();
-    const keys = await generateIdentityKeys();
-    const content = await identityKeysToBase64(keys);
-    const secretKey = await deriveIdentityKeystoreKey(baseKey);
-    const encryptedKeys = await encryptKeystoreContent(secretKey, content, userID, IDENTITY_KEYSTORE_TAG);
-    const result = {
-      userID,
-      type,
-      encryptedKeys
-    };
-    return result;
-  } catch (error) {
-    throw new Error("Failed to create identity keystore", { cause: error });
-  }
-}
-async function openIdentityKeystore(encryptedKeystore) {
-  try {
-    if (encryptedKeystore.type != "identity" /* IDENTITY */) {
-      throw new Error("Input is invalid");
-    }
-    const baseKey = getBaseKey();
-    const secretKey = await deriveIdentityKeystoreKey(baseKey);
-    const json = await decryptKeystoreContent(
-      secretKey,
-      encryptedKeystore.encryptedKeys,
-      encryptedKeystore.userID,
-      IDENTITY_KEYSTORE_TAG
-    );
-    const keys = await base64ToIdentityKeys(json);
-    return keys;
-  } catch (error) {
-    throw new Error("Failed to open identity keystore", { cause: error });
-  }
-}
-
-export { createEncryptionAndRecoveryKeystores, createIdentityKeystore, generateEncryptionKeys, generateIdentityKeys, generateRecoveryCodes, openEncryptionKeystore, openIdentityKeystore, openRecoveryKeystore };
-//# sourceMappingURL=keystore-crypto.mjs.map
-//# sourceMappingURL=keystore-crypto.mjs.map
+import "./utils-DS04iUcX.mjs";
+import "./hash-CXeGAwai.mjs";
+import "./symmetric-crypto-CrdS1Che.mjs";
+import "./derive-key-Be7hS-cN.mjs";
+import "./post-quantum-crypto-Vv34t6gX.mjs";
+import "./email-crypto-DJUEjTxA.mjs";
+import { i as openRecoveryKeystore, n as createEncryptionAndRecoveryKeystores, r as openEncryptionKeystore } from "./keystore-crypto-Bjgriq9h.mjs";
+
+export { createEncryptionAndRecoveryKeystores, openEncryptionKeystore, openRecoveryKeystore };

package/dist/keystore-service.d.mts

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