favalib 0.0.11 → 0.0.13

package/build/platformProviders/browser/qrCodeLib.mjs

@@ -0,0 +1,69 @@
+import { TwoFALibError } from '../../TwoFALibError.mjs';
+/**
+ * Gets the ImageData from an image, for browser environments.
+ * This ImageData is then further processed to get QR codes.
+ * @param input - The image to get the ImageData from.
+ * @returns A promise that resolves to the ImageData.
+ */
+export const getImageDataFromInput = (input) => {
+    return new Promise((resolve, reject) => {
+        if (input instanceof Uint8Array) {
+            reject(new TwoFALibError('Uint8Array input not supported in browser environment'));
+            return;
+        }
+        const img = new Image();
+        img.onload = () => {
+            const canvas = document.createElement('canvas');
+            canvas.width = img.width;
+            canvas.height = img.height;
+            const ctx = canvas.getContext('2d');
+            if (!ctx) {
+                reject(new TwoFALibError('Could not create canvas context'));
+                return;
+            }
+            ctx.drawImage(img, 0, 0);
+            resolve(ctx.getImageData(0, 0, img.width, img.height));
+        };
+        img.onerror = () => reject(new TwoFALibError('Failed to load image'));
+        if (typeof input === 'string') {
+            // URL or Data URL
+            img.src = input;
+        }
+        else {
+            // File object
+            const reader = new FileReader();
+            reader.onload = (e) => {
+                img.src = e.target?.result;
+            };
+            reader.onerror = () => reject(new TwoFALibError('Failed to read file'));
+            reader.readAsDataURL(input);
+        }
+    });
+};
+/**
+ * Browser implementation of QR code library wrapper
+ */
+export class BrowserQrCodeLib {
+    constructor() {
+        this.qrCodeModule = null;
+        this.getImageDataFromInput = getImageDataFromInput;
+    }
+    /**
+     * Gets the QR code module, loading it if necessary
+     * @returns Promise that resolves to the QR code module
+     */
+    async getQrCodeModule() {
+        if (!this.qrCodeModule) {
+            const qrcode = await import('qrcode');
+            this.qrCodeModule = qrcode.default;
+        }
+        return this.qrCodeModule;
+    }
+    /**
+     * @inheritdoc
+     */
+    async toDataURL(text) {
+        const qrCode = await this.getQrCodeModule();
+        return qrCode.toDataURL(text);
+    }
+}

package/build/{CryptoProviders/node/index.d.mts → platformProviders/node/cryptoLib.d.mts}

@@ -1,5 +1,5 @@
 import type CryptoLib from '../../interfaces/CryptoLib.mjs';
-import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, Passphrase, PrivateKey, PublicKey, Salt, SymmetricKey, SyncKey } from '../../interfaces/CryptoLib.mjs';
+import type { Encrypted, EncryptedPrivateKey, EncryptedSymmetricKey, Password, PrivateKey, PublicKey, Salt, SymmetricKey, SyncKey } from '../../interfaces/CryptoLib.mjs';
 /**
  * @inheritdoc
  */
