passbolt-browser-extension 3.0.6 → 4.6.2

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

@@ -0,0 +1,184 @@
+/**
+ * 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.9.0
+ */
+import {ConfigEvents} from "../event/configEvents";
+import App from "./appPagemod";
+import GetLegacyAccountService from "../service/account/getLegacyAccountService";
+import {UserEvents} from "../event/userEvents";
+import {KeyringEvents} from "../event/keyringEvents";
+import {AuthEvents} from "../event/authEvents";
+import {OrganizationSettingsEvents} from "../event/organizationSettingsEvents";
+import {LocaleEvents} from "../event/localeEvents";
+import {AppEvents} from "../event/appEvents";
+import {FolderEvents} from "../event/folderEvents";
+import {ResourceEvents} from "../event/resourceEvents";
+import {ResourceTypeEvents} from "../event/resourceTypeEvents";
+import {RoleEvents} from "../event/roleEvents";
+import {SecretEvents} from "../event/secretEvents";
+import {ShareEvents} from "../event/shareEvents";
+import {SubscriptionEvents} from "../event/subscriptionEvents";
+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 {MobileEvents} from "../event/mobileEvents";
+import GpgAuth from "../model/gpgauth";
+import {PownedPasswordEvents} from '../event/pownedPasswordEvents';
+import {MfaEvents} from "../event/mfaEvents";
+import {ClipboardEvents} from "../event/clipboardEvents";
+import {v4 as uuid} from "uuid";
+import BuildApiClientOptionsService from "../service/account/buildApiClientOptionsService";
+import {enableFetchMocks} from "jest-fetch-mock";
+import {RememberMeEvents} from "../event/rememberMeEvents";
+
+jest.spyOn(ConfigEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(AppEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(AuthEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(FolderEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(ResourceEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(ResourceTypeEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(RoleEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(KeyringEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(SecretEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(OrganizationSettingsEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(ShareEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(SubscriptionEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(UserEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(GroupEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(CommentEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(TagEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(FavoriteEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(ImportResourcesEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(ExportResourcesEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(ActionLogEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(MultiFactorAuthenticationEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(ThemeEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(LocaleEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(MobileEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(PownedPasswordEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(MfaEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(ClipboardEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(RememberMeEvents, "listen").mockImplementation(jest.fn());
+
+describe("App", () => {
+  beforeEach(async() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+    enableFetchMocks();
+  });
+
+  describe("App::attachEvents", () => {
+    it("Should attach events", async() => {
+      expect.assertions(32);
+      // data mocked
+      const port = {
+        _port: {
+          sender: {
+            tab: {
+              url: "https://localhost"
+            }
+          }
+        }
+      };
+      jest.spyOn(GetLegacyAccountService, 'get').mockImplementation(() => mockedAccount);
+
+      // mock functions
+      jest.spyOn(browser.cookies, "get").mockImplementation(() => ({value: "csrf-token"}));
+      jest.spyOn(GpgAuth.prototype, "isAuthenticated").mockImplementation(() => new Promise(resolve => resolve(true)));
+      jest.spyOn(GpgAuth.prototype, "isMfaRequired").mockImplementation(() => new Promise(resolve => resolve(false)));
+      const mockedAccount = {user_id: uuid(), domain: "https://test-domain.passbolt.com"};
+      const mockApiClient = await BuildApiClientOptionsService.buildFromAccount(mockedAccount);
+      jest.spyOn(GetLegacyAccountService, 'get').mockImplementation(() => mockedAccount);
+      // process
+      await App.attachEvents(port);
+      // expectations
+      const expectedPortAndTab = {port: port, tab: port._port.sender.tab};
+      expect(GetLegacyAccountService.get).toHaveBeenCalledWith({role: true});
+      expect(ConfigEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(AppEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(AuthEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(FolderEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(ResourceEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(ResourceTypeEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(RoleEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(KeyringEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(SecretEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(OrganizationSettingsEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(ShareEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(SubscriptionEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(UserEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(GroupEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(CommentEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(TagEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(FavoriteEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(ImportResourcesEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(ExportResourcesEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(ActionLogEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(MultiFactorAuthenticationEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(ThemeEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(LocaleEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(MobileEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(PownedPasswordEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(MfaEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(ClipboardEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(RememberMeEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(App.events).toStrictEqual([
+        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
+      ]);
+      expect(App.mustReloadOnExtensionUpdate).toBeFalsy();
+      expect(App.appName).toBe('App');
+    });
+  });
+
+  describe("App::canBeAttachedTo", () => {
+    it("Should have the canBeAttachedTo not valid", async() => {
+      expect.assertions(1);
+      // process
+      const canBeAttachedTo = await App.canBeAttachedTo({});
+      // expectations
+      expect(canBeAttachedTo).toBeFalsy();
+    });
+  });
+});

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

@@ -1,64 +1,90 @@
 /**
- * Passbolt Auth pagemod.
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
  *
- * This pagemod help with the authentication
+ * 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 (c) 2017 Passbolt SARL
- * @licence GNU Affero General Public License http://www.gnu.org/licenses/agpl-3.0.en.html
+ * @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
  */
-var app = require('../app');
-var User = require('../model/user').User;
-const {PageMod} = require('../sdk/page-mod');
-const Worker = require('../model/worker');
+import Pagemod from "./pagemod";
+import User from "../model/user";
+import {PortEvents} from "../event/portEvents";
+import ParseAuthUrlService from "../service/auth/parseAuthUrlService";
 
-var AuthBootstrap = function () {};
-AuthBootstrap._pageMod = undefined;
+class AuthBootstrap extends Pagemod {
+  /**
+   * @inheritDoc
+   * @returns {string}
+   */
+  get appName() {
+    return "AuthBootstrap";
+  }
 
-AuthBootstrap.init = function () {
+  /**
+   * @inheritDoc
+   */
+  get contentStyleFiles() {
+    return ['webAccessibleResources/css/themes/default/ext_external.min.css'];
+  }
 
-  if (typeof AuthBootstrap._pageMod !== 'undefined') {
-    AuthBootstrap._pageMod.destroy();
-    AuthBootstrap._pageMod = undefined;
+  /**
+   * @inheritDoc
+   */
+  get contentScriptFiles() {
+    return [
+      'contentScripts/js/dist/vendors.js',
+      'contentScripts/js/dist/login.js',
+    ];
   }
 
-  // The pagemod will be attached to the following pages:
-  // ✓ https://demo.passbolt.com/auth/login
-  // ✓ https://demo.passbolt.com/auth/login/
-  // ✓ https://demo.passbolt.com/auth/login#checkthis
-  // ✓ https://demo.passbolt.com/auth/login?redirect=%2somewhere
-  // ✓ https://demo.passbolt.com/auth/login?redirect=%2somewhere#nice
-  // ✗ https://demoxpassbolt.com/auth/login
-  // ✗ https://demo.passbolt.com/auth/login/nope
-  var user = User.getInstance();
-  var escapedDomain = user.settings.getDomain().replace(/\W/g, "\\$&");
-  var url = '^' + escapedDomain + '/auth/login/?(#.*)?(\\?.*)?$';
-  var regex = new RegExp(url);
+  /**
+   * @inheritDoc
+   */
+  get events() {
+    return [PortEvents];
+  }
 
-  AuthBootstrap._pageMod = new PageMod({
-    name: 'AuthBootstrap',
-    include: regex,
-    contentScriptWhen: 'ready',
-    contentStyleFile: [
-      // @deprecated when support for v2 is dropped
-      // used to control iframe styling without inline style in v3
-      'data/css/themes/default/ext_external.min.css'
-    ],
-    contentScriptFile: [
-      'content_scripts/js/dist/vendors.js',
-      'content_scripts/js/dist/login.js',
-    ],
-    attachTo: {existing: true, reload: true},
-    onAttach: function (worker) {
-      user.flushMasterPassword();
+  /**
+   * @inheritDoc
+   */
+  get mustReloadOnExtensionUpdate() {
+    return true;
+  }
 
-      /*
-       * Keep the pagemod event listeners at the end of the list, it answers to an event that allows
-       * the content code to know when the background page is ready.
-       */
-      app.events.pagemod.listen(worker);
+  /**
+   * @inheritDoc
+   */
+  async canBeAttachedTo(frameDetails) {
+    return this.assertTopFrameAttachConstraint(frameDetails)
+      && this.assertUrlAttachConstraint(frameDetails);
+  }
 
-      Worker.add('AuthBootstrap', worker);
+  /**
+   * 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 ParseAuthUrlService.test(frameDetails.url);
     }
-  });
-};
-exports.AuthBootstrap = AuthBootstrap;
+    return false;
+  }
+}
+
+export default new AuthBootstrap();

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

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

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

@@ -1,46 +1,72 @@
 /**
- * Passbolt Auth Form pagemod.
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2023 Passbolt SA (https://www.passbolt.com)
  *
- * This pagemod help with the authentication
+ * 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 (c) 2017 Passbolt SARL
- * @licence GNU Affero General Public License http://www.gnu.org/licenses/agpl-3.0.en.html
+ * @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 {PageMod} = require('../sdk/page-mod');
-var app = require('../app');
-var Worker = require('../model/worker');
+import Pagemod from "./pagemod";
+import GetLegacyAccountService from "../service/account/getLegacyAccountService";
+import {UserEvents} from "../event/userEvents";
+import {KeyringEvents} from "../event/keyringEvents";
+import {AuthEvents} from "../event/authEvents";
+import {ConfigEvents} from "../event/configEvents";
+import {OrganizationSettingsEvents} from "../event/organizationSettingsEvents";
+import {LocaleEvents} from "../event/localeEvents";
+import BuildApiClientOptionsService from "../service/account/buildApiClientOptionsService";
+import {RememberMeEvents} from "../event/rememberMeEvents";
 
-var Auth = function () {};
-Auth._pageMod = undefined;
-
-Auth.init = function () {
+class Auth extends Pagemod {
+  /**
+   * @inheritDoc
+   * @returns {string}
+   */
+  get appName() {
+    return "Auth";
+  }
 
-  if (typeof Auth._pageMod !== 'undefined') {
-    Auth._pageMod.destroy();
-    Auth._pageMod = undefined;
+  /**
+   * @inheritDoc
+   */
+  get events() {
+    return [
+      ConfigEvents,
+      UserEvents,
+      KeyringEvents,
+      AuthEvents,
+      OrganizationSettingsEvents,
+      LocaleEvents,
+      RememberMeEvents
+    ];
   }
-  Auth._pageMod = new PageMod({
-    name: 'Auth',
-    include: 'about:blank?passbolt=passbolt-iframe-login',
-    contentScriptWhen: 'ready',
-    contentScriptFile: [
-			// Warning: script and styles need to be modified in
-			// chrome/data/passbolt-iframe-login-form.html
-    ],
-    onAttach: function (worker) {
-      Worker.add('Auth', worker);
-      app.events.user.listen(worker);
-      app.events.keyring.listen(worker);
-      app.events.auth.listen(worker);
-      app.events.config.listen(worker);
-      app.events.siteSettings.listen(worker);
 
+  /**
+   * @inheritDoc
+   */
+  async attachEvents(port) {
+    try {
+      const tab = port._port.sender.tab;
+      const account = await GetLegacyAccountService.get();
+      const apiClientOptions = await BuildApiClientOptionsService.buildFromAccount(account);
+      for (const event of this.events) {
+        event.listen({port, tab}, apiClientOptions, account);
+      }
+    } catch (error) {
       /*
-       * Keep the pagemod event listeners at the end of the list, it answers to an event that allows
-       * the content code to know when the background page is ready.
+       * Ensure the application does not crash completely if the legacy account cannot be retrieved.
+       * The following controllers won't work as expected:
+       * - RequestHelpCredentialsLostController
        */
-      app.events.pagemod.listen(worker);
+      console.error('authPagemod::attach legacy account cannot be retrieved, please contact your administrator.');
+      console.error(error);
     }
-  });
-};
-exports.Auth = Auth;
+  }
+}
+
+export default new Auth();

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

@@ -0,0 +1,86 @@
+/**
+ * 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.9.0
+ */
+import {ConfigEvents} from "../event/configEvents";
+import Auth from "./authPagemod";
+import GetLegacyAccountService from "../service/account/getLegacyAccountService";
+import {UserEvents} from "../event/userEvents";
+import {KeyringEvents} from "../event/keyringEvents";
+import {AuthEvents} from "../event/authEvents";
+import {OrganizationSettingsEvents} from "../event/organizationSettingsEvents";
+import {LocaleEvents} from "../event/localeEvents";
+import {v4 as uuid} from 'uuid';
+import {enableFetchMocks} from "jest-fetch-mock";
+import BuildApiClientOptionsService from "../service/account/buildApiClientOptionsService";
+import {RememberMeEvents} from "../event/rememberMeEvents";
+
+jest.spyOn(ConfigEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(UserEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(KeyringEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(AuthEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(OrganizationSettingsEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(LocaleEvents, "listen").mockImplementation(jest.fn());
+jest.spyOn(RememberMeEvents, "listen").mockImplementation(jest.fn());
+
+describe("Auth", () => {
+  beforeEach(async() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+    enableFetchMocks();
+  });
+
+  describe("Auth::attachEvents", () => {
+    it("Should attach events", async() => {
+      expect.assertions(11);
+      // data mocked
+      const port = {
+        _port: {
+          sender: {
+            tab: {
+              url: "https://localhost"
+            }
+          }
+        }
+      };
+      jest.spyOn(browser.cookies, "get").mockImplementation(() => ({value: "csrf-token"}));
+      const mockedAccount = {user_id: uuid(), domain: "https://test-domain.passbolt.com"};
+      const mockApiClient = await BuildApiClientOptionsService.buildFromAccount(mockedAccount);
+      jest.spyOn(GetLegacyAccountService, 'get').mockImplementation(() => mockedAccount);
+      // process
+      await Auth.attachEvents(port);
+      // expectations
+      const expectedPortAndTab = {port: port, tab: port._port.sender.tab};
+      expect(GetLegacyAccountService.get).toHaveBeenCalledTimes(1);
+      expect(ConfigEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(UserEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(KeyringEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(AuthEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(OrganizationSettingsEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(LocaleEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(RememberMeEvents.listen).toHaveBeenCalledWith(expectedPortAndTab, mockApiClient, mockedAccount);
+      expect(Auth.events).toStrictEqual([ConfigEvents, UserEvents, KeyringEvents, AuthEvents, OrganizationSettingsEvents, LocaleEvents, RememberMeEvents]);
+      expect(Auth.mustReloadOnExtensionUpdate).toBeFalsy();
+      expect(Auth.appName).toBe('Auth');
+    });
+  });
+
+  describe("Auth::canBeAttachedTo", () => {
+    it("Should have the canBeAttachedTo not valid", async() => {
+      expect.assertions(1);
+      // process
+      const canBeAttachedTo = await Auth.canBeAttachedTo({});
+      // expectations
+      expect(canBeAttachedTo).toBeFalsy();
+    });
+  });
+});