passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/event/recoverEvents.js

@@ -1,128 +1,140 @@
 /**
  * Passbolt ~ Open source password manager for teams
- * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
  *
  * Licensed under GNU Affero General Public License version 3 of the or any later version.
  * For full copyright and license information, please see the LICENSE.txt
  * Redistributions of files must retain the above copyright notice.
  *
- * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @copyright     Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         2.0.0
  */
-const {SiteSettings} = require("../model/siteSettings");
-const {RecoverController} = require("../controller/recover/recoverController");
-const Worker = require('../model/worker');
-
-const listen = function (worker) {
-  /**
-   * The recover controller.
-   * @type {RecoverController}
-   * @private
-   */
-  const recoverController = new RecoverController(worker, worker.tab.url);
 
+import GetKeyInfoController from "../controller/crypto/getKeyInfoController";
+import RequestAccountRecoveryController from "../controller/recover/requestAccountRecoveryController";
+import GenerateRecoverAccountRecoveryRequestKeyController from "../controller/recover/generateRecoverAccountRecoveryRequestKeyController";
+import VerifyImportedKeyPassphraseController from "../controller/setup/verifyImportedKeyPassphraseController";
+import ImportRecoverPrivateKeyController from "../controller/recover/importRecoverPrivateKeyController";
+import StartRecoverController from "../controller/recover/startRecoverController";
+import CompleteRecoverController from "../controller/recover/completeRecoverController";
+import ValidatePrivateGpgKeyRecoverController from "../controller/crypto/validatePrivateGpgKeyRecoverController";
+import AbortAndRequestHelp from "../controller/recover/abortAndRequestHelpController";
+import SignInSetupController from "../controller/setup/signInSetupController";
+import SetSetupLocaleController from "../controller/setup/setSetupLocaleController";
+import GetOrganizationSettingsController from "../controller/organizationSettings/getOrganizationSettingsController";
+import GetAndInitializeAccountLocaleController from "../controller/account/getAndInitializeAccountLocaleController";
+import IsExtensionFirstInstallController from "../controller/extension/isExtensionFirstInstallController";
+import IsLostPassphraseCaseController from "../controller/accountRecovery/isLostPassphraseCaseController";
+import SetSetupSecurityTokenController from "../controller/setup/setSetupSecurityTokenController";
+import HasRecoverUserEnabledAccountRecoveryController from "../controller/recover/hasRecoverUserEnabledAccountRecoveryController";
+import GeneratePortIdController from "../controller/port/generatePortIdController";
+import GetUserPassphrasePoliciesController from "../controller/setup/getUserPassphrasePoliciesController";
+
+
+const listen = (worker, apiClientOptions, account) => {
   /*
-   * Initialize the recovery process.
+   * The recover runtime memory.
    *
-   * @listens passbolt.recover.site-settings
-   * @param requestId {uuid} The request identifier
+   * Used to store information collected during the user setup journey that shouldn't be stored on the react side of
+   * the application because of their confidentiality or for logic reason. By instance the passphrase of the user.
    */
-  worker.port.on('passbolt.recover.site-settings', async function (requestId) {
-    try {
-      const siteSettings = new SiteSettings(recoverController.setupEntity.domain);
-      const siteSettingsDto = await siteSettings.get();
-      worker.port.emit(requestId, 'SUCCESS', siteSettingsDto);
-    } catch(error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  const runtimeMemory = {};
+
+  worker.port.on('passbolt.recover.first-install', async requestId => {
+    const controller = new IsExtensionFirstInstallController(worker, requestId);
+    await controller._exec();
   });
 
-  /*
-   * Retrieve the recover info
-   *
-   * @listens passbolt.recover.info
-   * @param requestId {uuid} The request identifier
-   */
-  worker.port.on('passbolt.recover.info', async function (requestId) {
-    try {
-      const setupEntity = await recoverController.retrieveRecoverInfo();
-      worker.port.emit(requestId, 'SUCCESS', setupEntity);
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-      // In case of unexpected error at this step, let the API treat the case.
-      Worker.get('RecoverBootstrap', worker.tab.id).port.emit('passbolt.recover-bootstrap.remove-iframe');
-    }
+  worker.port.on('passbolt.recover.lost-passphrase-case', async requestId => {
+    const controller = new IsLostPassphraseCaseController(worker, requestId);
+    await controller._exec();
   });
 
-  /*
-   * Import secret key.
-   *
-   * @listens passbolt.recover.import-key
-   * @param requestId {uuid} The request identifier
-   * @param armoredKey {string} The armored key to import
-   */
-  worker.port.on('passbolt.recover.import-key', async function (requestId, armoredKey) {
-    try {
-      await recoverController.importKey(armoredKey);
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.organization-settings.get', async requestId => {
+    const controller = new GetOrganizationSettingsController(worker, requestId, apiClientOptions);
+    await controller._exec();
   });
 
-  /*
-   * Verify secret key passphrase
-   *
-   * @listens passbolt.recover.verify-passphrase
-   * @param requestId {uuid} The request identifier
-   * @param passphrase {string} The passphrase used to verify the secret key
-   * @param rememberUntilLogout {boolean} The passphrase should be remembered until the user is logged out
-   */
-  worker.port.on('passbolt.recover.verify-passphrase', async function (requestId, passphrase, rememberUntilLogout) {
-    try {
-      await recoverController.verifyPassphrase(passphrase, rememberUntilLogout);
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.recover.start', async requestId => {
+    const controller = new StartRecoverController(worker, requestId, apiClientOptions, account, runtimeMemory);
+    await controller._exec();
   });
 
-  /*
-   * Set the user security token
-   *
-   * @listens passbolt.recover.set-security-token
-   * @param requestId {uuid} The request identifier
-   * @param securityTokenDto {object} The security token dto. ie: {color: hex-string, text-color: hex-string, code: string}
-   */
-  worker.port.on('passbolt.recover.set-security-token', async function (requestId, securityTokenDto) {
-    try {
-      recoverController.setSecurityToken(securityTokenDto);
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.locale.get', async requestId => {
+    const controller = new GetAndInitializeAccountLocaleController(worker, requestId, apiClientOptions, account);
+    await controller._exec();
   });
 
-  /*
-   * Complete the recovery
-   *
-   * @listens passbolt.recover.complete
-   * @param requestId {uuid} The request identifier
-   */
-  worker.port.on('passbolt.recover.complete', async function (requestId) {
-    try {
-      await recoverController.complete();
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.locale.update-user-locale', async(requestId, localeDto) => {
+    const controller = new SetSetupLocaleController(worker, requestId, apiClientOptions, account);
+    await controller._exec(localeDto);
+  });
+
+  worker.port.on('passbolt.recover.has-user-enabled-account-recovery', async requestId => {
+    const controller = new HasRecoverUserEnabledAccountRecoveryController(worker, requestId, account);
+    await controller._exec();
+  });
+
+  worker.port.on('passbolt.recover.import-key', async(requestId, armoredKey) => {
+    const controller = new ImportRecoverPrivateKeyController(worker, requestId, account);
+    await controller._exec(armoredKey);
+  });
+
+  worker.port.on('passbolt.recover.verify-passphrase', async(requestId, passphrase) => {
+    const controller = new VerifyImportedKeyPassphraseController(worker, requestId, account, runtimeMemory);
+    await controller._exec(passphrase);
+  });
+
+  worker.port.on('passbolt.recover.set-security-token', async(requestId, securityTokenDto) => {
+    const controller = new SetSetupSecurityTokenController(worker, requestId, account);
+    await controller._exec(securityTokenDto);
+  });
+
+  worker.port.on('passbolt.recover.complete', async requestId => {
+    const controller = new CompleteRecoverController(worker, requestId, apiClientOptions, account);
+    await controller._exec();
+  });
+
+  worker.port.on('passbolt.recover.sign-in', async(requestId, rememberMe) => {
+    const controller = new SignInSetupController(worker, requestId, apiClientOptions, account, runtimeMemory);
+    await controller._exec(rememberMe);
+  });
+
+  worker.port.on('passbolt.recover.generate-account-recovery-request-key', async(requestId, generateGpgKeyPairDto) => {
+    const controller = new GenerateRecoverAccountRecoveryRequestKeyController(worker, requestId, apiClientOptions, account);
+    await controller._exec(generateGpgKeyPairDto);
+  });
+
+  worker.port.on('passbolt.recover.initiate-account-recovery-request', async requestId => {
+    const controller = new RequestAccountRecoveryController(worker, apiClientOptions, requestId, account);
+    await controller._exec();
+  });
+
+  worker.port.on('passbolt.keyring.get-key-info', async(requestId, armoredKey) => {
+    const controller = new GetKeyInfoController(worker, requestId);
+    await controller._exec(armoredKey);
+  });
+
+  worker.port.on('passbolt.recover.validate-private-key', async(requestId, key) => {
+    const controller = new ValidatePrivateGpgKeyRecoverController(worker, requestId);
+    await controller._exec(key);
+  });
+
+  worker.port.on('passbolt.recover.request-help-credentials-lost', async requestId => {
+    const controller = new AbortAndRequestHelp(worker, requestId, apiClientOptions, account);
+    await controller._exec();
+  });
+
+  worker.port.on('passbolt.port.generate-id', async requestId => {
+    const controller = new GeneratePortIdController(worker, requestId);
+    await controller._exec();
+  });
+
+  worker.port.on('passbolt.recover.get-user-passphrase-policies', async requestId => {
+    const controller = new GetUserPassphrasePoliciesController(worker, requestId, runtimeMemory);
+    await controller._exec();
   });
 };
-exports.listen = listen;
+export const RecoverEvents = {listen};

package/src/all/background_page/event/rememberMeEvents.js

@@ -0,0 +1,29 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.2.0
+ */
+
+import GetUserRememberMeLatestChoiceController from "../controller/rememberMe/getUserRememberMeLatestChoiceController";
+
+const listen = function(worker, _, account) {
+  /*
+   * Get the last rememberMe choice made by the user
+   *
+   * @listens passbolt.remember-me.get-user-latest-choice
+   */
+  worker.port.on('passbolt.remember-me.get-user-latest-choice', async requestId => {
+    const controller = new GetUserRememberMeLatestChoiceController(worker, requestId, account);
+    await controller._exec();
+  });
+};
+
+export const RememberMeEvents = {listen};

package/src/all/background_page/event/resourceEvents.js

@@ -4,25 +4,27 @@
  * @copyright (c) 2019 Passbolt SA
  * @licence GNU Affero General Public License http://www.gnu.org/licenses/agpl-3.0.en.html
  */
-const {User} = require('../model/user');
-const {Log} = require('../model/log');
-const {ResourceModel} = require('../model/resource/resourceModel');
+import ResourceModel from "../model/resource/resourceModel";
+import ResourceCreateController from "../controller/resource/resourceCreateController";
+import ResourceUpdateController from "../controller/resource/resourceUpdateController";
+import Log from "../model/log";
+import GetResourceGridUserSettingController
+  from "../controller/resourceGridSetting/getResourceGridUserSettingController";
+import SetResourceGridUserSettingController
+  from "../controller/resourceGridSetting/setResourceGridUserSettingController";
+import SetResourcesExpiryDateController from "../controller/resource/setResourcesExpiryDateController";
 
-const {ResourceCreateController} = require('../controller/resource/resourceCreateController.js');
-const {ResourceUpdateController} = require('../controller/resource/resourceUpdateController.js');
-
-const listen = function (worker) {
+const listen = function(worker, apiClientOptions, account) {
   /*
    * Pull the resources from the API and update the local storage.
    *
    * @listens passbolt.resources.update-local-storage
    * @param requestId {uuid} The request identifier
    */
-  worker.port.on('passbolt.resources.update-local-storage', async function (requestId) {
+  worker.port.on('passbolt.resources.update-local-storage', async requestId => {
     Log.write({level: 'debug', message: 'ResourceEvent listen passbolt.resources.update-local-storage'});
     try {
-      let apiClientOptions = await User.getInstance().getApiClientOptions();
-      let resourceModel = new ResourceModel(apiClientOptions);
+      const resourceModel = new ResourceModel(apiClientOptions, account);
       resourceModel.updateLocalStorage();
       worker.port.emit(requestId, 'SUCCESS');
     } catch (error) {
@@ -37,10 +39,9 @@ const listen = function (worker) {
    * @param requestId {uuid} The request identifier
    * @param options {object} The options to apply to the find
    */
-  worker.port.on('passbolt.resources.find-all', async function (requestId, options) {
+  worker.port.on('passbolt.resources.find-all', async(requestId, options) => {
     try {
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const resourceModel = new ResourceModel(clientOptions);
+      const resourceModel = new ResourceModel(apiClientOptions, account);
       const {contains, filters, orders} = options;
       const resources = await resourceModel.findAll(contains, filters, orders);
       worker.port.emit(requestId, 'SUCCESS', resources);
@@ -57,10 +58,9 @@ const listen = function (worker) {
    * @param requestId {uuid} The request identifier
    * @param options {object} The options to apply to the find
    */
-  worker.port.on('passbolt.resources.find-permissions', async function (requestId, resourceId) {
+  worker.port.on('passbolt.resources.find-permissions', async(requestId, resourceId) => {
     try {
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const resourceModel = new ResourceModel(clientOptions);
+      const resourceModel = new ResourceModel(apiClientOptions, account);
       const permissions = await resourceModel.findResourcePermissions(resourceId);
       worker.port.emit(requestId, 'SUCCESS', permissions);
     } catch (error) {
@@ -77,10 +77,9 @@ const listen = function (worker) {
    * @param resourceDto {object} The resource meta data
    * @param plaintextDto {string|object} The plaintext data to encrypt
    */
-  worker.port.on('passbolt.resources.create', async function (requestId, resourceDto, plaintextDto) {
+  worker.port.on('passbolt.resources.create', async(requestId, resourceDto, plaintextDto) => {
     try {
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const controller = new ResourceCreateController(worker, requestId, clientOptions);
+      const controller = new ResourceCreateController(worker, requestId, apiClientOptions, account);
       const savedResource = await controller.main(resourceDto, plaintextDto);
       worker.port.emit(requestId, 'SUCCESS', savedResource);
     } catch (error) {
@@ -96,11 +95,10 @@ const listen = function (worker) {
    * @param requestId {uuid} The request identifier
    * @param resourcesIds {array} The resources ids to delete
    */
-  worker.port.on('passbolt.resources.delete-all', async function (requestId, resourcesIds) {
+  worker.port.on('passbolt.resources.delete-all', async(requestId, resourcesIds) => {
     try {
       // TODO DeleteResourcesController with progress dialog if resourceIds > 1
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const resourceModel = new ResourceModel(clientOptions);
+      const resourceModel = new ResourceModel(apiClientOptions, account);
       await resourceModel.bulkDelete(resourcesIds);
       worker.port.emit(requestId, 'SUCCESS');
     } catch (error) {
@@ -117,10 +115,9 @@ const listen = function (worker) {
    * @param resource {array} The resource
    * @param editedPassword {} The resource
    */
-  worker.port.on('passbolt.resources.update', async function (requestId, resourceDto, plaintextDto) {
+  worker.port.on('passbolt.resources.update', async(requestId, resourceDto, plaintextDto) => {
     try {
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const controller = new ResourceUpdateController(worker, requestId, clientOptions);
+      const controller = new ResourceUpdateController(worker, requestId, apiClientOptions, account);
       const updatedResource = await controller.main(resourceDto, plaintextDto);
       worker.port.emit(requestId, 'SUCCESS', updatedResource);
     } catch (error) {
@@ -128,6 +125,41 @@ const listen = function (worker) {
       worker.port.emit(requestId, 'ERROR', error);
     }
   });
-}
 
-exports.listen = listen;
+  /*
+   * Get the resource grid setting
+   *
+   * @listens passbolt.resources.get-grid-setting
+   * @param requestId {uuid} The request identifier
+   */
+  worker.port.on('passbolt.resources.get-grid-setting', async requestId => {
+    const getResourceColumnsSettingsController = new GetResourceGridUserSettingController(worker, requestId, account);
+    await getResourceColumnsSettingsController._exec();
+  });
+
+  /*
+   * Set the resource grid setting
+   *
+   * @listens passbolt.resources.set-grid-setting
+   * @param requestId {uuid} The request identifier
+   * @param gridSetting {object} The grid setting
+   */
+  worker.port.on('passbolt.resources.set-grid-setting', async(requestId, gridSetting) => {
+    const setResourceColumnsSettingsController = new SetResourceGridUserSettingController(worker, requestId, account);
+    await setResourceColumnsSettingsController._exec(gridSetting);
+  });
+
+  /*
+   * Set the given resources expiration date
+   *
+   * @listens passbolt.resources.set-expiration-date
+   * @param requestId {uuid} The request identifier
+   * @param gridSetting {object} The grid setting
+   */
+  worker.port.on('passbolt.resources.set-expiration-date', async(requestId, passwordExpiryResourcesCollectionDto) => {
+    const controller = new SetResourcesExpiryDateController(worker, requestId, apiClientOptions);
+    await controller._exec(passwordExpiryResourcesCollectionDto);
+  });
+};
+
+export const ResourceEvents = {listen};

package/src/all/background_page/event/resourceTypeEvents.js

@@ -11,19 +11,22 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         3.0.6
  */
-const {ResourceTypeModel} = require("../model/resourceType/resourceTypeModel");
-const {User} = require('../model/user');
+import ResourceTypeModel from "../model/resourceType/resourceTypeModel";
 
-const listen = function (worker) {
+/**
+ * Listens the resource type events
+ * @param {Worker} worker
+ * @param {ApiClientOptions} apiClientOptions the api client options
+ */
+const listen = function(worker, apiClientOptions) {
   /*
    * Get the resource types from the local storage.
    *
    * @listens passbolt.resource-type.get-all
    * @param requestId {uuid} The request identifier
    */
-  worker.port.on('passbolt.resource-type.get-all', async function (requestId) {
+  worker.port.on('passbolt.resource-type.get-all', async requestId => {
     try {
-      const apiClientOptions = await User.getInstance().getApiClientOptions();
       const resourceTypeModel = new ResourceTypeModel(apiClientOptions);
       const resourceTypes = await resourceTypeModel.getOrFindAll();
       worker.port.emit(requestId, 'SUCCESS', resourceTypes);
@@ -31,6 +34,6 @@ const listen = function (worker) {
       worker.port.emit(requestId, 'ERROR', error);
     }
   });
-}
+};
 
-exports.listen = listen;
+export const ResourceTypeEvents = {listen};

package/src/all/background_page/event/roleEvents.js

@@ -11,20 +11,22 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         3.0.6
  */
-const {User} = require('../model/user');
-const {Log} = require('../model/log');
-const {RoleModel} = require("../model/role/roleModel");
+import RoleModel from "../model/role/roleModel";
 
-const listen = function (worker) {
+/**
+ * Listens the role events
+ * @param {Worker} worker
+ * @param {ApiClientOptions} apiClientOptions the api client options
+ */
+const listen = function(worker, apiClientOptions) {
   /*
-     * Get the resource types from the local storage.
-     *
-     * @listens passbolt.resource-type.get-all
-     * @param requestId {uuid} The request identifier
-     */
-  worker.port.on('passbolt.role.get-all', async function (requestId) {
+   * Get the resource types from the local storage.
+   *
+   * @listens passbolt.resource-type.get-all
+   * @param requestId {uuid} The request identifier
+   */
+  worker.port.on('passbolt.role.get-all', async requestId => {
     try {
-      const apiClientOptions = await User.getInstance().getApiClientOptions();
       const roleModel = new RoleModel(apiClientOptions);
       const roles = await roleModel.getOrFindAll();
       worker.port.emit(requestId, 'SUCCESS', roles);
@@ -32,6 +34,6 @@ const listen = function (worker) {
       worker.port.emit(requestId, 'ERROR', error);
     }
   });
-}
+};
 
-exports.listen = listen;
+export const RoleEvents = {listen};

package/src/all/background_page/event/secretEvents.js

@@ -5,30 +5,38 @@
  * @copyright (c) 2019 Passbolt SA
  * @licence GNU Affero General Public License http://www.gnu.org/licenses/agpl-3.0.en.html
  */
-const {SecretDecryptController} = require('../controller/secret/secretDecryptController');
-const {User} = require('../model/user');
+import SecretDecryptController from "../controller/secret/secretDecryptController";
+import PownedPasswordController from '../controller/secret/pownedPasswordController';
 
-const listen = function (worker) {
+/**
+ * Listens the secret events
+ * @param {Worker} worker
+ * @param {ApiClientOptions} apiClientOptions the api client options
+ * @param {AccountEntity} account the user account
+ */
+const listen = function(worker, apiClientOptions, account) {
   /*
    * Decrypt a given armored string.
    *
    * @listens passbolt.secret.decrypt
    * @param requestId {uuid} The request identifier
    */
-  worker.port.on('passbolt.secret.decrypt', async function (requestId, resourceId, options) {
-    try {
-      const apiClientOptions = await User.getInstance().getApiClientOptions();
-      let showProgress = true;
-      if (options && Object.prototype.hasOwnProperty.call(options, 'showProgress')) {
-        showProgress = options.showProgress;
-      }
-      const controller = new SecretDecryptController(worker, requestId, apiClientOptions);
-      const {plaintext} = await controller.main(resourceId, showProgress);
-      worker.port.emit(requestId, 'SUCCESS', plaintext);
-    } catch (error) {
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.secret.decrypt', async(requestId, resourceId) => {
+    const controller = new SecretDecryptController(worker, requestId, apiClientOptions, account);
+    await controller._exec(resourceId);
+  });
+
+  /*
+   * Check if password is powned
+   *
+   * @listens passbolt.secrets.powned-password
+   * @param requestId {uuid} The request identifier
+   * @param password {string} the password to check
+   */
+  worker.port.on('passbolt.secrets.powned-password', async(requestId, password) => {
+    const controller = new PownedPasswordController(worker, requestId);
+    await controller._exec(password);
   });
 };
 
-exports.listen = listen;
+export const SecretEvents = {listen};