favalib 0.0.11 → 0.0.13

package/build/subclasses/LibraryLoader.mjs

@@ -1,4 +1,4 @@
-import { InitializationError, TwoFALibError } from '../TwoFALibError.mjs';
+import { InitializationError } from '../TwoFALibError.mjs';
 /**
  * Class responsible for loading various external (big) libraries required by the application.
  * All libraries (except CryptoLib) are loaded on demand. This helps to reduce the initial bundle size.
@@ -6,14 +6,15 @@ import { InitializationError, TwoFALibError } from '../TwoFALibError.mjs';
 class LibraryLoader {
     /**
      * Constructs a new instance of LibraryLoader.
-     * @param cryptoLib - An instance of CryptoLib that is required for library operations.
-     * @throws {InitializationError} If the provided CryptoLib instance is invalid.
+     * @param platformProviders - Platform-specific providers containing CryptoLib and other providers.
+     * @throws {InitializationError} If the provided platform providers are invalid.
      */
-    constructor(cryptoLib) {
-        if (!cryptoLib) {
-            throw new InitializationError('CryptoLib is required');
+    constructor(platformProviders) {
+        if (!platformProviders?.CryptoLib) {
+            throw new InitializationError('PlatformProviders with CryptoLib is required');
         }
-        this.cryptoLib = cryptoLib;
+        this.platformProviders = platformProviders;
+        this.cryptoLib = new platformProviders.CryptoLib();
     }
     /**
      * @returns The CryptoLib instance.
@@ -21,28 +22,26 @@ class LibraryLoader {
     getCryptoLib() {
         return this.cryptoLib;
     }
+    /**
+     * @returns The PlatformProviders instance.
+     */
+    getPlatformProviders() {
+        return this.platformProviders;
+    }
     /**
      * Loads and returns the OpenPGP library on demand.
      * @returns A promise that resolves to the OpenPGP library.
      */
-    async getOpenPGPLib() {
-        if (!this.openPgpLib) {
-            const module = await import('openpgp');
-            // enable Authenticated Encryption with Associated Data
-            module.config.aeadProtect = true;
-            this.openPgpLib = module;
-        }
+    getOpenPGPLib() {
+        this.openPgpLib ??= new this.platformProviders.OpenPgpLib();
         return this.openPgpLib;
     }
     /**
      * Loads and returns the QR Generator library on demand.
      * @returns A promise that resolves to the QR Generator library.
      */
-    async getQrGeneratorLib() {
-        if (!this.qrGeneratorLib) {
-            const module = await import('qrcode');
-            this.qrGeneratorLib = module.default;
-        }
+    getQrGeneratorLib() {
+        this.qrGeneratorLib ??= new this.platformProviders.QrCodeLib();
         return this.qrGeneratorLib;
     }
     /**
@@ -56,21 +55,6 @@ class LibraryLoader {
         }
         return this.jsQrLib;
     }
-    /**
-     * Loads and returns the Canvas library on demand.
-     * @returns A promise that resolves to the Canvas library.
-     * @throws {TwoFALibError} If the library cannot be loaded in a browser environment.
-     */
-    async getCanvasLib() {
-        if (typeof window !== 'undefined') {
-            throw new TwoFALibError('Canvas lib can not be loaded in browser env');
-        }
-        if (!this.canvasLib) {
-            const module = await import('canvas');
-            this.canvasLib = module.default;
-        }
-        return this.canvasLib;
-    }
     /**
      * Loads and returns the URL Parser library on demand.
      * @returns A promise that resolves to the URL Parser library.
@@ -82,6 +66,14 @@ class LibraryLoader {
         }
         return this.urlParserLib;
     }
+    /**
+     * Loads and returns the WebSocket library on demand.
+     * @returns The WebSocket library.
+     */
+    getWebSocketLib() {
+        this.webSocketLib ??= this.platformProviders.WebSocketLib();
+        return this.webSocketLib;
+    }
     /**
      * Loads and returns the Zxcvbn library on demand.
      * @returns A promise that resolves to the Zxcvbn library.

package/build/subclasses/PersistentStorageManager.d.mts

@@ -1,8 +1,8 @@
-import type { EncryptedPrivateKey, EncryptedSymmetricKey, Passphrase, PrivateKey, Salt, SymmetricKey } from '../interfaces/CryptoLib.mjs';
+import type { EncryptedPrivateKey, EncryptedSymmetricKey, Password, PrivateKey, Salt, SymmetricKey } from '../interfaces/CryptoLib.mjs';
 import { EncryptedVaultStateString, LockedRepresentationString } from '../interfaces/Vault.mjs';
 import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
 import type { FavaMeta } from '../interfaces/FavaMeta.mjs';
-import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
+import type { PasswordExtraDict } from '../interfaces/PasswordExtraDict.js';
 import type { SaveFunction } from '../interfaces/SaveFunction.mjs';
 import type { DeviceId } from '../interfaces/SyncTypes.mjs';
 /**
@@ -10,7 +10,7 @@ import type { DeviceId } from '../interfaces/SyncTypes.mjs';
  */
 declare class PersistentStorageManager {
     private mediator;
-    private readonly passphraseExtraDict;
+    private readonly passwordExtraDict;
     private readonly favaMeta;
     private readonly privateKey;
     private readonly symmetricKey;
@@ -23,7 +23,7 @@ declare class PersistentStorageManager {
     /**
      * Constructs a new instance of PersistentStorageManager.
      * @param mediator - The mediator for accessing other components.
-     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     * @param passwordExtraDict - Additional words to be used for password strength evaluation.
      * @param favaMeta - Meta info containing at least a unique identifier for this device.
      * @param privateKey - The private key used for cryptographic operations.
      * @param symmetricKey - The symmetric key used for cryptographic operations.
@@ -32,7 +32,7 @@ declare class PersistentStorageManager {
      * @param salt - The salt used for key derivation.
      * @param saveFunction - The function to save the data.
      */
-    constructor(mediator: TwoFaLibMediator, passphraseExtraDict: PassphraseExtraDict, favaMeta: FavaMeta, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, saveFunction?: SaveFunction | undefined);
+    constructor(mediator: TwoFaLibMediator, passwordExtraDict: PasswordExtraDict, favaMeta: FavaMeta, privateKey: PrivateKey, symmetricKey: SymmetricKey, encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, saveFunction?: SaveFunction | undefined);
     private get cryptoLib();
     private get vaultDataManager();
     private get syncManager();
@@ -46,7 +46,7 @@ declare class PersistentStorageManager {
     getEncryptedVaultState(key?: SymmetricKey, forDeviceId?: DeviceId): Promise<EncryptedVaultStateString>;
     /**
      * Creates a partially encrypted representation of all data, except for
-     * the passphrase, that is needed to load the library. This can be used
+     * the password, that is needed to load the library. This can be used
      * for secure storage of the library's data.
      * @returns A promise that resolves with a json encoded string of
      * the partially encrypted library's data.
@@ -67,19 +67,19 @@ declare class PersistentStorageManager {
      */
     private performSave;
     /**
-     * Validates the provided passphrase against the current library passphrase.
+     * Validates the provided password against the current library password.
      * @param salt - The salt used for key derivation.
-     * @param passphrase - The passphrase to validate.
-     * @returns A promise that resolves with a boolean indicating whether the passphrase is valid.
+     * @param password - The password to validate.
+     * @returns A promise that resolves with a boolean indicating whether the password is valid.
      */
-    validatePassphrase(salt: Salt, passphrase: Passphrase): Promise<boolean>;
+    validatePassword(salt: Salt, password: Password): Promise<boolean>;
     /**
-     * Changes the library's passphrase.
-     * @param oldPassphrase - The current passphrase.
-     * @param newPassphrase - The new passphrase to set.
-     * @returns A promise that resolves when the passphrase change is complete.
-     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
+     * Changes the library's password.
+     * @param oldPassword - The current password.
+     * @param newPassword - The new password to set.
+     * @returns A promise that resolves when the password change is complete.
+     * @throws {AuthenticationError} If the provided old password is incorrect.
      */
-    changePassphrase(oldPassphrase: Passphrase, newPassphrase: Passphrase): Promise<void>;
+    changePassword(oldPassword: Password, newPassword: Password): Promise<void>;
 }
 export default PersistentStorageManager;

package/build/subclasses/PersistentStorageManager.mjs

@@ -1,6 +1,6 @@
 import { AuthenticationError } from '../TwoFALibError.mjs';
 import TwoFaLib from '../TwoFaLib.mjs';
-import { validatePassphraseStrength } from '../utils/creationUtils.mjs';
+import { validatePasswordStrength } from '../utils/creationUtils.mjs';
 /**
  * Manages all storage of data that should be persistent.
  */
@@ -9,7 +9,7 @@ class PersistentStorageManager {
     /**
      * Constructs a new instance of PersistentStorageManager.
      * @param mediator - The mediator for accessing other components.
-     * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+     * @param passwordExtraDict - Additional words to be used for password strength evaluation.
      * @param favaMeta - Meta info containing at least a unique identifier for this device.
      * @param privateKey - The private key used for cryptographic operations.
      * @param symmetricKey - The symmetric key used for cryptographic operations.
@@ -18,9 +18,9 @@ class PersistentStorageManager {
      * @param salt - The salt used for key derivation.
      * @param saveFunction - The function to save the data.
      */
-    constructor(mediator, passphraseExtraDict, favaMeta, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, saveFunction) {
+    constructor(mediator, passwordExtraDict, favaMeta, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, saveFunction) {
         this.mediator = mediator;
-        this.passphraseExtraDict = passphraseExtraDict;
+        this.passwordExtraDict = passwordExtraDict;
         this.favaMeta = favaMeta;
         this.privateKey = privateKey;
         this.symmetricKey = symmetricKey;
@@ -67,7 +67,7 @@ class PersistentStorageManager {
     }
     /**
      * Creates a partially encrypted representation of all data, except for
-     * the passphrase, that is needed to load the library. This can be used
+     * the password, that is needed to load the library. This can be used
      * for secure storage of the library's data.
      * @returns A promise that resolves with a json encoded string of
      * the partially encrypted library's data.
@@ -122,14 +122,14 @@ class PersistentStorageManager {
         await this.saveFunction(lockedRepresentation);
     }
     /**
-     * Validates the provided passphrase against the current library passphrase.
+     * Validates the provided password against the current library password.
      * @param salt - The salt used for key derivation.
-     * @param passphrase - The passphrase to validate.
-     * @returns A promise that resolves with a boolean indicating whether the passphrase is valid.
+     * @param password - The password to validate.
+     * @returns A promise that resolves with a boolean indicating whether the password is valid.
      */
-    async validatePassphrase(salt, passphrase) {
+    async validatePassword(salt, password) {
         try {
-            await this.cryptoLib.decryptKeys(this.encryptedPrivateKey, this.encryptedSymmetricKey, salt, passphrase);
+            await this.cryptoLib.decryptKeys(this.encryptedPrivateKey, this.encryptedSymmetricKey, salt, password);
             return true;
         }
         catch {
@@ -137,18 +137,18 @@ class PersistentStorageManager {
         }
     }
     /**
-     * Changes the library's passphrase.
-     * @param oldPassphrase - The current passphrase.
-     * @param newPassphrase - The new passphrase to set.
-     * @returns A promise that resolves when the passphrase change is complete.
-     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
+     * Changes the library's password.
+     * @param oldPassword - The current password.
+     * @param newPassword - The new password to set.
+     * @returns A promise that resolves when the password change is complete.
+     * @throws {AuthenticationError} If the provided old password is incorrect.
      */
-    async changePassphrase(oldPassphrase, newPassphrase) {
-        await validatePassphraseStrength(this.mediator.getComponent('libraryLoader'), newPassphrase, this.passphraseExtraDict);
-        const isValid = await this.validatePassphrase(this.salt, oldPassphrase);
+    async changePassword(oldPassword, newPassword) {
+        await validatePasswordStrength(this.mediator.getComponent('libraryLoader'), newPassword, this.passwordExtraDict);
+        const isValid = await this.validatePassword(this.salt, oldPassword);
         if (!isValid)
-            throw new AuthenticationError('Invalid old passphrase');
-        const { encryptedPrivateKey: newEncryptedPrivateKey, encryptedSymmetricKey: newEncryptedSymmetricKey, } = await this.cryptoLib.encryptKeys(this.privateKey, this.symmetricKey, this.salt, newPassphrase);
+            throw new AuthenticationError('Invalid old password');
+        const { encryptedPrivateKey: newEncryptedPrivateKey, encryptedSymmetricKey: newEncryptedSymmetricKey, } = await this.cryptoLib.encryptKeys(this.privateKey, this.symmetricKey, this.salt, newPassword);
         this.encryptedPrivateKey = newEncryptedPrivateKey;
         this.encryptedSymmetricKey = newEncryptedSymmetricKey;
         await this.save();

package/build/subclasses/StorageOperationsManager.d.mts

@@ -1,5 +1,5 @@
 import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
-import type { Passphrase } from '../interfaces/CryptoLib.mjs';
+import type { Password } from '../interfaces/CryptoLib.mjs';
 import type { SaveFunction } from '../interfaces/SaveFunction.mjs';
 /**
  * Manages the public operations related to the vault storage
@@ -21,13 +21,13 @@ declare class StorageOperationsManager {
      */
     forceSave(): Promise<void>;
     /**
-     * Changes the library's passphrase.
-     * @param oldPassphrase - The current passphrase.
-     * @param newPassphrase - The new passphrase to set.
-     * @returns A promise that resolves when the passphrase change is complete.
-     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
+     * Changes the library's password.
+     * @param oldPassword - The current password.
+     * @param newPassword - The new password to set.
+     * @returns A promise that resolves when the password change is complete.
+     * @throws {AuthenticationError} If the provided old password is incorrect.
      */
-    changePassphrase(oldPassphrase: Passphrase, newPassphrase: Passphrase): Promise<void>;
+    changePassword(oldPassword: Password, newPassword: Password): Promise<void>;
     /**
      * Sets the save function for the library.
      * @param saveFunction - The save function to set.

package/build/subclasses/StorageOperationsManager.mjs

@@ -23,14 +23,14 @@ class StorageOperationsManager {
         return this.persistentStorage.save();
     }
     /**
-     * Changes the library's passphrase.
-     * @param oldPassphrase - The current passphrase.
-     * @param newPassphrase - The new passphrase to set.
-     * @returns A promise that resolves when the passphrase change is complete.
-     * @throws {AuthenticationError} If the provided old passphrase is incorrect.
+     * Changes the library's password.
+     * @param oldPassword - The current password.
+     * @param newPassword - The new password to set.
+     * @returns A promise that resolves when the password change is complete.
+     * @throws {AuthenticationError} If the provided old password is incorrect.
      */
-    async changePassphrase(oldPassphrase, newPassphrase) {
-        return this.persistentStorage.changePassphrase(oldPassphrase, newPassphrase);
+    async changePassword(oldPassword, newPassword) {
+        return this.persistentStorage.changePassword(oldPassword, newPassword);
     }
     /**
      * Sets the save function for the library.

package/build/subclasses/SyncManager.mjs

@@ -141,12 +141,13 @@ class SyncManager {
      * Initializes the WebSocket connection to the server.
      */
     initServerConnection() {
-        const ws = new WebSocket(this.serverUrl);
+        const WebSocketLib = this.libraryLoader.getWebSocketLib();
+        const ws = new WebSocketLib(this.serverUrl);
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const syncManager = this;
-        ws.addEventListener('error', (event) => {
-            // eslint-disable-next-line @typescript-eslint/no-base-to-string
-            syncManager.log('warning', `Error in websocket: ${event.toString()}`);
+        ws.addEventListener('error', () => {
+            // no error information seems to be available...
+            syncManager.log('warning', `Error in websocket.`);
         });
         ws.addEventListener('message', function message(message) {
             try {
@@ -326,7 +327,7 @@ class SyncManager {
         };
         let returnQr = null;
         if (returnAs.qr) {
-            const qrGeneratorLib = await this.libraryLoader.getQrGeneratorLib();
+            const qrGeneratorLib = this.libraryLoader.getQrGeneratorLib();
             returnQr = await qrGeneratorLib.toDataURL(JSON.stringify(returnData));
         }
         const returnText = returnAs.text
@@ -352,7 +353,7 @@ class SyncManager {
         if (this.activeAddDeviceFlow) {
             throw new SyncAddDeviceFlowConflictError();
         }
-        const { addDevicePassword, initiatorDeviceId, timestamp, pass1Result } = await decodeInitiatorData(initiatorData, initiatorDataType, await this.libraryLoader.getJsQrLib(), this.libraryLoader.getCanvasLib.bind(this));
+        const { addDevicePassword, initiatorDeviceId, timestamp, pass1Result } = await decodeInitiatorData(initiatorData, initiatorDataType, await this.libraryLoader.getJsQrLib(), this.libraryLoader.getQrGeneratorLib());
         if (!addDevicePassword ||
             !initiatorDeviceId ||
             !timestamp ||

package/build/utils/creationUtils.d.mts

@@ -1,45 +1,45 @@
 import type { ZxcvbnResult } from '@zxcvbn-ts/core';
-import type CryptoLib from '../interfaces/CryptoLib.mjs';
-import type { Passphrase } from '../interfaces/CryptoLib.mjs';
+import type { PlatformProviders } from '../interfaces/PlatformProviders.mjs';
+import type { Password } from '../interfaces/CryptoLib.mjs';
 import type { DeviceType } from '../interfaces/SyncTypes.mjs';
 import TwoFaLib from '../TwoFaLib.mjs';
 import LibraryLoader from '../subclasses/LibraryLoader.mjs';
 import type { LockedRepresentationString } from '../interfaces/Vault.mjs';
-import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
+import type { PasswordExtraDict } from '../interfaces/PasswordExtraDict.js';
 import { SaveFunction } from '../interfaces/SaveFunction.mjs';
 /**
- * Evaluates the strength of a passphrase.
+ * Evaluates the strength of a password.
  * @param libraryLoader - An instance of LibraryLoader.
- * @param passphrase - The passphrase to evaluate.
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
- * @returns Promise resolving to the passphrase strength result.
+ * @param password - The password to evaluate.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
+ * @returns Promise resolving to the password strength result.
  */
-export declare const getPassphraseStrength: (libraryLoader: LibraryLoader, passphrase: Passphrase, passphraseExtraDict: PassphraseExtraDict) => Promise<ZxcvbnResult>;
+export declare const getPasswordStrength: (libraryLoader: LibraryLoader, password: Password, passwordExtraDict: PasswordExtraDict) => Promise<ZxcvbnResult>;
 /**
- * Validates the strength of a passphrase.
+ * Validates the strength of a password.
  * @param libraryLoader - An instance of LibraryLoader.
- * @param passphrase - The passphrase to validate.
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
- * @throws {InitializationError} If the passphrase is too weak.
+ * @param password - The password to validate.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
+ * @throws {InitializationError} If the password is too weak.
  */
-export declare const validatePassphraseStrength: (libraryLoader: LibraryLoader, passphrase: Passphrase, passphraseExtraDict: PassphraseExtraDict) => Promise<void>;
+export declare const validatePasswordStrength: (libraryLoader: LibraryLoader, password: Password, passwordExtraDict: PasswordExtraDict) => Promise<void>;
 /**
  * Returns utility functions useful in creating a new twoFaLib vault
- * @param cryptoLib - An instance of CryptoLib that is compatible with the environment.
+ * @param platformProviders - The platform-specific providers containing CryptoLib and other providers.
  * @param deviceType - A unique identifier for this device type (e.g. 2fa-cli).
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
  * @param saveFunction - The function to save the data.
  * @param serverUrl - The server URL for syncing.
- * @returns An object with methods to evaluate passphrase strength and create a new TwoFaLib vault.
+ * @returns An object with methods to evaluate password strength and create a new TwoFaLib vault.
  */
-export declare const getTwoFaLibVaultCreationUtils: (cryptoLib: CryptoLib, deviceType: DeviceType, passphraseExtraDict: PassphraseExtraDict, saveFunction?: SaveFunction, serverUrl?: string) => {
-    getPassphraseStrength: (passphrase: Passphrase, passphraseExtraDict: PassphraseExtraDict) => Promise<ZxcvbnResult>;
-    createNewTwoFaLibVault: (passphrase: Passphrase) => Promise<{
+export declare const getTwoFaLibVaultCreationUtils: (platformProviders: PlatformProviders, deviceType: DeviceType, passwordExtraDict: PasswordExtraDict, saveFunction?: SaveFunction, serverUrl?: string) => {
+    getPasswordStrength: (password: Password, passwordExtraDict: PasswordExtraDict) => Promise<ZxcvbnResult>;
+    createNewTwoFaLibVault: (password: Password) => Promise<{
         twoFaLib: TwoFaLib;
         publicKey: import("../interfaces/CryptoLib.mjs").PublicKey;
         encryptedPrivateKey: import("../interfaces/CryptoLib.mjs").EncryptedPrivateKey;
         encryptedSymmetricKey: import("../interfaces/CryptoLib.mjs").EncryptedSymmetricKey;
         salt: import("../interfaces/CryptoLib.mjs").Salt;
     }>;
-    loadTwoFaLibFromLockedRepesentation: (lockedRepresentationString: LockedRepresentationString, passphrase: Passphrase) => Promise<TwoFaLib>;
+    loadTwoFaLibFromLockedRepesentation: (lockedRepresentationString: LockedRepresentationString, password: Password) => Promise<TwoFaLib>;
 };

package/build/utils/creationUtils.mjs

@@ -3,15 +3,15 @@ import TwoFaLib from '../TwoFaLib.mjs';
 import { InitializationError, TwoFALibError } from '../TwoFALibError.mjs';
 import LibraryLoader from '../subclasses/LibraryLoader.mjs';
 /**
- * Evaluates the strength of a passphrase.
+ * Evaluates the strength of a password.
  * @param libraryLoader - An instance of LibraryLoader.
- * @param passphrase - The passphrase to evaluate.
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
- * @returns Promise resolving to the passphrase strength result.
+ * @param password - The password to evaluate.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
+ * @returns Promise resolving to the password strength result.
  */
-export const getPassphraseStrength = async (libraryLoader, passphrase, passphraseExtraDict) => {
+export const getPasswordStrength = async (libraryLoader, password, passwordExtraDict) => {
     const zxcvbn = await libraryLoader.getZxcvbn();
-    return zxcvbn(passphrase, [
+    return zxcvbn(password, [
         'twofactor',
         'authentication',
         'token',
@@ -34,20 +34,20 @@ export const getPassphraseStrength = async (libraryLoader, passphrase, passphras
         'key',
         'trust',
         'secure',
-        ...passphraseExtraDict,
+        ...passwordExtraDict,
     ]);
 };
 /**
- * Validates the strength of a passphrase.
+ * Validates the strength of a password.
  * @param libraryLoader - An instance of LibraryLoader.
- * @param passphrase - The passphrase to validate.
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
- * @throws {InitializationError} If the passphrase is too weak.
+ * @param password - The password to validate.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
+ * @throws {InitializationError} If the password is too weak.
  */
-export const validatePassphraseStrength = async (libraryLoader, passphrase, passphraseExtraDict) => {
-    const passphraseStrength = await getPassphraseStrength(libraryLoader, passphrase, passphraseExtraDict);
-    if (passphraseStrength.score < 3) {
-        throw new TwoFALibError('Passphrase is too weak');
+export const validatePasswordStrength = async (libraryLoader, password, passwordExtraDict) => {
+    const passwordStrength = await getPasswordStrength(libraryLoader, password, passwordExtraDict);
+    if (passwordStrength.score < 3) {
+        throw new TwoFALibError('Password is too weak');
     }
 };
 /**
@@ -55,17 +55,18 @@ export const validatePassphraseStrength = async (libraryLoader, passphrase, pass
  * @param libraryLoader - An instance of LibraryLoader.
  * @param deviceType - A unique identifier for the device type e.g. 2fa-cli.
  * @param serverUrl - The server URL for syncing.
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
  * @param saveFunction - The function to save the data.
- * @param passphrase - The passphrase to be used to encrypt the private key.
+ * @param password - The password to be used to encrypt the private key.
  * @returns Promise resolving to an object containing the newly created TwoFaLib instance and related data.
  */
-const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, passphraseExtraDict, saveFunction, passphrase) => {
+const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, passwordExtraDict, saveFunction, password) => {
     const cryptoLib = libraryLoader.getCryptoLib();
-    const { publicKey, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, } = await cryptoLib.createKeys(passphrase);
-    await validatePassphraseStrength(libraryLoader, passphrase, passphraseExtraDict);
+    const platformProviders = libraryLoader.getPlatformProviders();
+    const { publicKey, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, } = await cryptoLib.createKeys(password);
+    await validatePasswordStrength(libraryLoader, password, passwordExtraDict);
     const deviceId = genUuidV4();
-    const twoFaLib = new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, {
+    const twoFaLib = new TwoFaLib(deviceType, platformProviders, passwordExtraDict, privateKey, symmetricKey, encryptedPrivateKey, encryptedSymmetricKey, salt, publicKey, {
         deviceId,
     }, [], saveFunction, {
         serverUrl,
@@ -84,15 +85,16 @@ const createNewTwoFaLibVault = async (libraryLoader, deviceType, serverUrl, pass
  * Loads the library state from a previously locked representation.
  * @param libraryLoader - An instance of LibraryLoader.
  * @param deviceType - A unique identifier for this device type (e.g. 2fa-cli).
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
  * @param saveFunction - The function to save the data.
  * @param lockedRepresentationString - The string representation of the locked library state representation.
- * @param passphrase - The passphrase for decrypting the keys.
+ * @param password - The password for decrypting the keys.
  * @returns A promise that resolves when loading is complete.
  * @throws {InitializationError} If loading fails due to invalid or corrupted data.
  */
-const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, passphraseExtraDict, saveFunction, lockedRepresentationString, passphrase) => {
+const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, passwordExtraDict, saveFunction, lockedRepresentationString, password) => {
     const cryptoLib = libraryLoader.getCryptoLib();
+    const platformProviders = libraryLoader.getPlatformProviders();
     const lockedRepresentation = JSON.parse(lockedRepresentationString);
     if (!lockedRepresentation ||
         !lockedRepresentation.encryptedPrivateKey ||
@@ -101,7 +103,7 @@ const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, pa
         !lockedRepresentation.encryptedVaultState) {
         throw new InitializationError('lockedRepresentation is incomplete or corrupted');
     }
-    const { privateKey, symmetricKey, publicKey } = await cryptoLib.decryptKeys(lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, passphrase);
+    const { privateKey, symmetricKey, publicKey } = await cryptoLib.decryptKeys(lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, password);
     const vaultState = JSON.parse(await cryptoLib.decryptSymmetric(symmetricKey, lockedRepresentation.encryptedVaultState));
     if (!vaultState ||
         !vaultState.deviceId ||
@@ -109,25 +111,25 @@ const loadTwoFaLibFromLockedRepesentation = async (libraryLoader, deviceType, pa
         !vaultState.sync?.devices) {
         throw new InitializationError('encryptedVaultState is incomplete or corrupted');
     }
-    return new TwoFaLib(deviceType, cryptoLib, passphraseExtraDict, privateKey, symmetricKey, lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, publicKey, {
+    return new TwoFaLib(deviceType, platformProviders, passwordExtraDict, privateKey, symmetricKey, lockedRepresentation.encryptedPrivateKey, lockedRepresentation.encryptedSymmetricKey, lockedRepresentation.salt, publicKey, {
         deviceId: vaultState.deviceId,
         deviceFriendlyName: vaultState.deviceFriendlyName,
     }, vaultState.vault, saveFunction, vaultState.sync);
 };
 /**
  * Returns utility functions useful in creating a new twoFaLib vault
- * @param cryptoLib - An instance of CryptoLib that is compatible with the environment.
+ * @param platformProviders - The platform-specific providers containing CryptoLib and other providers.
  * @param deviceType - A unique identifier for this device type (e.g. 2fa-cli).
- * @param passphraseExtraDict - Additional words to be used for passphrase strength evaluation.
+ * @param passwordExtraDict - Additional words to be used for password strength evaluation.
  * @param saveFunction - The function to save the data.
  * @param serverUrl - The server URL for syncing.
- * @returns An object with methods to evaluate passphrase strength and create a new TwoFaLib vault.
+ * @returns An object with methods to evaluate password strength and create a new TwoFaLib vault.
  */
-export const getTwoFaLibVaultCreationUtils = (cryptoLib, deviceType, passphraseExtraDict, saveFunction, serverUrl) => {
-    const libraryLoader = new LibraryLoader(cryptoLib);
+export const getTwoFaLibVaultCreationUtils = (platformProviders, deviceType, passwordExtraDict, saveFunction, serverUrl) => {
+    const libraryLoader = new LibraryLoader(platformProviders);
     return {
-        getPassphraseStrength: getPassphraseStrength.bind(null, libraryLoader),
-        createNewTwoFaLibVault: createNewTwoFaLibVault.bind(null, libraryLoader, deviceType, serverUrl, passphraseExtraDict, saveFunction),
-        loadTwoFaLibFromLockedRepesentation: loadTwoFaLibFromLockedRepesentation.bind(null, libraryLoader, deviceType, passphraseExtraDict, saveFunction),
+        getPasswordStrength: getPasswordStrength.bind(null, libraryLoader),
+        createNewTwoFaLibVault: createNewTwoFaLibVault.bind(null, libraryLoader, deviceType, serverUrl, passwordExtraDict, saveFunction),
+        loadTwoFaLibFromLockedRepesentation: loadTwoFaLibFromLockedRepesentation.bind(null, libraryLoader, deviceType, passwordExtraDict, saveFunction),
     };
 };

package/build/utils/exportImportUtils.d.mts

@@ -1,6 +1,8 @@
 import type { NewEntry } from '../interfaces/Entry.mjs';
 import type Entry from '../interfaces/Entry.mjs';
 import type { EntryId } from '../interfaces/Entry.mjs';
+import type { QrCodeLib } from '../interfaces/QrCodeLib.mjs';
+import type { OpenPgpLib } from '../interfaces/OpenPgpLib.mjs';
 /**
  * Parses an OTP URI and extracts the relevant information to create a new entry.
  * @param UrlParser - The URL parsing library.
@@ -15,7 +17,7 @@ export declare const parseOtpUri: (UrlParser: typeof import("whatwg-url"), otpUr
  * @param entries - An array of OTP entries.
  * @returns A promise that resolves to the HTML string.
  */
-export declare const generateHtmlExport: (qrGeneratorLib: typeof import("qrcode"), entries: Entry[]) => Promise<string>;
+export declare const generateHtmlExport: (qrGeneratorLib: QrCodeLib, entries: Entry[]) => Promise<string>;
 /**
  * Generates a text export of OTP URIs for the provided entries.
  * @param entries - An array of OTP entries.
@@ -42,7 +44,7 @@ export declare const processImportLines: (lines: string[], importFromUri: (uri:
  * @param password - The password to use for encryption.
  * @returns A promise that resolves to the encrypted data.
  */
-export declare const encryptExport: (openPgpLib: typeof import("openpgp"), data: string, password: string) => Promise<string>;
+export declare const encryptExport: (openPgpLib: OpenPgpLib, data: string, password: string) => Promise<string>;
 /**
  * Decrypts the given data using OpenPGP.
  * @param openPgpLib - The OpenPGP library.
@@ -50,4 +52,4 @@ export declare const encryptExport: (openPgpLib: typeof import("openpgp"), data:
  * @param password - The password to use for decryption.
  * @returns A promise that resolves to the decrypted data.
  */
-export declare const decryptExport: (openPgpLib: typeof import("openpgp"), data: string, password: string) => Promise<string>;
+export declare const decryptExport: (openPgpLib: OpenPgpLib, data: string, password: string) => Promise<string>;

package/build/utils/exportImportUtils.mjs

@@ -162,13 +162,7 @@ export const processImportLines = async (lines, importFromUri) => {
  * @returns A promise that resolves to the encrypted data.
  */
 export const encryptExport = async (openPgpLib, data, password) => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const encrypted = await openPgpLib.encrypt({
-        message: await openPgpLib.createMessage({ text: data }),
-        passwords: [password],
-        format: 'armored',
-    });
-    return encrypted;
+    return openPgpLib.encrypt(data, password);
 };
 /**
  * Decrypts the given data using OpenPGP.
@@ -178,9 +172,5 @@ export const encryptExport = async (openPgpLib, data, password) => {
  * @returns A promise that resolves to the decrypted data.
  */
 export const decryptExport = async (openPgpLib, data, password) => {
-    const decrypted = await openPgpLib.decrypt({
-        message: await openPgpLib.readMessage({ armoredMessage: data }),
-        passwords: [password],
-    });
-    return decrypted.data;
+    return openPgpLib.decrypt(data, password);
 };