passbolt-browser-extension 3.0.6 → 4.6.2

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

@@ -6,37 +6,50 @@
  * @copyright (c) 2017 Passbolt SARL
  * @licence GNU Affero General Public License http://www.gnu.org/licenses/agpl-3.0.en.html
  */
-const {User} = require('../model/user');
-const {UserModel} = require('../model/user/userModel');
-const {UserEntity} = require('../model/entity/user/userEntity');
-const {UserDeleteTransferEntity} = require('../model/entity/user/transfer/userDeleteTransfer');
-const {AvatarUpdateEntity} = require("../model/entity/avatar/update/avatarUpdateEntity");
+import UserModel from "../model/user/userModel";
+import AccountModel from "../model/account/accountModel";
+import UpdatePrivateKeyController from "../controller/account/updatePrivateKeyController";
+import UserDeleteTransferEntity from "../model/entity/user/transfer/userDeleteTransfer";
+import UserEntity from "../model/entity/user/userEntity";
+import SecurityTokenEntity from "../model/entity/securityToken/securityTokenEntity";
+import AvatarUpdateEntity from "../model/entity/avatar/update/avatarUpdateEntity";
+import UpdateUserLocalStorageController from "../controller/user/updateUserLocalStorageController";
+import GetOrFindLoggedInUserController from "../controller/user/getOrFindLoggedInUserController";
+import UpdateUserController from "../controller/user/updateUserController";
 