@@ -11,7 +11,7 @@ declare class NodeCryptoLib implements CryptoLib {
     /**
      * @inheritdoc
      */
-    createKeys(passphrase: Passphrase): Promise<{
+    createKeys(password: Password): Promise<{
         privateKey: PrivateKey;
         symmetricKey: SymmetricKey;
         publicKey: PublicKey;
@@ -22,14 +22,14 @@ declare class NodeCryptoLib implements CryptoLib {
     /**
      * @inheritdoc
      */
-    encryptKeys(privateKey: PrivateKey, symmetricKey: SymmetricKey, salt: Salt, passphrase: Passphrase): Promise<{
+    encryptKeys(privateKey: PrivateKey, symmetricKey: SymmetricKey, salt: Salt, password: Password): Promise<{
         encryptedPrivateKey: EncryptedPrivateKey;
         encryptedSymmetricKey: EncryptedSymmetricKey;
     }>;
     /**
      * @inheritdoc
      */
-    decryptKeys(encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, passphrase: Passphrase): Promise<{
+    decryptKeys(encryptedPrivateKey: EncryptedPrivateKey, encryptedSymmetricKey: EncryptedSymmetricKey, salt: Salt, password: Password): Promise<{
         privateKey: PrivateKey;
         publicKey: PublicKey;
         symmetricKey: SymmetricKey;

package/build/{CryptoProviders/node/index.mjs → platformProviders/node/cryptoLib.mjs}

@@ -4,7 +4,7 @@ import { generateKeyPair as generateKeyPairCb, generateKey as generateKeyCb, pub
 import { argon2id } from 'hash-wasm';
 import { toUint8Array } from 'uint8array-extras';
 import { CryptoError } from '../../TwoFALibError.mjs';
-import { generatePassphraseHash } from '../browser/index.mjs';
+import { generatePasswordHash } from '../browser/cryptoLib.mjs';
 const generateKeyPair = promisify(generateKeyPairCb);
 const generateKey = promisify(generateKeyCb);
 /**
@@ -20,11 +20,11 @@ class NodeCryptoLib {
     /**
      * @inheritdoc
      */
-    async createKeys(passphrase) {
+    async createKeys(password) {
         // create random salt
         const salt = randomBytes(16).toString('base64');
         // create passwordHash
-        const passphraseHash = await generatePassphraseHash(salt, passphrase);
+        const passwordHash = await generatePasswordHash(salt, password);
         // Generate public/private key pair
         const { publicKey, privateKey: encryptedPrivateKey } = await generateKeyPair('rsa', {
             modulusLength: 4096,
@@ -36,13 +36,13 @@ class NodeCryptoLib {
                 type: 'pkcs8',
                 format: 'pem',
                 cipher: 'aes-256-cbc',
-                passphrase: passphraseHash,
+                passphrase: passwordHash,
             },
         });
         // Create and encrypt symmetric key with public key
         const symmetricKey = await this.createSymmetricKey();
         const encryptedSymmetricKey = await this.encrypt(publicKey, symmetricKey);
-        const { privateKey } = await this.decryptKeys(encryptedPrivateKey, encryptedSymmetricKey, salt, passphrase);
+        const { privateKey } = await this.decryptKeys(encryptedPrivateKey, encryptedSymmetricKey, salt, password);
         return {
             privateKey: privateKey,
             symmetricKey,
@@ -55,9 +55,9 @@ class NodeCryptoLib {
     /**
      * @inheritdoc
      */
-    async encryptKeys(privateKey, symmetricKey, salt, passphrase) {
+    async encryptKeys(privateKey, symmetricKey, salt, password) {
         // recreate passwordHash
-        const passphraseHash = await generatePassphraseHash(salt, passphrase);
+        const passwordHash = await generatePasswordHash(salt, password);
         // Encrypt private key
         const privateKeyObject = createPrivateKey({
             key: privateKey,
@@ -67,7 +67,7 @@ class NodeCryptoLib {
             type: 'pkcs8',
             format: 'pem',
             cipher: 'aes-256-cbc',
-            passphrase: passphraseHash,
+            passphrase: passwordHash,
         });
         // Encrypt symmetric key with public key
         const publicKeyObject = createPublicKey(privateKeyObject);
@@ -84,9 +84,9 @@ class NodeCryptoLib {
     /**
      * @inheritdoc
      */
-    async decryptKeys(encryptedPrivateKey, encryptedSymmetricKey, salt, passphrase) {
+    async decryptKeys(encryptedPrivateKey, encryptedSymmetricKey, salt, password) {
         // recreate passwordHash
-        const passphraseHash = await generatePassphraseHash(salt, passphrase);
+        const passwordHash = await generatePasswordHash(salt, password);
         let privateKeyObject;
         let privateKey;
         try {
@@ -94,7 +94,7 @@ class NodeCryptoLib {
                 key: encryptedPrivateKey,
                 type: 'pkcs8',
                 format: 'pem',
-                passphrase: passphraseHash,
+                passphrase: passwordHash,
             });
             privateKey = privateKeyObject.export({
                 type: 'pkcs8',
@@ -105,7 +105,7 @@ class NodeCryptoLib {
             // eslint-disable-next-line no-restricted-globals
             if (err instanceof Error && 'code' in err) {
                 if (err.code === 'ERR_OSSL_BAD_DECRYPT') {
-                    throw new CryptoError('Invalid passphrase');
+                    throw new CryptoError('Invalid password');
                 }
                 if (err.code === 'ERR_OSSL_UNSUPPORTED') {
                     throw new CryptoError('Invalid private key');

package/build/platformProviders/node/index.d.mts

@@ -0,0 +1,6 @@
+import type { PlatformProviders } from '../../interfaces/PlatformProviders.mjs';
+/**
+ * Node.js-specific platform providers
+ */
+export declare const nodeProviders: PlatformProviders;
+export default nodeProviders;

package/build/platformProviders/node/index.mjs

@@ -0,0 +1,13 @@
+import NodeCryptoLib from './cryptoLib.mjs';
+import { NodeQrCodeLib } from './qrCodeLib.mjs';
+import { NodeOpenPgpLib } from './openPgpLib.mjs';
+/**
+ * Node.js-specific platform providers
+ */
+export const nodeProviders = {
+    CryptoLib: NodeCryptoLib,
+    WebSocketLib: () => WebSocket,
+    QrCodeLib: NodeQrCodeLib,
+    OpenPgpLib: NodeOpenPgpLib,
+};
+export default nodeProviders;

package/build/platformProviders/node/openPgpLib.d.mts

@@ -0,0 +1,20 @@
+import type { OpenPgpLib } from '../../interfaces/OpenPgpLib.mjs';
+/**
+ * Node.js implementation of OpenPGP library wrapper
+ */
+export declare class NodeOpenPgpLib implements OpenPgpLib {
+    private openPgpModule;
+    /**
+     * Gets the OpenPGP module, loading it if necessary
+     * @returns Promise that resolves to the OpenPGP module
+     */
+    private getOpenPgpModule;
+    /**
+     * @inheritdoc
+     */
+    encrypt(data: string, password: string): Promise<string>;
+    /**
+     * @inheritdoc
+     */
+    decrypt(data: string, password: string): Promise<string>;
+}

package/build/platformProviders/node/openPgpLib.mjs

@@ -0,0 +1,44 @@
+/**
+ * Node.js implementation of OpenPGP library wrapper
+ */
+export class NodeOpenPgpLib {
+    constructor() {
+        this.openPgpModule = null;
+    }
+    /**
+     * Gets the OpenPGP module, loading it if necessary
+     * @returns Promise that resolves to the OpenPGP module
+     */
+    async getOpenPgpModule() {
+        if (!this.openPgpModule) {
+            this.openPgpModule = await import('openpgp');
+            // enable Authenticated Encryption with Associated Data
+            this.openPgpModule.config.aeadProtect = true;
+        }
+        return this.openPgpModule;
+    }
+    /**
+     * @inheritdoc
+     */
+    async encrypt(data, password) {
+        const openPgp = await this.getOpenPgpModule();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const encrypted = await openPgp.encrypt({
+            message: await openPgp.createMessage({ text: data }),
+            passwords: [password],
+            format: 'armored',
+        });
+        return encrypted;
+    }
+    /**
+     * @inheritdoc
+     */
+    async decrypt(data, password) {
+        const openPgp = await this.getOpenPgpModule();
+        const decrypted = await openPgp.decrypt({
+            message: await openPgp.readMessage({ armoredMessage: data }),
+            passwords: [password],
+        });
+        return decrypted.data;
+    }
+}

package/build/platformProviders/node/qrCodeLib.d.mts

@@ -0,0 +1,28 @@
+import type { ImageData } from 'canvas';
+import type { QrCodeLib } from '../../interfaces/QrCodeLib.mjs';
+/**
+ * Gets the ImageData from an image, for Node.js environments.
+ * This ImageData is then further processed to get QR codes.
+ * @param inputImage - The image to get the ImageData from.
+ * @returns A promise that resolves to the ImageData.
+ */
+export declare const getImageDataFromInput: (inputImage: string | File | Uint8Array) => Promise<ImageData>;
+/**
+ * Node.js implementation of QR code library wrapper
+ */
+export declare class NodeQrCodeLib implements QrCodeLib {
+    private qrCodeModule;
+    /**
+     * Gets the QR code module, loading it if necessary
+     * @returns Promise that resolves to the QR code module
+     */
+    private getQrCodeModule;
+    /**
+     * @inheritdoc
+     */
+    toDataURL(text: string): Promise<string>;
+    /**
+     * @inheritdoc
+     */
+    getImageDataFromInput(imageInput: string | File | Uint8Array): Promise<ImageData>;
+}

package/build/platformProviders/node/qrCodeLib.mjs

@@ -0,0 +1,54 @@
+import { TwoFALibError } from '../../TwoFALibError.mjs';
+import { isUint8Array } from 'uint8array-extras';
+/**
+ * Gets the ImageData from an image, for Node.js environments.
+ * This ImageData is then further processed to get QR codes.
+ * @param inputImage - The image to get the ImageData from.
+ * @returns A promise that resolves to the ImageData.
+ */
+export const getImageDataFromInput = async (inputImage) => {
+    if (inputImage instanceof File) {
+        throw new TwoFALibError('Getting data from QR where image type is "File" is not supported in the node environment');
+    }
+    const canvasLib = await import('canvas');
+    const { createCanvas, loadImage } = canvasLib;
+    // eslint-disable-next-line no-restricted-globals
+    const input = isUint8Array(inputImage) ? Buffer.from(inputImage) : inputImage;
+    const image = await loadImage(input); // canvaslib expects a buffer
+    const canvas = createCanvas(image.width, image.height);
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(image, 0, 0);
+    return ctx.getImageData(0, 0, image.width, image.height);
+};
+/**
+ * Node.js implementation of QR code library wrapper
+ */
+export class NodeQrCodeLib {
+    constructor() {
+        this.qrCodeModule = null;
+    }
+    /**
+     * Gets the QR code module, loading it if necessary
+     * @returns Promise that resolves to the QR code module
+     */
+    async getQrCodeModule() {
+        if (!this.qrCodeModule) {
+            const qrcode = await import('qrcode');
+            this.qrCodeModule = qrcode.default;
+        }
+        return this.qrCodeModule;
+    }
+    /**
+     * @inheritdoc
+     */
+    async toDataURL(text) {
+        const qrCode = await this.getQrCodeModule();
+        return qrCode.toDataURL(text);
+    }
+    /**
+     * @inheritdoc
+     */
+    async getImageDataFromInput(imageInput) {
+        return getImageDataFromInput(imageInput);
+    }
+}

package/build/subclasses/ExportImportManager.d.mts

@@ -1,18 +1,18 @@
 import { EntryId } from '../interfaces/Entry.mjs';
-import type { PassphraseExtraDict } from '../interfaces/PassphraseExtraDict.js';
+import type { PasswordExtraDict } from '../interfaces/PasswordExtraDict.js';
 import type TwoFaLibMediator from '../TwoFaLibMediator.mjs';
 /**
  * Manages the export and import of entries in various formats.
  */
 declare class ExportImportManager {
     private readonly mediator;
-    private readonly passphraseExtraDict;
+    private readonly passwordExtraDict;
     /**
      * Constructs a new instance of ExportImportManager.
      * @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.
      */
-    constructor(mediator: TwoFaLibMediator, passphraseExtraDict: PassphraseExtraDict);
+    constructor(mediator: TwoFaLibMediator, passwordExtraDict: PasswordExtraDict);
     private get libraryLoader();
     private get vaultDataManager();
     private get vaultOperationsManager();
@@ -21,21 +21,21 @@ declare class ExportImportManager {
      * Export entries in the specified format, optionally (when a password is provided) encrypted.
      * If the password is not provided, the user be warned about the dangers of exporting clear text.
      * @param format - The export format ('text' or 'html').
-     * @param passphrase - Optional password for encryption.
+     * @param password - Optional password for encryption.
      * @param userWasWarnedAboutExportingClearText - Whether the user was warned about exporting clear text.
      * @returns A promise that resolves to the exported data as a string.
      */
-    exportEntries(format: 'text' | 'html', passphrase?: string, userWasWarnedAboutExportingClearText?: boolean): Promise<string>;
+    exportEntries(format: 'text' | 'html', password?: string, userWasWarnedAboutExportingClearText?: boolean): Promise<string>;
     private generateTextExport;
     private generateHtmlExport;
     /**
      * Import entries from a text file, optionally (when a password is provided) decrypt first
      * @param fileContents - The contents of the text file.
-     * @param passphrase - Optional password for decryption.
+     * @param password - Optional password for decryption.
      * @returns A promise that resolves to an array of objects, each containing the line number,
      *          the EntryId or null if it was not a valid entry and the error if there was one.
      */
-    importFromTextFile(fileContents: string, passphrase?: string): Promise<{
+    importFromTextFile(fileContents: string, password?: string): Promise<{
         lineNr: number;
         entryId: EntryId | null;
         error: unknown;

package/build/subclasses/ExportImportManager.mjs

@@ -1,7 +1,7 @@
 import { parseOtpUri, generateHtmlExport, generateTextExport, processImportLines, encryptExport, decryptExport, } from '../utils/exportImportUtils.mjs';
 import { getDataFromQRImage } from '../utils/qrUtils.mjs';
 import { ExportImportError } from '../TwoFALibError.mjs';
-import { validatePassphraseStrength } from '../utils/creationUtils.mjs';
+import { validatePasswordStrength } from '../utils/creationUtils.mjs';
 /**
  * Manages the export and import of entries in various formats.
  */
@@ -9,11 +9,11 @@ class ExportImportManager {
     /**
      * Constructs a new instance of ExportImportManager.
      * @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.
      */
-    constructor(mediator, passphraseExtraDict) {
+    constructor(mediator, passwordExtraDict) {
         this.mediator = mediator;
-        this.passphraseExtraDict = passphraseExtraDict;
+        this.passwordExtraDict = passwordExtraDict;
     }
     get libraryLoader() {
         return this.mediator.getComponent('libraryLoader');
@@ -31,13 +31,13 @@ class ExportImportManager {
      * Export entries in the specified format, optionally (when a password is provided) encrypted.
      * If the password is not provided, the user be warned about the dangers of exporting clear text.
      * @param format - The export format ('text' or 'html').
-     * @param passphrase - Optional password for encryption.
+     * @param password - Optional password for encryption.
      * @param userWasWarnedAboutExportingClearText - Whether the user was warned about exporting clear text.
      * @returns A promise that resolves to the exported data as a string.
      */
-    async exportEntries(format, passphrase, userWasWarnedAboutExportingClearText) {
+    async exportEntries(format, password, userWasWarnedAboutExportingClearText) {
         let exportData;
-        if (!passphrase && !userWasWarnedAboutExportingClearText) {
+        if (!password && !userWasWarnedAboutExportingClearText) {
             throw new ExportImportError('User was not warned about the dangers of unencrypted exporting');
         }
         if (format === 'text') {
@@ -49,9 +49,9 @@ class ExportImportManager {
         else {
             throw new ExportImportError('Invalid export format');
         }
-        if (passphrase) {
-            await validatePassphraseStrength(this.libraryLoader, passphrase, this.passphraseExtraDict);
-            return encryptExport(await this.libraryLoader.getOpenPGPLib(), exportData, passphrase);
+        if (password) {
+            await validatePasswordStrength(this.libraryLoader, password, this.passwordExtraDict);
+            return encryptExport(this.libraryLoader.getOpenPGPLib(), exportData, password);
         }
         return exportData;
     }
@@ -59,19 +59,19 @@ class ExportImportManager {
         return generateTextExport(this.vaultDataManager.getAllEntries());
     }
     async generateHtmlExport() {
-        const qrGeneratorLib = await this.libraryLoader.getQrGeneratorLib();
+        const qrGeneratorLib = this.libraryLoader.getQrGeneratorLib();
         return generateHtmlExport(qrGeneratorLib, this.vaultDataManager.getAllEntries());
     }
     /**
      * Import entries from a text file, optionally (when a password is provided) decrypt first
      * @param fileContents - The contents of the text file.
-     * @param passphrase - Optional password for decryption.
+     * @param password - Optional password for decryption.
      * @returns A promise that resolves to an array of objects, each containing the line number,
      *          the EntryId or null if it was not a valid entry and the error if there was one.
      */
-    async importFromTextFile(fileContents, passphrase) {
-        if (passphrase) {
-            const decrypted = await decryptExport(await this.libraryLoader.getOpenPGPLib(), fileContents, passphrase);
+    async importFromTextFile(fileContents, password) {
+        if (password) {
+            const decrypted = await decryptExport(this.libraryLoader.getOpenPGPLib(), fileContents, password);
             return this.importFromTextFile(decrypted);
         }
         const lines = fileContents.trim().split('\n');

package/build/subclasses/LibraryLoader.d.mts

@@ -1,52 +1,66 @@
 import type CryptoLib from '../interfaces/CryptoLib.mjs';
+import type { PlatformProviders } from '../interfaces/PlatformProviders.mjs';
+import type { QrCodeLib } from '../interfaces/QrCodeLib.mjs';
+import type { OpenPgpLib } from '../interfaces/OpenPgpLib.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.
  */
 declare class LibraryLoader {
+    private platformProviders;
     private cryptoLib;
     private openPgpLib?;
     private qrGeneratorLib?;
     private jsQrLib?;
-    private canvasLib?;
     private urlParserLib?;
     private zxcvbn?;
+    private webSocketLib?;
     /**
      * 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: CryptoLib);
+    constructor(platformProviders: PlatformProviders);
     /**
      * @returns The CryptoLib instance.
      */
     getCryptoLib(): CryptoLib;
+    /**
+     * @returns The PlatformProviders instance.
+     */
+    getPlatformProviders(): PlatformProviders;
     /**
      * Loads and returns the OpenPGP library on demand.
      * @returns A promise that resolves to the OpenPGP library.
      */
-    getOpenPGPLib(): Promise<typeof import("openpgp")>;
+    getOpenPGPLib(): OpenPgpLib;
     /**
      * Loads and returns the QR Generator library on demand.
      * @returns A promise that resolves to the QR Generator library.
      */
-    getQrGeneratorLib(): Promise<typeof import("qrcode")>;
+    getQrGeneratorLib(): QrCodeLib;
     /**
      * Loads and returns the JsQR library on demand.
      * @returns A promise that resolves to the JsQR library.
      */
     getJsQrLib(): Promise<typeof import("jsqr").default>;
-    /**
-     * 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.
-     */
-    getCanvasLib(): Promise<typeof import("canvas")>;
     /**
      * Loads and returns the URL Parser library on demand.
      * @returns A promise that resolves to the URL Parser library.
      */
     getUrlParserLib(): Promise<typeof import("whatwg-url")>;
+    /**
+     * Loads and returns the WebSocket library on demand.
+     * @returns The WebSocket library.
+     */
+    getWebSocketLib(): {
+        new (url: string | URL, protocols?: string | string[]): WebSocket;
+        prototype: WebSocket;
+        readonly CONNECTING: 0;
+        readonly OPEN: 1;
+        readonly CLOSING: 2;
+        readonly CLOSED: 3;
+    };
     /**
      * Loads and returns the Zxcvbn library on demand.
      * @returns A promise that resolves to the Zxcvbn library.