npm - favalib - Versions diffs - 0.0.1 - Mend

favalib 0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (67) hide show

package/build/Command/BaseCommand.d.mts +65 -0
package/build/Command/BaseCommand.mjs +54 -0
package/build/Command/CommandQueue.d.mts +28 -0
package/build/Command/CommandQueue.mjs +43 -0
package/build/Command/commandConstructors.d.mts +11 -0
package/build/Command/commandConstructors.mjs +11 -0
package/build/Command/commands/AddEntryCommand.d.mts +31 -0
package/build/Command/commands/AddEntryCommand.mjs +43 -0
package/build/Command/commands/AddSyncDeviceCommand.d.mts +36 -0
package/build/Command/commands/AddSyncDeviceCommand.mjs +42 -0
package/build/Command/commands/DeleteEntryCommand.d.mts +35 -0
package/build/Command/commands/DeleteEntryCommand.mjs +50 -0
package/build/Command/commands/UpdateEntryCommand.d.mts +38 -0
package/build/Command/commands/UpdateEntryCommand.mjs +51 -0
package/build/CryptoProviders/browser/index.d.mts +73 -0
package/build/CryptoProviders/browser/index.mjs +209 -0
package/build/CryptoProviders/node/index.d.mts +62 -0
package/build/CryptoProviders/node/index.mjs +189 -0
package/build/TwoFALibError.d.mts +77 -0
package/build/TwoFALibError.mjs +91 -0
package/build/TwoFaLib.d.mts +95 -0
package/build/TwoFaLib.mjs +180 -0
package/build/TwoFaLibEvent.d.mts +8 -0
package/build/TwoFaLibEvent.mjs +9 -0
package/build/TwoFaLibMediator.d.mts +37 -0
package/build/TwoFaLibMediator.mjs +58 -0
package/build/interfaces/CommandTypes.d.mts +20 -0
package/build/interfaces/CommandTypes.mjs +1 -0
package/build/interfaces/CryptoLib.d.mts +113 -0
package/build/interfaces/CryptoLib.mjs +1 -0
package/build/interfaces/Entry.d.mts +33 -0
package/build/interfaces/Entry.mjs +1 -0
package/build/interfaces/Events.d.mts +22 -0
package/build/interfaces/Events.mjs +1 -0
package/build/interfaces/PassphraseExtraDict.d.ts +2 -0
package/build/interfaces/PassphraseExtraDict.js +1 -0
package/build/interfaces/SyncTypes.d.mts +45 -0
package/build/interfaces/SyncTypes.mjs +1 -0
package/build/interfaces/Vault.d.mts +30 -0
package/build/interfaces/Vault.mjs +1 -0
package/build/main.d.mts +12 -0
package/build/main.mjs +5 -0
package/build/subclasses/CommandManager.d.mts +46 -0
package/build/subclasses/CommandManager.mjs +117 -0
package/build/subclasses/ExportImportManager.d.mts +58 -0
package/build/subclasses/ExportImportManager.mjs +105 -0
package/build/subclasses/LibraryLoader.d.mts +56 -0
package/build/subclasses/LibraryLoader.mjs +108 -0
package/build/subclasses/PersistentStorageManager.d.mts +71 -0
package/build/subclasses/PersistentStorageManager.mjs +127 -0
package/build/subclasses/SyncManager.d.mts +161 -0
package/build/subclasses/SyncManager.mjs +567 -0
package/build/subclasses/VaultDataManager.d.mts +68 -0
package/build/subclasses/VaultDataManager.mjs +114 -0
package/build/subclasses/VaultOperationsManager.d.mts +91 -0
package/build/subclasses/VaultOperationsManager.mjs +163 -0
package/build/utils/constants.d.mts +2 -0
package/build/utils/constants.mjs +1 -0
package/build/utils/creationUtils.d.mts +43 -0
package/build/utils/creationUtils.mjs +125 -0
package/build/utils/exportImportUtils.d.mts +53 -0
package/build/utils/exportImportUtils.mjs +185 -0
package/build/utils/qrUtils.d.mts +25 -0
package/build/utils/qrUtils.mjs +84 -0
package/build/utils/syncUtils.d.mts +26 -0
package/build/utils/syncUtils.mjs +78 -0
package/package.json +56 -0

