passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/controller/setup/startSetupController.js

@@ -0,0 +1,120 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * 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) 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         3.6.0
+ */
+import AuthModel from "../../model/auth/authModel";
+import SetupModel from "../../model/setup/setupModel";
+import {OpenpgpAssertion} from "../../utils/openpgp/openpgpAssertions";
+import WorkerService from "../../service/worker/workerService";
+
+class StartSetupController {
+  /**
+   * Constructor.
+   * @param {Worker} worker The associated worker.
+   * @param {string} requestId The associated request id.
+   * @param {ApiClientOptions} apiClientOptions The api client options.
+   * @param {AccountEntity} account The account being setting up.
+   * @param {Object} runtimeMemory The setup runtime memory.
+   */
+  constructor(worker, requestId, apiClientOptions, account, runtimeMemory) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.account = account;
+    this.authModel = new AuthModel(apiClientOptions);
+    this.setupModel = new SetupModel(apiClientOptions);
+    this.runtimeMemory = runtimeMemory;
+  }
+
+  /**
+   * Controller executor.
+   * @returns {Promise<void>}
+   */
+  async _exec() {
+    try {
+      await this.exec();
+      this.worker.port.emit(this.requestId, 'SUCCESS');
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Import user key.
+   * @returns {Promise<void>}
+   */
+  async exec() {
+    try {
+      await this._findAndSetAccountSetupServerPublicKey();
+      await this._findAndSetAccountSetupMeta();
+    } catch (error) {
+      await this._handleUnexpectedError(error);
+    }
+  }
+
+  /**
+   * Find and set the account server public key.
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _findAndSetAccountSetupServerPublicKey() {
+    const serverKeyDto = await this.authModel.getServerKey();
+    const serverPublicKey = await OpenpgpAssertion.readKeyOrFail(serverKeyDto.armored_key);
+    OpenpgpAssertion.assertPublicKey(serverPublicKey);
+
+    // associate the server public key to the account being set up.
+    this.account.serverPublicArmoredKey = serverPublicKey.armor();
+  }
+
+  /**
+   * Find and set account user meta.
+   * @returns {Promise<void>}
+   * @private
+   */
+  async _findAndSetAccountSetupMeta() {
+    const {user, accountRecoveryOrganizationPolicy, userPassphrasePolicies} = await this.setupModel.startSetup(
+      this.account.userId,
+      this.account.authenticationTokenToken
+    );
+
+    // Associate the user meta to the account being set up.
+    this.account.username = user?.username;
+    this.account.firstName = user?.profile.firstName;
+    this.account.lastName = user?.profile.lastName;
+
+    // As of v3.6.0 the user is stored only to know if account recovery was enabled for this account.
+    this.account.user = user;
+
+    // Keep the account recovery organization policy in the setup runtime memory.
+    if (accountRecoveryOrganizationPolicy) {
+      this.runtimeMemory.accountRecoveryOrganizationPolicy = accountRecoveryOrganizationPolicy;
+    }
+
+    // Keep the user passphrase policies in the setup runtime memory.
+    if (userPassphrasePolicies) {
+      this.runtimeMemory.userPassphrasePolicies = userPassphrasePolicies;
+    }
+  }
+
+  /**
+   * Handle unexpected error.
+   * Close the iframe and let the application served by the API handle the user.
+   * @param {Error} error The error.
+   * @private
+   */
+  async _handleUnexpectedError(error) {
+    (await WorkerService.get('SetupBootstrap', this.worker.tab.id)).port.emit('passbolt.setup-bootstrap.remove-iframe');
+    throw error;
+  }
+}
+
+export default StartSetupController;

package/src/all/background_page/controller/setup/startSetupController.test.js

@@ -0,0 +1,168 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * 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) 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         3.6.0
+ */
+
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import StartSetupController from "./startSetupController";
+import {enableFetchMocks} from "jest-fetch-mock";
+import {mockApiResponse} from "../../../../../test/mocks/mockApiResponse";
+import {defaultUserDto} from "passbolt-styleguide/src/shared/models/entity/user/userEntity.test.data";
+import {defaultVerifyDto} from "../../model/entity/auth/auth.test.data";
+import GetGpgKeyInfoService from "../../service/crypto/getGpgKeyInfoService";
+import UserEntity from "../../model/entity/user/userEntity";
+import {initialAccountSetupDto} from "../../model/entity/account/accountSetupEntity.test.data";
+import AccountSetupEntity from "../../model/entity/account/accountSetupEntity";
+import {OpenpgpAssertion} from "../../utils/openpgp/openpgpAssertions";
+import WorkerService from "../../service/worker/workerService";
+import AccountRecoveryOrganizationPolicyEntity from "../../model/entity/accountRecovery/accountRecoveryOrganizationPolicyEntity";
+import UserPassphrasePoliciesEntity from "passbolt-styleguide/src/shared/models/entity/userPassphrasePolicies/userPassphrasePoliciesEntity";
+import {defaultUserPassphrasePoliciesEntityDto} from "passbolt-styleguide/src/shared/models/userPassphrasePolicies/UserPassphrasePoliciesDto.test.data";
+import {enabledAccountRecoveryOrganizationPolicyDto} from "../../model/entity/accountRecovery/accountRecoveryOrganizationPolicyEntity.test.data";
+
+// Reset the modules before each test.
+beforeEach(() => {
+  enableFetchMocks();
+});
+
+describe("StartSetupController", () => {
+  describe("StartSetupController::exec", () => {
+    it("Should initiate the setup process and retrieve the setup material", async() => {
+      const account = new AccountSetupEntity(initialAccountSetupDto());
+      const runtimeMemory = {};
+      const controller = new StartSetupController(null, null, defaultApiClientOptions(), account, runtimeMemory);
+
+      // Mock API fetch organization settings
+      const mockVerifyDto = defaultVerifyDto();
+      fetch.doMockOnce(() => mockApiResponse(mockVerifyDto));
+      // Mock API fetch setup start.
+      const mockSetupStartDto = {user: defaultUserDto()};
+      fetch.doMockOnce(() => mockApiResponse(mockSetupStartDto));
+
+      expect.assertions(7);
+      await controller.exec();
+      const key = await OpenpgpAssertion.readKeyOrFail(mockVerifyDto.keydata);
+      expect(account.serverPublicArmoredKey).toEqual((await GetGpgKeyInfoService.getKeyInfo(key)).armoredKey);
+      expect(account.username).toEqual(mockSetupStartDto.user.username);
+      expect(account.firstName).toEqual(mockSetupStartDto.user.profile.first_name);
+      expect(account.lastName).toEqual(mockSetupStartDto.user.profile.last_name);
+      expect(account.user.toDto(UserEntity.ALL_CONTAIN_OPTIONS)).toEqual(mockSetupStartDto.user);
+      expect(runtimeMemory.accountRecoveryOrganizationPolicy).toBeUndefined();
+      expect(runtimeMemory.userPassphrasePolicies).toBeUndefined();
+    }, 10 * 1000);
+
+    it("Should initiate the setup process and retrieve the setup material with all configuration", async() => {
+      const account = new AccountSetupEntity(initialAccountSetupDto());
+      const accountRecoveryOrganizationPolicyDto = enabledAccountRecoveryOrganizationPolicyDto();
+      const userPassphrasePoliciesDto = defaultUserPassphrasePoliciesEntityDto();
+      const runtimeMemory = {};
+      const controller = new StartSetupController(null, null, defaultApiClientOptions(), account, runtimeMemory);
+
+      // Mock API fetch organization settings
+      const mockVerifyDto = defaultVerifyDto();
+      fetch.doMockOnce(() => mockApiResponse(mockVerifyDto));
+      // Mock API fetch setup start.
+      const mockSetupStartDto = {
+        user: defaultUserDto(),
+        account_recovery_organization_policy: accountRecoveryOrganizationPolicyDto,
+        user_passphrase_policy: userPassphrasePoliciesDto
+      };
+      fetch.doMockOnce(() => mockApiResponse(mockSetupStartDto));
+
+      expect.assertions(7);
+      await controller.exec();
+      const key = await OpenpgpAssertion.readKeyOrFail(mockVerifyDto.keydata);
+      expect(account.serverPublicArmoredKey).toEqual((await GetGpgKeyInfoService.getKeyInfo(key)).armoredKey);
+      expect(account.username).toEqual(mockSetupStartDto.user.username);
+      expect(account.firstName).toEqual(mockSetupStartDto.user.profile.first_name);
+      expect(account.lastName).toEqual(mockSetupStartDto.user.profile.last_name);
+      expect(account.user.toDto(UserEntity.ALL_CONTAIN_OPTIONS)).toEqual(mockSetupStartDto.user);
+      expect(runtimeMemory.accountRecoveryOrganizationPolicy).toStrictEqual(new AccountRecoveryOrganizationPolicyEntity(accountRecoveryOrganizationPolicyDto));
+      expect(runtimeMemory.userPassphrasePolicies).toStrictEqual(new UserPassphrasePoliciesEntity(userPassphrasePoliciesDto));
+    }, 10 * 1000);
+
+    it("Should not initiate the setup if the API does not provide a valid server public key", async() => {
+      const mockedWorker = {tab: {id: "tabID"}};
+      const account = new AccountSetupEntity(initialAccountSetupDto());
+      const runtimeMemory = {};
+      const controller = new StartSetupController(mockedWorker, null, defaultApiClientOptions(), account, runtimeMemory);
+
+      // Mock API fetch verify
+      const mockVerifyDto = defaultVerifyDto({keydata: "not a valid key"});
+      fetch.doMockOnce(() => mockApiResponse(mockVerifyDto));
+      // Mock Worker to assert error handler.
+      const mockedBootstrapSetupWorkerPortEmit = jest.fn();
+      WorkerService.get = jest.fn(() => ({
+        port: {
+          emit: mockedBootstrapSetupWorkerPortEmit
+        }
+      }));
+
+      expect.assertions(2);
+      const promise = controller.exec();
+      await expect(promise).rejects.toThrowError("The key should be a valid openpgp armored key string.");
+      expect(mockedBootstrapSetupWorkerPortEmit).toHaveBeenCalledWith("passbolt.setup-bootstrap.remove-iframe");
+    });
+
+    it("Should not initiate the setup if the API does not provide a valid user", async() => {
+      const mockedWorker = {tab: {id: "tabID"}};
+      const account = new AccountSetupEntity(initialAccountSetupDto());
+      const runtimeMemory = {};
+      const controller = new StartSetupController(mockedWorker, null, defaultApiClientOptions(), account, runtimeMemory);
+
+      // Mock API fetch organization settings
+      const mockVerifyDto = defaultVerifyDto();
+      fetch.doMockOnce(() => mockApiResponse(mockVerifyDto));
+      // Mock API fetch setup start.
+      const mockSetupStartDto = {user: null};
+      fetch.doMockOnce(() => mockApiResponse(mockSetupStartDto));
+      // Mock Worker to assert error handler.
+      const mockedBootstrapSetupWorkerPortEmit = jest.fn();
+      WorkerService.get = jest.fn(() => ({
+        port: {
+          emit: mockedBootstrapSetupWorkerPortEmit
+        }
+      }));
+
+      expect.assertions(2);
+      const promise = controller.exec();
+      await expect(promise).rejects.toThrowError("Could not validate property username.");
+      expect(mockedBootstrapSetupWorkerPortEmit).toHaveBeenCalledWith("passbolt.setup-bootstrap.remove-iframe");
+    });
+
+    it("Should not initiate the setup if the API does not provide a valid account recovery organization policy (not mandatory)", async() => {
+      const mockedWorker = {tab: {id: "tabID"}};
+      const account = new AccountSetupEntity(initialAccountSetupDto());
+      const runtimeMemory = {};
+      const controller = new StartSetupController(mockedWorker, null, defaultApiClientOptions(), account, runtimeMemory);
+
+      // Mock API fetch organization settings
+      const mockVerifyDto = defaultVerifyDto();
+      fetch.doMockOnce(() => mockApiResponse(mockVerifyDto));
+      // Mock API fetch setup start.
+      const mockSetupStartDto = {user: defaultUserDto(), account_recovery_organization_policy: {status: "not-valid-status"}};
+      fetch.doMockOnce(() => mockApiResponse(mockSetupStartDto));
+      // Mock Worker to assert error handler.
+      const mockedBootstrapSetupWorkerPortEmit = jest.fn();
+      WorkerService.get = jest.fn(() => ({
+        port: {
+          emit: mockedBootstrapSetupWorkerPortEmit
+        }
+      }));
+
+      expect.assertions(2);
+      const promise = controller.exec();
+      await expect(promise).rejects.toThrowError("Could not validate entity AccountRecoveryOrganizationPolicy.");
+      expect(mockedBootstrapSetupWorkerPortEmit).toHaveBeenCalledWith("passbolt.setup-bootstrap.remove-iframe");
+    });
+  });
+});

