@binsky/passman-client-ts 0.1.9 → 0.2.0

package/lib/Service/CredentialFilterService.d.ts

@@ -11,7 +11,7 @@ export declare enum FILTERS {
     ENCRYPTION_BROKEN = 7
 }
 export declare class CredentialFilterService {
-    static getFilteredCredentials: (allCredentials: Credential[], filter: FILTERS, additionalFilterText?: string) => Credential[];
+    static getFilteredCredentials: (allCredentials: Credential[], filter: FILTERS, additionalFilterText?: string, additionalFilterTags?: string[]) => Credential[];
     static getFilterStats: (allCredentials: Credential[]) => FilterStatsInterface;
     static isHidden(credential: Credential): boolean;
     static isDeleted(credential: Credential): boolean;
@@ -21,4 +21,5 @@ export declare class CredentialFilterService {
     static hasMediumStrength(credential: Credential): boolean;
     static hasGoodStrength(credential: Credential): boolean;
     static matchesFilterText(credential: Credential, filterText: string): boolean;
+    static matchesFilterTags(credential: Credential, filterTags: string[]): boolean;
 }

package/lib/Service/CredentialFilterService.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CredentialFilterService = exports.FILTERS = void 0;
 const core_1 = require("@zxcvbn-ts/core");
@@ -39,7 +49,7 @@ var FILTERS;
     FILTERS[FILTERS["ENCRYPTION_BROKEN"] = 7] = "ENCRYPTION_BROKEN"; // use FILTERS.ENCRYPTION_BROKEN only when you really know what you are doing
 })(FILTERS || (exports.FILTERS = FILTERS = {}));
 class CredentialFilterService {
-    static getFilteredCredentials = (allCredentials, filter, additionalFilterText = undefined) => {
+    static getFilteredCredentials = (allCredentials, filter, additionalFilterText = undefined, additionalFilterTags = undefined) => {
         let filtered = [];
         for (const credential of allCredentials) {
             if (filter === FILTERS.ENCRYPTION_BROKEN) {
@@ -55,8 +65,10 @@ class CredentialFilterService {
                 continue;
             }
             const additionalTextFilterEnabled = additionalFilterText !== undefined && additionalFilterText !== '';
+            const additionalTagsFilterEnabled = additionalFilterTags !== undefined && additionalFilterTags.length > 0;
             // filter text if possible, otherwise ignore filter and proceed
-            if (!additionalTextFilterEnabled || (additionalTextFilterEnabled && CredentialFilterService.matchesFilterText(credential, additionalFilterText))) {
+            if ((!additionalTextFilterEnabled || (additionalTextFilterEnabled && CredentialFilterService.matchesFilterText(credential, additionalFilterText))) &&
+                (!additionalTagsFilterEnabled || (additionalTagsFilterEnabled && CredentialFilterService.matchesFilterTags(credential, additionalFilterTags)))) {
                 if (filter === FILTERS.DELETED) {
                     // deleted credentials will not match any other category
                     if (CredentialFilterService.isDeleted(credential)) {
@@ -205,5 +217,8 @@ class CredentialFilterService {
         }
         return false;
     }
+    static matchesFilterTags(credential, filterTags) {
+        return credential.tags && credential.tags.filter(tag => filterTags.includes(tag.text)).length > 0;
+    }
 }
 exports.CredentialFilterService = CredentialFilterService;

package/lib/Service/CustomMathsService.js

@@ -49,18 +49,8 @@ class CustomMathsService {
         const max_range = 256;
         const range = Math.min(max - min + 1, max_range);
         let randomNumber;
-        let myCrypto = null;
-        if (window && window.crypto) {
-            myCrypto = window.crypto;
-        }
-        else if (crypto) {
-            myCrypto = crypto;
-        }
-        else {
-            return null;
-        }
         do {
-            myCrypto.getRandomValues(byteArray);
+            crypto.getRandomValues(byteArray);
             randomNumber = byteArray[0];
         } while (randomNumber >= Math.floor(max_range / range) * range);
         return min + (randomNumber % range);

package/lib/Service/DefaultLoggingService.d.ts

@@ -1,4 +1,7 @@
 import type { LoggingHandlerInterface } from "../Interfaces/LoggingHandlerInterface";
+/**
+ * Provides simple console logging.
+ */
 export declare class DefaultLoggingService implements LoggingHandlerInterface {
     onDebug(message: string): void;
     onInfo(message: string): void;

package/lib/Service/DefaultLoggingService.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultLoggingService = void 0;
+/**
+ * Provides simple console logging.
+ */
 class DefaultLoggingService {
     onDebug(message) {
         console.debug(message);

package/lib/Service/DefaultPersistenceService.d.ts

@@ -0,0 +1,12 @@
+import { PersistenceInterface } from "../Interfaces/PersistenceInterface";
+import { DecryptedDataCachingHandlerInterface } from "../Interfaces/DecryptedDataCachingHandlerInterface";
+import { RequestCachingHandlerInterface } from "../Interfaces/RequestCachingHandlerInterface";
+/**
+ * This default persistence service is useless and just a placeholder. It won't cache or persist anything!
+ */
+export declare class DefaultPersistenceService implements PersistenceInterface {
+    constructor();
+    autoRestoreOnReconstruction(): boolean;
+    getDecryptedDataCacheHandler(): DecryptedDataCachingHandlerInterface;
+    getRequestCacheHandler(): RequestCachingHandlerInterface;
+}

package/lib/Service/DefaultPersistenceService.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultPersistenceService = void 0;
+/**
+ * This default persistence service is useless and just a placeholder. It won't cache or persist anything!
+ */
+class DefaultPersistenceService {
+    constructor() {
+    }
+    autoRestoreOnReconstruction() {
+        return false;
+    }
+    getDecryptedDataCacheHandler() {
+        return undefined;
+    }
+    getRequestCacheHandler() {
+        return undefined;
+    }
+}
+exports.DefaultPersistenceService = DefaultPersistenceService;

package/lib/Service/OTPService.d.ts

@@ -1,22 +1,22 @@
 import { Secret } from "otpauth";
 import { OTPConfigInterface } from "../Interfaces/Credential/OTPConfigInterface";
 export declare class OTPService {
-    static mergeDefaultOTPConfig: (otp: OTPConfigInterface) => void;
-    static getSecretString: (secret: undefined | string | Secret) => string | undefined;
-    static getDataUrlFromCurrentOTPValues: (otp: OTPConfigInterface) => string;
+    static readonly mergeDefaultOTPConfig: (otp: OTPConfigInterface) => void;
+    static readonly getSecretString: (secret: undefined | string | Secret) => string | undefined;
+    static readonly getDataUrlFromCurrentOTPValues: (otp: OTPConfigInterface) => string;
     /**
      * Updates otp.qr_uri with a new QR code and data url based on the raw otp values.
      * @param otp
      */
-    static updateQRFromCurrentOTPValues: (otp: OTPConfigInterface) => void;
+    static readonly updateQRFromCurrentOTPValues: (otp: OTPConfigInterface) => void;
     /**
      * Returns the current token of the given OTP configuration.
      * @param otp
      */
-    static updateOTP: (otp: OTPConfigInterface) => string;
+    static readonly updateOTP: (otp: OTPConfigInterface) => string;
     /**
      * Parse input file asynchronous as QR code, extract the TOTP values and return the IOTPConfig, that's built from it.
      * @param input
      */
-    static parseOTPQrCodeFromInputFileData: (input: string | File | any) => Promise<OTPConfigInterface>;
+    static readonly parseOTPQrCodeFromInputFileData: (input: string | File | any) => Promise<OTPConfigInterface>;
 }

package/lib/Service/OTPService.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,6 +40,7 @@ exports.OTPService = void 0;
 const OTPAuth = __importStar(require("otpauth"));
 const qrcode_generator_1 = __importDefault(require("qrcode-generator"));
 const qrcode_parser_1 = __importDefault(require("qrcode-parser"));
+const OTPConfigInterface_1 = require("../Interfaces/Credential/OTPConfigInterface");
 class OTPService {
     static mergeDefaultOTPConfig = (otp) => {
         const defaults = {
@@ -123,7 +134,9 @@ class OTPService {
                 },
                 issuer: uri.searchParams.get('issuer'),
                 secret: uri.searchParams.get('secret'),
-                algorithm: uri.searchParams.get('algorithm') ? uri.searchParams.get('algorithm') : "SHA1",
+                algorithm: uri.searchParams.get('algorithm') && OTPConfigInterface_1.OTPAlgorithms.includes(uri.searchParams.get('algorithm'))
+                    ? uri.searchParams.get('algorithm')
+                    : "SHA1",
                 period: uri.searchParams.get('period') ? parseInt(uri.searchParams.get('period')) : 30,
                 digits: uri.searchParams.get('digits') ? parseInt(uri.searchParams.get('digits')) : 6,
             };

package/lib/Service/PassmanCrypto.d.ts

@@ -2,9 +2,14 @@ import { GenerateKeypairResponseInterface } from "../Interfaces/PassmanCrypto/Ge
 import { RSAKeypairInterface } from "../Interfaces/PassmanCrypto/RSAKeypairInterface";
 import { PEMRSAKeypairInterface } from "../Interfaces/PassmanCrypto/PEMRSAKeypairInterface";
 export declare class PassmanCrypto {
-    static generateRSAKeypair: (keyLength?: number) => Promise<GenerateKeypairResponseInterface>;
-    static rsaKeyPairToPEM: (keypair: RSAKeypairInterface) => PEMRSAKeypairInterface;
+    static readonly generateRSAKeypair: (keyLength?: number) => Promise<GenerateKeypairResponseInterface>;
+    static readonly rsaKeyPairToPEM: (keypair: RSAKeypairInterface) => PEMRSAKeypairInterface;
     private static readonly sjcl_encryption_config;
-    static encryptString: (plainText: string, key: string) => string;
-    static decryptString: (b64EncCiphertext: string, key: string) => string;
+    static readonly encryptString: (plainText: string, key: string) => string;
+    /**
+     * @param b64EncCiphertext
+     * @param key
+     * @throws untyped sjcl exceptions
+     */
+    static readonly decryptString: (b64EncCiphertext: string, key: string) => string | never;
 }

package/lib/Service/PassmanCrypto.js

@@ -45,14 +45,14 @@ class PassmanCrypto {
         const ct = sjcl_1.default.encrypt(key, plainText, PassmanCrypto.sjcl_encryption_config, rp);
         return js_base64_1.Base64.btoa(ct);
     };
+    /**
+     * @param b64EncCiphertext
+     * @param key
+     * @throws untyped sjcl exceptions
+     */
     static decryptString = (b64EncCiphertext, key) => {
         const ciphertext = js_base64_1.Base64.atob(b64EncCiphertext);
-        try {
-            return sjcl_1.default.decrypt(key, ciphertext);
-        }
-        catch (e) {
-            throw e;
-        }
+        return sjcl_1.default.decrypt(key, ciphertext);
     };
 }
 exports.PassmanCrypto = PassmanCrypto;

package/lib/Service/ReEncryptionService.js

@@ -52,7 +52,7 @@ class ReEncryptionService {
         progressState.credentialsStage.totalSteps = originalCredentials.length;
         for (let i = 0; i < originalCredentials.length; i++) {
             progressState.credentialsStage.doneSteps = i;
-            if (originalCredentials[i].sharedCredentialEncryptionKey) {
+            if (originalCredentials[i].encryptedSharedCredentialEncryptionKey) {
                 // don't re-encrypt credentials that are shared with us
                 progressState.credentialsStage.messages.push('Skip shared credential: ' + originalCredentials[i].label);
                 onProgress(progressState);
@@ -109,7 +109,7 @@ class ReEncryptionService {
             if (revisions && revisions.length > 0) {
                 for (let j = 0; j < revisions.length; j++) {
                     try {
-                        const tmpCredential = await Revision_1.default.fromData(revisions[j].credential_data, vault, vault.getServer());
+                        const tmpCredential = Revision_1.default.fromData(revisions[j].credential_data, vault, vault.getServer());
                         revisions[j].credential_data = tmpCredential.reEncryptAsClone(newPassword).getEncrypted();
                         revisionsToUpdateOnSuccess.push(revisions[j]);
                     }

package/lib/Service/RequestCachingService.d.ts

@@ -1,7 +1,10 @@
 import { RequestCachingHandlerInterface } from "../Interfaces/RequestCachingHandlerInterface";
+/**
+ * Service to be used within a custom persistence instance, by providing custom get/set callbacks.
+ */
 export declare class RequestCachingService implements RequestCachingHandlerInterface {
-    private onGetCallback;
-    private onSetCallback;
+    private readonly onGetCallback;
+    private readonly onSetCallback;
     constructor(onGetCallback: (key: string) => string, onSetCallback: (key: string, value: string) => void);
     set(key: string, value: string): Promise<void>;
     get(key: string): Promise<string>;

package/lib/Service/RequestCachingService.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestCachingService = void 0;
+/**
+ * Service to be used within a custom persistence instance, by providing custom get/set callbacks.
+ */
 class RequestCachingService {
     onGetCallback;
     onSetCallback;

package/lib/Service/ShareService.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShareService = void 0;
 const Credential_1 = __importDefault(require("../Model/Credential"));
-const PassmanCrypto_1 = require("./PassmanCrypto");
 const SharingACL_1 = require("../Model/SharingACL");
 class ShareService {
     static async getCredentialsSharedWithUs(vault, server, getCachedIfPossible = false) {
@@ -16,9 +15,8 @@ class ShareService {
         if (sharedItemsResponse) {
             for (const sharedItem of sharedItemsResponse) {
                 try {
-                    const decrypted_shared_key = PassmanCrypto_1.PassmanCrypto.decryptString(sharedItem.shared_key, vault.vaultKey);
-                    const sharedCredential = await Credential_1.default.fromData(sharedItem.credential_data, vault, server);
-                    sharedCredential.sharedCredentialEncryptionKey = decrypted_shared_key;
+                    const sharedCredential = Credential_1.default.fromData(sharedItem.credential_data, vault, server);
+                    sharedCredential.encryptedSharedCredentialEncryptionKey = sharedItem.shared_key;
                     // transfer acl data from sharedItem into the new Credential object
                     delete sharedItem.credential_data;
                     const permissionsSharingAcl = new SharingACL_1.SharingACL(sharedItem.permissions);