package/build/utils/exportImportUtils.mjs ADDED Viewed

@@ -0,0 +1,185 @@
+import { ExportImportError } from '../TwoFALibError.mjs';
+/**
+ * Determines the hashing algorithm based on the input string.
+ * @param alg - The algorithm string to parse.
+ * @returns The standardized algorithm name or null if unsupported.
+ */
+const parseOtpAlgorithm = (alg) => {
+    if (!alg) {
+        return 'SHA-1'; // default algorithm
+    }
+    switch (alg.toLowerCase()) {
+        case 'sha1':
+        case 'sha-1':
+        case 'algorithm.sha1':
+            return 'SHA-1';
+        case 'sha-256':
+            return 'SHA-256';
+        default:
+            return null;
+    }
+};
+/**
+ * Parses an OTP URI and extracts the relevant information to create a new entry.
+ * @param UrlParser - The URL parsing library.
+ * @param otpUri - The OTP URI to parse.
+ * @returns An object representing the new entry.
+ * @throws ExportImportError if the URI is invalid or contains unsupported features.
+ */
+export const parseOtpUri = (UrlParser, otpUri) => {
+    if (!otpUri.startsWith('otpauth://')) {
+        throw new ExportImportError('Invalid OTP URI');
+    }
+    const parsedUri = UrlParser.parseURL(otpUri);
+    if (!parsedUri) {
+        throw new ExportImportError('Failed to parse URI');
+    }
+    const { scheme, host, path, query } = parsedUri;
+    if (scheme !== 'otpauth') {
+        throw new ExportImportError(`Unsupported protocol "${scheme}"`);
+    }
+    if (host !== 'totp') {
+        throw new ExportImportError(`Unsupported OTP type "${String(host)}"`);
+    }
+    const searchParams = new URLSearchParams(query ?? '');
+    // some use /, some use :
+    const splitOn = path[0].includes('/') ? '/' : ':';
+    // ente double encodes its exports
+    let [issuer, name] = decodeURIComponent(decodeURIComponent(path[0])).split(splitOn);
+    const secret = searchParams.get('secret');
+    const algorithm = parseOtpAlgorithm(searchParams.get('algorithm'));
+    const digits = parseInt(searchParams.get('digits') ?? '6', 10);
+    const period = parseInt(searchParams.get('period') ?? '30', 10);
+    // if searchParams has an issuer, use that
+    if (searchParams.get('issuer')) {
+        if (!name) {
+            name = issuer;
+        }
+        issuer = searchParams.get('issuer');
+    }
+    // validate
+    if (!secret) {
+        throw new ExportImportError('Invalid OTP URI: missing secret');
+    }
+    if (!algorithm) {
+        throw new ExportImportError(`Unsupported algorithm "${searchParams.get('algorithm')}"`);
+    }
+    return {
+        name: name && name.length > 0 ? name : 'Imported Entry',
+        issuer: issuer && issuer.length > 0 ? issuer : 'Unknown Issuer',
+        type: 'TOTP',
+        payload: {
+            secret,
+            algorithm,
+            digits,
+            period,
+        },
+    };
+};
+const generateOtpUrl = (entry) => {
+    const { name, issuer, payload } = entry;
+    const { secret, algorithm, digits, period } = payload;
+    return `otpauth://totp/${encodeURIComponent(issuer)}:${encodeURIComponent(name)}?secret=${secret}&issuer=${encodeURIComponent(issuer)}&algorithm=${algorithm}&digits=${digits}&period=${period}`;
+};
+/**
+ * Generates an HTML page with QR codes for the provided OTP entries.
+ * @param qrGeneratorLib - The QR code generation library.
+ * @param entries - An array of OTP entries.
+ * @returns A promise that resolves to the HTML string.
+ */
+export const generateHtmlExport = async (qrGeneratorLib, entries) => {
+    const qrPromises = entries.map(async (entry) => {
+        const { name, issuer } = entry;
+        const otpUrl = generateOtpUrl(entry);
+        const qrCode = await qrGeneratorLib.toDataURL(otpUrl);
+        return `
+            <div class="entry">
+              <img src="${qrCode}" alt="QR Code for ${name}">
+              <p><strong>${name}</strong></p>
+              <p>Issuer: ${issuer}</p>
+            </div>
+          `;
+    });
+    const qrCodes = await Promise.all(qrPromises);
+    return `
+        <html>
+          <head>
+            <style>
+              .container { display: flex; flex-wrap: wrap; }
+              .entry { margin: 10px; text-align: center; }
+              img { width: 200px; height: 200px; }
+            </style>
+          </head>
+          <body>
+            <div class="container">
+              ${qrCodes.join('')}
+            </div>
+          </body>
+        </html>
+      `;
+};
+/**
+ * Generates a text export of OTP URIs for the provided entries.
+ * @param entries - An array of OTP entries.
+ * @returns A string containing the OTP URIs, one per line.
+ */
+export const generateTextExport = (entries) => {
+    return entries
+        .map((entry) => {
+        return generateOtpUrl(entry);
+    })
+        .join('\n');
+};
+/**
+ * Processes the lines of a text file containing OTP URIs and returns 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.
+ * @param lines - An array of strings, each containing an OTP URI.
+ * @param importFromUri - A function that takes a URI and returns a promise that resolves to the EntryId.
+ * @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.
+ */
+export const processImportLines = async (lines, importFromUri) => {
+    return Promise.all(lines
+        .filter((line) => line !== '')
+        .map(async (line, lineNr) => {
+        try {
+            return {
+                lineNr,
+                entryId: await importFromUri(line),
+                error: null,
+            };
+        }
+        catch (err) {
+            return { lineNr, entryId: null, error: err };
+        }
+    }));
+};
+/**
+ * Encrypts the given data using OpenPGP.
+ * @param openPgpLib - The OpenPGP library.
+ * @param data - The data to encrypt.
+ * @param password - The password to use for encryption.
+ * @returns A promise that resolves to the encrypted data.
+ */
+export const encryptExport = async (openPgpLib, data, password) => {
+    const encrypted = await openPgpLib.encrypt({
+        message: await openPgpLib.createMessage({ text: data }),
+        passwords: [password],
+        format: 'armored',
+    });
+    return encrypted;
+};
+/**
+ * Decrypts the given data using OpenPGP.
+ * @param openPgpLib - The OpenPGP library.
+ * @param data - The data to decrypt.
+ * @param password - The password to use for decryption.
+ * @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;
+};

package/build/utils/qrUtils.d.mts ADDED Viewed

@@ -0,0 +1,25 @@
+import type { ImageData } from 'canvas';
+import LibraryLoader from '../subclasses/LibraryLoader.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 declare const getImageDataBrowser: (input: string | File) => Promise<ImageData>;
+/**
+ * Gets the ImageData from an image, for Node.js environments.
+ * This ImageData is then further processed to get QR codes.
+ * @param canvasLib - The Canvas library.
+ * @param inputImage - The image to get the ImageData from.
+ * @returns A promise that resolves to the ImageData.
+ */
+export declare const getImageDataNode: (canvasLib: typeof import("canvas"), inputImage: Uint8Array | string) => Promise<ImageData>;
+/**
+ * Import an entry from a QR code image.
+ * @param libraryLoader - An instance of LibraryLoader.
+ * @param imageInput - The image containing the QR code
+ * @returns A promise that resolves to the qr data.
+ * @throws {InvalidInputExportImportError} If the QR code is invalid or doesn't contain a valid OTP URI.
+ */
+export declare const getDataFromQRImage: (libraryLoader: LibraryLoader, imageInput: string | File | Uint8Array) => Promise<string>;