package/src/all/background_page/controller/setup/verifyImportedKeyPassphraseController.js

@@ -0,0 +1,72 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * 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) 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         3.6.0
+ */
+
+import {OpenpgpAssertion} from "../../utils/openpgp/openpgpAssertions";
+import DecryptPrivateKeyService from "../../service/crypto/decryptPrivateKeyService";
+
+class VerifyImportedKeyPassphraseController {
+  /**
+   * Constructor.
+   * @param {Worker} worker The associated worker.
+   * @param {string} requestId The associated request id.
+   * @param {AbstractAccountEntity} account The account associated to the worker.
+   * @param {Object} runtimeMemory The setup runtime memory.
+   */
+  constructor(worker, requestId, account, runtimeMemory) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.account = account;
+    this.runtimeMemory = runtimeMemory;
+    this.runtimeMemory.passphrase = null;
+  }
+
+  /**
+   * Controller executor.
+   * @param {string} passphrase The passphrase with which to check setup's private key decryption
+   * @returns {Promise<void>}
+   */
+  async _exec(passphrase) {
+    try {
+      await this.exec(passphrase);
+      this.worker.port.emit(this.requestId, 'SUCCESS');
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Verify the imported key passphrase and store the passphrase in the runtime memory.
+   * @param {string} passphrase The passphrase.
+   * @throws {Error} if the account does not have a user private key yet defined.
+   * @throws {TypeError} if the passphrase is not a valid string.
+   * @throws {InvalidMasterPasswordError} if the passphrase can't be used to decrypt the account user private key.
+   * @returns {Promise<void>}
+   */
+  async exec(passphrase) {
+    const privateArmoredKey = this.account?.userPrivateArmoredKey;
+    if (!privateArmoredKey) {
+      throw new Error('An account user private key is required.');
+    }
+    if (typeof passphrase !== "string") {
+      throw new TypeError("The passphrase should be a string.");
+    }
+    const privateKey = await OpenpgpAssertion.readKeyOrFail(privateArmoredKey);
+    await DecryptPrivateKeyService.decrypt(privateKey, passphrase);
+    // The passphrase will be later use to sign in the user.
+    this.runtimeMemory.passphrase = passphrase;
+  }
+}
+
+export default VerifyImportedKeyPassphraseController;

package/src/all/background_page/controller/setup/verifyImportedKeyPassphraseController.test.js

@@ -0,0 +1,63 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * 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) 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         3.6.0
+ */
+import VerifyImportedKeyPassphraseController from "./verifyImportedKeyPassphraseController";
+import InvalidMasterPasswordError from "../../error/invalidMasterPasswordError";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import {pgpKeys} from "../../../../../test/fixtures/pgpKeys/keys";
+
+describe("VerifyImportedKeyPassphraseController", () => {
+  describe("VerifyImportedKeyPassphraseController::exec", () => {
+    it("Should pass if the passphrase is correct.", async() => {
+      const account = new AccountEntity(defaultAccountDto());
+      const runtimeMemory = {};
+      const controller = new VerifyImportedKeyPassphraseController(null, null, account, runtimeMemory);
+
+      expect.assertions(1);
+      const promise = controller.exec(pgpKeys.ada.passphrase);
+      await expect(promise).resolves.toBeUndefined();
+    }, 10000);
+
+    it("Should throw an exception if no passphrase provided.", () => {
+      const account = new AccountEntity(defaultAccountDto());
+      const runtimeMemory = {};
+      const controller = new VerifyImportedKeyPassphraseController(null, null, account, runtimeMemory);
+
+      expect.assertions(1);
+      const promise = controller.exec();
+      return expect(promise).rejects.toThrowError(new TypeError("The passphrase should be a string."));
+    }, 10000);
+
+    it("Should throw an exception if the passphrase is incorrect.", () => {
+      const account = new AccountEntity(defaultAccountDto());
+      const runtimeMemory = {};
+      const controller = new VerifyImportedKeyPassphraseController(null, null, account, runtimeMemory);
+
+      expect.assertions(1);
+      const promise = controller.exec("wrong passphrase");
+      return expect(promise).rejects.toThrowError(new InvalidMasterPasswordError());
+    }, 10000);
+
+    it("Should throw an exception if the setupEntity doesn't have a private key set.", () => {
+      const account = new AccountEntity(defaultAccountDto());
+      delete account._props.user_private_armored_key;
+      const runtimeMemory = {};
+      const controller = new VerifyImportedKeyPassphraseController(null, null, account, runtimeMemory);
+
+      expect.assertions(1);
+      const promise = controller.exec("whatever passphrase");
+      return expect(promise).rejects.toThrowError(new Error("An account user private key is required."));
+    });
+  });
+});

