passbolt-browser-extension 5.3.2 → 5.4.1

package/src/all/background_page/service/metadata/findMetadataKeysService.js

@@ -13,7 +13,6 @@
  */
 
 import MetadataKeysCollection from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysCollection";
-import DecryptMetadataPrivateKeysService from "../metadata/decryptMetadataPrivateKeysService";
 import MetadataKeysApiService from "../api/metadata/metadataKeysApiService";
 import {OpenpgpAssertion} from "../../utils/openpgp/openpgpAssertions";
 import CollectionValidationError from "passbolt-styleguide/src/shared/models/entity/abstract/collectionValidationError";
@@ -24,12 +23,10 @@ class FindMetadataKeysService {
    * Constructor
    *
    * @param {ApiClientOptions} apiClientOptions
-   * @param {AccountEntity} account the user account
    * @public
    */
-  constructor(apiClientOptions, account) {
+  constructor(apiClientOptions) {
     this.metadataKeysApiService = new MetadataKeysApiService(apiClientOptions);
-    this.decryptMetadataPrivateKeysService = new DecryptMetadataPrivateKeysService(account);
   }
 
   /**
@@ -37,12 +34,10 @@ class FindMetadataKeysService {
    *
    * @param {Object} [contains] Return entities associated models, example: {metadata_private_keys: true}.
    * @param {Object} [filters] Return entities applied filters, example: {deleted: true}.
-   * @param {string|null} [passphrase = null] The passphrase to use to decrypt the metadata. Marked as optional as it
-   * might be available in the passphrase session storage.
    * @returns {Promise<MetadataKeysCollection>}
    * @public
    */
-  async findAll(contains = {}, filters = {}, passphrase = null) {
+  async findAll(contains = {}, filters = {}) {
     const supportedOptions = MetadataKeysApiService.getSupportedContainOptions();
     if (contains && !Object.keys(contains).every(option => supportedOptions.includes(option))) {
       throw new Error("Unsupported contains parameter used, please check supported contains");
@@ -59,7 +54,6 @@ class FindMetadataKeysService {
       throw new Error("The metadata private keys should not be decrypted.");
     }
 
-    await this.decryptMetadataPrivateKeysService.decryptAllFromMetadataKeysCollection(collection, passphrase);
     await this.assertArmoredFingerprintPublicAndEntitysMatch(collection);
 
     return collection;
@@ -67,13 +61,15 @@ class FindMetadataKeysService {
 
   /**
    * Retrieve the metadata keys from the API with the contained data necessary for the local storage.
-   * @param {string|null} [passphrase = null] The passphrase to use to decrypt the metadata. Marked as optional as it
-   * might be available in the passphrase session storage.
    * @returns {Promise<MetadataKeysCollection>}
    * @public
    */
-  findAllForSessionStorage(passphrase = null) {
-    return this.findAll({metadata_private_keys: true, creator: true, "creator.profile": true}, {deleted: false}, passphrase);
+  async findAllForSessionStorage() {
+    const contains = {metadata_private_keys: true, creator: true, "creator.profile": true};
+    const filters = {deleted: false};
+    const metadataKeys = await this.findAll(contains, filters);
+    metadataKeys.filterOutMissingMetadataPrivateKeys();
+    return metadataKeys;
   }
 
   /**

package/src/all/background_page/service/metadata/findMetadataKeysService.test.js

@@ -15,7 +15,6 @@
 import {enableFetchMocks} from "jest-fetch-mock";
 import AccountEntity from "../../model/entity/account/accountEntity";
 import {defaultAccountDto} from "../../model/entity/account/accountEntity.test.data";
-import PassphraseStorageService from "../session_storage/passphraseStorageService";
 import BuildApiClientOptionsService from "../account/buildApiClientOptionsService";
 import FindMetadataKeysService from "./findMetadataKeysService";
 import {mockApiResponseError} from "passbolt-styleguide/test/mocks/mockApiResponse";
@@ -43,43 +42,25 @@ describe("FindMetadataKeysApiService", () => {
   });
 
   describe('::findAll', () => {
-    it("retrieves the metadata keys from API with the right contains and decrypt them using the passphrase from the session storage", async() => {
+    it("retrieves the metadata keys from API with the right contains", async() => {
       expect.assertions(5);
 
-      jest.spyOn(PassphraseStorageService, "get").mockReturnValue(pgpKeys.ada.passphrase);
-
       const id = uuidv4();
       const metadata_private_keys = [defaultMetadataPrivateKeyDto({metadata_key_id: id, data: pgpKeys.metadataKey.encryptedMetadataPrivateKeyDataMessage})];
       const fingerprint = "c0dce0aaea4d8cce961c26bddfb6e74e598f025c";
       const apiMetadataKeysCollection = [defaultMetadataKeyDto({id, metadata_private_keys, fingerprint})];
 
-      const service = new FindMetadataKeysService(apiClientOptions, account);
+      const service = new FindMetadataKeysService(apiClientOptions);
       jest.spyOn(service.metadataKeysApiService, "findAll").mockImplementation(() => apiMetadataKeysCollection);
       const resultDto = await service.findAll();
 
       expect(resultDto).toBeInstanceOf(MetadataKeysCollection);
       expect(resultDto).toHaveLength(apiMetadataKeysCollection.length);
-      expect(resultDto.hasEncryptedKeys()).toStrictEqual(false);
+      expect(resultDto.hasDecryptedKeys()).toStrictEqual(false);
       expect(service.metadataKeysApiService.findAll).toHaveBeenCalledTimes(1);
       expect(service.metadataKeysApiService.findAll).toHaveBeenCalledWith({}, {});
     });
 
-    it("does not retrieve the passphrase from the session storage if passed as parameter", async() => {
-      expect.assertions(1);
-
-      const id = uuidv4();
-      const metadata_private_keys = [defaultMetadataPrivateKeyDto({metadata_key_id: id, data: pgpKeys.metadataKey.encryptedMetadataPrivateKeyDataMessage})];
-      const fingerprint = "c0dce0aaea4d8cce961c26bddfb6e74e598f025c";
-      const apiMetadataKeysCollection = [defaultMetadataKeyDto({id, metadata_private_keys, fingerprint})];
-
-      const service = new FindMetadataKeysService(apiClientOptions, account);
-      jest.spyOn(PassphraseStorageService, "get");
-      jest.spyOn(service.metadataKeysApiService, "findAll").mockImplementation(() => apiMetadataKeysCollection);
-      await service.findAll({}, {}, pgpKeys.ada.passphrase);
-
-      expect(PassphraseStorageService.get).not.toHaveBeenCalled();
-    });
-
     it("throw an error if fingerprint is not matching with the armored public key", async() => {
       expect.assertions(2);
 
@@ -88,8 +69,7 @@ describe("FindMetadataKeysApiService", () => {
       const fingerprint = "c0dce0aaea4d8cce961c26bddfb6e74e598f025d";
       const apiMetadataKeysCollection = [defaultMetadataKeyDto({id, metadata_private_keys, fingerprint})];
 
-      const service = new FindMetadataKeysService(apiClientOptions, account);
-      jest.spyOn(PassphraseStorageService, "get").mockReturnValue(pgpKeys.ada.passphrase);
+      const service = new FindMetadataKeysService(apiClientOptions);
       jest.spyOn(service.metadataKeysApiService, "findAll").mockImplementation(() => apiMetadataKeysCollection);
 
       try {
@@ -112,8 +92,7 @@ describe("FindMetadataKeysApiService", () => {
       const metadata_private_keys = [decryptedMetadataPrivateKeyDto({metadata_key_id: id})];
       const apiMetadataKeysCollection = [defaultMetadataKeyDto({id, metadata_private_keys})];
 
-      const service = new FindMetadataKeysService(apiClientOptions, account);
-      jest.spyOn(PassphraseStorageService, "get").mockReturnValue(pgpKeys.ada.passphrase);
+      const service = new FindMetadataKeysService(apiClientOptions);
       jest.spyOn(service.metadataKeysApiService, "findAll").mockImplementation(() => apiMetadataKeysCollection);
 
       const expectedError = new Error("The metadata private keys should not be decrypted.");
@@ -162,7 +141,7 @@ describe("FindMetadataKeysApiService", () => {
   });
 
   describe('::findAllForSessionStorage', () => {
-    it("retrieves the metadata keys from API with the right contains and decrypt them using the passphrase from the session storage", async() => {
+    it("retrieves the metadata keys from API with the right contains ", async() => {
       expect.assertions(5);
 
       const id = uuidv4();
@@ -170,48 +149,43 @@ describe("FindMetadataKeysApiService", () => {
       const fingerprint = "c0dce0aaea4d8cce961c26bddfb6e74e598f025c";
       const apiMetadataKeysCollection = [defaultMetadataKeyDto({id, metadata_private_keys, fingerprint})];
 
-      const service = new FindMetadataKeysService(apiClientOptions, account);
-      jest.spyOn(PassphraseStorageService, "get").mockReturnValue(pgpKeys.ada.passphrase);
+      const service = new FindMetadataKeysService(apiClientOptions);
       jest.spyOn(service.metadataKeysApiService, "findAll").mockImplementation(() => apiMetadataKeysCollection);
       const resultDto = await service.findAllForSessionStorage();
 
       expect(resultDto).toBeInstanceOf(MetadataKeysCollection);
       expect(resultDto).toHaveLength(apiMetadataKeysCollection.length);
-      expect(resultDto.hasEncryptedKeys()).toStrictEqual(false);
+      expect(resultDto.hasDecryptedKeys()).toStrictEqual(false);
       expect(service.metadataKeysApiService.findAll).toHaveBeenCalledTimes(1);
       expect(service.metadataKeysApiService.findAll).toHaveBeenCalledWith({metadata_private_keys: true, creator: true, "creator.profile": true}, {deleted: false});
     });
 
-    it("retrieves the metadata keys from API with the right contains and decrypt them using the passphrase given in parameter", async() => {
-      expect.assertions(6);
+    it("filter out metadata key not having at least a metadata private key.", async() => {
+      expect.assertions(3);
 
-      const id = uuidv4();
-      const metadata_private_keys = [defaultMetadataPrivateKeyDto({metadata_key_id: id, data: pgpKeys.metadataKey.encryptedMetadataPrivateKeyDataMessage})];
       const fingerprint = "c0dce0aaea4d8cce961c26bddfb6e74e598f025c";
-      const apiMetadataKeysCollection = [defaultMetadataKeyDto({id, metadata_private_keys, fingerprint})];
+      const apiMetadataKeysCollection = [
+        defaultMetadataKeyDto({fingerprint}, {withMetadataPrivateKeys: true}),
+        defaultMetadataKeyDto({fingerprint: pgpKeys.ada.fingerprint, armored_key: pgpKeys.ada.public})
+      ];
 
-      const service = new FindMetadataKeysService(apiClientOptions, account);
-      jest.spyOn(PassphraseStorageService, "get");
+      const service = new FindMetadataKeysService(apiClientOptions);
       jest.spyOn(service.metadataKeysApiService, "findAll").mockImplementation(() => apiMetadataKeysCollection);
-      const resultDto = await service.findAllForSessionStorage(pgpKeys.ada.passphrase);
+      const resultDto = await service.findAllForSessionStorage();
 
-      expect(PassphraseStorageService.get).not.toHaveBeenCalled();
       expect(resultDto).toBeInstanceOf(MetadataKeysCollection);
-      expect(resultDto).toHaveLength(apiMetadataKeysCollection.length);
-      expect(resultDto.hasEncryptedKeys()).toStrictEqual(false);
-      expect(service.metadataKeysApiService.findAll).toHaveBeenCalledTimes(1);
-      expect(service.metadataKeysApiService.findAll).toHaveBeenCalledWith({metadata_private_keys: true, creator: true, "creator.profile": true}, {deleted: false});
+      expect(resultDto).toHaveLength(1);
+      expect(resultDto.hasDecryptedKeys()).toStrictEqual(false);
     });
 
-    it("throws an error if the keys from the API is already decrypted", async() => {
+    it("throws an error if one of the key from the API is already decrypted", async() => {
       expect.assertions(1);
 
       const id = uuidv4();
       const metadata_private_keys = [decryptedMetadataPrivateKeyDto({metadata_key_id: id})];
       const apiMetadataKeysCollection = [defaultMetadataKeyDto({id, metadata_private_keys})];
 
-      const service = new FindMetadataKeysService(apiClientOptions, account);
-      jest.spyOn(PassphraseStorageService, "get").mockReturnValue(pgpKeys.ada.passphrase);
+      const service = new FindMetadataKeysService(apiClientOptions);
       jest.spyOn(service.metadataKeysApiService, "findAll").mockImplementation(() => apiMetadataKeysCollection);
 
       const expectedError = new Error("The metadata private keys should not be decrypted.");
@@ -242,7 +216,7 @@ describe("FindMetadataKeysApiService", () => {
       expect.assertions(3);
 
       const apiMetadataKeysCollection = defaultMetadataKeysDtos();
-      const service = new FindMetadataKeysService(apiClientOptions, account);
+      const service = new FindMetadataKeysService(apiClientOptions);
       jest.spyOn(service, "findAll")
         .mockImplementation(() => new MetadataKeysCollection(apiMetadataKeysCollection));
 

package/src/all/background_page/service/metadata/findMetadataSetupSettingsService.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         5.4.0
+ */
+
+import MetadataSetupSettingsApiService from "../api/metadata/metadataSetupSettingsApiService";
+import MetadataSetupSettingsEntity from "passbolt-styleguide/src/shared/models/entity/metadata/metadataSetupSettingsEntity";
+
+/**
+ * The service aims to find metadata setup settings.
+ */
+export default class FindMetadataSetupSettingsService {
+  /**
+   * @constructor
+   * @param {ApiClientOptions} apiClientOptions The api client options
+   */
+  constructor(apiClientOptions) {
+    this.metadataSetupSettingsApiService = new MetadataSetupSettingsApiService(apiClientOptions);
+  }
+
+  /**
+   * Finds the metadata setup  settings.
+   * @returns {Promise<MetadataSetupSettingsEntity>}
+   */
+  async findSetupSettings() {
+    try {
+      const passboltResponse = await this.metadataSetupSettingsApiService.find();
+      return MetadataSetupSettingsEntity.createFromDefault(passboltResponse.body);
+    } catch (e) {
+      if (e?.data?.code === 404) {
+        return MetadataSetupSettingsEntity.createFromDefault();
+      }
+      throw e;
+    }
+  }
+}

package/src/all/background_page/service/metadata/findMetadataSetupSettingsService.test.js

@@ -0,0 +1,68 @@
+/**
+ * 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.4.0
+ */
+import {enableFetchMocks} from "jest-fetch-mock";
+import FindMetadataSetupSettingsService from "./findMetadataSetupSettingsService";
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import MetadataSetupSettingsEntity from "passbolt-styleguide/src/shared/models/entity/metadata/metadataSetupSettingsEntity";
+import {enableMetadataSetupSettingsDto} from "passbolt-styleguide/src/shared/models/entity/metadata/metadataSetupSettingsEntity.test.data";
+import {mockApiResponse, mockApiResponseError} from "../../../../../test/mocks/mockApiResponse";
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  enableFetchMocks();
+});
+
+describe("FindMetadataSetupSettingsService", () => {
+  describe("::findSetupSettings", () => {
+    it("retrieve the metadata setup settings.", async() => {
+      expect.assertions(2);
+
+      const expectedSettings = enableMetadataSetupSettingsDto();
+      const apiClientOptions = defaultApiClientOptions();
+      const service = new FindMetadataSetupSettingsService(apiClientOptions);
+
+      fetch.doMockOnceIf(/\/metadata\/setup\/settings\.json/, () => mockApiResponse(expectedSettings));
+
+      const metadataSetupSettingsEntity = await service.findSetupSettings();
+
+      expect(metadataSetupSettingsEntity).toBeInstanceOf(MetadataSetupSettingsEntity);
+      expect(metadataSetupSettingsEntity.enableEncryptedMetadataOnInstall).toStrictEqual(true);
+    });
+
+    it("should consider default disabled settings if the API sends back a 404", async() => {
+      expect.assertions(2);
+
+      const apiClientOptions = defaultApiClientOptions();
+      const service = new FindMetadataSetupSettingsService(apiClientOptions);
+
+      fetch.doMockOnceIf(/\/metadata\/setup\/settings.json/, () => mockApiResponseError(404, "Endpoint does not exists"));
+
+      const metadataSetupSettingsEntity = await service.findSetupSettings();
+
+      expect(metadataSetupSettingsEntity).toBeInstanceOf(MetadataSetupSettingsEntity);
+      expect(metadataSetupSettingsEntity.enableEncryptedMetadataOnInstall).toStrictEqual(false);
+    });
+
+    it("should not intercept the error from the API if something goes wrong and it is not a 404", async() => {
+      expect.assertions(1);
+
+      const apiClientOptions = defaultApiClientOptions();
+      const service = new FindMetadataSetupSettingsService(apiClientOptions);
+
+      fetch.doMockOnce(/\/metadata\/setup\/settings.json/, () => mockApiResponseError(500, "Something went wrong!"));
+
+      await expect(() => service.findSetupSettings()).rejects.toThrowError();
+    });
+  });
+});

package/src/all/background_page/service/metadata/generateMetadataKeyService.js

@@ -29,7 +29,7 @@ class GenerateMetadataKeyService {
   /**
    * Generate metadata key.
    * @param {string} passphrase The user passphrase.
-   * @return {ExternalGpgKeyPairEntity}
+   * @return {Promise<ExternalGpgKeyPairEntity>}
    */
   async generateKey(passphrase) {
     assertString(passphrase);

package/src/all/background_page/service/metadata/verifyOrTrustMetadataKeyService.test.js

@@ -100,6 +100,22 @@ describe("VerifyOrTrustMetadataKeyService", () => {
       expect(service.confirmMetadataKeyContentCodeService.requestConfirm).not.toHaveBeenCalled();
     });
 
+    it("does nothing if the user does not have a metadata private key shared with the active metadata key returned by the server.", async() => {
+      expect.assertions(2);
+
+      const metadataKeyDto = defaultMetadataKeyDto();
+      const metadataKeysCollection = new MetadataKeysCollection([metadataKeyDto]);
+
+      jest.spyOn(service.getOrFindMetadataKeysService.findAndUpdateMetadataKeysService.findMetadataKeysService, "findAll").mockReturnValue(metadataKeysCollection);
+      jest.spyOn(service.trustMetadataKeyService, "trust").mockImplementationOnce(jest.fn);
+      jest.spyOn(service.confirmMetadataKeyContentCodeService, "requestConfirm").mockImplementationOnce(jest.fn);
+
+      await service.verifyTrustedOrTrustNewMetadataKey(pgpKeys.ada.passphrase);
+
+      expect(service.trustMetadataKeyService.trust).not.toHaveBeenCalled();
+      expect(service.confirmMetadataKeyContentCodeService.requestConfirm).not.toHaveBeenCalled();
+    });
+
     it("throws if the active metadata key is not the one already trusted, and the user does not trust it.", async() => {
       expect.assertions(2);
 

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

@@ -37,6 +37,19 @@ export default class GetPassphraseService {
     return this.requestPassphrase(worker);
   }
 
+  /**
+   * Read the user master password from the storage.
+   * @return {Promise<string>}
+   * @throw Error if the passphrase is not available.
+   */
+  async getFromStorageOrFail() {
+    const passphrase = await PassphraseStorageService.get();
+    if (!passphrase) {
+      throw new Error("No passphrase found in the session storage.");
+    }
+    return passphrase;
+  }
+
   /**
    * Request the user passphrase.
    *

package/src/all/background_page/service/permission/findPermissionsService.js

@@ -38,7 +38,9 @@ class FindPermissionsService {
   async findAllByAcoForeignKeyForDisplay(resourceId) {
     assertUuid(resourceId, `Service error. The id '${resourceId}' is not a valid uuid.`);
     const permissionsCollectionDto = await this.permissionService.findAllByAcoForeignKey(resourceId, FindPermissionsService.DEFAULT_CONTAIN);
-    return new PermissionsCollection(permissionsCollectionDto);
+    const collection = new PermissionsCollection(permissionsCollectionDto);
+    collection.sort();
+    return collection;
   }
 
   /**

package/src/all/background_page/service/resource/delete/deleteResourceService.js

@@ -0,0 +1,60 @@
+/**
+ * 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.4.0
+ */
+import ResourceService from "../../api/resource/resourceService";
+import ResourceLocalStorage from "../../local_storage/resourceLocalStorage";
+import i18n from "../../../sdk/i18n";
+import {assertArrayUUID} from "../../../utils/assertions";
+import ExecuteConcurrentlyService from "../../execute/executeConcurrentlyService";
+class DeleteResourceService {
+  /**
+   * Constructor
+   * @param {AccountEntity} account The user account
+   * @param {ApiClientOptions} apiClientOptions The api client options
+   * @param {ProgressService} progressService
+   */
+  constructor(account, apiClientOptions, progressService) {
+    this.account = account;
+    this.resourceService = new ResourceService(apiClientOptions);
+    this.progressService = progressService;
+  }
+
+  /**
+   * Delete a bulk of resources
+   * @param {Array<string>} resourceIds The resourceIds
+   * @returns {Promise<void>}
+   */
+  async deleteResources(resourceIds) {
+    assertArrayUUID(resourceIds);
+    /**
+     * 1. Delete the Resources
+     * 2. Update the local storage
+     */
+    this.progressService.finishStep(i18n.t("Deleting Resource(s)"), true);
+    let deleteCounter = 0;
+    const deleteCallBacks = resourceId => {
+      this.progressService.updateStepMessage(i18n.t("Deleting resource(s) {{counter}}/{{total}}", {counter: ++deleteCounter, total: resourceIds.length}));
+      return this.resourceService.delete(resourceId);
+    };
+
+    const callbacks = resourceIds.map(resourceId => () => deleteCallBacks(resourceId));
+    const executeConcurrentlyService = new ExecuteConcurrentlyService();
+    await executeConcurrentlyService.execute(callbacks, 5);
+
+    this.progressService.finishStep(i18n.t("Updating resources local storage"), true);
+    await ResourceLocalStorage.deleteResources(resourceIds);
+  }
+}
+
+
+export default DeleteResourceService;

package/src/all/background_page/service/resource/delete/deleteResourceService.test.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         5.4.0
+ */
+
+import {defaultApiClientOptions} from "passbolt-styleguide/src/shared/lib/apiClient/apiClientOptions.test.data";
+import AccountEntity from "../../../model/entity/account/accountEntity";
+import {defaultAccountDto} from "../../../model/entity/account/accountEntity.test.data";
+import {defaultResourceDto} from "passbolt-styleguide/src/shared/models/entity/resource/resourceEntity.test.data";
+import DeleteResourceService from "./deleteResourceService";
+import ResourceLocalStorage from "../../local_storage/resourceLocalStorage";
+import ProgressService from "../../progress/progressService";
+
+jest.mock("../../../service/progress/progressService");
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("DeleteResourceService", () => {
+  let deleteResourceService, worker;
+  const account = new AccountEntity(defaultAccountDto());
+  const apiClientOptions = defaultApiClientOptions();
+
+  beforeEach(async() => {
+    worker = {
+      port: {
+        emit: jest.fn()
+      }
+    };
+    deleteResourceService = new DeleteResourceService(account, apiClientOptions, new ProgressService(worker, ""));
+    jest.spyOn(ResourceLocalStorage, "deleteResources");
+  });
+
+  describe("DeleteResourceService::deleteResources", () => {
+    it("Should delete the resources and call local storage update", async() => {
+      expect.assertions(5);
+
+      const resourceDto1 = defaultResourceDto();
+      const resourceDto2 = defaultResourceDto();
+      const resourceDto3 = defaultResourceDto();
+      jest.spyOn(deleteResourceService.resourceService, "delete").mockImplementation(() => {});
+      await deleteResourceService.deleteResources([resourceDto1.id, resourceDto2.id, resourceDto3.id]);
+
+      expect(deleteResourceService.resourceService.delete).toHaveBeenCalledTimes(3);
+      expect(deleteResourceService.resourceService.delete).toHaveBeenCalledWith(resourceDto1.id);
+      expect(deleteResourceService.resourceService.delete).toHaveBeenCalledWith(resourceDto2.id);
+      expect(deleteResourceService.resourceService.delete).toHaveBeenCalledWith(resourceDto3.id);
+      expect(ResourceLocalStorage.deleteResources).toHaveBeenCalledWith([resourceDto1.id, resourceDto2.id, resourceDto3.id]);
+    });
+
+    it("Should call progress service during the different steps of deletion", async() => {
+      expect.assertions(3);
+
+      const resourceDto1 = defaultResourceDto();
+      const resourceDto2 = defaultResourceDto();
+      const resourceDto3 = defaultResourceDto();
+      jest.spyOn(deleteResourceService.resourceService, "delete").mockImplementation(() => {});
+      await deleteResourceService.deleteResources([resourceDto1.id, resourceDto2.id, resourceDto3.id]);
+
+      expect(deleteResourceService.progressService.finishStep).toHaveBeenCalledTimes(2);
+      expect(deleteResourceService.progressService.finishStep).toHaveBeenCalledWith('Deleting Resource(s)', true);
+      expect(deleteResourceService.progressService.finishStep).toHaveBeenCalledWith("Updating resources local storage", true);
+    });
+  });
+});

package/src/all/background_page/service/resource/export/exportResourcesService.js

@@ -12,6 +12,7 @@
  * @since         4.10.1
  */
 
+import CustomFieldEntity from "passbolt-styleguide/src/shared/models/entity/customField/customFieldEntity";
 import ExternalFoldersCollection from "../../../model/entity/folder/external/externalFoldersCollection";
 import ExternalResourcesCollection from "../../../model/entity/resource/external/externalResourcesCollection";
 import ExternalTotpEntity from "../../../model/entity/totp/externalTotpEntity";
@@ -23,6 +24,7 @@ import DecryptPrivateKeyService from "../../crypto/decryptPrivateKeyService";
 import DecryptMetadataService from "../../metadata/decryptMetadataService";
 import DecryptAndParseResourceSecretService from "../../secret/decryptAndParseResourceSecretService";
 import FindResourcesService from "../findResourcesService";
+import CustomFieldsCollection from "passbolt-styleguide/src/shared/models/entity/customField/customFieldsCollection";
 
 /**
  * The service aim to export the resources to a file.
@@ -99,9 +101,29 @@ class ExportResourcesService {
       if (plaintextSecret.totp) {
         exportResourceEntity.totp = new ExternalTotpEntity(plaintextSecret.totp);
       }
+      if (plaintextSecret.customFields) {
+        exportResourceEntity.customFields = this.buildCustomFieldWithSecretDto(exportResourceEntity, plaintextSecret);
+      }
     }
   }
 
+  /**
+   * Build custom fields with secret
+   * @param {ExternalResourceEntity} exportResourcesFileEntity The export object
+   * @param {Object} plaintextSecret The plaintext secret
+   * @returns {CustomFieldsCollection}
+   */
+  buildCustomFieldWithSecretDto(exportResourceEntity, plaintextSecret) {
+    const customFieldsDto = [];
+    exportResourceEntity.customFields?.items?.forEach(customField => {
+      const customFieldDto = customField.toDto();
+      const secret = plaintextSecret.customFields.find(customFieldSecret => customFieldSecret.id === customFieldDto.id);
+      customFieldDto.secret_value = secret?.secret_value;
+      customFieldsDto.push(new CustomFieldEntity(customFieldDto));
+    });
+    return new CustomFieldsCollection(customFieldsDto);
+  }
+
   /**
    * Export
    * @param {ExportResourcesFileEntity} exportResourcesFileEntity The export object

package/src/all/background_page/service/resource/export/exportResourcesService.test.js

@@ -46,6 +46,8 @@ import {defaultDecryptedSharedMetadataKeysDtos} from "passbolt-styleguide/src/sh
 import MetadataKeysCollection from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysCollection";
 import EncryptMetadataService from "../../metadata/encryptMetadataService";
 import {defaultMetadataKeysSettingsDto} from "passbolt-styleguide/src/shared/models/entity/metadata/metadataKeysSettingsEntity.test.data";
+import CustomFieldsCollection from "passbolt-styleguide/src/shared/models/entity/customField/customFieldsCollection";
+import {defaultCustomFieldsCollection} from "passbolt-styleguide/src/shared/models/entity/customField/customFieldsCollection.test.data";
 
 jest.mock("../../../service/progress/progressService");
 
@@ -88,7 +90,6 @@ describe("ExportResourcesService", () => {
         {format: FORMAT_CSV_LASTPASS, expected: lastpassCsvFile},
         {format: FORMAT_CSV_1PASSWORD, expected: onePasswordCsvFile},
         {format: FORMAT_CSV_CHROMIUM, expected: chromiumCsvFile},
-        {format: FORMAT_CSV_BITWARDEN, expected: bitwardenCsvFile},
         {format: FORMAT_CSV_MOZILLA, expected: mozillaCsvFile},
         {format: FORMAT_CSV_SAFARI, expected: safariCsvFile},
         {format: FORMAT_CSV_DASHLANE, expected: dashlaneCsvFile},
@@ -136,6 +137,7 @@ describe("ExportResourcesService", () => {
         });
       });
       each([
+        {format: FORMAT_CSV_BITWARDEN, expected: bitwardenCsvFile},
         {format: FORMAT_CSV_KDBX, expected: KdbxCsvFile},
       ]).describe("Should export the csv file with password, description and totp.", test => {
         each([
@@ -322,4 +324,49 @@ describe("ExportResourcesService", () => {
       expect(service.progressService.finishStep).toHaveBeenCalledWith("Decrypting 1/1");
     });
   });
+
+  describe("::buildCustomFieldWithSecretDto", () => {
+    it("Should build custom fields with secret", () => {
+      expect.assertions(4);
+
+      const customFieldsCollection = defaultCustomFieldsCollection();
+
+      const plaintextSecret = {
+        customFields: [
+          {id: customFieldsCollection[0].id, secret_value: "Secret Value 1"},
+          {id: customFieldsCollection[1].id, secret_value: "Secret Value 2"}
+        ]
+      };
+
+      const exportResourceEntity = {
+        customFields: new CustomFieldsCollection(customFieldsCollection)
+      };
+
+      const result = service.buildCustomFieldWithSecretDto(exportResourceEntity, plaintextSecret);
+
+      expect(result).toBeInstanceOf(CustomFieldsCollection);
+      expect(result.items).toHaveLength(2);
+      expect(result.items[0].value).toEqual("Secret Value 1");
+      expect(result.items[1].value).toEqual("Secret Value 2");
+    });
+
+    it("Should handle missing custom fields", () => {
+      expect.assertions(2);
+
+      const exportResourceEntity = {
+        customFields: {
+          items: []
+        }
+      };
+
+      const plaintextSecret = {
+        customFields: []
+      };
+
+      const result = service.buildCustomFieldWithSecretDto(exportResourceEntity, plaintextSecret);
+
+      expect(result).toBeInstanceOf(CustomFieldsCollection);
+      expect(result.items).toHaveLength(0);
+    });
+  });
 });