-const listen = function (worker) {
-
-  /* ==================================================================================
+/**
+ * Listens the user events
+ * @param {Worker} worker
+ * @param {ApiClientOptions} apiClientOptions the api client options
+ * @param {AccountEntity} account the user account
+ */
+const listen = function(worker, apiClientOptions, account) {
+  /*
+   * ==================================================================================
    *  Getters for user
-   * ================================================================================== */
-
+   * ==================================================================================
+   */
   /*
-   * Get the current user as stored in the plugin.
+   * Get the users from the local storage.
    *
-   * @listens passbolt.user.get
+   * @listens passbolt.users.get-all
    * @param requestId {uuid} The request identifier
-   * @param data {array} The user filter
    */
-  worker.port.on('passbolt.user.get', function (requestId, data) {
+  worker.port.on('passbolt.users.get-all', async requestId => {
     try {
-      const user = User.getInstance().get(data);
-      worker.port.emit(requestId, 'SUCCESS', user);
-    } catch (e) {
-      worker.port.emit(requestId, 'ERROR', e.message);
+      const userModel = new UserModel(apiClientOptions, account);
+      const users = await userModel.getOrFindAll();
+      worker.port.emit(requestId, 'SUCCESS', users);
+    } catch (error) {
+      worker.port.emit(requestId, 'ERROR', error);
     }
   });
 
-  /* ==================================================================================
+  /*
+   * ==================================================================================
    *  CRUD
-   * ================================================================================== */
+   * ==================================================================================
+   */
   /*
    * Create a user user
    *
@@ -45,14 +58,13 @@ const listen = function (worker) {
    * @param userDto {Object} The user object, example:
    *  {username: 'ada@passbolt.com', profile: {first_name: 'ada', last_name: 'lovelace'}, role_id: <UUID>}
    */
-  worker.port.on('passbolt.users.create', async function (requestId, userDto) {
+  worker.port.on('passbolt.users.create', async(requestId, userDto) => {
     try {
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const userModel = new UserModel(clientOptions);
+      const userModel = new UserModel(apiClientOptions, account);
       const userEntity = new UserEntity(userDto);
       const updatedUser = await userModel.create(userEntity);
       worker.port.emit(requestId, 'SUCCESS', updatedUser);
-    } catch(error) {
+    } catch (error) {
       console.error(error);
       worker.port.emit(requestId, 'ERROR', error);
     }
@@ -64,40 +76,23 @@ const listen = function (worker) {
    * @listens passbolt.users.find-logged-in-user
    * @param requestId {uuid} The request identifier
    */
-  worker.port.on('passbolt.users.find-logged-in-user', async function (requestId) {
-    try {
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const userModel = new UserModel(clientOptions);
-      const loggedInUserId = User.getInstance().get().id;
-      const contains = {profile: true, role: true};
-      const userEntity = await userModel.findOne(loggedInUserId, contains, true);
-      worker.port.emit(requestId, 'SUCCESS', userEntity);
-    } catch(error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.users.find-logged-in-user', async(requestId, refreshCache) => {
+    const controller = new GetOrFindLoggedInUserController(worker, requestId, apiClientOptions, account);
+    await controller._exec(refreshCache);
   });
 
   /*
    * Update a user
    * Can be used to change the role or firstname/lastname but nothing else
    *
-   * @listens passbolt.user.update
+   * @listens passbolt.users.update
    * @param requestId {uuid} The request identifier
    * @param userDato {Object} The user object, example:
    *  {id: <UUID>, username: 'ada@passbolt.com', profile: {first_name: 'ada', last_name: 'lovelace'}, role_id: <UUID>}
    */
-  worker.port.on('passbolt.users.update', async function (requestId, userDto) {
-    try {
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const userModel = new UserModel(clientOptions);
-      const userEntity = new UserEntity(userDto);
-      const updatedUser = await userModel.update(userEntity, true);
-      worker.port.emit(requestId, 'SUCCESS', updatedUser);
-    } catch(error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.users.update', async(requestId, userDto) => {
+    const controller = new UpdateUserController(worker, requestId, apiClientOptions, account);
+    await controller._exec(userDto);
   });
 
   /*
@@ -108,33 +103,64 @@ const listen = function (worker) {
    * @param avatarBase64UpdateDto {object} The avatar dto
    *  {fileBase64: <string>, mimeType: <string>, filename: <string>}
    */
-  worker.port.on('passbolt.users.update-avatar', async function (requestId, userId, avatarBase64UpdateDto) {
+  worker.port.on('passbolt.users.update-avatar', async(requestId, userId, avatarBase64UpdateDto) => {
     try {
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const userModel = new UserModel(clientOptions);
+      const userModel = new UserModel(apiClientOptions, account);
       const avatarUpdateEntity = AvatarUpdateEntity.createFromFileBase64(avatarBase64UpdateDto);
       const updatedUser = await userModel.updateAvatar(userId, avatarUpdateEntity, true);
       worker.port.emit(requestId, 'SUCCESS', updatedUser);
-    } catch(error) {
+    } catch (error) {
+      console.error(error);
+      worker.port.emit(requestId, 'ERROR', error);
+    }
+  });
+
+  /*
+   * Update a user avatar
+   *
+   * @listens passbolt.users.update-security-token
+   * @param requestId {uuid} The request identifier
+   * @param {{code: string, color: string, textColor: string}} securityTokenDto
+   *
+   */
+  worker.port.on('passbolt.users.update-security-token', async(requestId, securityTokenDto) => {
+    try {
+      const accountModel = new AccountModel(apiClientOptions, account);
+      const securityTokenEntity = new SecurityTokenEntity(securityTokenDto);
+      await accountModel.changeSecurityToken(securityTokenEntity);
+      worker.port.emit(requestId, 'SUCCESS');
+    } catch (error) {
       console.error(error);
       worker.port.emit(requestId, 'ERROR', error);
     }
   });
 
+  /*
+   * Update the private key of the user and send the new recovery kit
+   *
+   * @listens passbolt.user.update-private-key
+   * @param requestId {uuid} The request identifier
+   * @param oldPassphrase {string} The old passphrase
+   * @param newPassphrase {string} The new passphrase
+   */
+  worker.port.on('passbolt.user.update-private-key', async(requestId, oldPassphrase, newPassphrase) => {
+    const controller = new UpdatePrivateKeyController(worker, requestId, apiClientOptions);
+    await controller._exec(oldPassphrase, newPassphrase);
+  });
+
   /*
    * Delete a user - dry run
    *
    * @param {string} requestId The request identifier uuid
    * @param {string} userId The user uuid
    */
-  worker.port.on('passbolt.users.delete-dry-run', async function (requestId, userId, transferDto) {
+  worker.port.on('passbolt.users.delete-dry-run', async(requestId, userId, transferDto) => {
     try {
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const userModel = new UserModel(clientOptions);
+      const userModel = new UserModel(apiClientOptions, account);
       const transferEntity = transferDto ? new UserDeleteTransferEntity(transferDto) : null;
       await userModel.deleteDryRun(userId, transferEntity);
       worker.port.emit(requestId, 'SUCCESS');
-    } catch(error) {
+    } catch (error) {
       console.error(error);
       worker.port.emit(requestId, 'ERROR', error);
     }
@@ -147,22 +173,23 @@ const listen = function (worker) {
    * @param {string} userId The user uuid
    * @param {object} [transferDto] optional data ownership transfer
    */
-  worker.port.on('passbolt.users.delete', async function (requestId, userId, transferDto) {
+  worker.port.on('passbolt.users.delete', async(requestId, userId, transferDto) => {
     try {
-      const clientOptions = await User.getInstance().getApiClientOptions();
-      const userModel = new UserModel(clientOptions);
+      const userModel = new UserModel(apiClientOptions, account);
       const transferEntity = transferDto ? new UserDeleteTransferEntity(transferDto) : null;
       await userModel.delete(userId, transferEntity);
       worker.port.emit(requestId, 'SUCCESS');
-    } catch(error) {
+    } catch (error) {
       console.error(error);
       worker.port.emit(requestId, 'ERROR', error);
     }
   });
 
-  /* ==================================================================================
+  /*
+   * ==================================================================================
    *  Others
-   * ================================================================================== */
+   * ==================================================================================
+   */
 
   /*
    * Pull the users from the API and update the local storage.
@@ -170,15 +197,9 @@ const listen = function (worker) {
    * @listens passbolt.users.update-local-storage
    * @param {uuid} requestId The request identifier
    */
-  worker.port.on('passbolt.users.update-local-storage', async function (requestId) {
-    try {
-      let userModel = new UserModel(await User.getInstance().getApiClientOptions());
-      await userModel.updateLocalStorage();
-      worker.port.emit(requestId, 'SUCCESS');
-    } catch (error) {
-      console.error(error);
-      worker.port.emit(requestId, 'ERROR', error);
-    }
+  worker.port.on('passbolt.users.update-local-storage', async requestId => {
+    const controller = new UpdateUserLocalStorageController(worker, requestId, apiClientOptions, account);
+    await controller._exec();
   });
 
   /*
@@ -188,9 +209,9 @@ const listen = function (worker) {
    * @param {uuid} requestId The request identifier
    * @param {string} username The user username
    */
-  worker.port.on('passbolt.users.resend-invite', async function(requestId, username) {
+  worker.port.on('passbolt.users.resend-invite', async(requestId, username) => {
     try {
-      let userModel = new UserModel(await User.getInstance().getApiClientOptions());
+      const userModel = new UserModel(apiClientOptions);
       await userModel.resendInvite(username);
       worker.port.emit(requestId, 'SUCCESS');
     } catch (error) {
@@ -200,4 +221,4 @@ const listen = function (worker) {
   });
 };
 
-exports.listen = listen;
+export const UserEvents = {listen};

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

@@ -0,0 +1,38 @@
+/**
+ * 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)
+ */
+import WebIntegrationController from "../controller/webIntegration/webIntegrationController";
+import RemovePortController from "../controller/port/removePortController";
+
+/**
+ * Listens the web integration events
+ * @param worker
+ */
+const listen = function(worker) {
+  /*
+   * Whenever the auto-save is required
+   * @listens passbolt.web-integration.autosave
+   * @param requestId {uuid} The request identifier
+   */
+  worker.port.on('passbolt.web-integration.autosave', async resourceToSave => {
+    const webIntegrationController = new WebIntegrationController(worker);
+    await webIntegrationController.autosave(resourceToSave);
+  });
+
+  /** Whenever the in-form-menu or in-call-to-action are removed */
+  worker.port.on('passbolt.port.disconnect', async applicationName => {
+    const removePortController = new RemovePortController(worker);
+    await removePortController._exec(applicationName);
+  });
+};
+
+export const WebIntegrationEvents = {listen};

package/src/all/background_page/index.html

@@ -3,7 +3,6 @@
 <head>
 	<meta charset="UTF-8">
 	<title>Passbolt Background Page</title>
-    <script type="text/javascript" src="vendors/openpgp.js"></script>
 	<script type="text/javascript" src="vendors.min.js"></script>
 	<script type="text/javascript" src="index.min.js"></script>
 </head>

package/src/all/background_page/index.js

@@ -4,109 +4,89 @@
  * @copyright (c) 2017 Passbolt SARL
  * @licence GNU Affero General Public License http://www.gnu.org/licenses/agpl-3.0.en.html
  */
-var storage = require('./sdk/storage').storage;
-window.storage = storage;
+import PortManager from "./sdk/port/portManager";
+import SystemRequirementService from "./service/systemRequirementService/systemRequirementService";
+import LocalStorageService from "./service/localStorage/localStorageService";
+import OnExtensionInstalledController from "./controller/extension/onExtensionInstalledController";
+import TabService from "./service/tab/tabService";
+import User from "./model/user";
+import GpgAuth from "./model/gpgauth";
+import Log from "./model/log";
+import StartLoopAuthSessionCheckService from "./service/auth/startLoopAuthSessionCheckService";
+import OnExtensionUpdateAvailableController from "./controller/extension/onExtensionUpdateAvailableController";
 
-const main = async function() {
-  const Config = require('./model/config');
-  const {Log} = require('./model/log');
-  const {GpgAuth} = require('./model/gpgauth');
-  const {User} = require('./model/user');
-  const {ResourceLocalStorage} = require('./service/local_storage/resourceLocalStorage');
-  const {ResourceTypeLocalStorage} = require('./service/local_storage/resourceTypeLocalStorage');
-  const {FolderLocalStorage} = require('./service/local_storage/folderLocalStorage');
-  const {AuthStatusLocalStorage} = require('./service/local_storage/authStatusLocalStorage');
-  const {UserLocalStorage} = require('./service/local_storage/userLocalStorage');
-  const {GroupLocalStorage} = require('./service/local_storage/groupLocalStorage');
-  const {RolesLocalStorage} = require("./service/local_storage/rolesLocalStorage");
-
-  /* ==================================================================================
-   *  Initialization of global objects
-   * ==================================================================================
-   */
-  Log.init();
-  Config.init();
-  User.init();
-  ResourceLocalStorage.init();
-  ResourceTypeLocalStorage.init();
-  FolderLocalStorage.init();
-  AuthStatusLocalStorage.init();
-  UserLocalStorage.init();
-  GroupLocalStorage.init();
-  RolesLocalStorage.init();
-
-  // Openpgpjs worker initialization
+const main = async() => {
   /**
-   * This option is needed because some secrets were encrypted using non-encryption RSA keys,
-   * due to an openpgpjs bug: https://github.com/openpgpjs/openpgpjs/pull/1148
-   */
-  openpgp.config.allow_insecure_decryption_with_signing_keys = true;
-  openpgp.initWorker({ path:'/vendors/openpgp.worker.js' });
-
-  /* ==================================================================================
-   *  Interface changes
-   *  Where we affect the look and feel of the firefox instance
-   * ==================================================================================
+   * Load all system requirement
    */
-  var ToolbarController = require('./controller/toolbarController').ToolbarController;
-  new ToolbarController();
+  await SystemRequirementService.get();
 
-  /* ==================================================================================
-   *  Page mods init
-   *  Run scripts in the context of web pages whose URL matches a given pattern.
-   *  see. https://developer.mozilla.org/en-US/Add-ons/SDK/High-Level_APIs/page-mod
-   * ==================================================================================
-   */
-  var pageMods = require('./app').pageMods;
-
-  pageMods.WebIntegration.init();
+  // When the extension is updated and the user is still connected, an event needs to be sent
+  checkAndProcessIfUserAuthenticated();
+};
 
-  // If the user is valid we enable the login pagemod
-  var user = User.getInstance();
+/**
+ * Check and process event if the user is authenticated
+ * @return {Promise<void>}
+ */
+const checkAndProcessIfUserAuthenticated = async() => {
+  const user = User.getInstance();
+  // Check if user is valid
   if (user.isValid()) {
-    // Auth pagemod init can also be triggered
-    // by debug, setup and user events (e.g. when config change)
-    pageMods.AuthBootstrap.init();
-
-    // App pagemod init is generally triggered after a successful login
-    // We only initialize it here for the cases where the user is already logged in
-    // It can happen when the extension is updated
     const auth = new GpgAuth();
     try {
       const isAuthenticated = await auth.isAuthenticated();
       if (isAuthenticated) {
-        await pageMods.AppBoostrap.init();
-        auth.startCheckAuthStatusLoop();
+        const startLoopAuthSessionCheckService = new StartLoopAuthSessionCheckService(auth);
+        await startLoopAuthSessionCheckService.exec();
+        const event = new Event('passbolt.auth.after-login');
+        self.dispatchEvent(event);
       }
-    } catch(error) {
-      // Service unavailable
-      // Do nothing...
+    } catch (error) {
+      /*
+       * Service unavailable
+       * Do nothing...
+       */
+      Log.write({level: 'debug', message: 'The Service is unavailable to check if the user is authenticated'});
     }
   }
+};
 
-  // Setup pagemods
-  pageMods.SetupBootstrap.init();
-  pageMods.Setup.init();
-  pageMods.RecoverBootstrap.init();
-  pageMods.Recover.init();
+main();
 
-  // Other pagemods active all the time
-  // but triggered by App or Auth
-  pageMods.File.init();
-  pageMods.Clipboard.init();
-  pageMods.Auth.init();
-  pageMods.QuickAccess.init();
-  pageMods.App.init();
 
-  // Debug pagemod
-  if (Config.isDebug()) {
-    pageMods.Debug.init();
-  }
+/**
+ * Add listener on passbolt logout
+ */
+self.addEventListener("passbolt.auth.after-logout", LocalStorageService.flush);
 
-};
+/**
+ * On installed the extension, add first install in the url tab of setup or recover
+ */
+browser.runtime.onInstalled.addListener(OnExtensionInstalledController.exec);
+
+/**
+ * On update available of the extension, update it when the user is logout
+ */
+browser.runtime.onUpdateAvailable.addListener(OnExtensionUpdateAvailableController.exec);
+
+/**
+ * Add listener on startup
+ */
+browser.runtime.onStartup.addListener(LocalStorageService.flush);
+
+/**
+ * Add listener on tab updated
+ */
+browser.tabs.onUpdated.addListener(TabService.exec);
+
+/**
+ * Add listener on connect port
+ */
+browser.runtime.onConnect.addListener(PortManager.onPortConnect);
+
+/**
+ * Add listener on tabs on removed
+ */
+browser.tabs.onRemoved.addListener(PortManager.onTabRemoved);
 
-// Init storage and get going.
-storage.init()
-  .then(function () {
-    main();
-  });

package/src/all/background_page/model/account/accountModel.js

@@ -10,27 +10,24 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const {UserEntity} = require("../entity/user/userEntity");
-const {User} = require('../user');
-const {Keyring} = require('../keyring');
-const {UserService} = require("../../service/api/user/userService");
+import {OpenpgpAssertion} from "../../utils/openpgp/openpgpAssertions";
+import Keyring from "../keyring";
+import User from "../user";
+import DecryptPrivateKeyService from "../../service/crypto/decryptPrivateKeyService";
+import EncryptPrivateKeyService from "../../service/crypto/encryptPrivateKeyService";
 
 class AccountModel {
   /**
    * Constructor
-   *
-   * @param {ApiClientOptions} apiClientOptions
    * @public
    */
-  constructor(apiClientOptions) {
+  constructor() {
     this.keyring = new Keyring();
-    this.userService = new UserService(apiClientOptions);
   }
 
   /**
    * Add an account to the browser extension.
    * @param {AccountEntity} accountEntity The account to add
-   * @returns {Promise<UserEntity>}
    * @throws {Error} if options are invalid or API error
    */
   async add(accountEntity) {
@@ -45,6 +42,45 @@ class AccountModel {
     await this.keyring.importPublic(accountEntity.userPublicArmoredKey, accountEntity.userId);
     await this.keyring.importPrivate(accountEntity.userPrivateArmoredKey);
   }
+
+  /**
+   * Change the security token
+   * @param securityTokenEntity the security token
+   * @returns {Promise<void>}
+   */
+  async changeSecurityToken(securityTokenEntity) {
+    await User.getInstance().updateSecurityToken(securityTokenEntity.toDto());
+  }
+
+  /**
+   * Decrypt and encrypt the private key with new passphrase of an account to the browser extension.
+   * @param {string} oldPassphrase The old passphrase
+   * @param {string} newPassphrase The new passphrase
+   * @returns {Promise<string>}
+   * @throws {Error} if something went wrong while updating the private passphrase
+   */
+  async rotatePrivateKeyPassphrase(oldPassphrase, newPassphrase) {
+    const privateArmoredKey = this.keyring.findPrivate().armoredKey;
+    const encryptedPrivateKey = await OpenpgpAssertion.readKeyOrFail(privateArmoredKey);
+    const decryptedPrivateKey = await DecryptPrivateKeyService.decrypt(encryptedPrivateKey, oldPassphrase);
+    const reEncryptedPrivateKey = await EncryptPrivateKeyService.encrypt(decryptedPrivateKey, newPassphrase);
+    return reEncryptedPrivateKey.armor();
+  }
+
+  /**
+   * Update the currently stored private key with the given private key into the local storage.
+   * @param {string} newPrivateArmoredKey armored private key
+   * @returns {Promise<void>}
+   * @throws {Error} if the new private key doesn't match the one already registered locally
+   */
+  async updatePrivateKey(newPrivateArmoredKey) {
+    const currentPrivateKey = this.keyring.findPrivate();
+    const newPrivateKey = await OpenpgpAssertion.readKeyOrFail(newPrivateArmoredKey);
+    if (currentPrivateKey.fingerprint.toUpperCase() !== newPrivateKey.getFingerprint().toUpperCase()) {
+      throw new Error("The private key to import doesn't match the current private key.");
+    }
+    await this.keyring.importPrivate(newPrivateArmoredKey);
+  }
 }
 
-exports.AccountModel = AccountModel;
+export default AccountModel;