passbolt-styleguide 3.8.4 → 3.9.0-alpha2

package/src/shared/services/api/secrets/pownedService.test.js

@@ -0,0 +1,63 @@
+/**
+ * Passbolt ~ Open source password manager for teams
+ * Copyright (c) 2021 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) 2021 Passbolt SA (https://www.passbolt.com)
+ * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
+ * @link          https://www.passbolt.com Passbolt(tm)
+ * @since         3.9.0
+ *
+ */
+
+import PownedService from "./pownedService";
+
+describe('PownedService', () => {
+  let port, pownedService;
+
+  beforeEach(() => {
+    port = {
+      request: jest.fn()
+    };
+    pownedService = new PownedService(port);
+  });
+
+  describe('evaluateSecret', () => {
+    it('should returns inDictionary=false and isPwnedServiceAvailable=true for secrets of length 8 or more', async() => {
+      expect.assertions(1);
+
+      port.request.mockResolvedValue(0);
+      const result = await pownedService.evaluateSecret('password123');
+      expect(result).toEqual({inDictionary: false, isPwnedServiceAvailable: true});
+    });
+
+    it('should returns inDictionary=true and isPwnedServiceAvailable=true for secrets of length less than 8', async() => {
+      expect.assertions(1);
+
+      const result = await pownedService.evaluateSecret('pass');
+      expect(result).toEqual({inDictionary: true, isPwnedServiceAvailable: true});
+    });
+
+    it('should returns inDictionary=false and isPwnedServiceAvailable=false when checkIfPasswordPowned throws an error', async() => {
+      expect.assertions(1);
+
+      port.request.mockRejectedValue(new Error());
+      const result = await pownedService.evaluateSecret('password123');
+      expect(result).toEqual({inDictionary: false, isPwnedServiceAvailable: false});
+    });
+  });
+
+  describe('checkIfPasswordPowned method', () => {
+    it('sould calls port.request with the correct arguments and returns the response', async() => {
+      expect.assertions(2);
+
+      port.request.mockResolvedValue(1);
+      const result = await pownedService.checkIfPasswordPowned('password123');
+      expect(port.request).toHaveBeenCalledWith('passbolt.secrets.powned-password', 'password123');
+      expect(result).toBe(true);
+    });
+  });
+});

package/src/shared/services/api/selfRegistration/selfRegistrationService.js

@@ -0,0 +1,64 @@
+/**
+ * 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.3
+ */
+
+import {ApiClient} from "../../../lib/apiClient/apiClient";
+
+const SELF_REGISTRATION_SETTINGS_RESOURCE_NAME = "self-registration/settings";
+
+/**
+ * Model related to the Self registration settings API
+ */
+class SelfRegistrationService {
+  /**
+   * Constructor
+   *
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    apiClientOptions.setResourceName(SELF_REGISTRATION_SETTINGS_RESOURCE_NAME);
+    this.apiClient = new ApiClient(apiClientOptions);
+  }
+
+  /**
+   * Find the self registration settings using Passbolt API
+   *
+   * @return {Promise<SelfRegistrationDto>}
+   */
+  async find() {
+    const selfRegistrationSettings = await this.apiClient.findAll();
+    const settings = selfRegistrationSettings?.body;
+    return settings;
+  }
+
+  /**
+   * save a the self registration settings using Passbolt API
+   * @param  {SelfRegistrationDto} dto
+   * @return {Promise<SelfRegistrationDto>}
+   */
+  async save(dto) {
+    await this.apiClient.create(dto);
+  }
+
+  /**
+   * remove settings for self registration using Passbolt API
+   * @param  {String} id
+   */
+  async delete(id) {
+    await this.apiClient.delete(id);
+  }
+}
+
+export default SelfRegistrationService;
+

package/src/shared/services/api/user/UserService.js

@@ -0,0 +1,45 @@
+/**
+ * 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 {ApiClient} from "../../../lib/apiClient/apiClient";
+
+const USER_DIRECTORY_RESOURCE_NAME = "users";
+
+/**
+ * Model related to the user service
+ */
+class UserService {
+  /**
+   * Constructor
+   *
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    this.apiClientOptions = apiClientOptions;
+    apiClientOptions.setResourceName(`${USER_DIRECTORY_RESOURCE_NAME}`);
+  }
+
+  /**
+   * Whenever the users is requested.
+   * @return {Promise<object>}
+   */
+  async findAll() {
+    const apiClient = new ApiClient(this.apiClientOptions);
+    return apiClient.findAll();
+  }
+}
+
+export default UserService;
+

package/src/shared/services/api/userDirectory/UserDirectoryService.js

