passbolt-browser-extension 5.2.0 → 5.3.2

package/src/chrome-mv3/serviceWorker/service/offscreen/handleOffscreenResponseService.js

@@ -0,0 +1,119 @@
+/**
+ * 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         5.3.2
+ */
+import {assertUuid} from "../../../../all/background_page/utils/assertions";
+import {SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN_RESPONSE_HANDLER} from "../../../offscreens/service/clipboard/writeClipobardOffscreenService";
+import {
+  SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_POLLING_HANDLER,
+  SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_RESPONSE_HANDLER
+} from "../../../offscreens/service/network/fetchOffscreenService";
+import {SEND_MESSAGE_TARGET_OFFSCREEN_ERROR_RESPONSE_HANDLER} from "../../../offscreens/service/offscreen/handleOffscreenRequestService";
+import ResponseClipboardOffscreenService from "../clipboard/responseClipboardOffscreenService";
+import ResponseFetchOffscreenService from "../network/responseFetchOffscreenService";
+
+export default class HandleOffscreenResponseService {
+  /**
+   * @type {object}
+   * @private
+   */
+  static _offscreenResponsePromisesCallbacks = {};
+
+  /**
+   * @type {Map<string, function>}
+   * @private
+   */
+  static REPONSE_HANDLE_MAP = {
+    [SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_RESPONSE_HANDLER]: ResponseFetchOffscreenService.handleFetchResponse,
+    [SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN_RESPONSE_HANDLER]: ResponseClipboardOffscreenService.handleClipboardResponse,
+    [SEND_MESSAGE_TARGET_OFFSCREEN_ERROR_RESPONSE_HANDLER]: HandleOffscreenResponseService.handleOffscreenError,
+  };
+
+  /**
+   * Handle offscreen response.
+   * @param {object} message Browser runtime.onMessage listener message.
+   */
+  static handleOffscreenResponse(message) {
+    if (message.target === SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_POLLING_HANDLER) {
+      //it's a polling message that is only here to keep the offscreen document alive.
+      return;
+    }
+
+    const responseHandler = HandleOffscreenResponseService.REPONSE_HANDLE_MAP[message.target];
+    if (!responseHandler) {
+      console.debug("HandleOffscreenResponseService received response not specific to offscreen.");
+      return;
+    }
+
+    HandleOffscreenResponseService._assertOffscreenResponse(message);
+    const promise = HandleOffscreenResponseService._consumeRequestPromiseCallbacksOrFail(message.id);
+
+    responseHandler(message, promise);
+  }
+
+  /**
+   * Handles generic offscreen error message.
+   * @param {object} message
+   * @param {{resolve: function, reject: function}} promise
+   * @private
+   */
+  static handleOffscreenError(message, promise) {
+    const error = new Error("Something went wrong while processing an offscreen request");
+
+    const errorCauseString = message?.data?.error;
+    if (errorCauseString) {
+      const cause = JSON.parse(errorCauseString);
+      error.cause = new Error();
+      error.cause.name = cause.name;
+      error.cause.message = cause.message;
+      error.cause.stack = cause.stack;
+    }
+
+    promise.reject(error);
+  }
+
+  /**
+   * Sets a new promise response callback for a given offscreen request id.
+   * @param {string} id
+   * @param {{resolve: function, reject: function}} promise
+   */
+  static setResponseCallback(id, promise) {
+    HandleOffscreenResponseService._offscreenResponsePromisesCallbacks[id] = promise;
+  }
+
+  /**
+   * Asserts that the given message is a valid offscreen response message.
+   * @param {object} message
+   * @throws {Error} if message.id is not a valid UUID
+   * @private
+   */
+  static _assertOffscreenResponse(message) {
+    assertUuid(message.id, "HandleOffscreenResponseService: message.id should be a valid uuid.");
+  }
+
+  /**
+   * Consume the offscreen request promise callbacks or fail.
+   * @param {string} id The identifier of the offscreen fetch request.
+   * @returns {Promise}
+   * @throws {Error} If no request promise callbacks can be found for the given offscreen fetch request id.
+   * @private
+   */
+  static _consumeRequestPromiseCallbacksOrFail(id) {
+    const offscreenRequestPromiseCallback = HandleOffscreenResponseService._offscreenResponsePromisesCallbacks[id];
+    if (!offscreenRequestPromiseCallback) {
+      throw new Error("HandleOffscreenResponseService: No request promise callbacks found for the given offscreen fetch request id.");
+    }
+    delete HandleOffscreenResponseService._offscreenResponsePromisesCallbacks[id];
+
+    return offscreenRequestPromiseCallback;
+  }
+}