package/build/utils/qrUtils.mjs ADDED Viewed

@@ -0,0 +1,84 @@
+import { isUint8Array } from 'uint8array-extras';
+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 getImageDataBrowser = (input) => {
+    return new Promise((resolve, reject) => {
+        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);
+        }
+    });
+};
+/**
+ * Gets the ImageData from an image, for Node.js environments.
+ * This ImageData is then further processed to get QR codes.
+ * @param canvasLib - The Canvas library.
+ * @param inputImage - The image to get the ImageData from.
+ * @returns A promise that resolves to the ImageData.
+ */
+export const getImageDataNode = async (canvasLib, inputImage) => {
+    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);
+};
+/**
+ * Import an entry from a QR code image.
+ * @param libraryLoader - An instance of LibraryLoader.
+ * @param imageInput - The image containing the QR code
+ * @returns A promise that resolves to the qr data.
+ * @throws {InvalidInputExportImportError} If the QR code is invalid or doesn't contain a valid OTP URI.
+ */
+export const getDataFromQRImage = async (libraryLoader, imageInput) => {
+    const jsQr = await libraryLoader.getJsQrLib();
+    let imageData;
+    if (typeof window !== 'undefined') {
+        // Browser environment
+        imageData = await getImageDataBrowser(imageInput);
+    }
+    else {
+        if (imageInput instanceof File) {
+            throw new TwoFALibError('Getting data from QR where image type is "File" is not supported in the node environment');
+        }
+        // Node.js environment
+        const canvasLib = await libraryLoader.getCanvasLib();
+        imageData = await getImageDataNode(canvasLib, imageInput);
+    }
+    const qrCodeResult = jsQr(imageData.data, imageData.width, imageData.height);
+    if (!qrCodeResult) {
+        throw new TwoFALibError("Couldn't read QR code data from image");
+    }
+    return qrCodeResult.data;
+};

