passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/model/entity/accountRecovery/accountRecoveryOrganizationPolicyEntity.test.js

@@ -0,0 +1,179 @@
+/**
+ * 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.6.0
+ */
+
+import each from "jest-each";
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
+import EntityValidationError from "passbolt-styleguide/src/shared/models/entity/abstract/entityValidationError";
+import AccountRecoveryOrganizationPolicyEntity from "./accountRecoveryOrganizationPolicyEntity";
+import {
+  createDisabledAccountRecoveryOrganizationPolicyDto,
+  createDisabledPreviouslyEnabledAccountRecoveryOrganizationPolicyDto,
+  createEnabledAccountRecoveryOrganizationPolicyDto,
+  createRotateKeyAccountRecoveryOrganizationPolicyDto,
+  disabledAccountRecoveryOrganizationPolicyDto,
+  disabledPreviouslyEnabledAccountRecoveryOrganizationPolicyDto,
+  enabledAccountRecoveryOrganizationPolicyDto, rotateKeyAccountRecoveryOrganizationPolicyDto
+} from "./accountRecoveryOrganizationPolicyEntity.test.data";
+import {users} from "passbolt-styleguide/src/shared/models/entity/user/userEntity.test.data";
+import {pgpKeys} from "../../../../../../test/fixtures/pgpKeys/keys";
+
+describe("AccountRecoveryOrganizationPolicy entity", () => {
+  it("schema must validate", () => {
+    EntitySchema.validateSchema(AccountRecoveryOrganizationPolicyEntity.ENTITY_NAME, AccountRecoveryOrganizationPolicyEntity.getSchema());
+  });
+
+  each([
+    {scenario: "Create disabled policy", dto: createDisabledAccountRecoveryOrganizationPolicyDto()},
+    {scenario: "Read disabled policy", dto: disabledAccountRecoveryOrganizationPolicyDto()},
+    {scenario: "Create enabled policy", dto: createEnabledAccountRecoveryOrganizationPolicyDto()},
+    {scenario: "Read enabled policy", dto: enabledAccountRecoveryOrganizationPolicyDto()},
+    {scenario: "Create disabled policy previously enabled", dto: createDisabledPreviouslyEnabledAccountRecoveryOrganizationPolicyDto()},
+    {scenario: "Read disabled policy previously enabled", dto: disabledPreviouslyEnabledAccountRecoveryOrganizationPolicyDto()},
+    {scenario: "Create rotate key policy", dto: createRotateKeyAccountRecoveryOrganizationPolicyDto()},
+    {scenario: "Read rotate key policy", dto: rotateKeyAccountRecoveryOrganizationPolicyDto()},
+  ]).describe("constructor works with data", _props => {
+    it(`it supports scenario ${_props.scenario}`, () => {
+      expect.assertions(1);
+      let entity;
+
+      try {
+        entity = new AccountRecoveryOrganizationPolicyEntity(_props.dto);
+      } catch (error) {
+        expect(error.details).toBe({});
+      }
+      expect(entity.toJSON()).toEqual(_props.dto);
+    });
+  });
+
+  it("constructor returns validation error if dto required fields are missing", () => {
+    try {
+      new AccountRecoveryOrganizationPolicyEntity({});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect(error instanceof EntityValidationError).toBe(true);
+      expect(error.hasError('policy', 'required')).toBe(true);
+    }
+  });
+
+  it("constructor returns validation error if dto fields are invalid", () => {
+    try {
+      new AccountRecoveryOrganizationPolicyEntity({'id': 'not-valid-uuid'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('id', 'format')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPolicyEntity({'policy': 'not-valid-policy'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('policy', 'enum')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPolicyEntity({'created_by': 'not-valid-uuid'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('created_by', 'format')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPolicyEntity({'modified_by': 'not-valid-uuid'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('modified_by', 'format')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPolicyEntity({'created': 'not-valid-date'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('created', 'format')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPolicyEntity({'modified': 'not-valid-date'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('modified', 'format')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPolicyEntity({'public_key_id': 'not-valid-uuid'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('public_key_id', 'type')).toBe(true);
+    }
+  });
+
+  describe("AccountRecoveryOrganizationPolicy assertValidCreatorGpgkey", () => {
+    it("should not validate the entity if creator is missing", async() => {
+      const dto = disabledAccountRecoveryOrganizationPolicyDto({creator: null});
+      const entity = new AccountRecoveryOrganizationPolicyEntity(dto);
+      expect.assertions(1);
+      try {
+        await AccountRecoveryOrganizationPolicyEntity.assertValidCreatorGpgkey(entity);
+      } catch (e) {
+        expect(e).toStrictEqual(new EntityValidationError('AccountRecoveryOrganizationPolicyEntity assertValidCreatorGpgkey expects a creator to be defined.'));
+      }
+    });
+
+    it("should not validate the entity if gpgkey is missing", async() => {
+      const dto = disabledAccountRecoveryOrganizationPolicyDto();
+      delete dto.creator.gpgkey;
+      const entity = new AccountRecoveryOrganizationPolicyEntity(dto);
+      expect.assertions(1);
+      try {
+        await AccountRecoveryOrganizationPolicyEntity.assertValidCreatorGpgkey(entity);
+      } catch (e) {
+        expect(e).toStrictEqual(new EntityValidationError('AccountRecoveryOrganizationPolicyEntity assertValidCreatorGpgkey expects a creator.gpgkey to be defined.'));
+      }
+    });
+
+    it("should not validate the entity if creator id and gpgkey.user_id are not matching", async() => {
+      const dto = disabledAccountRecoveryOrganizationPolicyDto();
+      dto.creator.id = users.ada.id;
+      dto.creator.gpgkey.user_id = users.admin.id;
+      const entity = new AccountRecoveryOrganizationPolicyEntity(dto);
+      expect.assertions(1);
+      try {
+        await AccountRecoveryOrganizationPolicyEntity.assertValidCreatorGpgkey(entity);
+      } catch (e) {
+        expect(e).toStrictEqual(new EntityValidationError("AccountRecoveryOrganizationPolicyEntity assertValidCreatorGpgkey expects the creator's id to match the gpgkey.user_id."));
+      }
+    });
+
+    it("should not validate the entity if fingerprint is not matching the gpgkey fingerprint", async() => {
+      const dto = disabledAccountRecoveryOrganizationPolicyDto();
+      dto.creator.gpgkey.fingerprint = pgpKeys.account_recovery_organization.fingerprint;
+      dto.creator.gpgkey.armored_key = pgpKeys.ada.public;
+      const entity = new AccountRecoveryOrganizationPolicyEntity(dto);
+      expect.assertions(1);
+      try {
+        await AccountRecoveryOrganizationPolicyEntity.assertValidCreatorGpgkey(entity);
+      } catch (e) {
+        expect(e).toStrictEqual(new EntityValidationError("AccountRecoveryOrganizationPolicyEntity assertValidCreatorGpgkey expects the gpgkey armoredKey's fingerprint to match the given fingerprint."));
+      }
+    });
+
+    it("should validate the entity if user_ids are mathching and if fingerprints are matching", async() => {
+      const dto = disabledAccountRecoveryOrganizationPolicyDto();
+      const entity = new AccountRecoveryOrganizationPolicyEntity(dto);
+      expect.assertions(1);
+      const promise = AccountRecoveryOrganizationPolicyEntity.assertValidCreatorGpgkey(entity);
+      await expect(promise).resolves.toBeUndefined();
+    });
+  });
+});

package/src/all/background_page/model/entity/accountRecovery/accountRecoveryOrganizationPublicKeyEntity.js

@@ -0,0 +1,175 @@
+/**
+ * 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.6.0
+ */
+import Entity from "passbolt-styleguide/src/shared/models/entity/abstract/entity";
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
+
+const ENTITY_NAME = 'AccountRecoveryOrganizationPublicKey';
+const FINGERPRINT_LENGTH = 40;
+
+class AccountRecoveryOrganizationPublicKeyEntity extends Entity {
+  /**
+   * @inheritDoc
+   * Note: Sanitize the DTO fingerprint by converting it to uppercase.
+   */
+  constructor(accountRecoveryOrganizationPublicKeyDto, options = {}) {
+    accountRecoveryOrganizationPublicKeyDto = AccountRecoveryOrganizationPublicKeyEntity.sanitizeDto(accountRecoveryOrganizationPublicKeyDto);
+
+    super(EntitySchema.validate(
+      AccountRecoveryOrganizationPublicKeyEntity.ENTITY_NAME,
+      accountRecoveryOrganizationPublicKeyDto,
+      AccountRecoveryOrganizationPublicKeyEntity.getSchema()
+    ), options);
+  }
+
+  /**
+   * Get resource entity schema
+   * @returns {Object} schema
+   */
+  static getSchema() {
+    return {
+      "type": "object",
+      "required": [
+        "armored_key"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "format": "uuid"
+        },
+        "armored_key": {
+          "type": "string",
+        },
+        "fingerprint": {
+          "anyOf": [{
+            "type": "string",
+            "length": FINGERPRINT_LENGTH
+          }, {
+            "type": "null"
+          }]
+        },
+        "created": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "modified": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "created_by": {
+          "type": "string",
+          "format": "uuid"
+        },
+        "modified_by": {
+          "type": "string",
+          "format": "uuid"
+        },
+        "deleted": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    };
+  }
+
+  /*
+   * ==================================================
+   * Sanitization
+   * ==================================================
+   */
+  /**
+   * Sanitize account recovery organization public key dto.
+   * @param {object} dto The dto to sanitiaze
+   * @returns {object}
+   */
+  static sanitizeDto(dto) {
+    dto = Object.assign({}, dto); // shallow clone.
+    if (dto.fingerprint) {
+      dto.fingerprint = this.sanitizeFingerPrint(dto.fingerprint);
+    }
+    return dto;
+  }
+
+  /**
+   * Sanitize a fingerprint.
+   * @param {string} fingerprint The fingerprint to sanitize.
+   * @return {string}
+   */
+  static sanitizeFingerPrint(fingerprint = "") {
+    return fingerprint.toUpperCase();
+  }
+
+  /*
+   * ==================================================
+   * Serialization
+   * ==================================================
+   */
+  /**
+   * Return a DTO ready to be sent to API
+   *
+   * @param {object} [contain] optional
+   * @returns {object}
+   */
+  toDto() {
+    return Object.assign({}, this._props);
+  }
+
+  /**
+   * Customizes JSON stringification behavior
+   * @returns {*}
+   */
+  toJSON() {
+    return this.toDto();
+  }
+
+  /*
+   * ==================================================
+   * Dynamic properties getters
+   * ==================================================
+   */
+  get armoredKey() {
+    return this._props.armored_key;
+  }
+
+  /**
+   * Get the public key fingerprint.
+   * @returns {string}
+   */
+  get fingerprint() {
+    return this._props.fingerprint;
+  }
+
+  /**
+   * Set the public key fingerprint.
+   * @param {string} fingerprint The fingerprint to set.
+   */
+  set fingerprint(fingerprint) {
+    EntitySchema.validateProp("fingerprint", fingerprint, AccountRecoveryOrganizationPublicKeyEntity.getSchema().properties.fingerprint);
+    this._props.fingerprint = AccountRecoveryOrganizationPublicKeyEntity.sanitizeFingerPrint(fingerprint);
+  }
+
+  /*
+   * ==================================================
+   * Static properties getters
+   * ==================================================
+   */
+  /**
+   * ResourceEntity.ENTITY_NAME
+   * @returns {string}
+   */
+  static get ENTITY_NAME() {
+    return ENTITY_NAME;
+  }
+}
+
+export default AccountRecoveryOrganizationPublicKeyEntity;

package/src/all/background_page/model/entity/accountRecovery/accountRecoveryOrganizationPublicKeyEntity.test.data.js

@@ -0,0 +1,85 @@
+/**
+ * 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.6.0
+ */
+
+import {v4 as uuidv4} from "uuid";
+import {pgpKeys} from "../../../../../../test/fixtures/pgpKeys/keys";
+
+// Create account recovery organization public key
+
+export const createAccountRecoveryOrganizationPublicKeyDto = data => {
+  const defaultData = {
+    armored_key: pgpKeys.account_recovery_organization.public,
+    fingerprint: pgpKeys.account_recovery_organization.fingerprint,
+  };
+
+  return Object.assign(defaultData, data || {});
+};
+
+export const defaultAccountRecoveryOrganizationPublicKeyDto = data => {
+  const defaultData = createAccountRecoveryOrganizationPublicKeyDto({
+    id: uuidv4(),
+    created_by: uuidv4(),
+    modified_by: uuidv4(),
+    created: "2022-01-13T13:19:04.661Z",
+    modified: "2022-01-13T13:19:04.661Z"
+  });
+
+  return Object.assign(defaultData, data || {});
+};
+
+// Create account recovery organization public key with alternative key
+
+export const createAlternativeAccountRecoveryOrganizationPublicKeyDto = data => {
+  const defaultData = {
+    armored_key: pgpKeys.account_recovery_organization_alternative.public,
+    fingerprint: pgpKeys.account_recovery_organization_alternative.fingerprint,
+  };
+
+  return Object.assign(defaultData, data || {});
+};
+
+export const alternativeAccountRecoveryOrganizationPublicKeyDto = data => {
+  const defaultData = createAccountRecoveryOrganizationPublicKeyDto({
+    id: uuidv4(),
+    created_by: uuidv4(),
+    modified_by: uuidv4(),
+    created: "2022-01-13T13:19:04.661Z",
+    modified: "2022-01-13T13:19:04.661Z"
+  });
+
+  return Object.assign(defaultData, data || {});
+};
+
+// Create revoked account recovery organization public key
+
+export const createRevokedAccountRecoveryOrganizationPublicKeyDto = data => {
+  const defaultData = {
+    armored_key: pgpKeys.account_recovery_organization.revoked,
+    fingerprint: pgpKeys.account_recovery_organization.fingerprint,
+  };
+
+  return Object.assign(defaultData, data || {});
+};
+
+export const revokedAccountRecoveryOrganizationPublicKeyDto = data => {
+  const defaultData = createRevokedAccountRecoveryOrganizationPublicKeyDto({
+    id: uuidv4(),
+    created_by: uuidv4(),
+    modified_by: uuidv4(),
+    created: "2022-01-13T13:19:04.661Z",
+    modified: "2022-01-13T13:19:04.661Z"
+  });
+
+  return Object.assign(defaultData, data || {});
+};

package/src/all/background_page/model/entity/accountRecovery/accountRecoveryOrganizationPublicKeyEntity.test.js

@@ -0,0 +1,117 @@
+/**
+ * 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.6.0
+ */
+
+import each from "jest-each";
+import EntitySchema from "passbolt-styleguide/src/shared/models/entity/abstract/entitySchema";
+import EntityValidationError from "passbolt-styleguide/src/shared/models/entity/abstract/entityValidationError";
+import AccountRecoveryOrganizationPublicKeyEntity from "./accountRecoveryOrganizationPublicKeyEntity";
+import {
+  alternativeAccountRecoveryOrganizationPublicKeyDto,
+  createAccountRecoveryOrganizationPublicKeyDto,
+  createAlternativeAccountRecoveryOrganizationPublicKeyDto,
+  createRevokedAccountRecoveryOrganizationPublicKeyDto,
+  defaultAccountRecoveryOrganizationPublicKeyDto,
+  revokedAccountRecoveryOrganizationPublicKeyDto
+} from "./accountRecoveryOrganizationPublicKeyEntity.test.data";
+
+describe("AccountRecoveryOrganizationPublicKey entity", () => {
+  it("schema must validate", () => {
+    EntitySchema.validateSchema(AccountRecoveryOrganizationPublicKeyEntity.ENTITY_NAME, AccountRecoveryOrganizationPublicKeyEntity.getSchema());
+  });
+
+  each([
+    {scenario: "Create", dto: createAccountRecoveryOrganizationPublicKeyDto()},
+    {scenario: "Read", dto: defaultAccountRecoveryOrganizationPublicKeyDto()},
+    {scenario: "Create revoked", dto: createRevokedAccountRecoveryOrganizationPublicKeyDto()},
+    {scenario: "Read revoked", dto: revokedAccountRecoveryOrganizationPublicKeyDto()},
+    {scenario: "Create alternative", dto: createAlternativeAccountRecoveryOrganizationPublicKeyDto()},
+    {scenario: "Read alternative", dto: alternativeAccountRecoveryOrganizationPublicKeyDto()},
+  ]).describe("constructor works with data", _props => {
+    it(`it supports scenario ${_props.scenario}`, () => {
+      const entity = new AccountRecoveryOrganizationPublicKeyEntity(_props.dto);
+      expect(entity.toJSON()).toEqual(_props.dto);
+    });
+  });
+
+  it("constructor returns validation error if dto required fields are missing", () => {
+    try {
+      new AccountRecoveryOrganizationPublicKeyEntity({});
+    } catch (error) {
+      expect(error instanceof EntityValidationError).toBe(true);
+      expect(error.details).toEqual({
+        armored_key: {required: 'The armored_key is required.'},
+      });
+    }
+  });
+
+  it("constructor returns validation error if dto fields are invalid", () => {
+    try {
+      new AccountRecoveryOrganizationPublicKeyEntity({'id': 'not-valid-uuid'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('id', 'format')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPublicKeyEntity({'armored_key': 42});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('armored_key', 'type')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPublicKeyEntity({'fingerprint': 'not-valid-fingerprint'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('fingerprint', 'type')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPublicKeyEntity({'created': 'not-valid-date'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('created', 'format')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPublicKeyEntity({'modified': 'not-valid-date'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('modified', 'format')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPublicKeyEntity({'created_by': 'not-valid-uuid'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('created_by', 'format')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPublicKeyEntity({'modified_by': 'not-valid-uuid'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('modified_by', 'format')).toBe(true);
+    }
+    try {
+      new AccountRecoveryOrganizationPublicKeyEntity({'deleted': 'not-valid-date'});
+      expect(false).toBe(true);
+    } catch (error) {
+      expect((error instanceof EntityValidationError)).toBe(true);
+      expect(error.hasError('deleted', 'format')).toBe(true);
+    }
+  });
+});
+