package/src/chrome-mv3/serviceWorker/service/offscreen/handleOffscreenResponseService.test.js

@@ -0,0 +1,159 @@
+/**
+ * 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         5.3.2
+ */
+
+import {SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN_RESPONSE_HANDLER} from "../../../offscreens/service/clipboard/writeClipobardOffscreenService";
+import {SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_RESPONSE_HANDLER} from "../../../offscreens/service/network/fetchOffscreenService";
+import {defaultCallbacks} from "../network/responseFetchOffscreenService.test.data";
+import HandleOffscreenResponseService from "./handleOffscreenResponseService";
+import {v4 as uuidv4} from "uuid";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("HandleOffscreenResponseService", () => {
+  let fetchFunction, clipboardWriteFunction;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    fetchFunction = jest.spyOn(HandleOffscreenResponseService.REPONSE_HANDLE_MAP, SEND_MESSAGE_TARGET_FETCH_OFFSCREEN_RESPONSE_HANDLER).mockImplementation(() => {});
+    clipboardWriteFunction = jest.spyOn(HandleOffscreenResponseService.REPONSE_HANDLE_MAP, SEND_MESSAGE_TARGET_CLIPBOARD_WRITE_OFFSCREEN_RESPONSE_HANDLER).mockImplementation(() => {});
+  });
+
+  describe("::handleOffscreenResponse", () => {
+    it("should handle fetch response and dispatch to the right service", () => {
+      expect.assertions(3);
+
+      const message = {
+        id: uuidv4(),
+        target: "service-worker-fetch-offscreen-response-handler"
+      };
+      const promises = defaultCallbacks();
+      HandleOffscreenResponseService.setResponseCallback(message.id, promises);
+
+      HandleOffscreenResponseService.handleOffscreenResponse(message);
+
+      expect(fetchFunction).toHaveBeenCalledTimes(1);
+      expect(fetchFunction).toHaveBeenCalledWith(message, promises);
+      expect(clipboardWriteFunction).not.toHaveBeenCalled();
+    });
+
+    it("should handle fetch polling response and dispatch to the right service", () => {
+      expect.assertions(2);
+
+      const message = {
+        target: "service-worker-fetch-offscreen-polling-handler"
+      };
+
+      HandleOffscreenResponseService.handleOffscreenResponse(message);
+
+      expect(fetchFunction).not.toHaveBeenCalled();
+      expect(clipboardWriteFunction).not.toHaveBeenCalled();
+    });
+
+    it("should handle clipboard writeText and dispatch to the right service", () => {
+      expect.assertions(3);
+
+      const message = {
+        id: uuidv4(),
+        target: "service-worker-clipboard-write-text-offscreen-response-handler"
+      };
+      const promises = defaultCallbacks();
+      HandleOffscreenResponseService.setResponseCallback(message.id, promises);
+
+      HandleOffscreenResponseService.handleOffscreenResponse(message);
+
+      expect(clipboardWriteFunction).toHaveBeenCalledTimes(1);
+      expect(clipboardWriteFunction).toHaveBeenCalledWith(message, promises);
+      expect(fetchFunction).not.toHaveBeenCalled();
+    });
+
+    it("should handle offscreen error message", () => {
+      expect.assertions(2);
+
+      const error = new Error("It went really bad somehow");
+      const expectedError = new Error("Something went wrong while processing an offscreen request");
+      expectedError.cause = error;
+
+      const message = {
+        id: uuidv4(),
+        target: "service-worker-offscreen-error-response-handler",
+        data: {error: JSON.stringify(error, Object.getOwnPropertyNames(error))},
+      };
+
+      const promises = defaultCallbacks();
+
+      HandleOffscreenResponseService.setResponseCallback(message.id, promises);
+      HandleOffscreenResponseService.handleOffscreenResponse(message);
+
+      expect(promises.reject).toHaveBeenCalledTimes(1);
+      expect(promises.reject).toHaveBeenCalledWith(expectedError);
+    });
+
+    it("should ignore message with unknown target", () => {
+      expect.assertions(2);
+
+      const message = {target: "???"};
+
+      HandleOffscreenResponseService.handleOffscreenResponse(message);
+
+      expect(clipboardWriteFunction).not.toHaveBeenCalled();
+      expect(fetchFunction).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("::_consumeRequestPromiseCallbacksOrFail", () => {
+    it("should consume the response handler associated to the given id", () => {
+      expect.assertions(3);
+
+      const id = crypto.randomUUID();
+      const callbacks = defaultCallbacks();
+      HandleOffscreenResponseService.setResponseCallback(id, callbacks);
+
+      const consumedCallbacks = HandleOffscreenResponseService._consumeRequestPromiseCallbacksOrFail(id);
+
+      expect(consumedCallbacks).not.toBeNull();
+      expect(consumedCallbacks).toEqual(callbacks);
+      expect(Object.keys(HandleOffscreenResponseService._offscreenResponsePromisesCallbacks).length).toEqual(0);
+    });
+
+    it("should throw if no associated callbacks found for the given id", () => {
+      expect.assertions(1);
+      const id = crypto.randomUUID();
+      expect(() => HandleOffscreenResponseService._consumeRequestPromiseCallbacksOrFail(id)).toThrow();
+    });
+  });
+
+  describe("::handleOffscreenError", () => {
+    it("should reject the given promise with an error containing the cause of the offscreen process failure", () => {
+      expect.assertions(2);
+
+      const callbacks = defaultCallbacks();
+      const error = new Error("Something went wrong with the fetch");
+      const message = {
+        data: {
+          error: JSON.stringify(error, Object.getOwnPropertyNames(error))
+        },
+
+      };
+      const expectedError = new Error("Something went wrong while processing an offscreen request");
+      expectedError.cause = message.data.error;
+
+      HandleOffscreenResponseService.handleOffscreenError(message, callbacks);
+
+      expect(callbacks.reject).toHaveBeenCalledTimes(1);
+      expect(callbacks.reject).toHaveBeenCalledWith(expectedError);
+    });
+  });
+});

package/src/firefox/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 2,
   "name": "__MSG_appName__",
   "short_name": "passbolt",
-  "version": "5.2.0",
+  "version": "5.3.2",
   "description": "__MSG_appDescription__",
   "default_locale": "en",
   "browser_specific_settings": {

package/src/safari/manifest.json

@@ -2,7 +2,7 @@
   "manifest_version": 3,
   "name": "__MSG_appName__",
   "short_name": "passbolt",
-  "version": "5.2.0.1",
+  "version": "5.3.2",
   "description": "__MSG_appDescription__",
   "default_locale": "en",
   "externally_connectable": {},

package/test/jest.setup.js

@@ -19,6 +19,7 @@ import "./mocks/mockTextEncoder";
 import "./mocks/mockCryptoKey";
 import "./matchers/extendExpect";
 import MockNavigatorLocks from './mocks/mockNavigatorLocks';
+import MockNavigatorClipboard from './mocks/mockNavigatorClipboard';
 import OrganizationSettingsModel from "../src/all/background_page/model/organizationSettings/organizationSettingsModel";
 import {Config} from "../src/all/background_page/model/config";
 import Keyring from "../src/all/background_page/model/keyring";
@@ -49,6 +50,9 @@ if (!global.navigator) {
 if (!global.navigator.locks) {
   global.navigator.locks = new MockNavigatorLocks();
 }
+if (!global.navigator.clipboard) {
+  global.navigator.clipboard = new MockNavigatorClipboard();
+}
 
 /*
  * quick polyfill for jest to have stucturedClone function defined

package/test/mocks/mockNavigatorClipboard.js

@@ -0,0 +1,40 @@
+/**
+ * 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         5.3.2
+ */
+
+/**
+ * Mock class to be used in replacement of navigator.clipboard
+ */
+export default class MockNavigatorClipboard {
+  /**
+   * @type {string}
+   * @private
+   */
+  _clipboardData = "";
+
+  /**
+   * @inheritDoc navigator.clipboard.readText
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Clipboard/readText
+   */
+  async readText() {
+    return this._clipboardData;
+  }
+
+  /**
+   * @inheritDoc navigator.clipboard.writeText
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Clipboard/writeText
+   */
+  async writeText(newClipText) {
+    this._clipboardData = newClipText;
+  }
+}

package/test/mocks/mockWebExtensionPolyfill.js

@@ -42,7 +42,8 @@ jest.mock("webextension-polyfill", () => {
       getURL: jest.fn(path => `chrome-extension://didegimhafipceonhjepacocaffmoppf/${path}`),
       // Force extension version
       getManifest: jest.fn(() => ({
-        version: "v3.6.0"
+        version: "5.3.0",
+        manifest_version: 3,
       })),
       // Runtime primitives not mocked by jest-webextension-mock v3.8.9
       OnInstalledReason: {

package/{webpack-offscreens.fetch.config.js → webpack-offscreens.config.js}

@@ -3,7 +3,7 @@ const TerserPlugin = require("terser-webpack-plugin");
 
 const config = {
   entry: {
-    'fetch': path.resolve(__dirname, './src/chrome-mv3/offscreens/fetch.js'),
+    'offscreen': path.resolve(__dirname, './src/chrome-mv3/offscreens/offscreen.js'),
   },
   mode: 'production',
   module: {

package/webpack.service-worker.config.js

@@ -13,6 +13,7 @@ const config = {
       browser: path.resolve(__dirname, './src/all/common/polyfill/browserPolyfill.js'),
       // Inject custom api client fetch to MV3 extension as workaround of the invalid certificate issue.
       customApiClientFetch: path.resolve(__dirname, './src/chrome-mv3/polyfill/fetchOffscreenPolyfill.js'),
+      customNavigatorClipboard: path.resolve(__dirname, './src/chrome-mv3/polyfill/clipboardOffscreenPolyfill.js'),
     })
   ],
   module: {

package/src/all/background_page/controller/clipboard/clipboardController.test.js

@@ -1,68 +0,0 @@
-/**
- * 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         3.9.0
- */
-
-import ClipboardController from './clipboardController';
-
-describe('ClipboardController', () => {
-  let controller, workerMock;
-  const toCopy = "text";
-
-  beforeEach(() => {
-    workerMock = {
-      port: {
-        emit: jest.fn()
-      }
-    };
-    navigator.clipboard = {
-      writeText: jest.fn()
-    };
-    controller = new ClipboardController(workerMock, 'request-id');
-  });
-
-  describe('constructor', () => {
-    it('should set the worker and requestId properties', () => {
-      expect.assertions(2);
-      expect(controller.worker).toBe(workerMock);
-      expect(controller.requestId).toBe('request-id');
-    });
-  });
-
-  describe('_exec', () => {
-    it('should call the exec method and emit a success message on the worker port', async() => {
-      expect.assertions(2);
-      const execSpy = jest.spyOn(controller, 'exec');
-      await controller._exec(toCopy);
-      expect(execSpy).toHaveBeenCalledWith(toCopy);
-      expect(workerMock.port.emit).toHaveBeenCalledWith('request-id', 'SUCCESS');
-    });
-
-    it('should emit an error message on the worker port if an error occurs', async() => {
-      expect.assertions(1);
-      const error = new Error('Some error');
-      jest.spyOn(controller, 'exec').mockImplementationOnce(() => {
-        throw error;
-      });
-      await controller._exec(toCopy);
-      expect(workerMock.port.emit).toHaveBeenCalledWith('request-id', 'ERROR', error);
-    });
-  });
-
-  describe('exec', () => {
-    it('should call navigator.clipboard method of the QuickAccessService', () => {
-      expect.assertions(1);
-      controller.exec(toCopy);
-      expect(navigator.clipboard.writeText).toHaveBeenCalledWith('text');
-    });
-  });
-});

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

@@ -1,28 +0,0 @@
-/**
- * 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         3.9.0
- */
-
-import ClipboardController from '../controller/clipboard/clipboardController';
-
-/**
- * Listens the clipboard events
- * @param worker
- */
-const listen = function(worker) {
-  worker.port.on('passbolt.clipboard.copy', async(requestId, text) => {
-    const clipboardController = new ClipboardController(worker, requestId, text);
-    await clipboardController._exec(text);
-  });
-};
-
-export const ClipboardEvents = {listen};