passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/service/local_storage/userRememberMeLatestChoiceLocalStorage.js

@@ -0,0 +1,82 @@
+/**
+ * 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.2.0
+ */
+import Log from "../../model/log";
+import UserRememberMeLatestChoiceEntity from "../../model/entity/rememberMe/userRememberMeLatestChoiceEntity";
+
+export const REMEMBER_ME_LATEST_CHOICE_LOCAL_STORAGE_KEY = 'userRememberMeLatestChoice';
+
+class UserRememberMeLatestChoiceLocalStorage {
+  /**
+   * Constructor
+   * @param account the user account
+   */
+  constructor(account) {
+    this.storageKey = this.getStorageKey(account);
+  }
+
+  /**
+   * Get the storage key.
+   * @param {AbstractAccountEntity} account The account to get the key for.
+   * @returns {string}
+   * @throws {Error} If it cannot retrieve account id.
+   */
+  getStorageKey(account) {
+    if (!account.id) {
+      throw new Error('Cannot retrieve account id, necessary to get a rememberMe storage key.');
+    }
+    return `${REMEMBER_ME_LATEST_CHOICE_LOCAL_STORAGE_KEY}-${account.id}`;
+  }
+
+  /**
+   * Flush the rememberMe local storage
+   * @return {Promise<void>}
+   */
+  async flush() {
+    Log.write({level: 'debug', message: 'UserRememberMeLatestChoiceLocalStorage flushed'});
+    await browser.storage.local.remove(this.storageKey);
+  }
+
+  /**
+   * Get the UserRememberMeLatestChoice local storage.
+   * @throws {Error} if operation failed
+   * @return {Promise<UserRememberMeLatestChoiceEntity|null>} the rememberMe entity or null by default.
+   */
+  async get() {
+    const value = await browser.storage.local.get([this.storageKey]);
+    if (!value || !value[this.storageKey]) {
+      return null;
+    }
+
+    // ensure this feature is not breaking anything by returning an accepted default value
+    try {
+      return new UserRememberMeLatestChoiceEntity(value[this.storageKey]);
+    } catch (e) {
+      console.error(e);
+      return null;
+    }
+  }
+
+  /**
+   * Set the rememberMe in local storage.
+   * @param {UserRememberMeLatestChoiceEntity} rememberMeLatestChoiceEntity the value to save.
+   * @return {Promise<void>}
+   */
+  async set(rememberMeLatestChoiceEntity) {
+    await navigator.locks.request(this.storageKey, async() => {
+      await browser.storage.local.set({[this.storageKey]: rememberMeLatestChoiceEntity.toDto()});
+    });
+  }
+}
+
+export default UserRememberMeLatestChoiceLocalStorage;

package/src/all/background_page/service/local_storage/userRememberMeLatestChoiceLocalStorage.test.js

@@ -0,0 +1,74 @@
+/**
+ * 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.2.0
+ */
+import GetLegacyAccountService from "../account/getLegacyAccountService";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import UserRememberMeLatestChoiceLocalStorage from "./userRememberMeLatestChoiceLocalStorage";
+import UserRememberMeLatestChoiceEntity from "../../model/entity/rememberMe/userRememberMeLatestChoiceEntity";
+
+describe("UserRememberMeLatestChoiceLocalStorage", () => {
+  // mock data
+  const account = new AccountEntity(defaultAccountDto());
+  // spy on
+  jest.spyOn(GetLegacyAccountService, "get").mockImplementation(() => account);
+
+  describe("rememberMeLocalStorage::get", () => {
+    it("Should return false if nothing stored in the storage", async() => {
+      expect.assertions(1);
+      const storage = new UserRememberMeLatestChoiceLocalStorage(account);
+      const result = await storage.get();
+      expect(result).toStrictEqual(null);
+    });
+
+    it("Should return the content stored in the local storage", async() => {
+      expect.assertions(1);
+      const storage = new UserRememberMeLatestChoiceLocalStorage(account);
+      const entity = new UserRememberMeLatestChoiceEntity({duration: 3600});
+      browser.storage.local.set({[storage.storageKey]: entity.toDto()});
+      expect(await storage.get()).toEqual(entity);
+    });
+
+    it("Should return null if the entity cannot be validated", async() => {
+      expect.assertions(1);
+      const storage = new UserRememberMeLatestChoiceLocalStorage(account);
+      browser.storage.local.set({[storage.storageKey]: "garbage"});
+      expect(await storage.get()).toEqual(null);
+    });
+  });
+
+  describe("UserRememberMeLatestChoiceLocalStorage::set", () => {
+    it("Should set the rememberMe choice in the local storage", async() => {
+      expect.assertions(2);
+      const storage = new UserRememberMeLatestChoiceLocalStorage(account);
+      const entity1 = new UserRememberMeLatestChoiceEntity({duration: -1});
+      await storage.set(entity1);
+      expect(await storage.get()).toStrictEqual(entity1);
+
+      const entity2 = new UserRememberMeLatestChoiceEntity({duration: 500});
+      await storage.set(entity2);
+      expect(await storage.get()).toStrictEqual(entity2);
+    });
+  });
+
+  describe("UserRememberMeLatestChoiceLocalStorage::flush", () => {
+    it("Should flush all the rememberMe option from the local storage", async() => {
+      expect.assertions(1);
+      const storage = new UserRememberMeLatestChoiceLocalStorage(account);
+      const entity = new UserRememberMeLatestChoiceEntity({duration: -1});
+      await storage.set(entity);
+      await storage.flush();
+      expect(await storage.get()).toStrictEqual(null);
+    });
+  });
+});

