passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/pagemod/accountRecoveryPagemod.test.js

@@ -0,0 +1,87 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2023 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) 2023 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.0.0
+ */
+import BuildApiClientOptionsService
+  from "../service/account/buildApiClientOptionsService";
+import {AccountRecoveryEvents} from "../event/accountRecoveryEvents";
+import AccountRecovery from "./accountRecoveryPagemod";
+import GetRequestLocalAccountService
+  from "../service/accountRecovery/getRequestLocalAccountService";
+
+jest.spyOn(GetRequestLocalAccountService, "getAccountMatchingContinueUrl").mockImplementation(jest.fn());
+jest.spyOn(BuildApiClientOptionsService, "buildFromAccount").mockImplementation(jest.fn());
+jest.spyOn(AccountRecoveryEvents, "listen").mockImplementation(jest.fn());
+
+describe("AccountRecovery", () => {
+  beforeEach(async() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  describe("AccountRecovery::attachEvents", () => {
+    it("Should attach events", async() => {
+      expect.assertions(6);
+      // data mocked
+      const port = {
+        _port: {
+          sender: {
+            tab: {
+              url: "https://passbolt.dev/account-recovery/continue/d57c10f5-639d-5160-9c81-8a0c6c4ec856/cb66b7ca-bb85-4088-b0da-c50f6f0c2a13"
+            }
+          }
+        }
+      };
+      // process
+      await AccountRecovery.attachEvents(port);
+      // expectations
+      expect(GetRequestLocalAccountService.getAccountMatchingContinueUrl).toHaveBeenCalledWith(port._port.sender.tab.url);
+      expect(BuildApiClientOptionsService.buildFromAccount).toHaveBeenCalled();
+      expect(AccountRecoveryEvents.listen).toHaveBeenCalledWith({port: port, tab: port._port.sender.tab}, undefined, undefined);
+      expect(AccountRecovery.events).toStrictEqual([AccountRecoveryEvents]);
+      expect(AccountRecovery.mustReloadOnExtensionUpdate).toBeFalsy();
+      expect(AccountRecovery.appName).toBe('AccountRecovery');
+    });
+
+    it("Should not attach events", async() => {
+      expect.assertions(3);
+      // data mocked
+      const port = {
+        _port: {
+          sender: {
+            tab: {
+              url: "https://passbolt.dev/account-recovery/continue/d57c10f5-639d-5160-9c81-8a0c6c4ec856/cb66b7ca-bb85-4088-b0da-c50f6f0c2a13"
+            }
+          }
+        },
+        disconnect: jest.fn()
+      };
+      jest.spyOn(GetRequestLocalAccountService, "getAccountMatchingContinueUrl").mockImplementation(() => { throw new Error("Error"); });
+      // process
+      await AccountRecovery.attachEvents(port);
+      // expectations
+      expect(GetRequestLocalAccountService.getAccountMatchingContinueUrl).toHaveBeenCalledWith(port._port.sender.tab.url);
+      expect(AccountRecoveryEvents.listen).not.toHaveBeenCalled();
+      expect(port.disconnect).toHaveBeenCalled();
+    });
+  });
+
+  describe("AccountRecovery::canBeAttachedTo", () => {
+    it("Should have the canBeAttachedTo not valid", async() => {
+      expect.assertions(1);
+      // process
+      const canBeAttachedTo = await AccountRecovery.canBeAttachedTo({});
+      // expectations
+      expect(canBeAttachedTo).toBeFalsy();
+    });
+  });
+});

package/src/all/background_page/pagemod/appBootstrapPagemod.js

@@ -0,0 +1,104 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2023 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) 2023 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.0.0
+ */
+import Pagemod from "./pagemod";
+import User from "../model/user";
+import GpgAuth from "../model/gpgauth";
+import {AppBootstrapEvents} from "../event/appBootstrapEvents";
+import ParseAppUrlService from "../service/app/parseAppUrlService";
+import {PortEvents} from "../event/portEvents";
+
+class AppBootstrap extends Pagemod {
+  /**
+   * @inheritDoc
+   * @returns {string}
+   */
+  get appName() {
+    return "AppBootstrap";
+  }
+
+  /**
+   * @inheritDoc
+   */
+  get contentStyleFiles() {
+    return ['webAccessibleResources/css/themes/default/ext_external.min.css'];
+  }
+
+  /**
+   * @inheritDoc
+   */
+  get contentScriptFiles() {
+    return [
+      'contentScripts/js/dist/vendors.js',
+      'contentScripts/js/dist/app.js'
+    ];
+  }
+
+  /**
+   * @inheritDoc
+   */
+  get events() {
+    return [AppBootstrapEvents, PortEvents];
+  }
+
+  /**
+   * @inheritDoc
+   */
+  get mustReloadOnExtensionUpdate() {
+    return true;
+  }
+
+  /**
+   * @inheritDoc
+   */
+  async canBeAttachedTo(frameDetails) {
+    return this.assertTopFrameAttachConstraint(frameDetails)
+      && this.assertUrlAttachConstraint(frameDetails) &&
+      await this.assertUserAuthenticated();
+  }
+
+  /**
+   * Assert that the attached frame is a top frame.
+   * @param {Object} frameDetails
+   * @returns {boolean}
+   */
+  assertTopFrameAttachConstraint(frameDetails) {
+    return frameDetails.frameId === Pagemod.TOP_FRAME_ID;
+  }
+
+  /**
+   * Assert that the attached frame is a top frame.
+   * @param {Object} frameDetails
+   * @returns {boolean}
+   */
+  assertUrlAttachConstraint(frameDetails) {
+    const user = User.getInstance();
+    if (user.isValid()) {
+      return ParseAppUrlService.test(frameDetails.url);
+    }
+    return false;
+  }
+
+  /**
+   * Is the constraint validated
+   * @returns {Promise<boolean>}
+   */
+  assertUserAuthenticated() {
+    const auth = new GpgAuth();
+    const onSuccess = value => value;
+    const onReject = () => false;
+    return auth.isAuthenticated().then(onSuccess, onReject);
+  }
+}
+
+export default new AppBootstrap();