package/build/utils/syncUtils.d.mts ADDED Viewed

@@ -0,0 +1,26 @@
+import { InitiateAddDeviceFlowResult } from '../interfaces/SyncTypes.mjs';
+/**
+ * Decodes the initiator data from a string or QR code.
+ * @param initiatorData - The initiator data to decode.
+ * @param initiatorDataType The type of the initiatorData, determines how it should be decoded
+ * @param jsQr - The QR code decoder.
+ * @param getCanvasLib - A function to get the Canvas library.
+ * @returns A promise that resolves to the decoded initiator data.
+ */
+export declare const decodeInitiatorData: (initiatorData: string | Uint8Array | File, initiatorDataType: "text" | "qr", jsQr: typeof import("jsqr").default, getCanvasLib: () => Promise<typeof import("canvas")>) => Promise<InitiateAddDeviceFlowResult>;
+/**
+ * Converts a JSONified Uint8Array to a Uint8Array.
+ * A JSONified Uint8Array is the output of JSON.stringify on a Uint8Array.
+ * Example:
+ * JSON.stringify(new Uint8Array([123, 456])) looks like this:
+ * '{"0":123,"1":200}'
+ * @param jsonObj - The JSONified Uint8Array to convert.
+ * @returns A Uint8Array containing the values of the JSONified Uint8Array.
+ */
+export declare const jsonifiedUint8ArraytoUint8Array: (jsonObj: Record<string, number>) => Uint8Array;
+/**
+ * Converts a JSON object to a record of Uint8Arrays.
+ * @param jsonObj - The JSON object to convert.
+ * @returns A record of Uint8Arrays.
+ */
+export declare const jsonToUint8Array: (jsonObj: Record<string, Record<string, number>>) => Record<string, Uint8Array>;

package/build/utils/syncUtils.mjs ADDED Viewed