package/src/all/background_page/service/passphrase/getPassphraseService.js

@@ -0,0 +1,152 @@
+/**
+ * Passphrase controller.
+ *
+ * @copyright (c) 2019 Passbolt SA
+ * @licence GNU Affero General Public License http://www.gnu.org/licenses/agpl-3.0.en.html
+ */
+
+import {OpenpgpAssertion} from "../../utils/openpgp/openpgpAssertions";
+import Keyring from "../../model/keyring";
+import DecryptPrivateKeyService from "../crypto/decryptPrivateKeyService";
+import {QuickAccessService} from "../ui/quickAccess.service";
+import UserAbortsOperationError from "../../error/userAbortsOperationError";
+import PassphraseStorageService from "../session_storage/passphraseStorageService";
+import WorkerService from "../worker/workerService";
+import UserRememberMeLatestChoiceLocalStorage from "../local_storage/userRememberMeLatestChoiceLocalStorage";
+import UserRememberMeLatestChoiceEntity from "../../model/entity/rememberMe/userRememberMeLatestChoiceEntity";
+import {assertPassphrase} from "../../utils/assertions";
+
+export default class GetPassphraseService {
+  constructor(account) {
+    this.userRememberMeLatestChoiceStorage = new UserRememberMeLatestChoiceLocalStorage(account);
+  }
+
+  /**
+   * Get the user master password.
+   *
+   * @param {Worker} worker The worker from which the request comes from.
+   * @return {Promise<string>}
+   * @throw Error if the passphrase is not valid.
+   */
+  async getPassphrase(worker) {
+    const passphrase = await PassphraseStorageService.get();
+    if (passphrase) {
+      return passphrase;
+    }
+    return this.requestPassphrase(worker);
+  }
+
+  /**
+   * Request the user passphrase.
+   *
+   * @param {Worker} worker The worker from which the request comes from.
+   * @throw Error if the passphrase is not valid.
+   * @return {Promise<string>}
+   */
+  async requestPassphrase(worker) {
+    const requestResult = await worker.port.request('passbolt.passphrase.request');
+    const {passphrase, rememberMe} = requestResult;
+    await this.validatePassphrase(passphrase);
+    await this.rememberPassphrase(passphrase, rememberMe);
+
+    return passphrase;
+  }
+
+  /**
+   * Request the user passphrase from the Quick Access
+   * @returns {Promise<string>}
+   */
+  async requestPassphraseFromQuickAccess() {
+    const storedPassphrase = await PassphraseStorageService.get();
+    if (storedPassphrase) {
+      return storedPassphrase;
+    }
+
+    /*
+     * Open the quick access to request the master passphrase to the user.
+     * Then once the quick access will have captured the passphrase, it will communicate it to its worker using requestId
+     * as message name. Basically, without changing the way the passphrase will be returned if the quick access was already
+     * open and it will have to reply to the request "passbolt.passphrase.request".
+     */
+    const requestId = (Math.round(Math.random() * Math.pow(2, 32))).toString();
+    const queryParameters = [
+      {name: "uiMode", value: "detached"},
+      {name: "feature", value: "request-passphrase"},
+      {name: "requestId", value: requestId}
+    ];
+    const quickAccessWindow = await QuickAccessService.openInDetachedMode(queryParameters);
+    const {passphrase, rememberMe} = await this.listenToDetachedQuickaccessPassphraseRequestResponse(requestId, quickAccessWindow);
+    await this.validatePassphrase(passphrase);
+    await this.rememberPassphrase(passphrase, rememberMe);
+
+    return passphrase;
+  }
+
+  /**
+   * Listen to the quick access passphrase request response.
+   * @param {string} requestId The requestId used by the quick access to return the user passphrase
+   * @param {window.Window} quickAccessWindow The window the quick access runs on.
+   * @returns {Promise<{passphrase: string, rememberMe: string}>}
+   */
+  async listenToDetachedQuickaccessPassphraseRequestResponse(requestId, quickAccessWindow) {
+    const tabId = quickAccessWindow?.tabs?.[0]?.id;
+    await WorkerService.waitExists('QuickAccess', tabId);
+    const quickAccessWorker = await WorkerService.get('QuickAccess', tabId);
+    let isResolved = false;
+
+    return new Promise((resolve, reject) => {
+      // When the passphrase is entered and valid, the quickaccess responds on the port with the requestId that has been given to it when opening it.
+      quickAccessWorker.port.on(requestId, (status, requestResult)  => {
+        isResolved = true;
+        if (status === 'SUCCESS') {
+          resolve(requestResult);
+        } else {
+          reject(requestResult);
+        }
+      });
+      // If the users closes the window manually before entering their passphrase, the operation is aborted.
+      quickAccessWorker.port._port.onDisconnect.addListener(() => {
+        if (!isResolved) {
+          isResolved = true;
+          const error = new UserAbortsOperationError("The dialog has been closed.");
+          reject(error);
+        }
+      });
+    });
+  }
+
+  /**
+   * Remember the user passphrase for a given duration.
+   * @param {string} passphrase The passphrase.
+   * @param {integer|string} duration The duration in second to remember the passphrase for.
+   *  If -1 given then it will remember the passphrase until the user is logged out.
+   * @private
+   */
+  async rememberPassphrase(passphrase, duration) {
+    if (!duration || !Number.isInteger(duration)) {
+      return;
+    }
+
+    await PassphraseStorageService.set(passphrase, duration);
+    const userRememberMeLatestChoiceEntity = new UserRememberMeLatestChoiceEntity({
+      duration: parseInt(duration, 10)
+    });
+    this.userRememberMeLatestChoiceStorage.set(userRememberMeLatestChoiceEntity);
+  }
+
+  /**
+   * Validate the passphrase.
+   * @param {string} passphrase The passphrase.
+   * @returns {Promise<void>}
+   * @throws {Error} Error if the passphrase is not a valid utf-8 string.
+   * @throws {InvalidMasterPasswordError} if the passphrase is not valid.
+   */
+  async validatePassphrase(passphrase) {
+    assertPassphrase(passphrase);
+
+    const keyring = new Keyring();
+    const userPrivateArmoredKey = keyring.findPrivate().armoredKey;
+    const userPrivateKey = await OpenpgpAssertion.readKeyOrFail(userPrivateArmoredKey);
+    await DecryptPrivateKeyService.decrypt(userPrivateKey, passphrase);
+  }
+}

