passbolt-browser-extension 5.3.2 → 5.4.1

package/src/all/background_page/service/resource/import/ImportResourcesService.js

@@ -79,7 +79,7 @@ class ImportResourcesService {
     const resourceToImportDto = importResourcesFile.importResources.toResourceCollectionImportDto();
     const resourcesCollection = new ResourcesCollection(resourceToImportDto);
     const clearTextMetadataResourcesCollection = new ResourcesCollection(resourceToImportDto);
-    await this.encryptMetadataService.encryptAllFromForeignModels(resourcesCollection, passphrase);
+    await this.encryptMetadata(resourcesCollection, passphrase);
     await this.bulkImportResources(importResourcesFile, resourcesCollection, clearTextMetadataResourcesCollection);
     importResourcesFile.mustTag && await this.bulkTagResources(importResourcesFile);
     await this.progressService.finishStep(null, true);
@@ -101,10 +101,24 @@ class ImportResourcesService {
     const progressGoal = 1 // Initialization
       + (importResourcesFile.mustImportFolders ? importResourcesFile.importFolders.items.length : 0) // #folders create API calls
       + importResourcesFile.importResources.items.length * 2 // #resource to encrypt + #resource create API calls
+      + 1 // #resource metadata encryption
       + (importResourcesFile.mustTag ? importResourcesFile.importResources.items.length : 0); // #resources tag API calls
     this.progressService.updateGoals(progressGoal);
   }
 
+
+  /**
+   * Encrypts the metadata of resources in a collection using the provided passphrase.
+   *
+   * @param {ResourcesCollection} resourcesCollection - The collection of resources to be encrypted.
+   * @param {string} passphrase - The passphrase used for encryption.
+   * @returns {Promise<void>} A promise that resolves when the encryption process is complete.
+   */
+  async encryptMetadata(resourcesCollection, passphrase) {
+    await this.progressService.finishStep(i18n.t('Encrypting {{total}} metadata', {total: resourcesCollection.items.length}));
+    await this.encryptMetadataService.encryptAllFromForeignModels(resourcesCollection, passphrase);
+  }
+
   /**
    * Encrypt the secrets
    * @param {ImportResourcesFileEntity} importResourcesFile The import object
@@ -115,14 +129,14 @@ class ImportResourcesService {
    */
   async encryptSecrets(importResourcesFile, userId, privateKey) {
     let i = 0;
+    const userPublicArmoredKey = this.keyring.findPublic(userId).armoredKey;
+    const userPublicKey = await OpenpgpAssertion.readKeyOrFail(userPublicArmoredKey);
     for (const importResourcesEntity of importResourcesFile.importResources) {
       i++;
       await this.progressService.finishStep(i18n.t('Encrypting {{counter}}/{{total}}', {counter: i, total: importResourcesFile.importResources.items.length}));
       // @todo The secret DTO could be carried by the external resource entity. It can be done when we arrange the external resource entity schema validation.
       const secretDto = this.buildSecretDto(importResourcesEntity);
       const serializedPlaintextDto = await this.resourceModel.serializePlaintextDto(importResourcesEntity.resourceTypeId, secretDto);
-      const userPublicArmoredKey = this.keyring.findPublic(userId).armoredKey;
-      const userPublicKey = await OpenpgpAssertion.readKeyOrFail(userPublicArmoredKey);
       const data = await EncryptMessageService.encrypt(serializedPlaintextDto, userPublicKey, [privateKey]);
       const secret = new SecretEntity({data: data});
       importResourcesEntity.secrets = new ResourceSecretsCollection([secret]);
@@ -147,11 +161,28 @@ class ImportResourcesService {
       importResourcesFile.secretClear = "";
       importResourcesFile.description = "";
       importResourcesFile.totp = null;
+      if (importResourcesFile.customFields) {
+        dto.custom_fields = this.buildCustomFieldSecretDto(importResourcesFile);
+      }
       return dto;
     }
     return importResourcesFile.secretClear;
   }
 
+  /**
+   * Build the custom field secret DTO.
+   * @param {ExternalResourceEntity} importResourcesFile The resource to import
+   * @returns {Object}
+   * @private
+   */
+  buildCustomFieldSecretDto(importResourcesFile) {
+    const customFieldsDto = [];
+    importResourcesFile.customFields?.items?.forEach(customField => {
+      customFieldsDto.push(customField.toSecretDto());
+    });
+    return customFieldsDto;
+  }
+
   /**
    * Import the folders.
    * @param {ImportResourcesFileEntity} importResourcesFile The import object

package/src/all/background_page/service/resource/import/ImportResourcesService.test.js

@@ -56,6 +56,8 @@ import each from "jest-each";
 import GetOrFindMetadataSettingsService from "../../metadata/getOrFindMetadataSettingsService";
 import ResourcesCollection from "../../../model/entity/resource/resourcesCollection";
 import DecryptMetadataService from "../../metadata/decryptMetadataService";
+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");
 
@@ -84,7 +86,6 @@ describe("ImportResourcesService", () => {
     return DecryptMessageService.decrypt(secretMessage, decryptedPrivateKey, [signingKey]);
   };
 
-
   beforeEach(async() => {
     worker = {
       port: {
@@ -154,7 +155,7 @@ describe("ImportResourcesService", () => {
           name: 'Password 1',
           resource_type_id: expectedResourceType.id,
           folder_parent_path: "import-ref",
-          uri: "https://url1.com",
+          uris: ["https://url1.com"],
           username: "Username 1",
         }));
 
@@ -163,7 +164,7 @@ describe("ImportResourcesService", () => {
           name: 'Password 2',
           resource_type_id: expectedResourceType.id,
           folder_parent_path: "import-ref",
-          uri: "https://url1.com",
+          uris: ["https://url1.com"],
           username: "Username 2",
           folder_parent_path_expected: "/Folder",
         }));
@@ -191,7 +192,7 @@ describe("ImportResourcesService", () => {
 
         const secret1 =  await decryptSecret(importResourceFileCSV.importResources.items[0].secrets.items[0].data, pgpKeys.ada.private, pgpKeys.ada.passphrase);
 
-        expect(secret1).toEqual("{\"password\":\"Secret 1\",\"description\":\"Description 1\",\"totp\":{\"secret_key\":\"THISISASECRET\",\"period\":30,\"digits\":6,\"algorithm\":\"SHA1\"}}");
+        expect(secret1).toEqual("{\"password\":\"Password 1\",\"description\":\"Description 1\",\"totp\":{\"secret_key\":\"THISISASECRET\",\"period\":30,\"digits\":6,\"algorithm\":\"SHA1\"}}");
 
         //Remove encrypted secrets checked previously
         delete importedResources[0]._secrets;
@@ -201,7 +202,7 @@ describe("ImportResourcesService", () => {
           name: 'Password 1',
           resource_type_id: expectedResourceType.id,
           folder_parent_path: "import-ref",
-          uri: "https://url1.com",
+          uris: ["https://url1.com"],
           username: "Username 1",
           folder_parent_path_expected: "/Folder 1",
         }));
@@ -237,7 +238,7 @@ describe("ImportResourcesService", () => {
           name: 'Password 1',
           resource_type_id: expectedResourceType.id,
           folder_parent_path: "import-ref",
-          uri: "https://url1.com",
+          uris: ["https://url1.com"],
           username: "Username 1",
           folder_parent_path_expected: "",
         }));
@@ -263,7 +264,7 @@ describe("ImportResourcesService", () => {
 
         const secret1 =  await decryptSecret(importResourceFileCSV.importResources.items[0].secrets.items[0].data, pgpKeys.ada.private, pgpKeys.ada.passphrase);
 
-        expect(secret1).toEqual("{\"password\":\"Secret 1\",\"description\":\"Description 1\",\"totp\":{\"secret_key\":\"THISISASECRET\",\"period\":30,\"digits\":6,\"algorithm\":\"SHA1\"}}");
+        expect(secret1).toEqual("{\"password\":\"Password 1\",\"description\":\"Description 1\",\"totp\":{\"secret_key\":\"THISISASECRET\",\"period\":30,\"digits\":6,\"algorithm\":\"SHA1\"}}");
 
         //Remove encrypted secrets checked previously
         delete importedResources[0]._secrets;
@@ -273,7 +274,7 @@ describe("ImportResourcesService", () => {
           name: 'Password 1',
           resource_type_id: expectedResourceType.id,
           folder_parent_path: "import-ref/Folder 1",
-          uri: "https://url1.com",
+          uris: ["https://url1.com"],
           username: "Username 1",
           folder_parent_path_expected: "",
         }));
@@ -382,7 +383,7 @@ describe("ImportResourcesService", () => {
     });
 
     it("Should inform the user about the progress", async() => {
-      expect.assertions(8);
+      expect.assertions(9);
 
       jest.spyOn(importResourcesService.progressService, "updateGoals");
       jest.spyOn(importResourcesService.progressService, "finishStep");
@@ -391,10 +392,11 @@ describe("ImportResourcesService", () => {
       await importResourcesService.importFile(importResourceFileCSV, passphrase);
 
       expect(importResourcesService.progressService.updateGoals).toHaveBeenCalledTimes(1);
-      expect(importResourcesService.progressService.updateGoals).toHaveBeenCalledWith(5);
-      expect(importResourcesService.progressService.finishStep).toHaveBeenCalledTimes(5);
+      expect(importResourcesService.progressService.updateGoals).toHaveBeenCalledWith(6);
+      expect(importResourcesService.progressService.finishStep).toHaveBeenCalledTimes(6);
       expect(importResourcesService.progressService.finishStep).toHaveBeenCalledWith("Encrypting 1/2");
       expect(importResourcesService.progressService.finishStep).toHaveBeenCalledWith("Encrypting 2/2");
+      expect(importResourcesService.progressService.finishStep).toHaveBeenCalledWith("Encrypting 2 metadata");
       expect(importResourcesService.progressService.finishStep).toHaveBeenCalledWith("Importing passwords 1/2");
       expect(importResourcesService.progressService.finishStep).toHaveBeenCalledWith("Importing passwords 2/2");
       expect(importResourcesService.progressService.finishStep).toHaveBeenCalledWith(null, true);
@@ -434,7 +436,7 @@ describe("ImportResourcesService", () => {
     });
 
     it("Should inform the user about the progress - <folder>", async() => {
-      expect.assertions(8);
+      expect.assertions(9);
 
       jest.spyOn(importResourcesService.progressService, "updateGoals");
 
@@ -447,9 +449,10 @@ describe("ImportResourcesService", () => {
       await importResourcesService.parseFile(importResourceFileCSV);
       await importResourcesService.importFile(importResourceFileCSV, passphrase);
 
-      expect(importResourcesService.progressService.finishStep).toHaveBeenCalledTimes(7);
+      expect(importResourcesService.progressService.finishStep).toHaveBeenCalledTimes(8);
       expect(importResourcesService.progressService.finishStep).toHaveBeenCalledWith("Encrypting 1/2");
       expect(importResourcesService.progressService.finishStep).toHaveBeenCalledWith("Encrypting 2/2");
+      expect(importResourcesService.progressService.finishStep).toHaveBeenCalledWith("Encrypting 2 metadata");
       expect(importResourcesService.progressService.finishStep).toHaveBeenCalledWith("Importing passwords 1/2");
       expect(importResourcesService.progressService.finishStep).toHaveBeenCalledWith("Importing passwords 2/2");
       expect(importResourcesService.progressService.finishStep).toHaveBeenCalledWith("Importing folders 1/2");
@@ -538,4 +541,43 @@ describe("ImportResourcesService", () => {
       expect(result.importFolders.items[0].name).toEqual("import-ref");
     });
   });
+
+  describe("::buildCustomFieldSecretDto", () => {
+    it("Should build the custom field secret DTO", () => {
+      expect.assertions(1);
+
+      const customFieldsDto = defaultCustomFieldsCollection();
+      const importResourcesFile = {
+        customFields: new CustomFieldsCollection(customFieldsDto)
+      };
+      const result = importResourcesService.buildCustomFieldSecretDto(importResourcesFile);
+
+      expect(result).toEqual([
+        {id: customFieldsDto[0].id, type: "text", secret_value: customFieldsDto[0].secret_value},
+        {id: customFieldsDto[1].id, type: "text", secret_value: customFieldsDto[1].secret_value}
+      ]);
+    });
+
+    it("Should return an empty array if no custom fields", () => {
+      expect.assertions(1);
+
+      const importResourcesFile = {
+        customFields: null
+      };
+      const result = importResourcesService.buildCustomFieldSecretDto(importResourcesFile);
+
+      expect(result).toEqual([]);
+    });
+
+    it("Should handle empty custom fields collection", () => {
+      expect.assertions(1);
+
+      const importResourcesFile = {
+        customFields: new CustomFieldsCollection([])
+      };
+      const result = importResourcesService.buildCustomFieldSecretDto(importResourcesFile);
+
+      expect(result).toEqual([]);
+    });
+  });
 });

package/src/all/background_page/service/sessionKey/decryptSessionKeysBundlesService.js

@@ -13,7 +13,6 @@
  */
 import {OpenpgpAssertion} from "../../utils/openpgp/openpgpAssertions";
 import PassphraseStorageService from '../session_storage/passphraseStorageService';
-import UserPassphraseRequiredError from "passbolt-styleguide/src/shared/error/userPassphraseRequiredError";
 import SessionKeysBundleEntity from "passbolt-styleguide/src/shared/models/entity/sessionKey/sessionKeysBundleEntity";
 import SessionKeysBundleDataEntity from "passbolt-styleguide/src/shared/models/entity/sessionKey/sessionKeysBundleDataEntity";
 import SessionKeysBundlesCollection from "passbolt-styleguide/src/shared/models/entity/sessionKey/sessionKeysBundlesCollection";
@@ -49,7 +48,7 @@ class DecryptSessionKeysBundlesService {
     }
     const message = await OpenpgpAssertion.readMessageOrFail(sessionKeysBundleEntity.data);
 
-    passphrase = passphrase || await this.getPassphraseFromLocalStorageOrFail();
+    passphrase = passphrase || await PassphraseStorageService.getOrFail();
 
     const userDecryptedPrivateArmoredKey = await DecryptPrivateKeyService.decryptArmoredKey(this.account.userPrivateArmoredKey, passphrase);
     const decryptedMessage = await DecryptMessageService.decrypt(message, userDecryptedPrivateArmoredKey);
@@ -73,7 +72,7 @@ class DecryptSessionKeysBundlesService {
   async decryptAll(sessionKeysBundlesCollection, passphrase = null) {
     assertType(sessionKeysBundlesCollection, SessionKeysBundlesCollection, "The given collection is not of the type SessionKeysBundlesCollection");
 
-    passphrase = passphrase || await this.getPassphraseFromLocalStorageOrFail();
+    passphrase = passphrase || await PassphraseStorageService.getOrFail();
 
     const items = sessionKeysBundlesCollection.items;
     for (let i = 0; i < items.length; i++) {
@@ -81,21 +80,6 @@ class DecryptSessionKeysBundlesService {
       await this.decryptOne(sessionKeysBundleEntity, passphrase);
     }
   }
-
-  /**
-   * Retrieve the user passphrase from the local storage or fail.
-   *
-   * @returns {Promise<string>}
-   * @throws {UserPassphraseRequiredError} if the `passphrase` is not set and cannot be retrieved.
-   * @private
-   */
-  async getPassphraseFromLocalStorageOrFail() {
-    const passphrase = await PassphraseStorageService.get();
-    if (!passphrase) {
-      throw new UserPassphraseRequiredError();
-    }
-    return passphrase;
-  }
 }
 
 export default DecryptSessionKeysBundlesService;

package/src/all/background_page/service/sessionKey/encryptSessionKeysBundlesService.js

@@ -12,7 +12,6 @@
  * @since         4.10.1
  */
 import PassphraseStorageService from '../session_storage/passphraseStorageService';
-import UserPassphraseRequiredError from "passbolt-styleguide/src/shared/error/userPassphraseRequiredError";
 import SessionKeysBundleEntity from "passbolt-styleguide/src/shared/models/entity/sessionKey/sessionKeysBundleEntity";
 import {assertString, assertType} from '../../utils/assertions';
 import DecryptPrivateKeyService from '../crypto/decryptPrivateKeyService';
@@ -45,28 +44,13 @@ class EncryptSessionKeysBundlesService {
       throw new TypeError("The session key bundle should be decrypted.");
     }
 
-    passphrase = passphrase || await this.getPassphraseFromSessionStorageOrFail();
+    passphrase = passphrase || await PassphraseStorageService.getOrFail();
 
     const userDecryptedPrivateKey = await DecryptPrivateKeyService.decryptArmoredKey(this.account.userPrivateArmoredKey, passphrase);
     const userPublicKey = await OpenpgpAssertion.readKeyOrFail(this.account.userPublicArmoredKey);
     const message = JSON.stringify(sessionKeysBundle.data.toDto());
     sessionKeysBundle.data = await EncryptMessageService.encrypt(message, userPublicKey, [userDecryptedPrivateKey]);
   }
-
-  /**
-   * Retrieve the user passphrase from the session storage or fail.
-   *
-   * @returns {Promise<string>}
-   * @throws {UserPassphraseRequiredError} if the `passphrase` is not set and cannot be retrieved.
-   * @private
-   */
-  async getPassphraseFromSessionStorageOrFail() {
-    const passphrase = await PassphraseStorageService.get();
-    if (!passphrase) {
-      throw new UserPassphraseRequiredError();
-    }
-    return passphrase;
-  }
 }
 
 export default EncryptSessionKeysBundlesService;

package/src/all/locales/cs-CZ/common.json

@@ -0,0 +1,130 @@
+{
+  "Adding tag...": "Přidávám tag...",
+  "An ECC key should be based on a supported curve.": "Klíč ECC by měl být založen na podporované křivce.",
+  "An internal error occurred. The server response could not be parsed. Please contact your administrator.": "Došlo k interní chybě. Odpověď serveru nelze zpracovat. Prosím obraťte se na správce systému.",
+  "An RSA key should have a length of {{size}} bits minimum.": "RSA klíč by měl mít délku nejméně {{size}} bitů.",
+  "Autofill failed. Could not find the active tab.": "Automatické vyplňování se nezdařilo. Nelze najít aktivní kartu.",
+  "Calculate permissions": "Vypočítat oprávnění",
+  "Calculating changes for {{name}}": "Vypočítávání změn pro {{name}}",
+  "Calculating folders permissions changes": "Výpočet změn oprávnění složek",
+  "Calculating resources permissions changes": "Výpočet změn oprávnění zdrojů",
+  "Calculating secrets": "Výpočet tajných klíčů",
+  "Calculating secrets {{counter}}/{{total}}": "Výpočet tajných klíčů {{counter}}/{{total}}",
+  "Confirming share operation": "Potvrzení operace sdílení",
+  "Could not verify the server key.": "Nepodařilo se ověřit klíč serveru.",
+  "Creating folder...": "Vytváření složky...",
+  "Creating password": "Vytváření hesla",
+  "Decrypting ...": "Dešifrování...",
+  "Decrypting {{counter}}/{{total}}": "Dešifrování {{counter}}/{{total}}",
+  "Decrypting secrets": "Dešifrování tajných klíčů",
+  "Decrypting secrets {{counter}}/{{total}}": "Dešifrování tajných klíčů {{counter}}/{{total}}",
+  "Delete {{count}} resource(s)_one": "Delete one resource",
+  "Delete {{count}} resource(s)_other": "Delete {{count}} resources",
+  "Delete Resources": "Delete Resources",
+  "Deleting Resource(s)": "Deleting Resource(s)",
+  "Deleting resource(s) {{counter}}/{{total}}": "Deleting resource(s) {{counter}}/{{total}}",
+  "Done": "Hotovo",
+  "Done!": "Hotovo!",
+  "Encrypting {{counter}}/{{total}}": "Šifrování {{counter}}/{{total}}",
+  "Encrypting {{total}} metadata": "Encrypting {{total}} metadata",
+  "Encrypting Metadata": "Šifrování metadat",
+  "Encrypting secret": "Šifrování tajemství",
+  "Encrypting Secret": "Šifrování tajného klíče",
+  "Encrypting secrets": "Šifrování tajných klíčů",
+  "Expiry date will be updated on {{count}} resource._one": "Datum vypršení platnosti bude aktualizováno u {{count}} zdroje.",
+  "Expiry date will be updated on {{count}} resource._other": "Datum vypršení platnosti bude aktualizováno na {{count}} zdrojích.",
+  "Exporting ...": "Exportování ...",
+  "Fetching parent permissions": "Načítání nadřazených oprávnění",
+  "Folder {{name}} can not be moved.": "Složku {{name}} nelze přesunout.",
+  "Folder {{name}} is already in folder {{destination}}.": "Složka {{name}} je již ve složce {{destination}}.",
+  "Folder {{name}} is already in the root folder.": "Složka {{name}} je již v kořenovém adresáři.",
+  "Generate file": "Vygenerovat soubor",
+  "Importing ...": "Importování...",
+  "Importing folders {{importedCount}}/{{total}}": "Importování složek {{importedCount}}/{{total}}",
+  "Importing passwords {{importedCount}}/{{total}}": "Importování hesel {{importedCount}}/{{total}}",
+  "Inactive worker on the page.": "Neaktivní worker na stránce.",
+  "Initialize": "Inicializovat",
+  "Initializing": "Inicializace",
+  "Initializing ...": "Inicializace ...",
+  "Mark as expired ...": "Označit jako neplatný ...",
+  "MFA authentication is required.": "Je vyžadováno ověření pomocí MFA.",
+  "Migrating metadata": "Migrace metadat",
+  "Migrating resources metadata page {{number}}/{{totalPagesCount}}": "Migrace metadat stránek zdrojů {{number}}/{{totalPagesCount}}",
+  "Moving {{count}} resources_one": "Přesouvání jednoho záznamu",
+  "Moving {{count}} resources_other": "Přesouvání {{count}} záznamů",
+  "Moving {{name}}": "Přesouvání {{name}}",
+  "Moving folder": "Přesouvání složky",
+  "Moving resources": "Přesunování zdrojů",
+  "Preparing...": "Probíhá příprava...",
+  "Private key not found.": "Soukromý klíč nebyl nalezen.",
+  "Public key can't be found.": "Veřejný klíč nebyl nalezen.",
+  "Rekeying users' key": "Překlíčování uživatelova klíče",
+  "Retrieving all resources parent folders permissions": "Získávání všech oprávnění nadřazených složek zdrojů",
+  "Retrieving destination folder permissions": "Získávání oprávnění cílové složky",
+  "Retrieving folders permissions": "Získávání oprávnění složek",
+  "Retrieving resource types": "Získávání typů zdrojů",
+  "Retrieving resources permissions": "Získávání oprávnění zdrojů",
+  "Retrieving secrets": "Získávání tajných klíčů",
+  "Saving permissions...": "Ukládání oprávnění...",
+  "Saving resource": "Ukládání záznamu",
+  "Server internal error. Check with your administrator.": "Interní chyba serveru. Kontaktujte správce systému.",
+  "Share {{count}} resource_one": "Sdílení jednoho zdroje",
+  "Share {{count}} resource_other": "Sdílet {{count}} zdrojů",
+  "Sharing folder {{name}}": "Sdílení složky {{name}}",
+  "Sharing folders": "Sdílení složek",
+  "Sharing folders {{counter}}/{{total}}": "Sdílení složek {{counter}}/{{total}}",
+  "Sharing resources": "Sdílení zdrojů",
+  "Sharing resources {{counter}}/{{total}}": "Sdílení zdrojů {{counter}}/{{total}}",
+  "Start sharing": "Začít sdílet",
+  "Synchronizing keyring": "Synchronizace klíčenky",
+  "Synchronizing keys": "Synchronizace klíčů",
+  "Tagging passwords {{taggedCount}}/{{total}}": "Označování hesel {{taggedCount}}/{{total}}",
+  "The encryption key used to share metadata between users could not be verified and is considered untrusted.": "Šifrovací klíč použitý k sdílení metadat mezi uživateli nemohl být ověřen a je považován za nespolehlivý.",
+  "The external service is unavailable": "Externí služba není k dispozici",
+  "The external service raised an error": "Externí služba způsobila chybu",
+  "The folder cannot be moved inside itself.": "Složku nelze přesunout do sebe sama.",
+  "The key should be a valid openpgp armored key string.": "Klíč by měl být platný řetězec klíče openpgp.",
+  "The key should be a valid openpgp key.": "Klíč by měl být platný openpgp klíč.",
+  "The key should be a valid openpgp private key.": "Klíč by měl být platný openpgp soukromý klíč.",
+  "The key should be a valid openpgp public key.": "Klíč by měl být platný openpgp veřejný klíč.",
+  "The keys should be an array of valid decrypted openpgp private keys.": "Klíče by měly být pole platných dešifrovaných openpgp soukromých klíčů.",
+  "The keys should be an array of valid encrypted openpgp private keys.": "Klíče by měly být pole platných šifrovaných openpgp soukromých klíčů.",
+  "The keys should be an array of valid openpgp armored key strings.": "Klíče by měly být pole platných openpgp textových řetězců.",
+  "The keys should be an array of valid openpgp private keys.": "Klíče by měly být pole platných openpgp soukromých klíčů.",
+  "The keys should be an array of valid openpgp public keys.": "Klíče by měly být pole platných openpgp veřejných klíčů.",
+  "The keys should be an array.": "Klíče by měly být pole.",
+  "The message should be a valid openpgp clear text message.": "Zpráva by měla být platná, v clear textu a ve formátu OpenPGP.",
+  "The message should be a valid openpgp message.": "Zpráva by měla být platná openpgp zpráva.",
+  "The message should be decrypted.": "Zpráva by měla být dešifrována.",
+  "The message should be of type string.": "Zpráva by měla být typu textový řetězec.",
+  "The message should contain at least one session key.": "Zpráva by měla obsahovat alespoň jeden klíč relace.",
+  "The operation has been aborted to maintain security integrity.": "Operace byla přerušena k udržení integritu bezpečnosti.",
+  "The private key should be a valid openpgp key.": "Soukromý klíč by měl být platný openpgp klíč.",
+  "The private key should be decrypted.": "Soukromý klíč by měl být dešifrovaný.",
+  "The private key should be encrypted.": "Soukromý klíč by měl být zašifrovaný.",
+  "The private key should not be expired.": "Soukromý klíč by neměl mít vypršenou platnost.",
+  "The private key should not be revoked.": "Soukromý klíč by neměl být revokovaný.",
+  "The private key should not have an expiry date.": "Soukromý klíč by neměl mít datum vypršení platnosti.",
+  "The private key should use a supported algorithm: RSA, ECDSA OR EDDSA.": "Soukromý klíč by měl používat podporovaný algoritmus: RSA, ECDSA NEBO EDDSA.",
+  "The server key cannot be parsed.": "Serverový klíč nelze rozparsovat.",
+  "The server key has changed.": "Klíč serveru byl změněn.",
+  "The server key is expired.": "Platnost klíče serveru vypršela.",
+  "The service is unavailable": "Tato služba není dostupná",
+  "The verificationResult keyID should be a valid keyID Object.": "VerificationResult keyID by měl být platným objektem keyID.",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "VerificationResult signature by měl být platnou ověřenou Promise<openpgp.Signature>.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "VerificationResult verified by měl být platnou ověřenou Promise<boolean>.",
+  "This is not a valid passphrase": "Toto není platné heslo",
+  "This key does not match any account.": "Tento klíč se neshoduje s žádným účtem.",
+  "This key is already used by another user.": "Tento klíč již používá jiný uživatel.",
+  "Unable to retrieve the active tab info.": "Nepodařilo se načíst informace o aktivní kartě.",
+  "Updating folders local storage": "Aktualizace místního úložiště složek",
+  "Updating group": "Aktualizování skupiny",
+  "Updating group ...": "Aktualizování skupiny ...",
+  "Updating password": "Aktualizování hesla",
+  "Updating resource": "Aktualizuji zdroj",
+  "Updating resources local storage": "Aktualizace místního úložiště zdrojů",
+  "Updating resources metadata": "Aktualizace metadat zdrojů",
+  "Updating resources metadata {{counter}}/{{total}}": "Aktualizace metadat zdrojů {{counter}}/{{total}}",
+  "Updating users' key...": "Aktualizuji klíč uživatele...",
+  "You have already started the process on another tab.": "Tento proces jste již zahájili na jiné kartě."
+}

package/src/all/locales/de-DE/common.json

@@ -18,9 +18,15 @@
   "Decrypting {{counter}}/{{total}}": "Entschlüsselung {{counter}}/{{total}}",
   "Decrypting secrets": "Geheimnisse werden entschlüsselt",
   "Decrypting secrets {{counter}}/{{total}}": "Geheimnisse werden entschlüsselt {{counter}}/{{total}}",
+  "Delete {{count}} resource(s)_one": "Delete one resource",
+  "Delete {{count}} resource(s)_other": "Delete {{count}} resources",
+  "Delete Resources": "Delete Resources",
+  "Deleting Resource(s)": "Deleting Resource(s)",
+  "Deleting resource(s) {{counter}}/{{total}}": "Deleting resource(s) {{counter}}/{{total}}",
   "Done": "Fertig",
   "Done!": "Fertig!",
   "Encrypting {{counter}}/{{total}}": "Verschlüsselung {{counter}}/{{total}}",
+  "Encrypting {{total}} metadata": "Encrypting {{total}} metadata",
   "Encrypting Metadata": "Metadaten werden verschlüsselt",
   "Encrypting secret": "Geheimnis wird verschlüsselt",
   "Encrypting Secret": "Geheimnis wird verschlüsselt",
@@ -73,7 +79,7 @@
   "Synchronizing keyring": "Schlüsselring wird synchronisiert",
   "Synchronizing keys": "Schlüssel werden synchronisiert",
   "Tagging passwords {{taggedCount}}/{{total}}": "Passwörter {{taggedCount}}/{{total}} werden markiert",
-  "The encryption key used to share metadata between users could not be verified and is considered untrusted.": "The encryption key used to share metadata between users could not be verified and is considered untrusted.",
+  "The encryption key used to share metadata between users could not be verified and is considered untrusted.": "Der für den Austausch von Metadaten zwischen Benutzern verwendete Verschlüsselungsschlüssel konnte nicht überprüft werden und gilt als nicht vertrauenswürdig.",
   "The external service is unavailable": "Der externe Dienst ist nicht verfügbar",
   "The external service raised an error": "Der externe Dienst hat einen Fehler ausgelöst",
   "The folder cannot be moved inside itself.": "Der Ordner kann nicht in sich selbst verschoben werden.",
@@ -92,7 +98,7 @@
   "The message should be decrypted.": "Die Nachricht sollte entschlüsselt werden.",
   "The message should be of type string.": "Die Nachricht sollte vom Typ String sein.",
   "The message should contain at least one session key.": "Die Nachricht sollte mindestens einen Sitzungsschlüssel enthalten.",
-  "The operation has been aborted to maintain security integrity.": "The operation has been aborted to maintain security integrity.",
+  "The operation has been aborted to maintain security integrity.": "Der Vorgang wurde abgebrochen, um die Sicherheitsintegrität zu wahren.",
   "The private key should be a valid openpgp key.": "Der private Schlüssel sollte ein gültiger OpenPGP Schlüssel sein.",
   "The private key should be decrypted.": "Der private Schlüssel sollte entschlüsselt werden.",
   "The private key should be encrypted.": "Der private Schlüssel sollte verschlüsselt werden.",
@@ -104,9 +110,9 @@
   "The server key has changed.": "Der Server-Schlüssel wurde geändert.",
   "The server key is expired.": "Der Server-Schlüssel ist abgelaufen.",
   "The service is unavailable": "Der Dienst ist nicht verfügbar",
-  "The verificationResult keyID should be a valid keyID Object.": "The verificationResult keyID should be a valid keyID Object.",
-  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.",
-  "The verificationResult verified should be a valid verified Promise<boolean>.": "The verificationResult verified should be a valid verified Promise<boolean>.",
+  "The verificationResult keyID should be a valid keyID Object.": "Die keyID des verificationResult sollte ein gültiges keyID-Objekt sein.",
+  "The verificationResult signature should be a valid verified Promise<openpgp.Signature>.": "Die verificationResult-Signatur sollte ein gültiges verifiziertes Promise<openpgp.Signature> sein.",
+  "The verificationResult verified should be a valid verified Promise<boolean>.": "Das verifizierte Ergebnis von verificationResult sollte ein gültiges verifiziertes Promise<boolean> sein.",
   "This is not a valid passphrase": "Dies ist kein gültiges Kennwort",
   "This key does not match any account.": "Dieser Schlüssel stimmt mit keinem Konto überein.",
   "This key is already used by another user.": "Dieser Schlüssel wird bereits von einem anderen Benutzer verwendet.",

package/src/all/locales/en-UK/common.json

@@ -18,9 +18,15 @@
   "Decrypting {{counter}}/{{total}}": "Decrypting {{counter}}/{{total}}",
   "Decrypting secrets": "Decrypting secrets",
   "Decrypting secrets {{counter}}/{{total}}": "Decrypting secrets {{counter}}/{{total}}",
+  "Delete {{count}} resource(s)_one": "Delete one resource",
+  "Delete {{count}} resource(s)_other": "Delete {{count}} resources",
+  "Delete Resources": "Delete Resources",
+  "Deleting Resource(s)": "Deleting Resource(s)",
+  "Deleting resource(s) {{counter}}/{{total}}": "Deleting resource(s) {{counter}}/{{total}}",
   "Done": "Done",
   "Done!": "Done!",
   "Encrypting {{counter}}/{{total}}": "Encrypting {{counter}}/{{total}}",
+  "Encrypting {{total}} metadata": "Encrypting {{total}} metadata",
   "Encrypting Metadata": "Encrypting Metadata",
   "Encrypting secret": "Encrypting secret",
   "Encrypting Secret": "Encrypting Secret",

package/src/all/locales/es-ES/common.json

@@ -18,9 +18,15 @@
   "Decrypting {{counter}}/{{total}}": "Desencriptando {{counter}}/{{total}}",
   "Decrypting secrets": "Descifrando secretos",
   "Decrypting secrets {{counter}}/{{total}}": "Descifrando secretos {{counter}}/{{total}}",
+  "Delete {{count}} resource(s)_one": "Eliminar un recurso",
+  "Delete {{count}} resource(s)_other": "Delete {{count}} resources",
+  "Delete Resources": "Delete Resources",
+  "Deleting Resource(s)": "Deleting Resource(s)",
+  "Deleting resource(s) {{counter}}/{{total}}": "Deleting resource(s) {{counter}}/{{total}}",
   "Done": "Hecho",
   "Done!": "Hecho!",
   "Encrypting {{counter}}/{{total}}": "Cifrando {{counter}}/{{total}}",
+  "Encrypting {{total}} metadata": "Encrypting {{total}} metadata",
   "Encrypting Metadata": "Cifrando metadatos",
   "Encrypting secret": "Cifrando secreto",
   "Encrypting Secret": "Cifrando secreto",

package/src/all/locales/fr-FR/common.json

@@ -18,9 +18,15 @@
   "Decrypting {{counter}}/{{total}}": "Déchiffrement {{counter}}/{{total}}",
   "Decrypting secrets": "Déchiffrement des secrets",
   "Decrypting secrets {{counter}}/{{total}}": "Déchiffrement des secrets {{counter}}/{{total}}",
+  "Delete {{count}} resource(s)_one": "Delete one resource",
+  "Delete {{count}} resource(s)_other": "Delete {{count}} resources",
+  "Delete Resources": "Delete Resources",
+  "Deleting Resource(s)": "Deleting Resource(s)",
+  "Deleting resource(s) {{counter}}/{{total}}": "Deleting resource(s) {{counter}}/{{total}}",
   "Done": "Terminé",
   "Done!": "Terminé!",
   "Encrypting {{counter}}/{{total}}": "Chiffrement {{counter}}/{{total}}",
+  "Encrypting {{total}} metadata": "Encrypting {{total}} metadata",
   "Encrypting Metadata": "Chiffrement des métadonnées",
   "Encrypting secret": "Chiffrement du secret",
   "Encrypting Secret": "Chiffrement du secret",

package/src/all/locales/it-IT/common.json

@@ -18,9 +18,15 @@
   "Decrypting {{counter}}/{{total}}": "Decriptazione {{counter}}/{{total}}",
   "Decrypting secrets": "Decriptazione dei segreti",
   "Decrypting secrets {{counter}}/{{total}}": "Decriptazione dei segreti {{counter}}/{{total}}",
+  "Delete {{count}} resource(s)_one": "Delete one resource",
+  "Delete {{count}} resource(s)_other": "Delete {{count}} resources",
+  "Delete Resources": "Delete Resources",
+  "Deleting Resource(s)": "Deleting Resource(s)",
+  "Deleting resource(s) {{counter}}/{{total}}": "Deleting resource(s) {{counter}}/{{total}}",
   "Done": "Completato",
   "Done!": "Completato!",
   "Encrypting {{counter}}/{{total}}": "Criptazione {{counter}}/{{total}}",
+  "Encrypting {{total}} metadata": "Encrypting {{total}} metadata",
   "Encrypting Metadata": "Criptazione dei metadati",
   "Encrypting secret": "Criptazione del segreto",
   "Encrypting Secret": "Criptazione del segreto",

package/src/all/locales/ja-JP/common.json

@@ -18,9 +18,15 @@
   "Decrypting {{counter}}/{{total}}": "{{counter}}/{{total}} を復号中",
   "Decrypting secrets": "シークレットを復号化中",
   "Decrypting secrets {{counter}}/{{total}}": "シークレットを復号化中 {{counter}}/{{total}}",
+  "Delete {{count}} resource(s)_one": "Delete one resource",
+  "Delete {{count}} resource(s)_other": "Delete {{count}} resources",
+  "Delete Resources": "Delete Resources",
+  "Deleting Resource(s)": "Deleting Resource(s)",
+  "Deleting resource(s) {{counter}}/{{total}}": "Deleting resource(s) {{counter}}/{{total}}",
   "Done": "完了",
   "Done!": "完了!",
   "Encrypting {{counter}}/{{total}}": "{{counter}}/{{total}} を暗号化中",
+  "Encrypting {{total}} metadata": "Encrypting {{total}} metadata",
   "Encrypting Metadata": "メタデータを暗号化中",
   "Encrypting secret": "秘密の暗号化",
   "Encrypting Secret": "シークレットを暗号化中",

package/src/all/locales/ko-KR/common.json

@@ -18,9 +18,15 @@
   "Decrypting {{counter}}/{{total}}": "복호화 중 {{counter}}/{{total}}",
   "Decrypting secrets": "비밀을 복호화 중",
   "Decrypting secrets {{counter}}/{{total}}": "{{counter}}/{{total}} 비밀을 복호화 중",
+  "Delete {{count}} resource(s)_one": "Delete one resource",
+  "Delete {{count}} resource(s)_other": "Delete {{count}} resources",
+  "Delete Resources": "Delete Resources",
+  "Deleting Resource(s)": "Deleting Resource(s)",
+  "Deleting resource(s) {{counter}}/{{total}}": "Deleting resource(s) {{counter}}/{{total}}",
   "Done": "완료",
   "Done!": "완료!",
   "Encrypting {{counter}}/{{total}}": "암호화 중 {{counter}}/{{total}}",
+  "Encrypting {{total}} metadata": "Encrypting {{total}} metadata",
   "Encrypting Metadata": "메타데이터 암호화",
   "Encrypting secret": "비밀 암호화 중",
   "Encrypting Secret": "비밀 암호화 중",

package/src/all/locales/lt-LT/common.json

@@ -18,9 +18,15 @@
   "Decrypting {{counter}}/{{total}}": "Iššifruoti {{counter}}/{{total}}",
   "Decrypting secrets": "Iššifruojamos paslaptys",
   "Decrypting secrets {{counter}}/{{total}}": "Iššifruojamos paslaptys {{counter}}/{{total}}",
+  "Delete {{count}} resource(s)_one": "Delete one resource",
+  "Delete {{count}} resource(s)_other": "Delete {{count}} resources",
+  "Delete Resources": "Delete Resources",
+  "Deleting Resource(s)": "Deleting Resource(s)",
+  "Deleting resource(s) {{counter}}/{{total}}": "Deleting resource(s) {{counter}}/{{total}}",
   "Done": "Atlikta",
   "Done!": "Atlikta!",
   "Encrypting {{counter}}/{{total}}": "Užšifruoti {{counter}}/{{total}}",
+  "Encrypting {{total}} metadata": "Encrypting {{total}} metadata",
   "Encrypting Metadata": "Šifruojami metaduomenys",
   "Encrypting secret": "Užšifruoti paslaptį",
   "Encrypting Secret": "Šifruojama paslaptis",