passbolt-browser-extension 3.0.6 → 4.6.2

package/src/all/background_page/model/import/resources/resourcesCsvImportParser.test.js

@@ -10,47 +10,53 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-import Validator from "validator";
-import PapaParse from "papaparse";
 import fs from "fs";
 
-import {FileFormatError} from "../../../error/fileFormatError";
-import {ResourcesCsvImportParser} from "./resourcesCsvImportParser";
+import FileFormatError from "../../../error/fileFormatError";
+import ResourcesCsvImportParser from "./resourcesCsvImportParser";
 
-import {Csv1PasswordRowParser} from "./csvRowParser/csv1PasswordRowParser";
-import {CsvKdbxRowParser} from "./csvRowParser/csvKdbxRowParser";
-import {CsvLastPassRowParser} from "./csvRowParser/csvLastPassRowParser";
+import Csv1PasswordRowParser from "./csvRowParser/csv1PasswordRowParser";
+import CsvKdbxRowParser from "./csvRowParser/csvKdbxRowParser";
+import CsvLastPassRowParser from "./csvRowParser/csvLastPassRowParser";
 
-import {ExternalResourceEntity} from "../../entity/resource/external/externalResourceEntity";
-import {ImportResourcesFileEntity} from "../../entity/import/importResourcesFileEntity";
-import {EntityValidationError} from "../../entity/abstract/entityValidationError";
-import {ImportError} from "../../../error/importError";
-
-// Reset the modules before each test.
-beforeEach(() => {
-  window.Validator = Validator;
-  window.PapaParse = PapaParse;
-  jest.resetModules();
-});
+import ExternalResourceEntity from "../../entity/resource/external/externalResourceEntity";
+import ImportResourcesFileEntity from "../../entity/import/importResourcesFileEntity";
+import EntityValidationError from "passbolt-styleguide/src/shared/models/entity/abstract/entityValidationError";
+import ImportError from "../../../error/importError";
+import BinaryConvert from "../../../utils/format/binaryConvert";
+import CsvChromiumRowParser from "./csvRowParser/csvChromiumRowParser";
+import CsvBitWardenRowParser from "./csvRowParser/csvBitWardenRowParser";
+import CsvSafariRowParser from "./csvRowParser/csvSafariRowParser";
+import CsvDashlaneRowParser from "./csvRowParser/csvDashlaneRowParser";
+import CsvMozillaPlatformRowParser from "./csvRowParser/csvMozillaPlatformRowParser";
+import CsvNordpassRowParser from "./csvRowParser/csvNordpassRowParser";
+import CsvLogMeOnceRowParser from "./csvRowParser/csvLogMeOnceRowParser";
 
 describe("ResourcesCsvImportParser", () => {
   it("should be aware of the supported row parsers", () => {
-    expect(ResourcesCsvImportParser.register).toHaveLength(3);
+    expect(ResourcesCsvImportParser.register).toHaveLength(10);
     const supportedRowParsers = [
       Csv1PasswordRowParser,
       CsvKdbxRowParser,
-      CsvLastPassRowParser
+      CsvLastPassRowParser,
+      CsvChromiumRowParser,
+      CsvBitWardenRowParser,
+      CsvSafariRowParser,
+      CsvDashlaneRowParser,
+      CsvMozillaPlatformRowParser,
+      CsvNordpassRowParser,
+      CsvLogMeOnceRowParser
     ];
     expect(ResourcesCsvImportParser.register).toEqual(expect.arrayContaining(supportedRowParsers));
   });
 
   it("should read import file encoded in base64", () => {
     const csv = "Title,Username,URL,Password,Notes,Group\n" +
-      "Password 1,Username 1,https://url1.com,Password 1,Description 1,\n"
+      "Password 1,Username 1,https://url1.com,Password 1,Description 1,\n";
     const importDto = {
       "ref": "import-ref",
       "file_type": "csv",
-      "file": btoa(csv)
+      "file": btoa(BinaryConvert.toBinary(csv))
     };
     const importEntity = new ImportResourcesFileEntity(importDto);
     const importer = new ResourcesCsvImportParser(importEntity);
@@ -65,25 +71,25 @@ describe("ResourcesCsvImportParser", () => {
     };
     expect(data).toEqual(expect.arrayContaining([csvRow]));
     const csvFields = ['Title', 'Username', 'URL', 'Password', 'Notes', 'Group'];
-    expect(fields).toEqual(expect.arrayContaining(csvFields))
+    expect(fields).toEqual(expect.arrayContaining(csvFields));
   });
 
   it("should determine row parser to use", () => {
     const csv = "Title,Username,URL,Password,Notes,Group\n" +
-      "Password 1,Username 1,https://url1.com,Password 1,Description 1,\n"
+      "Password 1,Username 1,https://url1.com,Password 1,Description 1,\n";
     const importDto = {
       "ref": "import-ref",
       "file_type": "csv",
-      "file": btoa(csv)
+      "file": btoa(BinaryConvert.toBinary(csv))
     };
     const importEntity = new ImportResourcesFileEntity(importDto);
     const importer = new ResourcesCsvImportParser(importEntity);
-    const {data, fields} = importer.readCsv();
+    const {fields} = importer.readCsv();
     const RowParser = importer.getRowParser(fields);
     expect(RowParser).toEqual(CsvKdbxRowParser);
   });
 
-  it("should throw an error if no row parser is identified", async () => {
+  it("should throw an error if no row parser is identified", async() => {
     const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-not-protected.kdbx", {encoding: 'base64'});
     const importDto = {
       "ref": "import-ref",
@@ -120,14 +126,14 @@ describe("ResourcesCsvImportParser", () => {
     }, data);
   }
 
-  it("should parse resources", async () => {
+  it("should parse resources", async() => {
     const csv = "Title,Username,URL,Password,Notes,Group\n" +
       "Password 1,username1,https://url1.com,Secret 1,Description 1,\n" +
       "Password 2,username2,https://url2.com,Secret 2,Description 2,\n";
     const importDto = {
       "ref": "import-ref",
       "file_type": "csv",
-      "file": btoa(csv)
+      "file": btoa(BinaryConvert.toBinary(csv))
     };
     const importEntity = new ImportResourcesFileEntity(importDto);
     const importer = new ResourcesCsvImportParser(importEntity);
@@ -140,7 +146,7 @@ describe("ResourcesCsvImportParser", () => {
     expect(importEntity.importResources.toJSON()).toEqual(expect.arrayContaining([resource2Dto]));
   });
 
-  it("should parse resources and folders", async () => {
+  it("should parse resources and folders", async() => {
     const csv = "Title,Username,URL,Password,Notes,Group\n" +
       // The algorithm should create the missing folders in the path if they have not been created yet, Folder 1 here
       "Password 1,username1,https://url1.com,Secret 1,Description 1,Folder 1/Folder 2\n" +
@@ -153,7 +159,7 @@ describe("ResourcesCsvImportParser", () => {
     const importDto = {
       "ref": "import-ref",
       "file_type": "csv",
-      "file": btoa(csv)
+      "file": btoa(BinaryConvert.toBinary(csv))
     };
     const importEntity = new ImportResourcesFileEntity(importDto);
     const importer = new ResourcesCsvImportParser(importEntity);
@@ -188,13 +194,13 @@ describe("ResourcesCsvImportParser", () => {
     expect(importEntity.importFolders.toJSON()).toEqual(expect.arrayContaining([folder1Dto]));
   });
 
-  it("should be able to parse an empty row", async () => {
+  it("should be able to parse an empty row", async() => {
     const csv = "Title,Username,URL,Password,Notes,Group\n" +
       ",,,,,\n";
     const importDto = {
       "ref": "import-ref",
       "file_type": "csv",
-      "file": btoa(csv)
+      "file": btoa(BinaryConvert.toBinary(csv))
     };
     const importEntity = new ImportResourcesFileEntity(importDto);
     const importer = new ResourcesCsvImportParser(importEntity);
@@ -209,14 +215,14 @@ describe("ResourcesCsvImportParser", () => {
     expect(importEntity.importResources.toJSON()).toEqual(expect.arrayContaining([expectedResourceDto]));
   });
 
-  it("should catch and keep a reference of import resource entity validation error", async () => {
+  it("should catch and keep a reference of import resource entity validation error", async() => {
     const name = "too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name";
     const csv = "Title,Username,URL,Password,Notes,Group\n" +
       `${name},,,,,\n`;
     const importDto = {
       "ref": "import-ref",
       "file_type": "csv",
-      "file": btoa(csv)
+      "file": btoa(BinaryConvert.toBinary(csv))
     };
     const importEntity = new ImportResourcesFileEntity(importDto);
     const importer = new ResourcesCsvImportParser(importEntity);
@@ -224,7 +230,7 @@ describe("ResourcesCsvImportParser", () => {
 
     expect(importEntity.importResources.items).toHaveLength(0);
     expect(importEntity.importResourcesErrors).toHaveLength(1);
-    let error = importEntity.importResourcesErrors[0];
+    const error = importEntity.importResourcesErrors[0];
     expect(error).toBeInstanceOf(ImportError);
     expect(error.sourceError).toBeInstanceOf(EntityValidationError);
     expect(error.sourceError.details).toHaveProperty("name");
@@ -232,14 +238,14 @@ describe("ResourcesCsvImportParser", () => {
     expect(error.data.Title).toEqual(resourceName);
   });
 
-  it("should catch and keep a reference of import folder entity validation error", async () => {
-    const path = "too-long-folder-name-too-long-folder-name-too-long-folder-name-too-long-folder-name";
+  it("should catch and keep a reference of import folder entity validation error", async() => {
+    const path = "too-long-folder-name-too-long-folder-name-too-long-folder-name-too-long-folder-nametoo-long-folder-name-too-long-folder-name-too-long-folder-name-too-long-folder-nametoo-long-folder-name-too-long-folder-name-too-long-folder-name-too-long-folder-nametoo-long-folder-name-too-long-folder-name-too-long-folder-name-too-long-folder-name";
     const csv = "Title,Username,URL,Password,Notes,Group\n" +
       `,,,,,${path}\n`;
     const importDto = {
       "ref": "import-ref",
       "file_type": "csv",
-      "file": btoa(csv)
+      "file": btoa(BinaryConvert.toBinary(csv))
     };
     const importEntity = new ImportResourcesFileEntity(importDto);
     const importer = new ResourcesCsvImportParser(importEntity);
@@ -251,7 +257,7 @@ describe("ResourcesCsvImportParser", () => {
 
     expect(importEntity.importFolders.items).toHaveLength(1); // The folder relative to the import reference
     expect(importEntity.importFoldersErrors).toHaveLength(1);
-    let error = importEntity.importFoldersErrors[0];
+    const error = importEntity.importFoldersErrors[0];
     expect(error).toBeInstanceOf(ImportError);
     expect(error.sourceError).toBeInstanceOf(EntityValidationError);
     expect(error.sourceError.details).toHaveProperty("name");

package/src/all/background_page/model/import/resources/resourcesKdbxImportParser.js

@@ -10,12 +10,15 @@
  * @license       https://opensource.org/licenses/AGPL-3.0 AGPL License
  * @link          https://www.passbolt.com Passbolt(tm)
  */
-const ByteUtils = require("kdbxweb/lib/utils/byte-utils");
-const {ImportError} = require("../../../error/importError");
-const {ExternalFoldersCollection} = require("../../entity/folder/external/externalFoldersCollection");
-const {ExternalResourcesCollection} = require("../../entity/resource/external/externalResourcesCollection");
-const {ExternalFolderEntity} = require("../../entity/folder/external/externalFolderEntity");
-const {ExternalResourceEntity} = require("../../entity/resource/external/externalResourceEntity");
+import ExternalFolderEntity from "../../entity/folder/external/externalFolderEntity";
+import ExternalResourceEntity from "../../entity/resource/external/externalResourceEntity";
+import ImportError from "../../../error/importError";
+import * as kdbxweb from 'kdbxweb';
+import {
+  RESOURCE_TYPE_PASSWORD_AND_DESCRIPTION_SLUG,
+  RESOURCE_TYPE_PASSWORD_DESCRIPTION_TOTP_SLUG
+} from "../../entity/resourceType/resourceTypeEntity";
+import TotpEntity from "../../entity/totp/totpEntity";
 
 class ResourcesKdbxImportParser {
   /**
@@ -43,7 +46,7 @@ class ResourcesKdbxImportParser {
    * @returns {Promise<kdbxweb.Kdbx>}
    */
   async readKdbxDb() {
-    const arrayBytes = ByteUtils.base64ToBytes(this.importEntity.file)
+    const arrayBytes = kdbxweb.ByteUtils.base64ToBytes(this.importEntity.file);
     const kdbxCredentials = this.readKdbxCredentials();
     return kdbxweb.Kdbx.load(arrayBytes.buffer, kdbxCredentials);
   }
@@ -56,10 +59,10 @@ class ResourcesKdbxImportParser {
     let keepassPassword = null;
     let keepassKeyFile = null;
     if (this.importEntity.password) {
-      keepassPassword = kdbxweb.ProtectedValue.fromString(this.importEntity.password)
+      keepassPassword = kdbxweb.ProtectedValue.fromString(this.importEntity.password);
     }
     if (this.importEntity.keyfile) {
-      keepassKeyFile = kdbxweb.ByteUtils.base64ToBytes(this.importEntity.keyfile)
+      keepassKeyFile = kdbxweb.ByteUtils.base64ToBytes(this.importEntity.keyfile);
     }
     return new kdbxweb.Credentials(keepassPassword, keepassKeyFile);
   }
@@ -70,7 +73,7 @@ class ResourcesKdbxImportParser {
    */
   parseFolder(kdbxGroup) {
     const externalFolderDto = {
-      name: kdbxGroup.name.trim(),
+      name: ExternalFolderEntity.escapeName(kdbxGroup.name),
       folder_parent_path: this.getKdbxEntryPath(kdbxGroup)
     };
 
@@ -109,7 +112,7 @@ class ResourcesKdbxImportParser {
   getKdbxEntryPath(kdbxEntry) {
     let ancestors = [];
     if (kdbxEntry.parentGroup) {
-      const getAncestors = group => group.parentGroup ? [...getAncestors(group.parentGroup), group.name] : [group.name];
+      const getAncestors = group => group.parentGroup ? [...getAncestors(group.parentGroup), ExternalFolderEntity.escapeName(group.name)] : [ExternalFolderEntity.escapeName(group.name)];
       ancestors = getAncestors(kdbxEntry.parentGroup);
     }
     return ancestors.join('/');
@@ -117,34 +120,41 @@ class ResourcesKdbxImportParser {
 
   /**
    * Parse a KdbxEntry and extract the resource
-   * @param {KdbxEntry} kdbxEntry The entry
+   * @param {kdbxweb.KdbxEntry} kdbxEntry The entry
    * @returns {Object}
    */
   parseResource(kdbxEntry) {
+    let resourceTypeSlug = RESOURCE_TYPE_PASSWORD_AND_DESCRIPTION_SLUG;
     const externalResourceDto = {
-      name: kdbxEntry.fields.Title ? kdbxEntry.fields.Title.trim() : "",
-      uri: kdbxEntry.fields.URL ? kdbxEntry.fields.URL.trim() : "",
-      username: kdbxEntry.fields.UserName ? kdbxEntry.fields.UserName.trim() : "",
-      description: kdbxEntry.fields.Notes ? kdbxEntry.fields.Notes.trim() : "",
+      name: kdbxEntry.fields.get('Title') ? kdbxEntry.fields.get('Title').trim() : "",
+      uri: kdbxEntry.fields.get('URL') ? kdbxEntry.fields.get('URL').trim() : "",
+      username: kdbxEntry.fields.get('UserName') ? kdbxEntry.fields.get('UserName').trim() : "",
+      description: kdbxEntry.fields.get('Notes') ? kdbxEntry.fields.get('Notes').trim() : "",
       folder_parent_path: this.getKdbxEntryPath(kdbxEntry),
-      secret_clear: '' // By default a secret can be null
+      secret_clear: '', // By default a secret can be null
+      expired: kdbxEntry.times.expires ? kdbxEntry.times.expiryTime?.toISOString() : null,
     };
-    if (typeof kdbxEntry.fields.Password == 'object') {
-      externalResourceDto.secret_clear = kdbxEntry.fields.Password.getText();
+    if (typeof kdbxEntry.fields.get('Password') === 'object') {
+      externalResourceDto.secret_clear = kdbxEntry.fields.get('Password').getText();
     }
-
-    // @todo pebble
-    const resourceType = this.parseResourceType();
-    if (resourceType) {
-      externalResourceDto.resource_type_id = resourceType.id;
-    }
-
-    // Sanitize.
-    if (!externalResourceDto.name.length) {
-      externalResourceDto.name = ExternalResourceEntity.DEFAULT_RESOURCE_NAME;
-    }
-
     try {
+      const totp = this.getTotp(kdbxEntry);
+      if (totp) {
+        externalResourceDto.totp = totp;
+        resourceTypeSlug = RESOURCE_TYPE_PASSWORD_DESCRIPTION_TOTP_SLUG;
+      }
+
+      // @todo pebble
+      const resourceType = this.parseResourceType(resourceTypeSlug);
+      if (resourceType) {
+        externalResourceDto.resource_type_id = resourceType.id;
+      }
+
+      // Sanitize.
+      if (!externalResourceDto.name.length) {
+        externalResourceDto.name = ExternalResourceEntity.DEFAULT_RESOURCE_NAME;
+      }
+
       this.importEntity.importResources.push(externalResourceDto);
     } catch (error) {
       this.importEntity.importResourcesErrors.push(new ImportError("Cannot parse resource", externalResourceDto, error));
@@ -152,13 +162,32 @@ class ResourcesKdbxImportParser {
   }
 
   /**
-   * Parse the resource type id
+   * Get the totp
+   * @param {kdbxweb.KdbxEntry} kdbxEntry
+   * @return {*}
+   */
+  getTotp(kdbxEntry) {
+    if (kdbxEntry.fields.get('otp')) {
+      const totpUrl = typeof kdbxEntry.fields.get('otp') === 'object' ? kdbxEntry.fields.get('otp').getText() : kdbxEntry.fields.get('otp');
+      const totpUrlDecoded = new URL(decodeURIComponent(totpUrl));
+      const totp = TotpEntity.createTotpFromUrl(totpUrlDecoded);
+      return totp.toDto();
+    } else if (typeof kdbxEntry.fields.get('TimeOtp-Secret-Base32') === 'object') {
+      const totp = TotpEntity.createTotpFromKdbxWindows(kdbxEntry.fields);
+      return totp.toDto();
+    }
+  }
+
+  /**
+   * Parse the resource type according to the resource type slug
+   * @param {string} resourceTypeSlug
    * @returns {ResourceTypeEntity}
    */
-  parseResourceType() {
+  parseResourceType(resourceTypeSlug) {
     if (this.resourceTypesCollection) {
-      return this.resourceTypesCollection.getFirst('slug', 'password-and-description');
+      return this.resourceTypesCollection.getFirst('slug', resourceTypeSlug);
     }
+    return null;
   }
 
   /**
@@ -174,4 +203,4 @@ class ResourcesKdbxImportParser {
   }
 }
 
-exports.ResourcesKdbxImportParser = ResourcesKdbxImportParser;
+export default ResourcesKdbxImportParser;

package/src/all/background_page/model/import/resources/resourcesKdbxImportParser.test.js

@@ -1,5 +1,5 @@
 /**
- * @jest-environment ./.jest.custom-kdbx-environment
+ * @jest-environment ./test/jest.custom-kdbx-environment
  */
 /**
  * Passbolt ~ Open source password manager for teams
@@ -14,23 +14,22 @@
  * @link          https://www.passbolt.com Passbolt(tm)
  */
 import fs from "fs";
-import Validator from "validator";
-import kdbxweb from "kdbxweb/dist/kdbxweb";
-
-import {ResourcesKdbxImportParser} from "./resourcesKdbxImportParser";
-import {ImportResourcesFileEntity} from "../../entity/import/importResourcesFileEntity";
-import {EntityValidationError} from "../../entity/abstract/entityValidationError";
-import {ImportError} from "../../../error/importError";
-
-// Reset the modules before each test.
-beforeEach(() => {
-  global.kdbxweb = kdbxweb;
-  global.Validator = Validator;
-  jest.resetModules();
-});
+import * as kdbxweb from "kdbxweb";
+import ResourcesKdbxImportParser from "./resourcesKdbxImportParser";
+import ImportResourcesFileEntity from "../../entity/import/importResourcesFileEntity";
+import EntityValidationError from "passbolt-styleguide/src/shared/models/entity/abstract/entityValidationError";
+import ImportError from "../../../error/importError";
+import ResourceTypesCollection from "../../entity/resourceType/resourceTypesCollection";
+import {resourceTypesCollectionDto} from "passbolt-styleguide/src/shared/models/entity/resourceType/resourceTypesCollection.test.data";
+import {
+  TEST_RESOURCE_TYPE_PASSWORD_AND_DESCRIPTION,
+  TEST_RESOURCE_TYPE_PASSWORD_DESCRIPTION_TOTP,
+} from "passbolt-styleguide/src/shared/models/entity/resourceType/resourceTypeEntity.test.data";
+import {defaultTotpDto} from "../../entity/totp/totpDto.test.data";
 
 describe("ResourcesKdbxImportParser", () => {
-  it("should read import file", async () => {
+  it("should read import file", async() => {
+    expect.assertions(1);
     const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-not-protected.kdbx", {encoding: 'base64'});
     const importDto = {
       "ref": "import-ref",
@@ -43,7 +42,8 @@ describe("ResourcesKdbxImportParser", () => {
     expect(kdbx).toBeInstanceOf(kdbxweb.Kdbx);
   });
 
-  it("should read import file protected by password", async () => {
+  it("should read import file protected by password", async() => {
+    expect.assertions(1);
     const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-protected-password.kdbx", {encoding: 'base64'});
     const importDto = {
       "ref": "import-ref",
@@ -61,7 +61,8 @@ describe("ResourcesKdbxImportParser", () => {
     expect(kdbx).toBeInstanceOf(kdbxweb.Kdbx);
   });
 
-  it("should not be able to read import file protected by password if wrong password", async () => {
+  it("should not be able to read import file protected by password if wrong password", async() => {
+    expect.assertions(1);
     const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-protected-password.kdbx", {encoding: 'base64'});
     const importDto = {
       "ref": "import-ref",
@@ -72,13 +73,13 @@ describe("ResourcesKdbxImportParser", () => {
     const parser = new ResourcesKdbxImportParser(importEntity);
     try {
       await parser.readKdbxDb();
-      expect(true).toBeFalsy();
     } catch (error) {
       expect(error).toBeInstanceOf(kdbxweb.KdbxError);
     }
   });
 
-  it("should read import file protected by keyfile", async () => {
+  it("should read import file protected by keyfile", async() => {
+    expect.assertions(1);
     const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-protected-keyfile.kdbx", {encoding: 'base64'});
     const keyfile = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-keyfile.key", {encoding: 'base64'});
     const importDto = {
@@ -97,7 +98,8 @@ describe("ResourcesKdbxImportParser", () => {
     expect(kdbx).toBeInstanceOf(kdbxweb.Kdbx);
   });
 
-  it("should not be able to read import file protected by keyfile if wrong keyfile", async () => {
+  it("should not be able to read import file protected by keyfile if wrong keyfile", async() => {
+    expect.assertions(1);
     const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-protected-keyfile.kdbx", {encoding: 'base64'});
     const importDto = {
       "ref": "import-ref",
@@ -108,7 +110,6 @@ describe("ResourcesKdbxImportParser", () => {
     const parser = new ResourcesKdbxImportParser(importEntity);
     try {
       await parser.readKdbxDb();
-      expect(true).toBeFalsy();
     } catch (error) {
       expect(error).toBeInstanceOf(kdbxweb.KdbxError);
     }
@@ -121,7 +122,8 @@ describe("ResourcesKdbxImportParser", () => {
       uri: `https://url${num}.com`,
       description: `Description ${num}`,
       secret_clear: `Secret ${num}`,
-      folder_parent_path: ``
+      folder_parent_path: ``,
+      expired: null,
     }, data);
   }
 
@@ -132,7 +134,8 @@ describe("ResourcesKdbxImportParser", () => {
     }, data);
   }
 
-  it("should parse resources and folders", async () => {
+  it("should parse resources and folders", async() => {
+    expect.assertions(15);
     const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-not-protected.kdbx", {encoding: 'base64'});
     const importDto = {
       "ref": "import-ref",
@@ -176,7 +179,79 @@ describe("ResourcesKdbxImportParser", () => {
     expect(importEntity.importFolders.toJSON()).toEqual(expect.arrayContaining([folder5Dto]));
   });
 
-  it("should catch and keep a reference of import resource entity validation error", async () => {
+  it("should parse resources with TOTP and folders", async() => {
+    expect.assertions(6);
+    const resourceTypesCollection = new ResourceTypesCollection(resourceTypesCollectionDto());
+    const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-with-totp-protected-password.kdbx", {encoding: 'base64'});
+    const importDto = {
+      "ref": "import-ref",
+      "file_type": "kdbx",
+      "file": file,
+      "options": {
+        "credentials": {
+          "password": "passbolt"
+        }
+      }
+    };
+    const importEntity = new ImportResourcesFileEntity(importDto);
+    const parser = new ResourcesKdbxImportParser(importEntity, resourceTypesCollection);
+    await parser.parseImport();
+
+    // Assert resources
+    const totp = defaultTotpDto({secret_key: "TJSNMLGTCYOEMXZG"});
+    expect(importEntity.importResources.items).toHaveLength(2);
+    const resource1Dto = buildExternalResourceDto(1, {totp: totp, folder_parent_path: "import-ref/Root", resource_type_id: TEST_RESOURCE_TYPE_PASSWORD_DESCRIPTION_TOTP, expired: "2023-11-10T08:09:04.000Z"});
+    expect(importEntity.importResources.toJSON()).toEqual(expect.arrayContaining([resource1Dto]));
+    const resource2Dto = buildExternalResourceDto(2, {totp: totp, folder_parent_path: "import-ref/Root", resource_type_id: TEST_RESOURCE_TYPE_PASSWORD_DESCRIPTION_TOTP});
+    expect(importEntity.importResources.toJSON()).toEqual(expect.arrayContaining([resource2Dto]));
+
+    // Assert folders
+    expect(importEntity.importFolders.items).toHaveLength(2);
+    const folderRefDto = {name: "import-ref", folder_parent_path: ""};
+    expect(importEntity.importFolders.toJSON()).toEqual(expect.arrayContaining([folderRefDto]));
+    const folderKdbxRootDto = {name: "Root", folder_parent_path: "import-ref"};
+    expect(importEntity.importFolders.toJSON()).toEqual(expect.arrayContaining([folderKdbxRootDto]));
+  });
+
+  it("should parse resources with TOTP and folders from kdbx windows", async() => {
+    expect.assertions(7);
+    const resourceTypesCollection = new ResourceTypesCollection(resourceTypesCollectionDto());
+    const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-windows-with-totp-protected-password.kdbx", {encoding: 'base64'});
+    const importDto = {
+      "ref": "import-ref",
+      "file_type": "kdbx",
+      "file": file,
+      "options": {
+        "credentials": {
+          "password": "passbolt"
+        }
+      }
+    };
+    const importEntity = new ImportResourcesFileEntity(importDto);
+    const parser = new ResourcesKdbxImportParser(importEntity, resourceTypesCollection);
+    await parser.parseImport();
+
+    // Assert resources
+    const totp = defaultTotpDto({secret_key: "THISISANOTHERSECRET"});
+    const totp2 = defaultTotpDto({secret_key: "THISISTOTPSECRT", algorithm: "SHA256", digits: 8, period: 60});
+    expect(importEntity.importResources.items).toHaveLength(3);
+    const resource1Dto = buildExternalResourceDto(1, {folder_parent_path: "import-ref/Database", resource_type_id: TEST_RESOURCE_TYPE_PASSWORD_AND_DESCRIPTION});
+    expect(importEntity.importResources.toJSON()).toEqual(expect.arrayContaining([resource1Dto]));
+    const resource2Dto = buildExternalResourceDto(2, {totp: totp, folder_parent_path: "import-ref/Database", resource_type_id: TEST_RESOURCE_TYPE_PASSWORD_DESCRIPTION_TOTP});
+    expect(importEntity.importResources.toJSON()).toEqual(expect.arrayContaining([resource2Dto]));
+    const resource3Dto = buildExternalResourceDto(3, {totp: totp2, folder_parent_path: "import-ref/Database", resource_type_id: TEST_RESOURCE_TYPE_PASSWORD_DESCRIPTION_TOTP});
+    expect(importEntity.importResources.toJSON()).toEqual(expect.arrayContaining([resource3Dto]));
+
+    // Assert folders
+    expect(importEntity.importFolders.items).toHaveLength(2);
+    const folderRefDto = {name: "import-ref", folder_parent_path: ""};
+    expect(importEntity.importFolders.toJSON()).toEqual(expect.arrayContaining([folderRefDto]));
+    const folderKdbxRootDto = {name: "Database", folder_parent_path: "import-ref"};
+    expect(importEntity.importFolders.toJSON()).toEqual(expect.arrayContaining([folderKdbxRootDto]));
+  });
+
+  it("should catch and keep a reference of import resource entity validation error", async() => {
+    expect.assertions(16);
     const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-content-error-not-protected.kdbx", {encoding: 'base64'});
     const importDto = {
       "ref": "import-ref",
@@ -188,12 +263,12 @@ describe("ResourcesKdbxImportParser", () => {
     await parser.parseImport();
 
     // Assert resources
-    expect(importEntity.importResources.items).toHaveLength(1);
+    expect(importEntity.importResources.items).toHaveLength(2);
     const resource1Dto = buildExternalResourceDto(1, {folder_parent_path: "import-ref/Root/Folder 1"});
     expect(importEntity.importResources.toJSON()).toEqual(expect.arrayContaining([resource1Dto]));
 
     // Assert folders
-    expect(importEntity.importFolders.items).toHaveLength(3);
+    expect(importEntity.importFolders.items).toHaveLength(4);
     const folderRefDto = {name: "import-ref", folder_parent_path: ""};
     expect(importEntity.importFolders.toJSON()).toEqual(expect.arrayContaining([folderRefDto]));
     const folderKdbxRootDto = {name: "Root", folder_parent_path: "import-ref"};
@@ -202,19 +277,13 @@ describe("ResourcesKdbxImportParser", () => {
     expect(importEntity.importFolders.toJSON()).toEqual(expect.arrayContaining([folder1RootDto]));
 
     // Assert folders errors
-    expect(importEntity.importFoldersErrors).toHaveLength(2);
+    expect(importEntity.importFoldersErrors).toHaveLength(1);
     // Folder name exceeding max length
     let error = importEntity.importFoldersErrors[0];
     expect(error).toBeInstanceOf(ImportError);
     expect(error.sourceError).toBeInstanceOf(EntityValidationError);
     expect(error.sourceError.details).toHaveProperty("name");
-    expect(error.data.name).toEqual("too-long-folder-name-too-long-folder-name-too-long-folder-name-too-long-folder-name");
-    // Folder name containing /
-    error = importEntity.importFoldersErrors[1];
-    expect(error).toBeInstanceOf(ImportError);
-    expect(error.sourceError).toBeInstanceOf(EntityValidationError);
-    expect(error.sourceError.details).toHaveProperty("name");
-    expect(error.data.name).toEqual("/folder-name-with-/");
+    expect(error.data.name).toEqual("too-long-folder-name-too-long-folder-name-too-long-folder-name-too-long-folder-nametoo-long-folder-name-too-long-folder-name-too-long-folder-name-too-long-folder-nametoo-long-folder-name-too-long-folder-name-too-long-folder-name-too-long-folder-nametoo-long-folder-name-too-long-folder-name-too-long-folder-name-too-long-folder-name");
 
     // Assert resources errors
     expect(importEntity.importResourcesErrors).toHaveLength(1);
@@ -225,4 +294,25 @@ describe("ResourcesKdbxImportParser", () => {
     const resourceName = "too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name-too-long-resource-name";
     expect(error.data.name).toEqual(resourceName);
   });
+
+  it("should import the expiration date", async() => {
+    const file = fs.readFileSync("./src/all/background_page/model/import/resources/kdbx/kdbx-protected-password.kdbx", {encoding: 'base64'});
+    const importDto = {
+      "ref": "import-ref",
+      "file_type": "kdbx",
+      "file": file,
+      "options": {
+        "credentials": {
+          "password": "passbolt"
+        }
+      }
+    };
+    const importEntity = new ImportResourcesFileEntity(importDto);
+    const parser = new ResourcesKdbxImportParser(importEntity);
+    await parser.parseImport();
+
+    // Assert resources
+    expect(importEntity.importResources.items).toHaveLength(2);
+    expect(importEntity.importResources.items[1].expired).toStrictEqual("2020-11-16T23:00:42.000Z");
+  });
 });