@@ -0,0 +1,108 @@
+/**
+ * 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 {ApiClient} from "../../../lib/apiClient/apiClient";
+
+const USER_DIRECTORY_RESOURCE_NAME = "directorysync";
+
+/**
+ * Model related to the user directory service settings
+ */
+class UserDirectoryService {
+  /**
+   * Constructor
+   *
+   * @param {ApiClientOptions} apiClientOptions
+   * @public
+   */
+  constructor(apiClientOptions) {
+    this.apiClientOptions = apiClientOptions;
+    apiClientOptions.setResourceName(`${USER_DIRECTORY_RESOURCE_NAME}`);
+  }
+
+  /**
+   * Find the user directory setting using Passbolt API
+   *
+   * @return {Promise<Array<SmtpSettingsDto>>|null>}
+   */
+  async findAll() {
+    this.apiClientOptions.setResourceName(`${USER_DIRECTORY_RESOURCE_NAME}/settings`);
+    const apiClient = new ApiClient(this.apiClientOptions);
+    return (await apiClient.findAll()).body;
+  }
+
+  /**
+   * update the given user directory settings using Passbolt API
+   * @param {UserDirectoryDto} UserDirectoryDto
+   * @returns {Promise<UserDirectoryDto>}
+   */
+  async update(userDirectoryDto) {
+    this.apiClientOptions.setResourceName(`${USER_DIRECTORY_RESOURCE_NAME}`);
+    const apiClient = new ApiClient(this.apiClientOptions);
+    return (await apiClient.update('settings', userDirectoryDto)).body;
+  }
+
+  /**
+   * delete the given user directory settings using Passbolt API
+   */
+  async delete() {
+    this.apiClientOptions.setResourceName(`${USER_DIRECTORY_RESOURCE_NAME}`);
+    const apiClient = new ApiClient(this.apiClientOptions);
+    return apiClient.delete("settings");
+  }
+
+
+  /**
+   * Whenever the test users directory is requested.
+   * @return {Promise<object>}
+   */
+  async test(usersDirectory) {
+    this.apiClientOptions.setResourceName(`${USER_DIRECTORY_RESOURCE_NAME}/settings/test`);
+    const apiClient = new ApiClient(this.apiClientOptions);
+    return apiClient.create(usersDirectory);
+  }
+
+  /**
+   * Whenever the simulate synchronize users directory is requested.
+   * @return {Promise<object>}
+   */
+  async simulate() {
+    this.apiClientOptions.setResourceName(`${USER_DIRECTORY_RESOURCE_NAME}`);
+    const apiClient = new ApiClient(this.apiClientOptions);
+    return (await apiClient.get("synchronize/dry-run")).body;
+  }
+
+  /**
+   * Whenever the simulate synchronize users directory is requested.
+   * @return {Promise<object>}
+   */
+  async synchronize() {
+    this.apiClientOptions.setResourceName(`${USER_DIRECTORY_RESOURCE_NAME}/synchronize`);
+    const apiClient = new ApiClient(this.apiClientOptions);
+    return (await apiClient.create({})).body;
+  }
+
+
+  /**
+   * Whenever the users is requested.
+   * @return {Promise<object>}
+   */
+  async findUsers() {
+    this.apiClientOptions.setResourceName(`${USER_DIRECTORY_RESOURCE_NAME}/users`);
+    const apiClient = new ApiClient(this.apiClientOptions);
+    return apiClient.findAll();
+  }
+}
+
+export default UserDirectoryService;

package/src/shared/services/forms/Mfa/MfaFormService.js