package/src/all/background_page/service/passphrase/getPassphraseService.test.js

@@ -0,0 +1,258 @@
+/**
+ * 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.2.0
+ */
+
+import UserAbortsOperationError from "../../error/userAbortsOperationError";
+import AccountEntity from "../../model/entity/account/accountEntity";
+import PassphraseStorageService from "../session_storage/passphraseStorageService";
+import GetPassphraseService from "./getPassphraseService";
+import {QuickAccessService} from "../../service/ui/quickAccess.service";
+import WorkerService from "../worker/workerService";
+import WorkersSessionStorage from "../sessionStorage/workersSessionStorage";
+import PortManager from "../../sdk/port/portManager";
+import MockPort from "passbolt-styleguide/src/react-extension/test/mock/MockPort";
+import MockExtension from "../../../../../test/mocks/mockExtension";
+import {pgpKeys} from "../../../../../test/fixtures/pgpKeys/keys";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import DecryptPrivateKeyService from "../crypto/decryptPrivateKeyService";
+import {OpenpgpAssertion} from "../../utils/openpgp/openpgpAssertions";
+import {v4 as uuid} from "uuid";
+import UserRememberMeLatestChoiceEntity from "../../model/entity/rememberMe/userRememberMeLatestChoiceEntity";
+
+jest.mock("../ui/quickAccess.service");
+jest.mock("../session_storage/passphraseStorageService");
+jest.mock("../crypto/decryptPrivateKeyService");
+jest.mock("../../utils/openpgp/openpgpAssertions");
+
+describe("GetPassphraseService", () => {
+  const userData = pgpKeys.ada;
+  const expectedPassphrase = userData.passphrase;
+  const account = new AccountEntity(defaultAccountDto());
+  const passphraseRequestResponse = {
+    passphrase: expectedPassphrase,
+    rememberMe: 400
+  };
+
+  beforeEach(async() => {
+    jest.clearAllMocks();
+    jest.resetModules();
+    await MockExtension.withConfiguredAccount(userData);
+  });
+
+  const waitFor = () => () => new Promise(resolve => setTimeout(resolve, 0));
+
+  const getTestWorker = () => {
+    const tab = {id: 1};
+    const worker = {
+      tab: tab,
+      port: new MockPort()
+    };
+    //@todo: put this on styleguide MockPort.js instead
+    worker.port._port = {
+      onDisconnect: {
+        addListener: callback => worker.port.addRequestListener("disconnect", callback)
+      },
+      sender: {tab: tab}
+    };
+    worker.port.simulateDisconnect = () => worker.port.request("disconnect");
+    worker.port.addRequestListener("passbolt.passphrase.request", async() => passphraseRequestResponse);
+
+    return worker;
+  };
+
+  describe("GetPassphraseService::getPassphrase", () => {
+    it("should return the user's private key's passphrase that the user entered when the local storage is empty", async() => {
+      expect.assertions(2);
+      const worker = getTestWorker();
+      PassphraseStorageService.get.mockImplementation(async() => null);
+      const service = new GetPassphraseService(account);
+      const receivedPassphrase = await service.getPassphrase(worker);
+
+      expect(receivedPassphrase).toStrictEqual(expectedPassphrase);
+      expect(PassphraseStorageService.get).toHaveBeenCalledTimes(1);
+    });
+
+    it("should return the user's private key's passphrase stored in the local storage", async() => {
+      expect.assertions(2);
+      const worker = getTestWorker();
+      PassphraseStorageService.get.mockImplementation(async() => expectedPassphrase);
+      worker.port.addRequestListener("passbolt.passphrase.request", () => { throw new Error("Should not be called during this test"); });
+      const service = new GetPassphraseService(account);
+      const receivedPassphrase = await service.getPassphrase(worker);
+
+      expect(receivedPassphrase).toStrictEqual(expectedPassphrase);
+      expect(PassphraseStorageService.get).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("GetPassphraseService::requestPassphrase", () => {
+    it("should call `passbolt.passphrase.request` to retrieve passphrase from a user input", async() => {
+      expect.assertions(1);
+      const worker = getTestWorker();
+      const service = new GetPassphraseService(account);
+      const receivedPassphrase = await service.requestPassphrase(worker);
+
+      expect(receivedPassphrase).toStrictEqual(expectedPassphrase);
+    });
+
+    it("should throw an exception if the user doesn't input its passphrase", async() => {
+      expect.assertions(1);
+      const expectedError = new UserAbortsOperationError();
+      const worker = getTestWorker();
+      worker.port.addRequestListener("passbolt.passphrase.request", () => { throw expectedError; });
+      const service = new GetPassphraseService(account);
+      try {
+        await service.requestPassphrase(worker);
+      } catch (e) {
+        expect(e).toStrictEqual(expectedError);
+      }
+    });
+  });
+
+  describe("GetPassphraseService::requestPassphraseFromQuickAccess", () => {
+    jest.spyOn(WorkerService, "waitExists");
+    jest.spyOn(WorkersSessionStorage, "getWorkersByNameAndTabId");
+    jest.spyOn(PortManager, "isPortExist");
+    jest.spyOn(PortManager, "getPortById");
+
+    it("should abort the operation if the quickaccess port is disconnected", async() => {
+      expect.assertions(1);
+      const quickAccessWorker = getTestWorker();
+
+      WorkerService.waitExists.mockImplementation(() => {});
+      PassphraseStorageService.get.mockImplementation(async() => null);
+      PortManager.isPortExist.mockImplementation(async() => true);
+      PortManager.getPortById.mockImplementation(async() => quickAccessWorker.port);
+      WorkersSessionStorage.getWorkersByNameAndTabId.mockImplementation(async() => [quickAccessWorker]);
+
+      const service = new GetPassphraseService(account);
+
+      const receivedPassphrasePromise = service.requestPassphraseFromQuickAccess();
+      await waitFor()();
+      quickAccessWorker.port.simulateDisconnect();
+
+      try {
+        await receivedPassphrasePromise;
+      } catch (e) {
+        expect(e).toBeInstanceOf(UserAbortsOperationError);
+      }
+    });
+
+    it("should get the passphrase from the quickaccess in detached mode", async() => {
+      expect.assertions(2);
+      const quickAccessWorker = getTestWorker();
+      const expectedTabId = uuid();
+      const mockedPopupWindow = {
+        tabs: [{id: expectedTabId}]
+      };
+      let requestId = null;
+
+      PassphraseStorageService.get.mockImplementation(async() => null);
+      WorkerService.waitExists.mockImplementation(() => {});
+      WorkersSessionStorage.getWorkersByNameAndTabId.mockImplementation(async() => [quickAccessWorker]);
+      PortManager.isPortExist.mockImplementation(async() => true);
+      PortManager.getPortById.mockImplementation(async() => quickAccessWorker.port);
+
+      QuickAccessService.openInDetachedMode.mockImplementation(popupParameters => {
+        const expectedParameters = [
+          {name: "uiMode", value: "detached"},
+          {name: "feature", value: "request-passphrase"},
+          {name: "requestId", value: expect.any(String)}
+        ];
+
+        expect(popupParameters).toStrictEqual(expectedParameters);
+
+        requestId = popupParameters[2].value;
+        return mockedPopupWindow;
+      });
+
+
+      const service = new GetPassphraseService(account);
+
+      const receivedPassphrasePromise = service.requestPassphraseFromQuickAccess();
+      await waitFor()();
+
+      //@todo: to be fixed on styleguide and use it the proper way instead;
+      quickAccessWorker.port.emitListener[requestId]("SUCCESS", passphraseRequestResponse);
+      const receivedPassphrase = await receivedPassphrasePromise;
+
+      expect(receivedPassphrase).toStrictEqual(expectedPassphrase);
+    });
+
+    it("should not open the quickacces if the the passphrase is registered locally", async() => {
+      expect.assertions(2);
+      const worker = getTestWorker();
+      worker.port.addRequestListener("passbolt.passphrase.request", () => { throw new Error("Should not be called during this test"); });
+      PassphraseStorageService.get.mockImplementation(async() => expectedPassphrase);
+      const service = new GetPassphraseService(account);
+      const receivedPassphrase = await service.requestPassphraseFromQuickAccess();
+
+      expect(receivedPassphrase).toStrictEqual(expectedPassphrase);
+      expect(QuickAccessService.openInDetachedMode).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("GetPassphraseService::rememberPassphrase", () => {
+    it("should call the storage service to remember the session", async() => {
+      expect.assertions(4);
+      const service = new GetPassphraseService(account);
+      const setStorageSpy = jest.spyOn(service.userRememberMeLatestChoiceStorage, "set");
+
+      const passphraseToRemember = "passphrase to remember";
+      const durationForRememberance = -1;
+      const expectedEntityToSave = new UserRememberMeLatestChoiceEntity({duration: durationForRememberance});
+      await service.rememberPassphrase(passphraseToRemember, durationForRememberance);
+
+      expect(PassphraseStorageService.set).toHaveBeenCalledTimes(1);
+      expect(PassphraseStorageService.set).toHaveBeenCalledWith(passphraseToRemember, durationForRememberance);
+      expect(setStorageSpy).toHaveBeenCalledTimes(1);
+      expect(setStorageSpy).toHaveBeenCalledWith(expectedEntityToSave);
+    });
+
+
+    it("should not remember the session if the duration session is not formatted properly", async() => {
+      expect.assertions(2);
+      const service = new GetPassphraseService(account);
+      const setStorageSpy = jest.spyOn(service.userRememberMeLatestChoiceStorage, "set");
+
+      const passphraseToRemember = "passphrase to remember";
+      const durationForRememberance = "wrong value";
+      await service.rememberPassphrase(passphraseToRemember, durationForRememberance);
+
+      expect(PassphraseStorageService.set).not.toHaveBeenCalled();
+      expect(setStorageSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("GetPassphraseService::validatePassphrase", () => {
+    it("should validate the passphrase with the current user's private key", async() => {
+      expect.assertions(2);
+      const service = new GetPassphraseService(account);
+      await service.validatePassphrase(expectedPassphrase);
+
+      expect(OpenpgpAssertion.readKeyOrFail).toHaveBeenCalledTimes(1);
+      expect(DecryptPrivateKeyService.decrypt).toHaveBeenCalledTimes(1);
+    });
+
+    it("should throw an error if the passphrase is not properly formatted", async() => {
+      expect.assertions(1);
+      const expectedError = new Error("The given parameter should be a valid UTF8 string.");
+      const service = new GetPassphraseService(account);
+      try {
+        await service.validatePassphrase({data: 1234567890});
+      } catch (e) {
+        expect(e).toStrictEqual(expectedError);
+      }
+    });
+  });
+});

package/src/all/background_page/service/passwordExpirySettings/passwordExpirySettingsGetOrFindService.js

@@ -0,0 +1,49 @@
+/**
+ * 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.5.0
+ */
+import PasswordExpirySettingsModel from "../../model/passwordExpiry/passwordExpirySettingsModel";
+
+export const PASSWORD_EXPIRY_SETTINGS_LOCK = 'passwordExpirySettingsLock';
+/**
+ * The passwordExpirySettingsGetOrFindService perform a get or update the password expiry settings local storage
+ */
+class PasswordExpirySettingsGetOrFindService {
+  constructor(account, apiClientOptions) {
+    this.storageKey = this.getStorageKey(account);
+    this.passwordExpirySettingsModel = new PasswordExpirySettingsModel(account, apiClientOptions);
+  }
+
+  /**
+   * Get the storage key.
+   * @param {AbstractAccountEntity} account The account to get the key for.
+   * @returns {string}
+   * @throws {Error} If it cannot retrieve account id.
+   */
+  getStorageKey(account) {
+    if (!account.id) {
+      throw new Error('Cannot retrieve account id, necessary to lock the password expiry settings get or find service.');
+    }
+    return `${PASSWORD_EXPIRY_SETTINGS_LOCK}-${account.id}`;
+  }
+
+  /**
+   * Get or find the password expiry settings in local storage.
+   * @param {boolean} refreshCache
+   * @return {Promise<PasswordExpirySettingsEntity>}
+   */
+  async exec(refreshCache = false) {
+    return await navigator.locks.request(this.storageKey, async() => await this.passwordExpirySettingsModel.getOrFindOrDefault(refreshCache));
+  }
+}
+
+export default PasswordExpirySettingsGetOrFindService;

package/src/all/background_page/service/passwordExpirySettings/passwordExpirySettingsGetOrFindService.test.js

@@ -0,0 +1,45 @@
+/**
+ * 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.5.0
+ */
+
+import AccountEntity from "../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
+import PasswordExpirySettingsGetOrFindService from "./passwordExpirySettingsGetOrFindService";
+import BuildApiClientOptionsService from "../account/buildApiClientOptionsService";
+import {enableFetchMocks} from "jest-fetch-mock";
+
+describe("PasswordExpirySettingsGetOrFindService", () => {
+  beforeEach(() => {
+    enableFetchMocks();
+    fetch.resetMocks();
+    jest.spyOn(browser.cookies, "get").mockImplementationOnce(() => ({value: "csrf-token"}));
+    jest.resetModules();
+  });
+
+  describe("PasswordExpirySettingsGetOrFindService::exec", () => {
+    it("should check if the lock is called", async() => {
+      expect.assertions(1);
+      // data
+      const account = new AccountEntity(defaultAccountDto());
+      const apiClientOptions = await BuildApiClientOptionsService.buildFromAccount(account);
+      const passwordExpirySettingsService = new PasswordExpirySettingsGetOrFindService(account, apiClientOptions);
+      // mocked functions
+      jest.spyOn(passwordExpirySettingsService.passwordExpirySettingsModel, "getOrFindOrDefault").mockImplementationOnce(jest.fn);
+      jest.spyOn(navigator.locks, "request");
+      // execution
+      await passwordExpirySettingsService.exec();
+      // expectations
+      expect(navigator.locks.request).toHaveBeenCalledWith(passwordExpirySettingsService.storageKey, expect.anything(Function));
+    });
+  });
+});