passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/controller/exportAccount/exportDesktopAccountController.js

@@ -0,0 +1,75 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.3.0
+ */
+
+import DesktopTransferModel from "../../model/desktopTransfer/desktopTransferModel";
+import FileService from "../../service/file/fileService";
+import GetPassphraseService from "../../service/passphrase/getPassphraseService";
+import {Buffer} from 'buffer';
+import DecryptPrivateKeyService from "../../service/crypto/decryptPrivateKeyService";
+import SignMessageService from "../../service/crypto/signMessageService";
+import {OpenpgpAssertion} from "../../utils/openpgp/openpgpAssertions";
+
+const PUBLIC_FILENAME = "account-kit.passbolt";
+const MIME_TYPE_TEXT_PLAIN = "application/passbolt";
+
+class ExportDesktopAccountController {
+  /**
+   * ExportAccountController constructor
+   * @param {Worker} worker
+   * @param {string} requestId uuid
+   * @param {AccountEntity}  account
+   */
+  constructor(worker, requestId, account) {
+    this.worker = worker;
+    this.requestId = requestId;
+    this.desktopTransferModel = new DesktopTransferModel();
+    this.account = account;
+    this.getPassphraseService = new GetPassphraseService(account);
+  }
+
+  /**
+   * Controller executor.
+   * @returns {Promise<void>}
+   */
+  async _exec() {
+    try {
+      await this.exec.apply(this, arguments);
+      this.worker.port.emit(this.requestId, 'SUCCESS');
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Export account for desktop application
+   *
+   * @return {Promise<string>}
+   */
+  async exec() {
+    const passphrase = await this.getPassphraseService.getPassphrase(this.worker);
+    const accountKit = await this.desktopTransferModel.getAccountKit(this.account);
+    const accountKitDto = accountKit.toDto();
+
+    const accountKitMessage = await OpenpgpAssertion.createCleartextMessageOrFail(JSON.stringify(accountKitDto));
+    const privateKeyForSigning = await OpenpgpAssertion.readKeyOrFail(accountKitDto["user_private_armored_key"]);
+    const decryptedPrivateKey = await DecryptPrivateKeyService.decrypt(privateKeyForSigning, passphrase);
+    const signedAccountKit = await SignMessageService.signClearMessage(accountKitMessage, [decryptedPrivateKey]);
+    const fileContent = Buffer.from(signedAccountKit).toString('base64');
+    await FileService.saveFile(PUBLIC_FILENAME, fileContent, MIME_TYPE_TEXT_PLAIN, this.worker.tab.id);
+  }
+}
+
+export default ExportDesktopAccountController;
+

package/src/all/background_page/controller/exportAccount/exportDesktopAccountController.test.data.js

@@ -0,0 +1,25 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.3.0
+ */
+import {v4 as uuid} from "uuid";
+
+export const worker = {
+  port: {
+    emit: jest.fn()
+  },
+  tab: {
+    id: uuid()
+  }
+};
+
+export const requestId = uuid();

package/src/all/background_page/controller/exportAccount/exportDesktopAccountController.test.js

@@ -0,0 +1,104 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.3.0
+ */
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import ExportDesktopAccountController from "./exportDesktopAccountController";
+import {requestId, worker} from "./exportDesktopAccountController.test.data";
+import FileService from "../../service/file/fileService";
+import GetLegacyAccountService from "../../service/account/getLegacyAccountService";
+import {Buffer} from 'buffer';
+import {pgpKeys} from "../../../../../test/fixtures/pgpKeys/keys";
+import DecryptPrivateKeyService from "../../service/crypto/decryptPrivateKeyService";
+import SignMessageService from "../../service/crypto/signMessageService";
+import {OpenpgpAssertion} from "../../utils/openpgp/openpgpAssertions";
+
+describe("ExportDesktopAccountController", () => {
+  const account = new AccountEntity(defaultAccountDto());
+  const controller = new ExportDesktopAccountController(worker, requestId, account);
+
+  beforeEach(() => {
+    jest.spyOn(controller.getPassphraseService, "getPassphrase").mockImplementation(() => pgpKeys.ada.passphrase);
+    jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
+    jest.spyOn(controller.desktopTransferModel, "getAccountKit");
+  });
+
+  describe("ExportDesktopAccountController::exec", () => {
+    it("Should request the passphrase before any other action.", async() => {
+      expect.assertions(3);
+      //Simulate an error to check is the other methods have not been called
+      jest.spyOn(controller.getPassphraseService, "getPassphrase").mockRejectedValue(() => new Error());
+      jest.spyOn(FileService, "saveFile").mockImplementation(jest.fn());
+
+      try {
+        await controller.exec();
+      } catch {}
+
+      expect(controller.getPassphraseService.getPassphrase).toHaveBeenCalledWith(worker);
+      expect(controller.desktopTransferModel.getAccountKit).not.toHaveBeenCalled();
+      expect(FileService.saveFile).not.toHaveBeenCalled();
+    });
+    it("Should save the signed account kit.", async() => {
+      expect.assertions(5);
+
+      let resultSignedAccountKit;
+      jest.spyOn(DecryptPrivateKeyService, "decrypt");
+      jest.spyOn(SignMessageService, "signClearMessage");
+      jest.spyOn(FileService, "saveFile").mockImplementation(jest.fn((_, content) => {
+        resultSignedAccountKit = content;
+      }));
+
+      await controller.exec();
+
+      expect(SignMessageService.signClearMessage).toHaveBeenCalled();
+      expect(DecryptPrivateKeyService.decrypt).toHaveBeenCalled();
+      expect(controller.desktopTransferModel.getAccountKit).toHaveBeenCalled();
+      expect(FileService.saveFile).toHaveBeenCalledWith("account-kit.passbolt", expect.anything(), "application/passbolt", worker.tab.id);
+      // Assert the account kit output.
+      const signedResultAccountKit = Buffer.from(resultSignedAccountKit, "base64").toString();
+      const serializedResultAccountKit = await OpenpgpAssertion.readClearMessageOrFail(signedResultAccountKit);
+      const resultAccountKitDto = JSON.parse(serializedResultAccountKit.getText());
+      expect(resultAccountKitDto.user_id).toEqual(account.userId);
+    });
+  });
+
+  describe("ExportDesktopAccountController::_exec", () => {
+    it("Should call exec method.", async() => {
+      expect.assertions(1);
+      jest.spyOn(controller, "exec");
+
+      await controller._exec();
+
+      expect(controller.exec).toHaveBeenCalled();
+    });
+
+    it("Should emit success when the file is downloaded.", async() => {
+      expect.assertions(1);
+      await controller._exec();
+
+      expect(worker.port.emit).toHaveBeenCalledWith(requestId, 'SUCCESS');
+    });
+
+
+    it("Should emit error when an error occured.", async() => {
+      expect.assertions(1);
+      const error = new Error('Cannot download');
+      controller.getPassphraseService.getPassphrase.mockRejectedValue(error);
+
+      await controller._exec();
+
+      expect(worker.port.emit).toHaveBeenCalledWith(requestId, 'ERROR', error);
+    });
+  });
+});
+

package/src/all/background_page/controller/extension/getExtensionVersionController.js

@@ -0,0 +1,51 @@
+/**
+ * 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
+ */
+
+class GetExtensionVersionController {
+  /**
+   * Constructor
+   * @param {Worker} worker
+   * @param {string} requestId uuid
+   */
+  constructor(worker, requestId) {
+    this.worker = worker;
+    this.requestId = requestId;
+  }
+
+  /**
+   * Wrapper of exec function to run it with worker.
+   *
+   * @return {Promise<void>}
+   */
+  async _exec() {
+    try {
+      const result = await this.exec();
+      this.worker.port.emit(this.requestId, "SUCCESS", result);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Get the extension version.
+   *
+   * @return {Promise<string>}
+   */
+  async exec() {
+    return chrome.runtime.getManifest().version;
+  }
+}
+
+export default GetExtensionVersionController;

package/src/all/background_page/controller/extension/getExtensionVersionController.test.js

@@ -0,0 +1,28 @@
+/**
+ * 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 GetExtensionVersionController from "./getExtensionVersionController";
+
+describe("GetExtensionVersionController", () => {
+  describe("GetExtensionVersionController::exec", () => {
+    it("Should retrieve the extension version.", async() => {
+      // extension version is mocked in .jest.setup.js
+      const controller = new GetExtensionVersionController();
+      const version = await controller.exec();
+
+      expect.assertions(1);
+      await expect(version).toEqual("v3.6.0");
+    });
+  });
+});

package/src/all/background_page/controller/extension/isExtensionFirstInstallController.js

@@ -0,0 +1,51 @@
+/**
+ * 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
+ */
+
+class IsExtensionFirstInstallController {
+  /**
+   * Constructor
+   * @param {Worker} worker
+   * @param {string} requestId uuid
+   */
+  constructor(worker, requestId) {
+    this.worker = worker;
+    this.requestId = requestId;
+  }
+
+  /**
+   * Wrapper of exec function to run it with worker.
+   *
+   * @return {Promise<void>}
+   */
+  async _exec() {
+    try {
+      const result = await this.exec();
+      this.worker.port.emit(this.requestId, "SUCCESS", result);
+    } catch (error) {
+      console.error(error);
+      this.worker.port.emit(this.requestId, 'ERROR', error);
+    }
+  }
+
+  /**
+   * Check if it's the extension first install.
+   *
+   * @return {Promise<boolean>}
+   */
+  async exec() {
+    return this.worker.tab.url.indexOf('first-install') !== -1;
+  }
+}
+
+export default IsExtensionFirstInstallController;

package/src/all/background_page/controller/extension/isExtensionFirstInstallController.test.js

@@ -0,0 +1,45 @@
+/**
+ * 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 IsExtensionFirstInstallController from "./isExtensionFirstInstallController";
+
+describe("IsExtensionFirstInstallController", () => {
+  describe("IsExtensionFirstInstallController::exec", () => {
+    it("Should return false if it's not the extension first install.", async() => {
+      const mockedWorker = {
+        tab: {
+          url: "moz-extension://134c1a66-c6e3-1343-a5d4-63c511465c17/data/app.html"
+        }
+      };
+      const controller = new IsExtensionFirstInstallController(mockedWorker);
+      const check = await controller.exec();
+
+      expect.assertions(1);
+      await expect(check).toEqual(false);
+    });
+
+    it("Should return true if it's the extension first install.", async() => {
+      const mockedWorker = {
+        tab: {
+          url: "moz-extension://134c1a66-c6e3-1343-a5d4-63c511465c17/data/app.html?first-install=1"
+        }
+      };
+      const controller = new IsExtensionFirstInstallController(mockedWorker);
+      const check = await controller.exec();
+
+      expect.assertions(1);
+      await expect(check).toEqual(true);
+    });
+  });
+});

package/src/all/background_page/controller/extension/onExtensionInstalledController.js

@@ -0,0 +1,107 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.4.0
+ *
+ * On extension installed controller
+ */
+import PagemodManager from "../../pagemod/pagemodManager";
+import WebNavigationService from "../../service/webNavigation/webNavigationService";
+import ParseSetupUrlService from "../../service/setup/parseSetupUrlService";
+import ParseRecoverUrlService from "../../service/recover/parseRecoverUrlService";
+
+class OnExtensionInstalledController {
+  /**
+   * Execute the OnExtensionInstalledController process
+   * @param details
+   * @returns {Promise<void>}
+   */
+  static async exec(details) {
+    switch (details.reason) {
+      case browser.runtime.OnInstalledReason.INSTALL:
+        await OnExtensionInstalledController.onInstall();
+        break;
+      case browser.runtime.OnInstalledReason.UPDATE:
+        await OnExtensionInstalledController.onUpdate();
+        break;
+      default:
+        console.debug(`The install reason ${details.reason} is not supported`);
+        break;
+    }
+  }
+  /**
+   * On installed the extension, add first install in the url tab of setup or recover
+   */
+  static async onInstall() {
+    // Apply on tabs that match the regex
+    await browser.tabs.query({currentWindow: true}).then(updateTabMatchUrl).then(closeTabWebStore);
+  }
+
+  /**
+   * On update the extension, for pagemod with refresh option and tabs that match the url refresh it
+   */
+  static async onUpdate() {
+    // Apply on tabs that match the pagemod url regex with refresh option
+    await browser.tabs.query({}).then(reloadTabsMatchPagemodUrl);
+  }
+}
+
+/**
+ *  Find the tab setup or recover and update url
+ * @param tabs
+ * @returns {Promise<unknown[]>}
+ */
+const updateTabMatchUrl = tabs => Promise.all(tabs.map(tab => {
+  if (tab && (ParseSetupUrlService.test(tab.url) || ParseRecoverUrlService.test(tab.url))) {
+    const url = new URL(tab.url);
+    url.searchParams.set('first-install', 1);
+    return browser.tabs.update(tab.id, {
+      url: url.href,
+      active: true
+    });
+  }
+  return tab;
+}));
+
+
+/**
+ * Find the tab web store and close it
+ * @private
+ * @param tabs
+ * @returns {Promise<unknown[]>}
+ */
+const closeTabWebStore = tabs => {
+  const urlWebStoreRegex = `https:\/\/(chromewebstore.google.com|addons.mozilla.org)\/(.*)\/passbolt`;
+  return Promise.all(tabs.map(tab => tab.url.match(urlWebStoreRegex) ? browser.tabs.remove(tab.id) : tab));
+};
+
+
+/**
+ * Reload the tabs that match pagemod url
+ * @param tabs
+ */
+const reloadTabsMatchPagemodUrl = tabs => {
+  tabs.map(tab => {
+    if (PagemodManager.hasPagemodMatchUrlToReload(tab.url)) {
+      browser.tabs.reload(tab.id);
+    } else {
+      // For other tabs detect and inject the new content script
+      const frameDetails = {
+        frameId: 0,
+        tabId: tab.id,
+        url: tab.url
+      };
+      WebNavigationService.exec(frameDetails);
+    }
+  });
+};
+
+export default OnExtensionInstalledController;

package/src/all/background_page/controller/extension/onExtensionInstalledController.test.js

@@ -0,0 +1,109 @@
+/**
+ * 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 OnExtensionInstalledController from "./onExtensionInstalledController";
+import User from "../../model/user";
+import UserSettings from "../../model/userSettings/userSettings";
+import WebNavigationService from "../../service/webNavigation/webNavigationService";
+
+// Reset the modules before each test.
+beforeEach(() => {
+  jest.resetModules();
+  jest.clearAllMocks();
+});
+
+describe("OnExtensionInstalledController", () => {
+  describe("OnExtensionInstalledController::exec", () => {
+    it("Should exec install if the reason is install", async() => {
+      expect.assertions(7);
+      // data mocked
+      const details = {
+        reason: browser.runtime.OnInstalledReason.INSTALL
+      };
+      const tabs = [
+        {id: 1, url: "https://passbolt.dev/setup/start/571bec7e-6cce-451d-b53a-f8c93e147228/5ea0fc9c-b180-4873-8e00-9457862e43e0"},
+        {id: 2, url: "https://passbolt.dev/setup/recover/start/571bec7e-6cce-451d-b53a-f8c93e147228/5ea0fc9c-b180-4873-8e00-9457862e43e0"},
+        {id: 3, url: "https://passbolt.dev/auth/login"},
+        {id: 4, url: "https://localhost"},
+        {id: 5, url: "https://chromewebstore.google.com/id/passbolt"},
+        {id: 6, url: "https://addons.mozilla.org/id/passbolt"}
+      ];
+      // mock function
+      jest.spyOn(OnExtensionInstalledController, "onInstall");
+      jest.spyOn(browser.tabs, "query").mockImplementation(() => Promise.resolve(tabs));
+      jest.spyOn(browser.tabs, "update").mockImplementation(tabId => tabs.find(tab => tab.id === tabId));
+      // process
+      await OnExtensionInstalledController.exec(details);
+      // expectation
+      expect(OnExtensionInstalledController.onInstall).toHaveBeenCalled();
+      expect(browser.tabs.update).toHaveBeenCalledWith(tabs[0].id, {url: `${tabs[0].url}?first-install=1`, active: true});
+      expect(browser.tabs.update).toHaveBeenCalledWith(tabs[1].id, {url: `${tabs[1].url}?first-install=1`, active: true});
+      expect(browser.tabs.update).toHaveBeenCalledTimes(2);
+      expect(browser.tabs.remove).toHaveBeenCalledWith(tabs[4].id);
+      expect(browser.tabs.remove).toHaveBeenCalledWith(tabs[5].id);
+      expect(browser.tabs.remove).toHaveBeenCalledTimes(2);
+    });
+
+    it("Should exec update if the reason is update", async() => {
+      expect.assertions(9);
+      // data mocked
+      const details = {
+        reason: browser.runtime.OnInstalledReason.UPDATE
+      };
+      const tabs = [
+        {id: 1, url: "https://passbolt.dev/setup/start/571bec7e-6cce-451d-b53a-f8c93e147228/5ea0fc9c-b180-4873-8e00-9457862e43e0"},
+        {id: 2, url: "https://passbolt.dev/setup/recover/start/571bec7e-6cce-451d-b53a-f8c93e147228/5ea0fc9c-b180-4873-8e00-9457862e43e0"},
+        {id: 3, url: "https://passbolt.dev/auth/login"},
+        {id: 4, url: "https://passbolt.dev"},
+        {id: 5, url: "https://passbolt.com"},
+        {id: 6, url: "https://localhost"}
+      ];
+      // mock function
+      jest.spyOn(OnExtensionInstalledController, "onUpdate");
+      jest.spyOn(WebNavigationService, "exec");
+      jest.spyOn(browser.tabs, "query").mockImplementationOnce(() => Promise.resolve(tabs));
+      jest.spyOn(User.getInstance(), "isValid").mockImplementation(() => true);
+      jest.spyOn(UserSettings.prototype, "getDomain").mockImplementation(() => "https://passbolt.dev");
+      // process
+      await OnExtensionInstalledController.exec(details);
+      // expectation
+      expect(OnExtensionInstalledController.onUpdate).toHaveBeenCalled();
+      expect(browser.tabs.reload).toHaveBeenCalledWith(tabs[0].id);
+      expect(browser.tabs.reload).toHaveBeenCalledWith(tabs[1].id);
+      expect(browser.tabs.reload).toHaveBeenCalledWith(tabs[2].id);
+      expect(browser.tabs.reload).toHaveBeenCalledWith(tabs[3].id);
+      expect(browser.tabs.reload).toHaveBeenCalledTimes(4);
+      expect(WebNavigationService.exec).toHaveBeenCalledWith({frameId: 0, tabId: tabs[4].id, url: tabs[4].url});
+      expect(WebNavigationService.exec).toHaveBeenCalledWith({frameId: 0, tabId: tabs[5].id, url: tabs[5].url});
+      expect(WebNavigationService.exec).toHaveBeenCalledTimes(2);
+    });
+
+    it("Should not exec update neither install if the reason is unknown", async() => {
+      expect.assertions(2);
+      // data mocked
+      const details = {
+        reason: "unknown"
+      };
+      // mock function
+      jest.spyOn(OnExtensionInstalledController, "onUpdate");
+      jest.spyOn(OnExtensionInstalledController, "onInstall");
+
+      // process
+      await OnExtensionInstalledController.exec(details);
+      // expectation
+      expect(OnExtensionInstalledController.onUpdate).not.toHaveBeenCalled();
+      expect(OnExtensionInstalledController.onInstall).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/all/background_page/controller/extension/onExtensionUpdateAvailableController.js

@@ -0,0 +1,56 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.6.0
+ *
+ * On extension update available controller
+ */
+import User from "../../model/user";
+import GpgAuth from "../../model/gpgauth";
+
+class OnExtensionUpdateAvailableController {
+  /**
+   * Execute the OnExtensionUpdateAvailableController process
+   * @returns {Promise<void>}
+   */
+  static async exec() {
+    if (await isUserAuthenticated()) {
+      // Add listener on passbolt logout to update the extension
+      self.addEventListener("passbolt.auth.after-logout", () => browser.runtime.reload());
+    } else {
+      browser.runtime.reload();
+    }
+  }
+}
+
+/**
+ * Check and process event if the user is authenticated
+ * @return {Promise<bool>}
+ */
+const isUserAuthenticated = async() => {
+  const user = User.getInstance();
+  // Check if user is valid
+  if (user.isValid()) {
+    const auth = new GpgAuth();
+    try {
+      return await auth.isAuthenticated();
+    } catch (error) {
+      /*
+       * Service unavailable
+       */
+      console.debug('The Service is unavailable to check if the user is authenticated');
+      console.error(error);
+    }
+  }
+  return false;
+};
+
+export default OnExtensionUpdateAvailableController;