@@ -0,0 +1,78 @@
+import { base64ToString } from 'uint8array-extras';
+import { getImageDataBrowser, getImageDataNode } from './qrUtils.mjs';
+import { SyncError } from '../TwoFALibError.mjs';
+/**
+ * Decodes the initiator data from a string or QR code.
+ * @param initiatorData - The initiator data to decode.
+ * @param initiatorDataType The type of the initiatorData, determines how it should be decoded
+ * @param jsQr - The QR code decoder.
+ * @param getCanvasLib - A function to get the Canvas library.
+ * @returns A promise that resolves to the decoded initiator data.
+ */
+export const decodeInitiatorData = async (initiatorData, initiatorDataType, jsQr, getCanvasLib) => {
+    if (initiatorDataType === 'qr') {
+        try {
+            let imageData;
+            if (typeof window !== 'undefined') {
+                if (initiatorData instanceof Uint8Array) {
+                    throw new SyncError('Invalid initiator data type, should be a string or File in browser environment');
+                }
+                // Browser environment
+                imageData = await getImageDataBrowser(initiatorData);
+            }
+            else {
+                if (!(initiatorData instanceof Uint8Array)) {
+                    throw new SyncError('Invalid initiator data type, should be a Uint8Array in Node.js environment');
+                }
+                // Node.js environment
+                const canvasLib = await getCanvasLib();
+                imageData = await getImageDataNode(canvasLib, initiatorData);
+            }
+            const qrCodeResult = jsQr(imageData.data, imageData.width, imageData.height);
+            if (!qrCodeResult) {
+                throw new SyncError('Invalid QR code');
+            }
+            return JSON.parse(qrCodeResult.data);
+        }
+        catch (error) {
+            // eslint-disable-next-line no-restricted-globals
+            if (error instanceof Error) {
+                throw new SyncError('Failed to decode QR code: ' + error.message);
+            }
+            throw new SyncError('Failed to decode QR code: unknown error.');
+        }
+    }
+    else {
+        if (typeof initiatorData !== 'string') {
+            throw new SyncError('Invalid initiator data');
+        }
+        const parsedInitiatorData = JSON.parse(base64ToString(initiatorData));
+        if (!parsedInitiatorData || typeof parsedInitiatorData !== 'object') {
+            throw new SyncError('Invalid initiator data');
+        }
+        return parsedInitiatorData;
+    }
+};
+/**
+ * Converts a JSONified Uint8Array to a Uint8Array.
+ * A JSONified Uint8Array is the output of JSON.stringify on a Uint8Array.
+ * Example:
+ * JSON.stringify(new Uint8Array([123, 456])) looks like this:
+ * '{"0":123,"1":200}'
+ * @param jsonObj - The JSONified Uint8Array to convert.
+ * @returns A Uint8Array containing the values of the JSONified Uint8Array.
+ */
+export const jsonifiedUint8ArraytoUint8Array = (jsonObj) => {
+    return new Uint8Array(Object.values(jsonObj));
+};
+/**
+ * Converts a JSON object to a record of Uint8Arrays.
+ * @param jsonObj - The JSON object to convert.
+ * @returns A record of Uint8Arrays.
+ */
+export const jsonToUint8Array = (jsonObj) => {
+    return Object.entries(jsonObj).reduce((acc, [key, value]) => ({
+        ...acc,
+        [key]: jsonifiedUint8ArraytoUint8Array(value),
+    }), {});
+};

package/package.json ADDED Viewed

@@ -0,0 +1,56 @@
+{
+  "name": "favalib",
+  "version": "0.0.1",
+  "description": "",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./build/main.mjs",
+      "types": "./build/main.d.mts"
+    },
+    "./cryptoProviders/browser": {
+      "import": "./build/CryptoProviders/browser/index.mjs",
+      "types": "./build/CryptoProviders/browser/index.d.mts"
+    },
+    "./cryptoProviders/node": {
+      "import": "./build/CryptoProviders/node/index.mjs",
+      "types": "./build/CryptoProviders/node/index.d.mts"
+    }
+  },
+  "types": "./build/main.d.mts",
+  "files": [
+    "build/**"
+  ],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node-forge": "^1.3.11",
+    "@types/qrcode": "^1.5.5",
+    "@types/uuid": "^10.0.0",
+    "@types/whatwg-url": "^11.0.5",
+    "@vitest/coverage-v8": "^2.1.2",
+    "eslint": "^9.12.0",
+    "type-fest": "^4.26.1",
+    "vitest": "^2.1.2"
+  },
+  "dependencies": {
+    "@zxcvbn-ts/core": "^3.0.4",
+    "@zxcvbn-ts/language-common": "^3.0.4",
+    "@zxcvbn-ts/language-en": "^3.0.2",
+    "canvas": "^2.11.2",
+    "hash-wasm": "^4.11.0",
+    "isomorphic-ws": "^5.0.0",
+    "jpake-ts": "^1.0.1",
+    "jsqr": "^1.4.0",
+    "node-forge": "^1.3.1",
+    "openpgp": "^5.11.2",
+    "qrcode": "^1.5.4",
+    "totp-generator": "^1.0.0",
+    "typescript-event-target": "^1.1.1",
+    "uint8array-extras": "^1.4.0",
+    "uuid": "^10.0.0",
+    "vitest-websocket-mock": "^0.4.0",
+    "whatwg-url": "^14.0.0",
+    "ws": "^8.18.0"
+  }
+}