passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/{content_scripts → contentScripts}/js/app/Setup.js

@@ -11,33 +11,25 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  * @since        3.0.0
  */
-import React, {Component} from "react";
+import React from "react";
 import ReactDOM from "react-dom";
 import ExtBootstrapSetup from "passbolt-styleguide/src/react-extension/ExtBootstrapSetup";
-/* eslint-disable no-unused-vars */
-import Port from "../../../data/js/lib/port";
-/* eslint-enable no-unused-vars */
-
-/**
- * Wait until the background pagemod is ready.
- * @returns {Promise}
- */
-async function waitPagemodIsReady() {
-  let resolver;
-  const promise = new Promise(resolve => { resolver = resolve; });
-
-  const checkInterval = setInterval(() => {
-    port.request("passbolt.pagemod.is-ready").then(() => {
-      resolver();
-      clearInterval(checkInterval);
-    });
-  }, 50);
-
-  return promise;
-}
+import Port from "../../../webAccessibleResources/js/lib/port";
+import MessageService from "../service/messageService";
+import MessageEventHandler from "../message/messageEventHandler";
+import ConnectPortController from "../controller/connectPortController";
 
 async function main() {
-  await waitPagemodIsReady();
+  // Port connection
+  const port = new Port(self.portname);
+  // Emit a success if the port is still connected
+  port.on("passbolt.port.check", requestId => port.emit(requestId, "SUCCESS"));
+  await port.connect();
+  // Message listener
+  const messageService = new MessageService();
+  const messageEventHandler = new MessageEventHandler(messageService);
+  messageEventHandler.listen("passbolt.port.connect", ConnectPortController, port);
+  // Start ExtBootstrapSetup
   const browserExtensionUrl = chrome.runtime.getURL("/");
   const domContainer = document.createElement("div");
   document.body.appendChild(domContainer);

package/src/all/contentScripts/js/controller/connectPortController.js

@@ -0,0 +1,37 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.0.0
+ */
+
+class ConnectPortController {
+  /**
+   * ConnectPortController constructor
+   * @param {Port} port
+   */
+  constructor(port) {
+    this.port = port;
+  }
+
+  /**
+   * Connect port.
+   *
+   * @param portId {string} The port id
+   * @return {Promise<string>}
+   */
+  async exec(portId) {
+    if (this.port._name === portId) {
+      await this.port.connectIfDisconnected();
+    }
+  }
+}
+
+export default ConnectPortController;

package/src/all/contentScripts/js/controller/connectPortController.test.js

@@ -0,0 +1,51 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.0.0
+ */
+import ConnectPortController from "./connectPortController";
+
+describe("ConnectPortController", () => {
+  beforeEach(async() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+  });
+
+  describe("ConnectPortController::exec", () => {
+    it("Should connect port", async() => {
+      expect.assertions(1);
+      // data mocked
+      const port = {
+        _name: "name",
+        connectIfDisconnected: jest.fn()
+      };
+      // process
+      const connectPortController = new ConnectPortController(port);
+      await connectPortController.exec("name");
+      // expectations
+      expect(port.connectIfDisconnected).toHaveBeenCalled();
+    });
+
+    it("Should not connect port if port name is unknown", async() => {
+      expect.assertions(1);
+      // data mocked
+      const port = {
+        _name: "unknown",
+        connectIfDisconnected: jest.fn()
+      };
+      // process
+      const connectPortController = new ConnectPortController(port);
+      await connectPortController.exec("name");
+      // expectations
+      expect(port.connectIfDisconnected).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/all/contentScripts/js/message/messageEventHandler.js

@@ -0,0 +1,63 @@
+/**
+ * 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         4.0.0
+ */
+
+import MessageService from "../service/messageService";
+
+/**
+ * Message event handler.
+ */
+class MessageEventHandler {
+  /**
+   * Message Event Handler constructor
+   */
+  constructor(messageService) {
+    if (!(messageService instanceof MessageService)) {
+      throw new Error('The messageService should be a valid MessageService instance.');
+    }
+    this.messageService = messageService;
+  }
+
+  /**
+   * Listen to the event.
+   * @param {string} message The message to listen to.
+   * @param {Class} ControllerClass The controller class that aims to treat the message.
+   * @param {any} controllerArgs The controller additional parameters.
+   */
+  listen(message, ControllerClass, ...controllerArgs) {
+    if (typeof message !== 'string') {
+      throw new Error('The message should be a valid string.');
+    }
+    if (!message.length) {
+      throw new Error('The message should not be empty.');
+    }
+    if (typeof ControllerClass !== 'function') {
+      throw new Error('The ControllerClass should be a valid class.');
+    }
+
+    const callback = async(...callbackArgs) => {
+      callbackArgs = callbackArgs || {};
+      try {
+        const controllersArgs = controllerArgs || {};
+        const controller = new ControllerClass(...controllersArgs);
+        const result = await controller.exec(...callbackArgs);
+        await this.messageService.success(result);
+      } catch (error) {
+        await this.messageService.error(error);
+      }
+    };
+    this.messageService.addListener(message, callback);
+  }
+}
+
+export default MessageEventHandler;

package/src/all/contentScripts/js/message/messageEventHandler.test.data.js

@@ -0,0 +1,30 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 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         4.0.0
+ */
+
+export class ControllerMessageEventHandlerMock {
+  exec() {
+  }
+}
+
+export class ControllerWithResponseMessageEventHandlerMock {
+  exec() {
+    return 'controller-exec-output';
+  }
+}
+
+export class ControllerMessageEventHandlerErrorExecMock {
+  exec() {
+    throw new Error('Execution error');
+  }
+}

package/src/all/contentScripts/js/message/messageEventHandler.test.js

@@ -0,0 +1,154 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 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         4.0.0
+ */
+import MessageService from "../service/messageService";
+import MessageEventHandler from "./messageEventHandler";
+import {
+  ControllerMessageEventHandlerErrorExecMock,
+  ControllerMessageEventHandlerMock, ControllerWithResponseMessageEventHandlerMock
+} from "./messageEventHandler.test.data";
+import {ControllerMessageEventHandlerConstructorMock} from "./messageEventHandlerConstructorMock.test.data";
+
+/*
+ * The class we need to mock the constructor needs to be separated in a dedicated file.
+ * If not spyOn cannot be used on the same mocked class as the one mocked as following.
+ */
+jest.mock("./messageEventHandlerConstructorMock.test.data");
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("MessageEventHandler", () => {
+  describe("MessageEventHandler::constructor", () => {
+    it("Should instantiate the class", async() => {
+      expect.assertions(1);
+      const messageService = new MessageService();
+      const messageEventHandler = new MessageEventHandler(messageService);
+      expect(messageEventHandler).toBeInstanceOf(MessageEventHandler);
+    });
+
+    it("Should not instantiate the class if the message service is not valid", async() => {
+      expect.assertions(2);
+      expect(() => new MessageEventHandler(null)).toThrowError('The messageService should be a valid MessageService instance.');
+      expect(() => new MessageEventHandler({messageService: 'not a valid message service'})).toThrowError('The messageService should be a valid MessageService instance.');
+    });
+  });
+
+  describe("MessageEventHandler::listen", () => {
+    it("Should listen to message, execute the controller and resolve the message.", async() => {
+      expect.assertions(2);
+      const messageService = new MessageService();
+      const messageEventHandler = new MessageEventHandler(messageService);
+
+      const spyControllerClassExec = jest.spyOn(ControllerMessageEventHandlerMock.prototype, "exec");
+      const spyMessageServiceSuccess = jest.spyOn(messageService, "success");
+
+      messageEventHandler.listen('message-to-listen', ControllerMessageEventHandlerMock);
+      await messageService._onMessage(['message-to-listen']);
+      expect(spyControllerClassExec).toHaveBeenCalled();
+      expect(spyMessageServiceSuccess).toHaveBeenCalled();
+    });
+
+    it("Should listen to message, execute the controller and resolve the message with the controller response.", async() => {
+      expect.assertions(2);
+      const messageService = new MessageService();
+      const messageEventHandler = new MessageEventHandler(messageService);
+
+      const spyControllerClassExec = jest.spyOn(ControllerWithResponseMessageEventHandlerMock.prototype, "exec");
+      const spyMessageServiceSuccess = jest.spyOn(messageService, "success");
+
+      messageEventHandler.listen('message-to-listen', ControllerWithResponseMessageEventHandlerMock);
+      await messageService._onMessage(['message-to-listen']);
+      expect(spyControllerClassExec).toHaveBeenCalled();
+      expect(spyMessageServiceSuccess).toHaveBeenCalledWith('controller-exec-output');
+    });
+
+    it("Should listen to message, execute the controller and reject the message with the controller error.", async() => {
+      expect.assertions(3);
+      const messageService = new MessageService();
+      const messageEventHandler = new MessageEventHandler(messageService);
+
+      const spyControllerClassExec = jest.spyOn(ControllerMessageEventHandlerErrorExecMock.prototype, "exec");
+      const spyMessageServiceEmit = jest.spyOn(messageService, "error");
+      messageEventHandler.listen('message-to-listen', ControllerMessageEventHandlerErrorExecMock);
+      let expectedError;
+
+      try {
+        await messageService._onMessage(['message-to-listen']);
+      } catch (error) {
+        expectedError = error;
+        expect(error).toBeInstanceOf(Error);
+      }
+
+      expect(spyControllerClassExec).toThrow();
+      expect(spyMessageServiceEmit).toHaveBeenCalledWith(expectedError);
+    });
+
+    it("Should listen to message, instantiate the controller with parameters, execute the controller and resolve the message.", async() => {
+      expect.assertions(3);
+      const messageService = new MessageService();
+      const messageEventHandler = new MessageEventHandler(messageService);
+
+      const spyControllerClassExec = jest.spyOn(ControllerMessageEventHandlerConstructorMock.prototype, "exec");
+      const spyMessageServiceSuccess = jest.spyOn(messageService, "success");
+
+      messageEventHandler.listen('message-to-listen', ControllerMessageEventHandlerConstructorMock, 'ctl-arg1-value', 'ctl-arg2-value');
+      await messageService._onMessage(['message-to-listen']);
+
+      expect(ControllerMessageEventHandlerConstructorMock).toHaveBeenCalledWith('ctl-arg1-value', 'ctl-arg2-value');
+      expect(spyControllerClassExec).toHaveBeenCalled();
+      expect(spyMessageServiceSuccess).toHaveBeenCalled();
+    });
+
+    it("Should listen to message, instantiate the controller with parameters, execute the controller with parameters and resolve the message.", async() => {
+      expect.assertions(3);
+      const messageService = new MessageService();
+      const messageEventHandler = new MessageEventHandler(messageService);
+
+      const spyControllerClassExec = jest.spyOn(ControllerMessageEventHandlerConstructorMock.prototype, "exec");
+      const spyMessageServiceSuccess = jest.spyOn(messageService, "success");
+
+      messageEventHandler.listen('message-to-listen', ControllerMessageEventHandlerConstructorMock, 'ctl-arg1-value', 'ctl-arg2-value');
+      await messageService._onMessage(['message-to-listen', 'event-arg1-value', 'event-arg2-value']);
+
+      expect(ControllerMessageEventHandlerConstructorMock).toHaveBeenCalledWith('ctl-arg1-value', 'ctl-arg2-value');
+      expect(spyControllerClassExec).toHaveBeenCalledWith('event-arg1-value', 'event-arg2-value');
+      expect(spyMessageServiceSuccess).toHaveBeenCalled();
+    });
+
+    it("Should throw an error if the message is not a string.", async() => {
+      expect.assertions(2);
+      const messageService = new MessageService();
+      const messageEventHandler = new MessageEventHandler(messageService);
+      expect(() => messageEventHandler.listen(null, ControllerMessageEventHandlerMock)).toThrowError('The message should be a valid string.');
+      expect(() => messageEventHandler.listen(() => {}, ControllerMessageEventHandlerMock)).toThrowError('The message should be a valid string.');
+    });
+
+    it("Should throw an error if the message is empty.", async() => {
+      expect.assertions(1);
+      const messageService = new MessageService();
+      const messageEventHandler = new MessageEventHandler(messageService);
+      class ControllerMessageEventHandlerTestClass {}
+      expect(() => messageEventHandler.listen('', ControllerMessageEventHandlerTestClass)).toThrowError('The message should not be empty.');
+    });
+
+    it("Should throw an error if ControllerClass is not a class.", async() => {
+      expect.assertions(2);
+      const messageService = new MessageService();
+      const messageEventHandler = new MessageEventHandler(messageService);
+      expect(() => messageEventHandler.listen('message', null)).toThrowError('The ControllerClass should be a valid class');
+      expect(() => messageEventHandler.listen('message', 12)).toThrowError('The ControllerClass should be a valid class');
+    });
+  });
+});

package/src/all/contentScripts/js/message/messageEventHandlerConstructorMock.test.data.js

@@ -0,0 +1,18 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 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         4.0.0
+ */
+
+export class ControllerMessageEventHandlerConstructorMock {
+  exec() {
+  }
+}

package/src/all/contentScripts/js/service/messageService.js

@@ -0,0 +1,76 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         4.0.0
+ */
+
+class MessageService {
+  constructor() {
+    this._listeners = {};
+    this._onMessage = this._onMessage.bind(this);
+    browser.runtime.onMessage.addListener(this._onMessage);
+  }
+
+  /**
+   * When a message is received on the content script
+   * Triggers all the callback associated with that message name
+   *
+   * @param msg
+   * @private
+   */
+  async _onMessage(msg) {
+    const eventName = msg[0];
+    if (typeof this._listeners[eventName] !== 'undefined' && this._listeners[eventName].length > 0) {
+      const listeners = this._listeners[eventName];
+      for (let i = 0; i < listeners.length; i++) {
+        const listener = listeners[i];
+        const args = Array.prototype.slice.call(msg, 1);
+        await listener.callback.apply(this, args);
+      }
+    }
+  }
+
+  /**
+   * Add listener for a message name on the current port
+   *
+   * @param name string
+   * @param callback function
+   */
+  addListener(name, callback) {
+    if (typeof this._listeners[name] === 'undefined') {
+      this._listeners[name] = [];
+    }
+    this._listeners[name].push({
+      name: name,
+      callback: callback
+    });
+  }
+
+  /**
+   * Resolve the mesage in case of success.
+   * @param {any} response the response payload
+   * @return {Promise<any>}
+   */
+  success(response) {
+    return Promise.resolve(response);
+  }
+
+  /**
+   * Reject the message in case of error.
+   * @param {any} error the error payload
+   * @return {Promise<any>}
+   */
+  error(error) {
+    return Promise.reject(error);
+  }
+}
+
+export default MessageService;

package/src/all/contentScripts/js/service/messageService.test.js

@@ -0,0 +1,54 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ *
+ * Licensed under GNU Affero General Public License version 3 of the or any later version.
+ * For full copyright and license information, please see the LICENSE.txt
+ * Redistributions of files must retain the above copyright notice.
+ *
+ * @copyright     Copyright (c) 2022 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.8.0
+ */
+import MessageService from "./messageService";
+
+describe("MessageService", () => {
+  describe("MessageService::onMessage", () => {
+    it("Should receive a message know by message service", async() => {
+      expect.assertions(2);
+      // data mocked
+      const callback = jest.fn();
+      // process
+      const messageService = new MessageService();
+      messageService.addListener("test", callback);
+      messageService._onMessage(["test", "argument"]);
+      // expectation
+      expect(browser.runtime.onMessage.addListener).toHaveBeenCalled();
+      expect(callback).toHaveBeenCalledWith("argument");
+    });
+  });
+
+  describe("MessageService::emit", () => {
+    it("Should emit a success message", async() => {
+      expect.assertions(1);
+      // process
+      const messageService = new MessageService();
+      const result = await messageService.success("result");
+      // expectation
+      expect(result).toStrictEqual("result");
+    });
+
+    it("Should emit an error message", async() => {
+      expect.assertions(1);
+      // process
+      const messageService = new MessageService();
+      try {
+        await messageService.error("error");
+      } catch (error) {
+        // expectation
+        expect(error).toStrictEqual("error");
+      }
+    });
+  });
+});

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

@@ -0,0 +1,94 @@
+{
+  "Adding tag...": "Tag wird hinzugefügt...",
+  "An ECC key should be based on a supported curve.": "Ein ECC-Schlüssel sollte auf einer unterstützten Kurve basieren.",
+  "An internal error occurred. The server response could not be parsed. Please contact your administrator.": "Ein interner Fehler ist aufgetreten. Die Antwort des Servers konnte nicht analysiert werden. Bitte kontaktieren Sie Ihren Administrator.",
+  "An RSA key should have a length of {{size}} bits minimum.": "Ein RSA-Schlüssel sollte eine Mindestlänge von {{size}} Bits haben.",
+  "Autofill failed. Could not find the active tab.": "Automatisches Ausfüllen fehlgeschlagen. Der aktive Tab konnte nicht gefunden werden.",
+  "Calculate permissions": "Berechtigungen berechnen",
+  "Calculating changes ...": "Änderungen werden berechnet...",
+  "Calculating changes for {{name}}": "Änderungen für {{name}} werden berechnet",
+  "Calculating changes...": "Änderungen werden berechnet...",
+  "Could not move, expecting a folder to be provided.": "Verschieben nicht möglich, es wurde kein Ordner angegeben.",
+  "Could not move, expecting at least a resource to be provided.": "Verschieben nicht möglich, es muss mindestens eine Ressource angegeben werden.",
+  "Could not verify the server key.": "Der Serverschlüssel konnte nicht verifiziert werden.",
+  "Creating folder...": "Ordner wird erstellt...",
+  "Creating password": "Passwort wird erstellt",
+  "Decrypting ...": "Entschlüsselung ...",
+  "Decrypting {{counter}}/{{total}}": "Entschlüsselung {{counter}}/{{total}}",
+  "Done": "Fertig",
+  "Done!": "Fertig!",
+  "Encrypting": "Verschlüsselung",
+  "Encrypting {{counter}}/{{total}}": "Verschlüsselung {{counter}}/{{total}}",
+  "Encrypting secret": "Geheimnis wird verschlüsselt",
+  "Expiry date will be updated on {{count}} resource._one": "Das Ablaufdatum wird auf {{count}} Ressource aktualisiert.",
+  "Expiry date will be updated on {{count}} resource._other": "Das Ablaufdatum wird auf {{count}} Ressourcen aktualisiert.",
+  "Exporting ...": "Exportieren ...",
+  "Fetching parent permissions": "Übergeordnete Berechtigungen werden abgerufen",
+  "Folder {{name}} can not be moved.": "Der Ordner {{name}} kann nicht verschoben werden.",
+  "Folder {{name}} is already in folder {{destination}}.": "Der Ordner {{name}} befindet sich bereits im Ordner {{destination}}.",
+  "Generate file": "Datei erzeugen",
+  "Importing ...": "Importieren ...",
+  "Importing folders {{importedCount}}/{{total}}": "Ordner {{importedCount}}/{{total}} werden importiert",
+  "Importing passwords {{importedCount}}/{{total}}": "Passwörter {{importedCount}}/{{total}} werden importiert",
+  "Inactive worker on the page.": "Inaktives Worker auf der Seite.",
+  "Initialize": "Initialisieren",
+  "Initializing": "Initialisierung",
+  "Initializing ...": "Initialisierung ...",
+  "Mark as expired ...": "Als abgelaufen markieren ...",
+  "MFA authentication is required.": "MFA-Authentifizierung ist erforderlich.",
+  "Moving {{name}}": "{{name}} wird verschoben",
+  "Moving {{total}} resources": "{{total}} Ressourcen werden verschoben",
+  "Moving folder": "Ordner wird verschoben",
+  "Moving one resource": "Eine Ressource wird verschoben",
+  "Preparing...": "Vorbereitung...",
+  "Private key not found.": "Privater Schlüssel nicht gefunden.",
+  "Public key can't be found.": "Öffentlicher Schlüssel konnte nicht gefunden werden.",
+  "Rekeying users' key": "Benutzerschlüssel erneut eingeben",
+  "Saving permissions...": "Berechtigungen werden gespeichert...",
+  "Saving resource": "Ressource wird gespeichert",
+  "Server internal error. Check with your administrator.": "Interner Serverfehler. Kontaktieren Sie Ihren Administrator.",
+  "Share {{count}} password_one": "{{count}} Passwort teilen",
+  "Share {{count}} password_other": "{{count}} Passwörter teilen",
+  "Sharing folder {{name}}": "Ordner {{name}} wird geteilt",
+  "Start sharing": "Teilen beginnen",
+  "Synchronizing keyring": "Schlüsselring wird synchronisiert",
+  "Synchronizing keys": "Schlüssel werden synchronisiert",
+  "Tagging passwords {{taggedCount}}/{{total}}": "Passwörter {{taggedCount}}/{{total}} werden markiert",
+  "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.",
+  "The folder cannot be shared. Insufficient rights.": "Der Ordner kann nicht geteilt werden. Unzureichende Rechte.",
+  "The key should be a valid openpgp armored key string.": "Der Schlüssel sollte ein gültiger Openpgp armored Schlüsselstring sein.",
+  "The key should be a valid openpgp key.": "Der Schlüssel sollte ein gültiger openpgp-Schlüssel sein.",
+  "The key should be a valid openpgp private key.": "Der Schlüssel sollte ein gültiger privater openpgp-Schlüssel sein.",
+  "The key should be a valid openpgp public key.": "Der Schlüssel sollte ein gültiger öffentlicher openpgp-Schlüssel sein.",
+  "The keys should be an array of valid decrypted openpgp private keys.": "Die Schlüssel sollten ein Array gültiger entschlüsselter Openpgp privater Schlüssel sein.",
+  "The keys should be an array of valid encrypted openpgp private keys.": "Die Schlüssel sollten ein Array gültiger verschlüsselter Openpgp Privatschlüssel sein.",
+  "The keys should be an array of valid openpgp armored key strings.": "Die Schlüssel sollten ein Array gültiger Openpgp armored Schlüsselstrings sein.",
+  "The keys should be an array of valid openpgp private keys.": "Die Schlüssel sollten ein Array gültiger Openpgp Privatschlüssel sein.",
+  "The keys should be an array of valid openpgp public keys.": "Die Schlüssel sollten ein Array gültiger Openpgp öffentlicher Schlüssel sein.",
+  "The keys should be an array.": "Die Schlüssel müssen ein Array sein.",
+  "The message should be a valid openpgp clear text message.": "Die Nachricht sollte eine gültige OpenPGP-Klartextnachricht sein.",
+  "The message should be a valid openpgp message.": "Die Nachricht sollte eine gültige Openpgp-Nachricht sein.",
+  "The message should be of type string.": "Die Nachricht sollte vom Typ String sein.",
+  "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.",
+  "The private key should not be expired.": "Der private Schlüssel sollte nicht abgelaufen sein.",
+  "The private key should not be revoked.": "Der private Schlüssel sollte nicht widerrufen werden.",
+  "The private key should not have an expiry date.": "Der private Schlüssel sollte kein Ablaufdatum haben.",
+  "The private key should use a supported algorithm: RSA, ECDSA OR EDDSA.": "Der private Schlüssel sollte einen unterstützten Algorithmus verwenden: RSA, ECDSA oder EDDSA.",
+  "The server key cannot be parsed.": "Der Server-Schlüssel kann nicht geparst werden.",
+  "The server key has changed.": "Der Serverschlü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",
+  "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.",
+  "Unable to retrieve the active tab info.": "Aktive Tab-Informationen können nicht abgerufen werden.",
+  "Updating group": "Gruppe wird aktualisiert",
+  "Updating group ...": "Gruppe wird aktualisiert ...",
+  "Updating password": "Passwort wird aktualisiert",
+  "Updating resource": "Ressource wird aktualisiert",
+  "Updating users' key...": "Aktualisiere Benutzer-Schlüssel..."
+}