@@ -0,0 +1,195 @@
+
+/**
+ * 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 XRegExp from 'xregexp';
+
+/**
+ * Model related to the MFA form settings
+ */
+class MfaFormService {
+  /**
+   * Constructor
+   *
+   * @param {context} context
+   * @public
+   */
+  constructor(context, translation) {
+    this.context = context;
+    this.translation = translation;
+  }
+
+  /**
+   * getInstance for singleton pattern
+   * @param {context} context
+   * @public
+   */
+  static getInstance(context, translation) {
+    if (!this.instance) {
+      this.instance = new MfaFormService(context, translation);
+    }
+    return this.instance;
+  }
+
+  /**
+   * killInstance singleton
+   * @param {context} context
+   * @public
+   */
+  static killInstance() {
+    this.instance = null;
+  }
+
+  /**
+   * The input validation for forms
+   * @param {string} inputValue
+   * @param {string} regex
+   * @param {Object} messages
+   *
+   * @return {Promise<Array<MFADto>>|null>}
+   */
+  validateInput(inputValue, regex, messages) {
+    const value = inputValue.trim();
+    if (!value.length) {
+      return this.translation(messages.required);
+    } else if (!XRegExp(regex).test(value)) {
+      return this.translation(messages.regex);
+    }
+    return null;
+  }
+
+  /**
+   * Validate the duo yubikey client identifier input.
+   * @returns {Promise<void>}
+   */
+  validateYubikeyClientIdentifier(value) {
+    const messages = {required: "A client identifier is required.", regex: "The client identifier should be an integer."};
+    const result = this.validateInput(value, "^[0-9]{1,64}$", messages);
+    this.context.setError("yubikeyClientIdentifierError", result);
+    return result;
+  }
+
+  /**
+   * Validate the duo secret key input.
+   * @returns {Promise<void>}
+   */
+  validateYubikeySecretKey(value) {
+    const messages = {required: "A secret key is required.", regex: "This secret key is not valid."};
+    const result = this.validateInput(value, "^[a-zA-Z0-9\\/=+]{10,128}$", messages);
+    this.context.setError('yubikeySecretKeyError', result);
+    return result;
+  }
+
+  /**
+   * Validate the duo hostname input.
+   * @returns {Promise<void>}
+   */
+  validateDuoHostname(value) {
+    const messages = {required: "A hostname is required.", regex: "This is not a valid hostname."};
+    const result = this.validateInput(value, "^api-[a-fA-F0-9]{8,16}\\.duosecurity\\.com$", messages);
+    this.context.setError("duoHostnameError", result);
+    return result;
+  }
+
+  /**
+   * Validate the duo integration key input.
+   * @returns {Promise<void>}
+   */
+  validateDuoIntegrationKey(value) {
+    const messages = {required: "An integration key is required.", regex: "This is not a valid integration key."};
+    const result = this.validateInput(value, "^[a-zA-Z0-9]{16,32}$", messages);
+    this.context.setError("duoIntegrationKeyError", result);
+    return result;
+  }
+
+  /**
+   * Validate the duo secret key input.
+   * @returns {Promise<void>}
+   */
+  validateDuoSecretKey(value) {
+    const messages = {required: "A secret key is required.", regex: "This is not a valid secret key."};
+    const result = this.validateInput(value, "^[a-zA-Z0-9]{32,128}$", messages);
+    this.context.setError("duoSecretKeyError", result);
+    return result;
+  }
+
+  /**
+   * Validate the duo salt input.
+   * @returns {Promise<void>}
+   */
+  validateDuoSalt(value) {
+    const messages = {required: "A salt is required.", regex: "The salt should be between 40 and 128 characters in length."};
+    const result = this.validateInput(value, "^.{40,128}$", messages);
+    this.context.setError("duoSaltError", result);
+    return result;
+  }
+
+  /**
+   * Validate the Yubikey inputs.
+   * @returns {Promise<void>}
+   */
+  validateYubikeyInputs() {
+    let yubikeyClientIdentifierError = null;
+    let yubikeySecretKeyError = null;
+    const settings = this.context.getSettings();
+    let result = {};
+
+    if (settings.yubikeyToggle) {
+      yubikeyClientIdentifierError = this.validateYubikeyClientIdentifier(settings.yubikeyClientIdentifier);
+      yubikeySecretKeyError = this.validateYubikeySecretKey(settings.yubikeySecretKey);
+      result = {yubikeyClientIdentifierError, yubikeySecretKeyError};
+    }
+    return  result;
+  }
+
+  /**
+   * Validate the duo inputq.
+   * @returns {Promise<void>}
+   */
+  validateDuoInputs() {
+    let duoHostnameError = null;
+    let duoIntegrationKeyError = null;
+    let duoSaltError = null;
+    let duoSecretKeyError = null;
+    let result = {};
+
+    const settings = this.context.getSettings();
+    if (settings.duoToggle) {
+      duoHostnameError = this.validateDuoHostname(settings.duoHostname),
+      duoIntegrationKeyError = this.validateDuoIntegrationKey(settings.duoIntegrationKey),
+      duoSecretKeyError = this.validateDuoSecretKey(settings.duoSecretKey);
+      duoSaltError = this.validateDuoSalt(settings.duoSalt),
+
+      result =  {duoHostnameError, duoIntegrationKeyError, duoSaltError, duoSecretKeyError};
+    }
+    return result;
+  }
+
+  /**
+   * Validate the form.
+   * @returns {Promise<boolean>}
+   */
+  async validate() {
+    // Validate the form inputs.
+    const validation = Object.assign(this.validateYubikeyInputs(), this.validateDuoInputs());
+
+    await this.context.setErrors(validation);
+    //Check if we have errors
+    return Object.values(validation).filter(x => x).length === 0;
+  }
+}
+
+export default MfaFormService;
+
+