package/src/all/background_page/controller/share/shareFoldersController.js

@@ -11,16 +11,16 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since         2.8.0
  */
-const {Crypto} = require('../../model/crypto');
-const {Keyring} = require('../../model/keyring');
-const {Share} = require('../../model/share');
-const {FolderModel} = require('../../model/folder/folderModel');
-const {ResourceModel} = require('../../model/resource/resourceModel');
-const {PermissionChangesCollection} = require('../../model/entity/permission/change/permissionChangesCollection');
-const {FoldersCollection} = require('../../model/entity/folder/foldersCollection');
-
-const passphraseController = require('../passphrase/passphraseController');
-const progressController = require('../progress/progressController');
+import Keyring from "../../model/keyring";
+import ResourceModel from "../../model/resource/resourceModel";
+import GetPassphraseService from "../../service/passphrase/getPassphraseService";
+import GetDecryptedUserPrivateKeyService from "../../service/account/getDecryptedUserPrivateKeyService";
+import FolderModel from "../../model/folder/folderModel";
+import FoldersCollection from "../../model/entity/folder/foldersCollection";
+import PermissionChangesCollection from "../../model/entity/permission/change/permissionChangesCollection";
+import i18n from "../../sdk/i18n";
+import ProgressService from "../../service/progress/progressService";
+import ShareModel from "../../model/share/shareModel";
 
 class ShareFoldersController {
   /**
@@ -28,16 +28,16 @@ class ShareFoldersController {
    *
    * @param {Worker} worker
    * @param {string} requestId uuid
-   * @param {ApiClientOptions} apiClientOptions
+   * @param {ApiClientOptions} apiClientOptions the api client options
+   * @param {AccountEntity} account The account associated to the worker.
    */
-  constructor(worker, requestId, apiClientOptions) {
+  constructor(worker, requestId, apiClientOptions, account) {
     this.worker = worker;
     this.requestId = requestId;
     this.folderModel = new FolderModel(apiClientOptions);
-    this.resourceModel = new ResourceModel(apiClientOptions);
+    this.resourceModel = new ResourceModel(apiClientOptions, account);
+    this.shareModel = new ShareModel(apiClientOptions);
     this.keyring = new Keyring();
-    this.crypto = new Crypto();
-
     // Work variables
     this.folders = null;
     this.folder = null;
@@ -50,6 +50,9 @@ class ShareFoldersController {
 
     this.passphrase = null;
     this.privateKey = null;
+
+    this.progressService = new ProgressService(this.worker);
+    this.getPassphraseService = new GetPassphraseService(account);
   }
 
   /**
@@ -64,23 +67,26 @@ class ShareFoldersController {
 
     try {
       await this.getPassphrase();
-    } catch(error) {
+    } catch (error) {
       this.cleanup();
       throw error;
     }
 
     try {
-      await progressController.open(this.worker, `Sharing folder ${this.folder.name}`, 1, 'Initializing...');
+      this.progressService.title = i18n.t('Sharing folder {{name}}', {name: this.folder.name});
+      this.progressService.start(null, i18n.t('Initializing ...'));
       await this.findAllForShare();
-      await this.setGoals();
-      await this.calculateChanges();
+      this.progressService.updateGoals(this.getGoals());
+
+      await this.progressService.finishStep(i18n.t('Calculating changes...'), true);
+      this.calculateChanges();
       await this.share();
-      await progressController.update(this.worker, this.goals, 'Done');
-      await progressController.close(this.worker);
-      this.cleanup()
-    } catch(error) {
-      await progressController.close(this.worker);
-      this.cleanup()
+      await this.progressService.finishStep(i18n.t('Done'), true);
+      await this.progressService.close();
+      this.cleanup();
+    } catch (error) {
+      await this.progressService.close();
+      this.cleanup();
       throw error;
     }
   }
@@ -105,7 +111,7 @@ class ShareFoldersController {
     this.originalChanges = changes;
 
     if (!this.folder.isOwner()) {
-      throw new Error('The folder cannot be shared. Insufficient rights.');
+      throw new Error(i18n.t('The folder cannot be shared. Insufficient rights.'));
     }
   }
 
@@ -114,10 +120,12 @@ class ShareFoldersController {
    * @returns {Promise<void>}
    */
   async getPassphrase() {
-    // Get the passphrase if needed and decrypt secret key
-    // We do this to confirm the move even if there is nothing to decrypt/re-encrypt
-    const passphrase = await passphraseController.get(this.worker);
-    this.privateKey = await this.crypto.getAndDecryptPrivateKey(passphrase);
+    /*
+     * Get the passphrase if needed and decrypt secret key
+     * We do this to confirm the move even if there is nothing to decrypt/re-encrypt
+     */
+    const passphrase = await this.getPassphraseService.getPassphrase(this.worker);
+    this.privateKey = await GetDecryptedUserPrivateKeyService.getKey(passphrase);
   }
 
   /**
@@ -125,8 +133,10 @@ class ShareFoldersController {
    * @returns {Promise<void>}
    */
   async findAllForShare() {
-    // Get all folders contained in this folder
-    // and get all the resources contain in this folder and subfolders
+    /*
+     * Get all folders contained in this folder
+     * and get all the resources contain in this folder and subfolders
+     */
     this.subFolders = await this.folderModel.getAllChildren([this.folder.id]);
     this.resources = await this.resourceModel.getAllByParentIds([this.folder.id, ...this.subFolders.ids]);
 
@@ -145,34 +155,32 @@ class ShareFoldersController {
 
   /**
    * Set goals and init progress counter
-   * @returns {Promise<void>}
+   * @returns {number}
    */
-  async setGoals() {
-    // calculate changes for folder + subfolders + resources
-    // init + (folders to update * 2) + (resources to update * get secret, decrypt, encrypt, share) + sync keyring
-    this.goals = 3 + (this.subFolders.length * 2) + (this.resources.length * 4);
-    this.progress = 0;
-    await progressController.updateGoals(this.worker, this.goals);
-    await progressController.update(this.worker, this.progress++, 'Calculating changes...');
+  getGoals() {
+    /*
+     * calculate changes for folder + subfolders + resources
+     * init + (folders to update * 2) + (resources to update * get secret, decrypt, encrypt, share) + sync keyring
+     */
+    return 3 + (this.subFolders.length * 2) + (this.resources.length * 4);
   }
 
   /**
-   *
-   * @returns {Promise<void>}
+   * Build changes to be used in bulk share
    */
   calculateChanges() {
     // Add current folder changes to final folders changes
     this.foldersChanges.merge(this.originalChanges);
 
     // Calculate changes for subfolders
-    for (let subfolder of this.subFolders) {
+    for (const subfolder of this.subFolders) {
       this.foldersChanges.merge(PermissionChangesCollection.reuseChanges(
         subfolder.permission.aco, subfolder.id, subfolder.permissions, this.originalChanges, this.folder.permissions
       ));
     }
 
     // Calculate changes for resources inside these folders
-    for (let resource of this.resources) {
+    for (const resource of this.resources) {
       this.resourcesChanges.merge(PermissionChangesCollection.reuseChanges(
         resource.permission.aco, resource.id, resource.permissions, this.originalChanges, this.folder.permissions
       ));
@@ -186,21 +194,22 @@ class ShareFoldersController {
   async share() {
     // Update folders permissions
     if (this.foldersChanges.length) {
-      let folders = new FoldersCollection([this.folder]);
+      const folders = new FoldersCollection([this.folder]);
       folders.merge(this.subFolders);
-      await Share.bulkShareFolders(folders, this.foldersChanges, this.folderModel,  async message => {
-        await progressController.update(this.worker, this.progress++, message);
+      await this.shareModel.bulkShareFolders(folders, this.foldersChanges,  async message => {
+        await this.progressService.finishStep(message);
       });
+      await this.folderModel.updateLocalStorage();
     }
 
     // Share resources
     if (this.resourcesChanges.length) {
-      let resourcesDto = this.resources.toDto({secrets:true});
-      let changesDto = this.resourcesChanges.toDto();
-      await progressController.update(this.worker, this.progress++, 'Synchronizing keys');
+      const resourcesDto = this.resources.toDto({secrets: true});
+      const changesDto = this.resourcesChanges.toDto();
+      await this.progressService.finishStep(i18n.t('Synchronizing keys'), true);
       await this.keyring.sync();
-      await Share.bulkShareResources(resourcesDto, changesDto, this.privateKey, async message => {
-        await progressController.update(this.worker, this.progress++, message);
+      await this.shareModel.bulkShareResources(resourcesDto, changesDto, this.privateKey, async message => {
+        await this.progressService.finishStep(message);
       });
       await this.resourceModel.updateLocalStorage();
     }
@@ -215,4 +224,4 @@ class ShareFoldersController {
   }
 }
 
-exports.ShareFoldersController = ShareFoldersController;
+export default ShareFoldersController;