package/src/all/background_page/pagemod/appBootstrapPagemod.test.js

@@ -0,0 +1,124 @@
+/**
+ * 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.8.0
+ */
+import User from "../model/user";
+import GpgAuth from "../model/gpgauth";
+import UserSettings from "../model/userSettings/userSettings";
+import AppBootstrap from "./appBootstrapPagemod";
+import WorkersSessionStorage from "../service/sessionStorage/workersSessionStorage";
+import WorkerEntity from "../model/entity/worker/workerEntity";
+import ScriptExecution from "../sdk/scriptExecution";
+import {AppBootstrapEvents} from "../event/appBootstrapEvents";
+import Pagemod from "./pagemod";
+import each from "jest-each";
+import {PortEvents} from "../event/portEvents";
+
+const spyAddWorker = jest.spyOn(WorkersSessionStorage, "addWorker");
+jest.spyOn(ScriptExecution.prototype, "injectPortname").mockImplementation(jest.fn());
+jest.spyOn(ScriptExecution.prototype, "injectCss").mockImplementation(jest.fn());
+jest.spyOn(ScriptExecution.prototype, "injectJs").mockImplementation(jest.fn());
+jest.spyOn(AppBootstrapEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(PortEvents, "listen").mockImplementation(jest.fn());
+
+describe("AppBootstrap", () => {
+  beforeEach(async() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  describe("AppBootstrap::injectFile", () => {
+    it("Should inject file", async() => {
+      expect.assertions(10);
+      // process
+      await AppBootstrap.injectFiles(1, 0);
+      // expectations
+      expect(spyAddWorker).toHaveBeenCalledWith(expect.any(WorkerEntity));
+      expect(spyAddWorker).toHaveBeenCalledTimes(1);
+      expect(ScriptExecution.prototype.injectPortname).toHaveBeenCalledTimes(1);
+      expect(ScriptExecution.prototype.injectCss).toHaveBeenCalledWith(AppBootstrap.contentStyleFiles);
+      expect(ScriptExecution.prototype.injectJs).toHaveBeenCalledWith(AppBootstrap.contentScriptFiles);
+      expect(AppBootstrap.contentStyleFiles).toStrictEqual(['webAccessibleResources/css/themes/default/ext_external.min.css']);
+      expect(AppBootstrap.contentScriptFiles).toStrictEqual(['contentScripts/js/dist/vendors.js', 'contentScripts/js/dist/app.js']);
+      expect(AppBootstrap.events).toStrictEqual([AppBootstrapEvents, PortEvents]);
+      expect(AppBootstrap.mustReloadOnExtensionUpdate).toBeTruthy();
+      expect(AppBootstrap.appName).toBe('AppBootstrap');
+    });
+  });
+
+  describe("AppBootstrap::isConstraintValidated", () => {
+    it("Should be able to attach app bootstrap pagemod to browser frame", async() => {
+      expect.assertions(1);
+      // mock functions
+      jest.spyOn(User.getInstance(), "isValid").mockImplementation(() => true);
+      jest.spyOn(GpgAuth.prototype, "isAuthenticated").mockImplementation(() => new Promise(resolve => resolve(true)));
+      jest.spyOn(UserSettings.prototype, "getDomain").mockImplementation(() => "https://passbolt.dev");
+      const result = await AppBootstrap.canBeAttachedTo({frameId: Pagemod.TOP_FRAME_ID, url: "https://passbolt.dev/app"});
+      expect(result).toBeTruthy();
+    });
+
+    each([
+      {scenario: "No domain", url: "app", frameId: Pagemod.TOP_FRAME_ID},
+      {scenario: "Not top frame", url: "https://passbolt.dev/app", frameId: 1},
+    ]).describe("Should not be able to attach a pagemod to browser frame", _props => {
+      it(`Should be able to attach a pagemod to browser frame: ${_props.scenario}`, async() => {
+        expect.assertions(1);
+        const result = await AppBootstrap.canBeAttachedTo({frameId: _props.frameId, url: _props.url});
+        expect(result).toBeFalsy();
+      });
+    });
+
+    it("Should not be able to attach a pagemod if the user is not valid", async() => {
+      expect.assertions(1);
+      // mock functions
+      jest.spyOn(User.getInstance(), "isValid").mockImplementation(() => false);
+      // process
+      const result = await AppBootstrap.canBeAttachedTo({frameId: 0});
+      // expectations
+      expect(result).toBeFalsy();
+    });
+
+    it("Should not be able to attach a pagemod if the user is not authenticated", async() => {
+      expect.assertions(1);
+      // mock functions
+      jest.spyOn(User.getInstance(), "isValid").mockImplementation(() => true);
+      jest.spyOn(GpgAuth.prototype, "isAuthenticated").mockImplementation(() => new Promise(resolve => resolve(false)));
+      jest.spyOn(UserSettings.prototype, "getDomain").mockImplementation(() => "https://passbolt");
+      // process
+      const constraint = await AppBootstrap.canBeAttachedTo({frameId: 0});
+      // expectations
+      expect(constraint).toBeFalsy();
+    });
+  });
+
+  describe("AppBootstrap::attachEvents", () => {
+    it("Should attach events", async() => {
+      expect.assertions(2);
+      // data mocked
+      const port = {
+        on: () => jest.fn(),
+        _port: {
+          sender: {
+            tab: {
+              url: "https://localhost"
+            }
+          }
+        }
+      };
+      // process
+      await AppBootstrap.attachEvents(port);
+      // expectations
+      expect(AppBootstrapEvents.listen).toHaveBeenCalledWith({port: port, tab: port._port.sender.tab, name: AppBootstrap.appName});
+      expect(PortEvents.listen).toHaveBeenCalledWith({port: port, tab: port._port.sender.tab, name: AppBootstrap.appName});
+    });
+  });
+});

package/src/all/background_page/pagemod/appPagemod.js

@@ -1,72 +1,127 @@
 /**
- * React application pagemod.
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
  *
- * @copyright (c) 2020 Passbolt SA
- * @licence GNU Affero General Public License http://www.gnu.org/licenses/agpl-3.0.en.html
- */
-const {PageMod} = require('../sdk/page-mod');
-const app = require('../app');
-const Worker = require('../model/worker');
-const GpgAuth = require('../model/gpgauth').GpgAuth;
-
-/*
- * This pagemod help bootstrap the passbolt application from a passbolt server app page
+ * 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) 2023 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.0.0
  */
-const App = function () {};
-App._pageMod = null;
+import Pagemod from "./pagemod";
+import GetLegacyAccountService from "../service/account/getLegacyAccountService";
+import GpgAuth from "../model/gpgauth";
+import AppInitController from "../controller/app/appInitController";
+import {AppEvents} from "../event/appEvents";
+import {ConfigEvents} from "../event/configEvents";
+import {AuthEvents} from "../event/authEvents";
+import {FolderEvents} from "../event/folderEvents";
+import {ResourceEvents} from "../event/resourceEvents";
+import {ResourceTypeEvents} from "../event/resourceTypeEvents";
+import {RoleEvents} from "../event/roleEvents";
+import {KeyringEvents} from "../event/keyringEvents";
+import {SecretEvents} from "../event/secretEvents";
+import {OrganizationSettingsEvents} from "../event/organizationSettingsEvents";
+import {ShareEvents} from "../event/shareEvents";
+import {SubscriptionEvents} from "../event/subscriptionEvents";
+import {UserEvents} from "../event/userEvents";
+import {GroupEvents} from "../event/groupEvents";
+import {CommentEvents} from "../event/commentEvents";
+import {TagEvents} from "../event/tagEvents";
+import {FavoriteEvents} from "../event/favoriteEvents";
+import {ImportResourcesEvents} from "../event/importResourcesEvents";
+import {ExportResourcesEvents} from "../event/exportResourcesEvents";
+import {ActionLogEvents} from "../event/actionLogEvents";
+import {MultiFactorAuthenticationEvents} from "../event/multiFactorAuthenticationEvents";
+import {ThemeEvents} from "../event/themeEvents";
+import {LocaleEvents} from "../event/localeEvents";
+import {MobileEvents} from "../event/mobileEvents";
+import {PownedPasswordEvents} from '../event/pownedPasswordEvents';
+import {MfaEvents} from "../event/mfaEvents";
+import {ClipboardEvents} from "../event/clipboardEvents";
+import BuildApiClientOptionsService from "../service/account/buildApiClientOptionsService";
+import {RememberMeEvents} from "../event/rememberMeEvents";
 
-App.init = function () {
+class App extends Pagemod {
+  /**
+   * @inheritDoc
+   * @returns {string}
+   */
+  get appName() {
+    return "App";
+  }
 
-  if (App._pageMod) {
-    App._pageMod.destroy();
-    App._pageMod = null;
+  /**
+   * @inheritDoc
+   */
+  get events() {
+    return [
+      ConfigEvents,
+      AppEvents,
+      AuthEvents,
+      FolderEvents,
+      ResourceEvents,
+      ResourceTypeEvents,
+      RoleEvents,
+      KeyringEvents,
+      SecretEvents,
+      OrganizationSettingsEvents,
+      ShareEvents,
+      SubscriptionEvents,
+      UserEvents,
+      GroupEvents,
+      CommentEvents,
+      TagEvents,
+      FavoriteEvents,
+      ImportResourcesEvents,
+      ExportResourcesEvents,
+      ActionLogEvents,
+      MultiFactorAuthenticationEvents,
+      ThemeEvents,
+      LocaleEvents,
+      MobileEvents,
+      PownedPasswordEvents,
+      MfaEvents,
+      ClipboardEvents,
+      RememberMeEvents
+    ];
   }
 
-  App._pageMod = new PageMod({
-    name: 'App',
-    include: 'about:blank?passbolt=passbolt-iframe-app',
-    contentScriptWhen: 'end',
-    contentScriptFile: [
-      // Warning: script and styles need to be modified in
-      // chrome/data/passbolt-iframe-app.html
-    ],
-    onAttach: async function (worker) {
+  /**
+   * @inheritDoc
+   */
+  async attachEvents(port) {
+    try {
+      const tab = port._port.sender.tab;
       const auth = new GpgAuth();
       if (!await auth.isAuthenticated() || await auth.isMfaRequired()) {
         console.error('Can not attach application if user is not logged in.');
         return;
       }
 
-      // Initialize the events listeners.
-      app.events.app.listen(worker);
-      app.events.auth.listen(worker);
-      app.events.clipboard.listen(worker);
-      app.events.config.listen(worker);
-      app.events.folder.listen(worker);
-      app.events.resource.listen(worker);
-      app.events.resourceType.listen(worker);
-      app.events.role.listen(worker);
-      app.events.keyring.listen(worker);
-      app.events.secret.listen(worker);
-      app.events.siteSettings.listen(worker);
-      app.events.share.listen(worker);
-      app.events.user.listen(worker);
-      app.events.group.listen(worker);
-      app.events.comment.listen(worker);
-      app.events.tag.listen(worker);
-      app.events.favorite.listen(worker);
-      app.events.importResources.listen(worker);
-      app.events.exportResources.listen(worker);
-      app.events.actionLogs.listen(worker);
-      app.events.multiFactorAuthentication.listen(worker);
-      app.events.theme.listen(worker);
+      // Init the application.
+      const appInitController = new AppInitController();
+      await appInitController.main();
 
-      // Keep the pagemod event listeners at the end of the list.
-      app.events.pagemod.listen(worker);
-
-      Worker.add('App', worker);
+      const account = await GetLegacyAccountService.get({role: true});
+      const apiClientOptions = await BuildApiClientOptionsService.buildFromAccount(account);
+      for (const event of this.events) {
+        event.listen({port, tab}, apiClientOptions, account);
+      }
+    } catch (error) {
+      /*
+       * Ensure the application does not crash completely if the legacy account cannot be retrieved.
+       * The following controllers won't work as expected:
+       * - AccountRecoverySaveUserSettingsController
+       * - ReviewRequestController
+       */
+      console.error('appPagemod::attach legacy account cannot be retrieved, please contact your administrator.');
+      console.error(error);
     }
-  });
-};
+  }
+}
 
-exports.App = App;
+export default new App();