bitwarden/directory-connector
1
0
Fork 0
mirror of https://github.com/bitwarden/directory-connector synced 2025-12-05 23:53:21 +00:00
Code Issues Releases Wiki Activity

Tools - Remove importer and exporters (#402)

Browse Source 
* Remove all importers and related files

* Remove exporter and all related files

* Remove packages: papaparse and jsdom

---------

Co-authored-by: Daniel James Smith <djsmith85@users.noreply.github.com>
This commit is contained in:
Daniel James Smith
2024-01-17 20:33:24 +01:00
committed by GitHub
parent a9f1d32ce0
commit 37bdd75c67
158 changed files with 0 additions and 21145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
jslib/angular/src/services/jslib-services.module.ts
View File

@@ -11,7 +11,6 @@ import { CryptoService as CryptoServiceAbstraction } from "@/jslib/common/src/ab
import { CryptoFunctionService as CryptoFunctionServiceAbstraction } from "@/jslib/common/src/abstractions/cryptoFunction.service";
import { EnvironmentService as EnvironmentServiceAbstraction } from "@/jslib/common/src/abstractions/environment.service";
import { EventService as EventServiceAbstraction } from "@/jslib/common/src/abstractions/event.service";
import { ExportService as ExportServiceAbstraction } from "@/jslib/common/src/abstractions/export.service";
import { FileUploadService as FileUploadServiceAbstraction } from "@/jslib/common/src/abstractions/fileUpload.service";
import { FolderService as FolderServiceAbstraction } from "@/jslib/common/src/abstractions/folder.service";
import { I18nService as I18nServiceAbstraction } from "@/jslib/common/src/abstractions/i18n.service";
@@ -51,7 +50,6 @@ import { ConsoleLogService } from "@/jslib/common/src/services/consoleLog.servic
import { CryptoService } from "@/jslib/common/src/services/crypto.service";
import { EnvironmentService } from "@/jslib/common/src/services/environment.service";
import { EventService } from "@/jslib/common/src/services/event.service";
import { ExportService } from "@/jslib/common/src/services/export.service";
import { FileUploadService } from "@/jslib/common/src/services/fileUpload.service";
import { FolderService } from "@/jslib/common/src/services/folder.service";
import { KeyConnectorService } from "@/jslib/common/src/services/keyConnector.service";
@@ -371,16 +369,6 @@ import { ValidationService } from "./validation.service";
),
deps: [StorageServiceAbstraction, "SECURE_STORAGE"],
},
{
provide: ExportServiceAbstraction,
useClass: ExportService,
deps: [
FolderServiceAbstraction,
CipherServiceAbstraction,
ApiServiceAbstraction,
CryptoServiceAbstraction,
],
},
{
provide: SearchServiceAbstraction,
useClass: SearchService,

31
jslib/common/spec/importers/bitwardenJsonImporter.spec.ts
View File

@@ -1,31 +0,0 @@
import { Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
import { CryptoService } from "@/jslib/common/src/abstractions/crypto.service";
import { I18nService } from "@/jslib/common/src/abstractions/i18n.service";
import { BitwardenJsonImporter } from "@/jslib/common/src/importers/bitwardenJsonImporter";
import { data as passwordProtectedData } from "./testData/bitwardenJson/passwordProtected.json";
describe("bitwarden json importer", () => {
let sut: BitwardenJsonImporter;
let cryptoService: SubstituteOf<CryptoService>;
let i18nService: SubstituteOf<I18nService>;
beforeEach(() => {
cryptoService = Substitute.for<CryptoService>();
i18nService = Substitute.for<I18nService>();
sut = new BitwardenJsonImporter(cryptoService, i18nService);
});
it("should fail if password is needed", async () => {
expect((await sut.parse(passwordProtectedData)).success).toBe(false);
});
it("should return password needed error message", async () => {
const expected = "Password required error message";
i18nService.t("importPasswordRequired").returns(expected);
expect((await sut.parse(passwordProtectedData)).errorMessage).toEqual(expected);
});
});

113
jslib/common/spec/importers/bitwardenPasswordProtectedImporter.spec.ts
View File

@@ -1,113 +0,0 @@
import { Substitute, Arg, SubstituteOf } from "@fluffy-spoon/substitute";
import { CryptoService } from "@/jslib/common/src/abstractions/crypto.service";
import { I18nService } from "@/jslib/common/src/abstractions/i18n.service";
import { KdfType } from "@/jslib/common/src/enums/kdfType";
import { BitwardenPasswordProtectedImporter } from "@/jslib/common/src/importers/bitwardenPasswordProtectedImporter";
import { Utils } from "@/jslib/common/src/misc/utils";
import { ImportResult } from "@/jslib/common/src/models/domain/importResult";
import { data as emptyDecryptedData } from "./testData/bitwardenJson/empty.json";
describe("BitwardenPasswordProtectedImporter", () => {
let importer: BitwardenPasswordProtectedImporter;
let cryptoService: SubstituteOf<CryptoService>;
let i18nService: SubstituteOf<I18nService>;
const password = Utils.newGuid();
const result = new ImportResult();
let jDoc: {
encrypted?: boolean;
passwordProtected?: boolean;
salt?: string;
kdfIterations?: any;
kdfType?: any;
encKeyValidation_DO_NOT_EDIT?: string;
data?: string;
};
beforeEach(() => {
cryptoService = Substitute.for<CryptoService>();
i18nService = Substitute.for<I18nService>();
jDoc = {
encrypted: true,
passwordProtected: true,
salt: "c2FsdA==",
kdfIterations: 100000,
kdfType: KdfType.PBKDF2_SHA256,
encKeyValidation_DO_NOT_EDIT: Utils.newGuid(),
data: Utils.newGuid(),
};
result.success = true;
importer = new BitwardenPasswordProtectedImporter(cryptoService, i18nService, password);
});
describe("Required Json Data", () => {
it("succeeds with default jdoc", async () => {
cryptoService.decryptToUtf8(Arg.any(), Arg.any()).resolves(emptyDecryptedData);
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(true);
});
it("fails if encrypted === false", async () => {
jDoc.encrypted = false;
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
});
it("fails if encrypted === null", async () => {
jDoc.encrypted = null;
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
});
it("fails if passwordProtected === false", async () => {
jDoc.passwordProtected = false;
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
});
it("fails if passwordProtected === null", async () => {
jDoc.passwordProtected = null;
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
});
it("fails if salt === null", async () => {
jDoc.salt = null;
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
});
it("fails if kdfIterations === null", async () => {
jDoc.kdfIterations = null;
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
});
it("fails if kdfIterations is not a number", async () => {
jDoc.kdfIterations = "not a number";
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
});
it("fails if kdfType === null", async () => {
jDoc.kdfType = null;
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
});
it("fails if kdfType is not a string", async () => {
jDoc.kdfType = "not a valid kdf type";
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
});
it("fails if kdfType is not a known kdfType", async () => {
jDoc.kdfType = -1;
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
});
it("fails if encKeyValidation_DO_NOT_EDIT === null", async () => {
jDoc.encKeyValidation_DO_NOT_EDIT = null;
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
});
it("fails if data === null", async () => {
jDoc.data = null;
expect((await importer.parse(JSON.stringify(jDoc))).success).toEqual(false);
});
});
});

367
jslib/common/spec/importers/dashlaneCsvImporter.spec.ts
View File

@@ -1,367 +0,0 @@
import { CipherType } from "@/jslib/common/src/enums/cipherType";
import { DashlaneCsvImporter as Importer } from "@/jslib/common/src/importers/dashlaneImporters/dashlaneCsvImporter";
import { credentialsData } from "./testData/dashlaneCsv/credentials.csv";
import { identityData } from "./testData/dashlaneCsv/id.csv";
import { multiplePersonalInfoData } from "./testData/dashlaneCsv/multiplePersonalInfo.csv";
import { paymentsData } from "./testData/dashlaneCsv/payments.csv";
import { personalInfoData } from "./testData/dashlaneCsv/personalInfo.csv";
import { secureNoteData } from "./testData/dashlaneCsv/securenotes.csv";
describe("Dashlane CSV Importer", () => {
let importer: Importer;
beforeEach(() => {
importer = new Importer();
});
it("should parse login records", async () => {
const result = await importer.parse(credentialsData);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.name).toEqual("example.com");
expect(cipher.login.username).toEqual("jdoe");
expect(cipher.login.password).toEqual("somePassword");
expect(cipher.login.totp).toEqual("someTOTPSeed");
expect(cipher.login.uris.length).toEqual(1);
const uriView = cipher.login.uris.shift();
expect(uriView.uri).toEqual("https://www.example.com");
expect(cipher.notes).toEqual("some note for example.com");
});
it("should parse an item and create a folder", async () => {
const result = await importer.parse(credentialsData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.folders.length).toBe(1);
expect(result.folders[0].name).toBe("Entertainment");
expect(result.folderRelationships[0]).toEqual([0, 0]);
});
it("should parse payment records", async () => {
const result = await importer.parse(paymentsData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(2);
// Account
const cipher = result.ciphers.shift();
expect(cipher.type).toBe(CipherType.Card);
expect(cipher.name).toBe("John's savings account");
expect(cipher.card.brand).toBeNull();
expect(cipher.card.cardholderName).toBe("John Doe");
expect(cipher.card.number).toBe("accountNumber");
expect(cipher.card.code).toBeNull();
expect(cipher.card.expMonth).toBeNull();
expect(cipher.card.expYear).toBeNull();
expect(cipher.fields.length).toBe(4);
expect(cipher.fields[0].name).toBe("type");
expect(cipher.fields[0].value).toBe("bank");
expect(cipher.fields[1].name).toBe("routing_number");
expect(cipher.fields[1].value).toBe("routingNumber");
expect(cipher.fields[2].name).toBe("country");
expect(cipher.fields[2].value).toBe("US");
expect(cipher.fields[3].name).toBe("issuing_bank");
expect(cipher.fields[3].value).toBe("US-ALLY");
// CreditCard
const cipher2 = result.ciphers.shift();
expect(cipher2.type).toBe(CipherType.Card);
expect(cipher2.name).toBe("John Doe");
expect(cipher2.card.brand).toBe("Visa");
expect(cipher2.card.cardholderName).toBe("John Doe");
expect(cipher2.card.number).toBe("41111111111111111");
expect(cipher2.card.code).toBe("123");
expect(cipher2.card.expMonth).toBe("01");
expect(cipher2.card.expYear).toBe("23");
expect(cipher2.fields.length).toBe(2);
expect(cipher2.fields[0].name).toBe("type");
expect(cipher2.fields[0].value).toBe("credit_card");
expect(cipher2.fields[1].name).toBe("country");
expect(cipher2.fields[1].value).toBe("US");
});
it("should parse ids records", async () => {
const result = await importer.parse(identityData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
// Type card
const cipher = result.ciphers.shift();
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("John Doe card");
expect(cipher.identity.fullName).toBe("John Doe");
expect(cipher.identity.firstName).toBe("John");
expect(cipher.identity.middleName).toBeNull();
expect(cipher.identity.lastName).toBe("Doe");
expect(cipher.identity.licenseNumber).toBe("123123123");
expect(cipher.fields.length).toBe(3);
expect(cipher.fields[0].name).toEqual("type");
expect(cipher.fields[0].value).toEqual("card");
expect(cipher.fields[1].name).toEqual("issue_date");
expect(cipher.fields[1].value).toEqual("2022-1-30");
expect(cipher.fields[2].name).toEqual("expiration_date");
expect(cipher.fields[2].value).toEqual("2032-1-30");
// Type passport
const cipher2 = result.ciphers.shift();
expect(cipher2.type).toBe(CipherType.Identity);
expect(cipher2.name).toBe("John Doe passport");
expect(cipher2.identity.fullName).toBe("John Doe");
expect(cipher2.identity.firstName).toBe("John");
expect(cipher2.identity.middleName).toBeNull();
expect(cipher2.identity.lastName).toBe("Doe");
expect(cipher2.identity.passportNumber).toBe("123123123");
expect(cipher2.fields.length).toBe(4);
expect(cipher2.fields[0].name).toEqual("type");
expect(cipher2.fields[0].value).toEqual("passport");
expect(cipher2.fields[1].name).toEqual("issue_date");
expect(cipher2.fields[1].value).toEqual("2022-1-30");
expect(cipher2.fields[2].name).toEqual("expiration_date");
expect(cipher2.fields[2].value).toEqual("2032-1-30");
expect(cipher2.fields[3].name).toEqual("place_of_issue");
expect(cipher2.fields[3].value).toEqual("somewhere in Germany");
// Type license
const cipher3 = result.ciphers.shift();
expect(cipher3.type).toBe(CipherType.Identity);
expect(cipher3.name).toBe("John Doe license");
expect(cipher3.identity.fullName).toBe("John Doe");
expect(cipher3.identity.firstName).toBe("John");
expect(cipher3.identity.middleName).toBeNull();
expect(cipher3.identity.lastName).toBe("Doe");
expect(cipher3.identity.licenseNumber).toBe("1234556");
expect(cipher3.identity.state).toBe("DC");
expect(cipher3.fields.length).toBe(3);
expect(cipher3.fields[0].name).toEqual("type");
expect(cipher3.fields[0].value).toEqual("license");
expect(cipher3.fields[1].name).toEqual("issue_date");
expect(cipher3.fields[1].value).toEqual("2022-8-10");
expect(cipher3.fields[2].name).toEqual("expiration_date");
expect(cipher3.fields[2].value).toEqual("2022-10-10");
// Type social_security
const cipher4 = result.ciphers.shift();
expect(cipher4.type).toBe(CipherType.Identity);
expect(cipher4.name).toBe("John Doe social_security");
expect(cipher4.identity.fullName).toBe("John Doe");
expect(cipher4.identity.firstName).toBe("John");
expect(cipher4.identity.middleName).toBeNull();
expect(cipher4.identity.lastName).toBe("Doe");
expect(cipher4.identity.ssn).toBe("123123123");
expect(cipher4.fields.length).toBe(1);
expect(cipher4.fields[0].name).toEqual("type");
expect(cipher4.fields[0].value).toEqual("social_security");
// Type tax_number
const cipher5 = result.ciphers.shift();
expect(cipher5.type).toBe(CipherType.Identity);
expect(cipher5.name).toBe("tax_number");
expect(cipher5.identity.licenseNumber).toBe("123123123");
expect(cipher5.fields.length).toBe(1);
expect(cipher5.fields[0].name).toEqual("type");
expect(cipher5.fields[0].value).toEqual("tax_number");
});
it("should parse secureNote records", async () => {
const result = await importer.parse(secureNoteData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
const cipher = result.ciphers.shift();
expect(cipher.type).toBe(CipherType.SecureNote);
expect(cipher.name).toBe("01");
expect(cipher.notes).toBe("test");
});
it("should parse personal information records (multiple identities)", async () => {
const result = await importer.parse(multiplePersonalInfoData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(6);
// name
const cipher = result.ciphers.shift();
expect(cipher.type).toBe(CipherType.SecureNote);
expect(cipher.name).toBe("MR John Doe");
expect(cipher.fields.length).toBe(7);
expect(cipher.fields[0].name).toEqual("type");
expect(cipher.fields[0].value).toEqual("name");
expect(cipher.fields[1].name).toEqual("title");
expect(cipher.fields[1].value).toEqual("MR");
expect(cipher.fields[2].name).toEqual("first_name");
expect(cipher.fields[2].value).toEqual("John");
expect(cipher.fields[3].name).toEqual("last_name");
expect(cipher.fields[3].value).toEqual("Doe");
expect(cipher.fields[4].name).toEqual("login");
expect(cipher.fields[4].value).toEqual("jdoe");
expect(cipher.fields[5].name).toEqual("date_of_birth");
expect(cipher.fields[5].value).toEqual("2022-01-30");
expect(cipher.fields[6].name).toEqual("place_of_birth");
expect(cipher.fields[6].value).toEqual("world");
// email
const cipher2 = result.ciphers.shift();
expect(cipher2.type).toBe(CipherType.SecureNote);
expect(cipher2.name).toBe("Johns email");
expect(cipher2.fields.length).toBe(4);
expect(cipher2.fields[0].name).toEqual("type");
expect(cipher2.fields[0].value).toEqual("email");
expect(cipher2.fields[1].name).toEqual("email");
expect(cipher2.fields[1].value).toEqual("jdoe@example.com");
expect(cipher2.fields[2].name).toEqual("email_type");
expect(cipher2.fields[2].value).toEqual("personal");
expect(cipher2.fields[3].name).toEqual("item_name");
expect(cipher2.fields[3].value).toEqual("Johns email");
// number
const cipher3 = result.ciphers.shift();
expect(cipher3.type).toBe(CipherType.SecureNote);
expect(cipher3.name).toBe("John's number");
expect(cipher3.fields.length).toBe(3);
expect(cipher3.fields[0].name).toEqual("type");
expect(cipher3.fields[0].value).toEqual("number");
expect(cipher3.fields[1].name).toEqual("item_name");
expect(cipher3.fields[1].value).toEqual("John's number");
expect(cipher3.fields[2].name).toEqual("phone_number");
expect(cipher3.fields[2].value).toEqual("+49123123123");
// address
const cipher4 = result.ciphers.shift();
expect(cipher4.type).toBe(CipherType.SecureNote);
expect(cipher4.name).toBe("John's home address");
expect(cipher4.fields.length).toBe(12);
expect(cipher4.fields[0].name).toEqual("type");
expect(cipher4.fields[0].value).toEqual("address");
expect(cipher4.fields[1].name).toEqual("item_name");
expect(cipher4.fields[1].value).toEqual("John's home address");
expect(cipher4.fields[2].name).toEqual("address");
expect(cipher4.fields[2].value).toEqual("1 some street");
expect(cipher4.fields[3].name).toEqual("country");
expect(cipher4.fields[3].value).toEqual("de");
expect(cipher4.fields[4].name).toEqual("state");
expect(cipher4.fields[4].value).toEqual("DE-0-NW");
expect(cipher4.fields[5].name).toEqual("city");
expect(cipher4.fields[5].value).toEqual("some city");
expect(cipher4.fields[6].name).toEqual("zip");
expect(cipher4.fields[6].value).toEqual("123123");
expect(cipher4.fields[7].name).toEqual("address_recipient");
expect(cipher4.fields[7].value).toEqual("John");
expect(cipher4.fields[8].name).toEqual("address_building");
expect(cipher4.fields[8].value).toEqual("1");
expect(cipher4.fields[9].name).toEqual("address_apartment");
expect(cipher4.fields[9].value).toEqual("1");
expect(cipher4.fields[10].name).toEqual("address_floor");
expect(cipher4.fields[10].value).toEqual("1");
expect(cipher4.fields[11].name).toEqual("address_door_code");
expect(cipher4.fields[11].value).toEqual("123");
// website
const cipher5 = result.ciphers.shift();
expect(cipher5.type).toBe(CipherType.SecureNote);
expect(cipher5.name).toBe("Website");
expect(cipher5.fields.length).toBe(3);
expect(cipher5.fields[0].name).toEqual("type");
expect(cipher5.fields[0].value).toEqual("website");
expect(cipher5.fields[1].name).toEqual("item_name");
expect(cipher5.fields[1].value).toEqual("Website");
expect(cipher5.fields[2].name).toEqual("url");
expect(cipher5.fields[2].value).toEqual("website.com");
// 2nd name/identity
const cipher6 = result.ciphers.shift();
expect(cipher6.type).toBe(CipherType.SecureNote);
expect(cipher6.name).toBe("Mrs Jane Doe");
expect(cipher6.fields.length).toBe(7);
expect(cipher6.fields[0].name).toEqual("type");
expect(cipher6.fields[0].value).toEqual("name");
expect(cipher6.fields[1].name).toEqual("title");
expect(cipher6.fields[1].value).toEqual("Mrs");
expect(cipher6.fields[2].name).toEqual("first_name");
expect(cipher6.fields[2].value).toEqual("Jane");
expect(cipher6.fields[3].name).toEqual("last_name");
expect(cipher6.fields[3].value).toEqual("Doe");
expect(cipher6.fields[4].name).toEqual("login");
expect(cipher6.fields[4].value).toEqual("jdoe");
expect(cipher6.fields[5].name).toEqual("date_of_birth");
expect(cipher6.fields[5].value).toEqual("2022-01-30");
expect(cipher6.fields[6].name).toEqual("place_of_birth");
expect(cipher6.fields[6].value).toEqual("earth");
});
it("should combine personal information records to one identity if only one identity present", async () => {
const result = await importer.parse(personalInfoData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("MR John Doe");
expect(cipher.identity.fullName).toBe("MR John Doe");
expect(cipher.identity.title).toBe("MR");
expect(cipher.identity.firstName).toBe("John");
expect(cipher.identity.middleName).toBeNull();
expect(cipher.identity.lastName).toBe("Doe");
expect(cipher.identity.username).toBe("jdoe");
expect(cipher.identity.email).toBe("jdoe@example.com");
expect(cipher.identity.phone).toBe("+49123123123");
expect(cipher.fields.length).toBe(9);
expect(cipher.fields[0].name).toBe("date_of_birth");
expect(cipher.fields[0].value).toBe("2022-01-30");
expect(cipher.fields[1].name).toBe("place_of_birth");
expect(cipher.fields[1].value).toBe("world");
expect(cipher.fields[2].name).toBe("email_type");
expect(cipher.fields[2].value).toBe("personal");
expect(cipher.fields[3].name).toBe("address_recipient");
expect(cipher.fields[3].value).toBe("John");
expect(cipher.fields[4].name).toBe("address_building");
expect(cipher.fields[4].value).toBe("1");
expect(cipher.fields[5].name).toBe("address_apartment");
expect(cipher.fields[5].value).toBe("1");
expect(cipher.fields[6].name).toBe("address_floor");
expect(cipher.fields[6].value).toBe("1");
expect(cipher.fields[7].name).toBe("address_door_code");
expect(cipher.fields[7].value).toBe("123");
expect(cipher.fields[8].name).toBe("url");
expect(cipher.fields[8].value).toBe("website.com");
});
});

74
jslib/common/spec/importers/firefoxCsvImporter.spec.ts
View File

@@ -1,74 +0,0 @@
import { FirefoxCsvImporter as Importer } from "@/jslib/common/src/importers/firefoxCsvImporter";
import { CipherView } from "@/jslib/common/src/models/view/cipherView";
import { LoginUriView } from "@/jslib/common/src/models/view/loginUriView";
import { LoginView } from "@/jslib/common/src/models/view/loginView";
import { data as firefoxAccountsData } from "./testData/firefoxCsv/firefoxAccountsData.csv";
import { data as simplePasswordData } from "./testData/firefoxCsv/simplePasswordData.csv";
const CipherData = [
{
title: "should parse password",
csv: simplePasswordData,
expected: Object.assign(new CipherView(), {
id: null,
organizationId: null,
folderId: null,
name: "example.com",
login: Object.assign(new LoginView(), {
username: "foo",
password: "bar",
uris: [
Object.assign(new LoginUriView(), {
uri: "https://example.com",
}),
],
}),
notes: null,
type: 1,
}),
},
{
title: 'should skip "chrome://FirefoxAccounts"',
csv: firefoxAccountsData,
expected: Object.assign(new CipherView(), {
id: null,
organizationId: null,
folderId: null,
name: "example.com",
login: Object.assign(new LoginView(), {
username: "foo",
password: "bar",
uris: [
Object.assign(new LoginUriView(), {
uri: "https://example.com",
}),
],
}),
notes: null,
type: 1,
}),
},
];
describe("Firefox CSV Importer", () => {
CipherData.forEach((data) => {
it(data.title, async () => {
const importer = new Importer();
const result = await importer.parse(data.csv);
expect(result != null).toBe(true);
expect(result.ciphers.length).toBeGreaterThan(0);
const cipher = result.ciphers.shift();
let property: keyof typeof data.expected;
for (property in data.expected) {
// eslint-disable-next-line
if (data.expected.hasOwnProperty(property)) {
// eslint-disable-next-line
expect(cipher.hasOwnProperty(property)).toBe(true);
expect(cipher[property]).toEqual(data.expected[property]);
}
}
});
});
});

77
jslib/common/spec/importers/fsecureFskImporter.spec.ts
View File

@@ -1,77 +0,0 @@
import { FSecureFskImporter as Importer } from "@/jslib/common/src/importers/fsecureFskImporter";
const TestDataWithStyleSetToWebsite: string = JSON.stringify({
data: {
"8d58b5cf252dd06fbd98f5289e918ab1": {
color: "#00baff",
reatedDate: 1609302913,
creditCvv: "",
creditExpiry: "",
creditNumber: "",
favorite: 0,
modifiedDate: 1609302913,
notes: "note",
password: "word",
passwordList: [],
passwordModifiedDate: 1609302913,
rev: 1,
service: "My first pass",
style: "website",
type: 1,
url: "https://bitwarden.com",
username: "pass",
},
},
});
const TestDataWithStyleSetToGlobe: string = JSON.stringify({
data: {
"8d58b5cf252dd06fbd98f5289e918ab1": {
color: "#00baff",
reatedDate: 1609302913,
creditCvv: "",
creditExpiry: "",
creditNumber: "",
favorite: 0,
modifiedDate: 1609302913,
notes: "note",
password: "word",
passwordList: [],
passwordModifiedDate: 1609302913,
rev: 1,
service: "My first pass",
style: "globe",
type: 1,
url: "https://bitwarden.com",
username: "pass",
},
},
});
describe("FSecure FSK Importer", () => {
it("should parse data with style set to website", async () => {
const importer = new Importer();
const result = await importer.parse(TestDataWithStyleSetToWebsite);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.login.username).toEqual("pass");
expect(cipher.login.password).toEqual("word");
expect(cipher.login.uris.length).toEqual(1);
const uriView = cipher.login.uris.shift();
expect(uriView.uri).toEqual("https://bitwarden.com");
});
it("should parse data with style set to globe", async () => {
const importer = new Importer();
const result = await importer.parse(TestDataWithStyleSetToGlobe);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.login.username).toEqual("pass");
expect(cipher.login.password).toEqual("word");
expect(cipher.login.uris.length).toEqual(1);
const uriView = cipher.login.uris.shift();
expect(uriView.uri).toEqual("https://bitwarden.com");
});
});

189
jslib/common/spec/importers/keepass2XmlImporter.spec.ts
View File

@@ -1,189 +0,0 @@
import { KeePass2XmlImporter as Importer } from "@/jslib/common/src/importers/keepass2XmlImporter";
const TestData = `<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<KeePassFile>
<Meta>
<Generator>KeePass</Generator>
<DatabaseName />
<DatabaseNameChanged>2016-12-31T21:33:52Z</DatabaseNameChanged>
<DatabaseDescription />
<DatabaseDescriptionChanged>2016-12-31T21:33:52Z</DatabaseDescriptionChanged>
<DefaultUserName />
<DefaultUserNameChanged>2016-12-31T21:33:52Z</DefaultUserNameChanged>
<MaintenanceHistoryDays>365</MaintenanceHistoryDays>
<Color />
<MasterKeyChanged>2016-12-31T21:33:59Z</MasterKeyChanged>
<MasterKeyChangeRec>-1</MasterKeyChangeRec>
<MasterKeyChangeForce>-1</MasterKeyChangeForce>
<MemoryProtection>
<ProtectTitle>False</ProtectTitle>
<ProtectUserName>False</ProtectUserName>
<ProtectPassword>True</ProtectPassword>
<ProtectURL>False</ProtectURL>
<ProtectNotes>False</ProtectNotes>
</MemoryProtection>
<RecycleBinEnabled>True</RecycleBinEnabled>
<RecycleBinUUID>AAAAAAAAAAAAAAAAAAAAAA==</RecycleBinUUID>
<RecycleBinChanged>2016-12-31T21:33:52Z</RecycleBinChanged>
<EntryTemplatesGroup>AAAAAAAAAAAAAAAAAAAAAA==</EntryTemplatesGroup>
<EntryTemplatesGroupChanged>2016-12-31T21:33:52Z</EntryTemplatesGroupChanged>
<HistoryMaxItems>10</HistoryMaxItems>
<HistoryMaxSize>6291456</HistoryMaxSize>
<LastSelectedGroup>AAAAAAAAAAAAAAAAAAAAAA==</LastSelectedGroup>
<LastTopVisibleGroup>AAAAAAAAAAAAAAAAAAAAAA==</LastTopVisibleGroup>
<Binaries />
<CustomData />
</Meta>
<Root>
<Group>
<UUID>KvS57lVwl13AfGFLwkvq4Q==</UUID>
<Name>Root</Name>
<Notes />
<IconID>48</IconID>
<Times>
<CreationTime>2016-12-31T21:33:52Z</CreationTime>
<LastModificationTime>2016-12-31T21:33:52Z</LastModificationTime>
<LastAccessTime>2017-01-01T22:58:00Z</LastAccessTime>
<ExpiryTime>2016-12-31T21:33:52Z</ExpiryTime>
<Expires>False</Expires>
<UsageCount>1</UsageCount>
<LocationChanged>2016-12-31T21:33:52Z</LocationChanged>
</Times>
<IsExpanded>True</IsExpanded>
<DefaultAutoTypeSequence />
<EnableAutoType>null</EnableAutoType>
<EnableSearching>null</EnableSearching>
<LastTopVisibleEntry>AAAAAAAAAAAAAAAAAAAAAA==</LastTopVisibleEntry>
<Group>
<UUID>P0ParXgGMBW6caOL2YrhqQ==</UUID>
<Name>Folder2</Name>
<Notes>a note about the folder</Notes>
<IconID>48</IconID>
<Times>
<CreationTime>2016-12-31T21:43:30Z</CreationTime>
<LastModificationTime>2016-12-31T21:43:43Z</LastModificationTime>
<LastAccessTime>2017-01-01T22:58:00Z</LastAccessTime>
<ExpiryTime>2016-12-31T21:43:30Z</ExpiryTime>
<Expires>False</Expires>
<UsageCount>1</UsageCount>
<LocationChanged>2016-12-31T21:43:43Z</LocationChanged>
</Times>
<IsExpanded>True</IsExpanded>
<DefaultAutoTypeSequence />
<EnableAutoType>null</EnableAutoType>
<EnableSearching>null</EnableSearching>
<LastTopVisibleEntry>AAAAAAAAAAAAAAAAAAAAAA==</LastTopVisibleEntry>
<Entry>
<UUID>fAa543oYlgnJKkhKag5HLw==</UUID>
<IconID>1</IconID>
<ForegroundColor />
<BackgroundColor />
<OverrideURL />
<Tags />
<Times>
<CreationTime>2016-12-31T21:34:13Z</CreationTime>
<LastModificationTime>2016-12-31T21:40:23Z</LastModificationTime>
<LastAccessTime>2016-12-31T21:40:23Z</LastAccessTime>
<ExpiryTime>2016-12-31T21:34:13Z</ExpiryTime>
<Expires>False</Expires>
<UsageCount>0</UsageCount>
<LocationChanged>2016-12-31T21:43:48Z</LocationChanged>
</Times>
<String>
<Key>att2</Key>
<Value>att2value</Value>
</String>
<String>
<Key>attr1</Key>
<Value>att1value
line1
line2</Value>
</String>
<String>
<Key>Notes</Key>
<Value>This is a note!!!
line1
line2</Value>
</String>
<String>
<Key>Password</Key>
<Value ProtectInMemory="True">googpass</Value>
</String>
<String>
<Key>Title</Key>
<Value>Google</Value>
</String>
<String>
<Key>URL</Key>
<Value>google.com</Value>
</String>
<String>
<Key>UserName</Key>
<Value>googleuser</Value>
</String>
<AutoType>
<Enabled>True</Enabled>
<DataTransferObfuscation>0</DataTransferObfuscation>
</AutoType>
<History>
<Entry>
<UUID>fAa543oYlgnJKkhKag5HLw==</UUID>
<IconID>0</IconID>
<ForegroundColor />
<BackgroundColor />
<OverrideURL />
<Tags />
<Times>
<CreationTime>2016-12-31T21:34:13Z</CreationTime>
<LastModificationTime>2016-12-31T21:34:40Z</LastModificationTime>
<LastAccessTime>2016-12-31T21:34:40Z</LastAccessTime>
<ExpiryTime>2016-12-31T21:34:13Z</ExpiryTime>
<Expires>False</Expires>
<UsageCount>0</UsageCount>
<LocationChanged>2016-12-31T21:34:40Z</LocationChanged>
</Times>
<String>
<Key>Notes</Key>
<Value>This is a note!!!
line1
line2</Value>
</String>
<String>
<Key>Password</Key>
<Value ProtectInMemory="True">googpass</Value>
</String>
<String>
<Key>Title</Key>
<Value>Google</Value>
</String>
<String>
<Key>URL</Key>
<Value>google.com</Value>
</String>
<String>
<Key>UserName</Key>
<Value>googleuser</Value>
</String>
<AutoType>
<Enabled>True</Enabled>
<DataTransferObfuscation>0</DataTransferObfuscation>
</AutoType>
</Entry>
</History>
</Entry>
</Group>
</Group>
<DeletedObjects />
</Root>
</KeePassFile>`;
describe("KeePass2 Xml Importer", () => {
it("should parse XML data", async () => {
const importer = new Importer();
const result = await importer.parse(TestData);
expect(result != null).toBe(true);
});
});

108
jslib/common/spec/importers/keeperJsonImporter.spec.ts
View File

@@ -1,108 +0,0 @@
import { KeeperJsonImporter as Importer } from "@/jslib/common/src/importers/keeperImporters/keeperJsonImporter";
import { Utils } from "@/jslib/common/src/misc/utils";
import { testData as TestData } from "./testData/keeperJson/testData";
describe("Keeper Json Importer", () => {
const testDataJson = JSON.stringify(TestData);
let importer: Importer;
beforeEach(() => {
importer = new Importer();
});
it("should parse login data", async () => {
const result = await importer.parse(testDataJson);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.name).toEqual("Bank Account 1");
expect(cipher.login.username).toEqual("customer1234");
expect(cipher.login.password).toEqual("4813fJDHF4239fdk");
expect(cipher.login.uris.length).toEqual(1);
const uriView = cipher.login.uris.shift();
expect(uriView.uri).toEqual("https://chase.com");
expect(cipher.notes).toEqual("These are some notes.");
const cipher2 = result.ciphers.shift();
expect(cipher2.name).toEqual("Bank Account 2");
expect(cipher2.login.username).toEqual("mybankusername");
expect(cipher2.login.password).toEqual("w4k4k193f$^&@#*%2");
expect(cipher2.login.uris.length).toEqual(1);
const uriView2 = cipher2.login.uris.shift();
expect(uriView2.uri).toEqual("https://amex.com");
expect(cipher2.notes).toEqual("Some great information here.");
const cipher3 = result.ciphers.shift();
expect(cipher3.name).toEqual("Some Account");
expect(cipher3.login.username).toEqual("someUserName");
expect(cipher3.login.password).toEqual("w4k4k1wergf$^&@#*%2");
expect(cipher3.notes).toBeNull();
expect(cipher3.fields).toBeNull();
expect(cipher3.login.uris.length).toEqual(1);
const uriView3 = cipher3.login.uris.shift();
expect(uriView3.uri).toEqual("https://example.com");
});
it("should import TOTP when present", async () => {
const result = await importer.parse(testDataJson);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.login.totp).toBeNull();
// 2nd Cipher
const cipher2 = result.ciphers.shift();
expect(cipher2.login.totp).toEqual(
"otpauth://totp/Amazon:me@company.com?secret=JBSWY3DPEHPK3PXP&issuer=Amazon&algorithm=SHA1&digits=6&period=30"
);
});
it("should parse custom fields", async () => {
const result = await importer.parse(testDataJson);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.fields.length).toBe(1);
expect(cipher.fields[0].name).toEqual("Account Number");
expect(cipher.fields[0].value).toEqual("123-456-789");
// 2nd Cipher
const cipher2 = result.ciphers.shift();
expect(cipher2.fields.length).toBe(2);
expect(cipher2.fields[0].name).toEqual("Security Group");
expect(cipher2.fields[0].value).toEqual("Public");
expect(cipher2.fields[1].name).toEqual("IP Address");
expect(cipher2.fields[1].value).toEqual("12.45.67.8");
});
it("should create folders and assigned ciphers to them", async () => {
const result = await importer.parse(testDataJson);
expect(result != null).toBe(true);
const folders = result.folders;
expect(folders.length).toBe(2);
expect(folders[0].name).toBe("Optional Private Folder 1");
expect(folders[1].name).toBe("My Customer 1");
expect(result.folderRelationships[0]).toEqual([0, 0]);
expect(result.folderRelationships[1]).toEqual([1, 0]);
expect(result.folderRelationships[2]).toEqual([1, 1]);
});
it("should create collections if part of an organization", async () => {
importer.organizationId = Utils.newGuid();
const result = await importer.parse(testDataJson);
expect(result != null).toBe(true);
const collections = result.collections;
expect(collections.length).toBe(2);
expect(collections[0].name).toBe("Optional Private Folder 1");
expect(collections[1].name).toBe("My Customer 1");
expect(result.collectionRelationships[0]).toEqual([0, 0]);
expect(result.collectionRelationships[1]).toEqual([1, 0]);
expect(result.collectionRelationships[2]).toEqual([1, 1]);
});
});

202
jslib/common/spec/importers/lastpassCsvImporter.spec.ts
View File

@@ -1,202 +0,0 @@
import { CipherType } from "@/jslib/common/src/enums/cipherType";
import { FieldType } from "@/jslib/common/src/enums/fieldType";
import { LastPassCsvImporter as Importer } from "@/jslib/common/src/importers/lastpassCsvImporter";
import { ImportResult } from "@/jslib/common/src/models/domain/importResult";
import { CipherView } from "@/jslib/common/src/models/view/cipherView";
import { FieldView } from "@/jslib/common/src/models/view/fieldView";
function baseExcept(result: ImportResult) {
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
}
function expectLogin(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Login);
expect(cipher.name).toBe("example.com");
expect(cipher.notes).toBe("super secure notes");
expect(cipher.login.uri).toBe("http://example.com");
expect(cipher.login.username).toBe("someUser");
expect(cipher.login.password).toBe("myPassword");
expect(cipher.login.totp).toBe("Y64VEVMBTSXCYIWRSHRNDZW62MPGVU2G");
}
const CipherData = [
{
title: "should parse expiration date",
csv: `url,username,password,extra,name,grouping,fav
http://sn,,,"NoteType:Credit Card
Name on Card:John Doe
Type:
Number:1234567812345678
Security Code:123
Start Date:October,2017
Expiration Date:June,2020
Notes:some text
",Credit-card,,0`,
expected: Object.assign(new CipherView(), {
id: null,
organizationId: null,
folderId: null,
name: "Credit-card",
notes: "some text\n",
type: 3,
card: {
cardholderName: "John Doe",
number: "1234567812345678",
code: "123",
expYear: "2020",
expMonth: "6",
},
fields: [
Object.assign(new FieldView(), {
name: "Start Date",
value: "October,2017",
type: FieldType.Text,
}),
],
}),
},
{
title: "should parse blank card note",
csv: `url,username,password,extra,name,grouping,fav
http://sn,,,"NoteType:Credit Card
Name on Card:
Type:
Number:
Security Code:
Start Date:,
Expiration Date:,
Notes:",empty,,0`,
expected: Object.assign(new CipherView(), {
id: null,
organizationId: null,
folderId: null,
name: "empty",
notes: null,
type: 3,
card: {
expMonth: undefined,
},
fields: [
Object.assign(new FieldView(), {
name: "Start Date",
value: ",",
type: FieldType.Text,
}),
],
}),
},
{
title: "should parse card expiration date w/ no exp year",
csv: `url,username,password,extra,name,grouping,fav
http://sn,,,"NoteType:Credit Card
Name on Card:John Doe
Type:Visa
Number:1234567887654321
Security Code:321
Start Date:,
Expiration Date:January,
Notes:",noyear,,0`,
expected: Object.assign(new CipherView(), {
id: null,
organizationId: null,
folderId: null,
name: "noyear",
notes: null,
type: 3,
card: {
cardholderName: "John Doe",
number: "1234567887654321",
code: "321",
expMonth: "1",
},
fields: [
Object.assign(new FieldView(), {
name: "Type",
value: "Visa",
type: FieldType.Text,
}),
Object.assign(new FieldView(), {
name: "Start Date",
value: ",",
type: FieldType.Text,
}),
],
}),
},
{
title: "should parse card expiration date w/ no month",
csv: `url,username,password,extra,name,grouping,fav
http://sn,,,"NoteType:Credit Card
Name on Card:John Doe
Type:Mastercard
Number:8765432112345678
Security Code:987
Start Date:,
Expiration Date:,2020
Notes:",nomonth,,0`,
expected: Object.assign(new CipherView(), {
id: null,
organizationId: null,
folderId: null,
name: "nomonth",
notes: null,
type: 3,
card: {
cardholderName: "John Doe",
number: "8765432112345678",
code: "987",
expYear: "2020",
expMonth: undefined,
},
fields: [
Object.assign(new FieldView(), {
name: "Type",
value: "Mastercard",
type: FieldType.Text,
}),
Object.assign(new FieldView(), {
name: "Start Date",
value: ",",
type: FieldType.Text,
}),
],
}),
},
];
describe("Lastpass CSV Importer", () => {
CipherData.forEach((data) => {
it(data.title, async () => {
const importer = new Importer();
const result = await importer.parse(data.csv);
expect(result != null).toBe(true);
expect(result.ciphers.length).toBeGreaterThan(0);
const cipher = result.ciphers.shift();
let property: keyof typeof data.expected;
for (property in data.expected) {
// eslint-disable-next-line
if (data.expected.hasOwnProperty(property)) {
// eslint-disable-next-line
expect(cipher.hasOwnProperty(property)).toBe(true);
expect(cipher[property]).toEqual(data.expected[property]);
}
}
});
});
it("should parse login with totp", async () => {
const input = `url,username,password,totp,extra,name,grouping,fav
http://example.com,someUser,myPassword,Y64VEVMBTSXCYIWRSHRNDZW62MPGVU2G,super secure notes,example.com,,0`;
const importer = new Importer();
const result = await importer.parse(input);
baseExcept(result);
const cipher = result.ciphers[0];
expectLogin(cipher);
});
});

633
jslib/common/spec/importers/mykiCsvImporter.spec.ts
View File

@@ -1,633 +0,0 @@
import { CipherType } from "@/jslib/common/src/enums/cipherType";
import { MykiCsvImporter as Importer } from "@/jslib/common/src/importers/mykiCsvImporter";
import { CipherView } from "@/jslib/common/src/models/view/cipherView";
import { userAccountData } from "./testData/mykiCsv/UserAccount.csv";
import { userCreditCardData } from "./testData/mykiCsv/UserCreditCard.csv";
import { userIdCardData } from "./testData/mykiCsv/UserIdCard.csv";
import { userIdentityData } from "./testData/mykiCsv/UserIdentity.csv";
import { userNoteData } from "./testData/mykiCsv/UserNote.csv";
import { userTwoFaData } from "./testData/mykiCsv/UserTwofa.csv";
function expectDriversLicense(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Joe User's nickname");
expect(cipher.notes).toBe("Additional information");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.licenseNumber).toBe("123456");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Driver's License");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("02/02/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("02/02/2024");
}
function expectPassport(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Passport ID card");
expect(cipher.notes).toBe("Additional information field");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.passportNumber).toBe("1234567");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Passport");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2028");
}
function expectSocialSecurity(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Social Security ID card");
expect(cipher.notes).toBe("Additional information field text");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.ssn).toBe("123455678");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Social Security");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2028");
}
function expectIdCard(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("ID card type ID card");
expect(cipher.notes).toBe("Additional Information field text");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.licenseNumber).toBe("1234566");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("ID Card");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2028");
}
function expectTaxNumber(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Tax number ID card");
expect(cipher.notes).toBe("Additinoal information text field");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.licenseNumber).toBe("12345678");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Tax Number");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2028");
}
function expectBankAccount(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Bank account ID card");
expect(cipher.notes).toBe("Additional text information here");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.licenseNumber).toBe("12344556677");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Bank Account");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2028");
}
function expectInsuranceCard(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Insurance card ID card");
expect(cipher.notes).toBe("Additional information text goes here");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.licenseNumber).toBe("123456677");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Insurance Card");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2022");
}
function expectHealthCard(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Health card Id card");
expect(cipher.notes).toBe("More info");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.licenseNumber).toBe("1234670");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Health Card");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2028");
}
function expectMembershipCard(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Membership ID card");
expect(cipher.notes).toBe("Add'l info");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.licenseNumber).toBe("12345709");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Membership");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2028");
}
function expectDatabase(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Database ID card");
expect(cipher.notes).toBe("Addin't info");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.licenseNumber).toBe("12345089u");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Database");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2028");
}
function expectOutdoorLicense(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Outdoor license ID card");
expect(cipher.notes).toBe("Additional info");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.licenseNumber).toBe("123890090");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Outdoor License");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2028");
}
function expectRewardProgram(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Reward program Id card");
expect(cipher.notes).toBe("1234890");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.licenseNumber).toBe("12345890b");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Reward Program");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2028");
}
function expectSoftwareLicense(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Software license ID card");
expect(cipher.notes).toBe(
"It seems like the fields don't change, which makes it pretty useless that they have so many ID card types."
);
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.licenseNumber).toBe("1234567c");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Software License");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2028");
}
function expectTourVisa(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Tour visa ID card");
expect(cipher.notes).toBe("Additional Informaion text");
expect(cipher.identity.fullName).toBe("Joe M User");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.licenseNumber).toBe("123456lkhj");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(5);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toEqual("tags");
expect(cipher.fields[1].value).toEqual("someTag");
expect(cipher.fields[2].name).toEqual("idType");
expect(cipher.fields[2].value).toEqual("Tour Visa");
expect(cipher.fields[3].name).toEqual("idIssuanceDate");
expect(cipher.fields[3].value).toEqual("03/07/2022");
expect(cipher.fields[4].name).toEqual("idExpirationDate");
expect(cipher.fields[4].value).toEqual("03/07/2028");
}
describe("Myki CSV Importer", () => {
let importer: Importer;
beforeEach(() => {
importer = new Importer();
});
it("should parse userAccount records", async () => {
const result = await importer.parse(userAccountData);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.name).toEqual("PasswordNickname");
expect(cipher.login.username).toEqual("user.name@email.com");
expect(cipher.login.password).toEqual("abc123");
expect(cipher.login.totp).toEqual("someTOTPSeed");
expect(cipher.login.uris.length).toEqual(1);
const uriView = cipher.login.uris.shift();
expect(uriView.uri).toEqual("http://www.google.com");
expect(cipher.notes).toEqual("This is the additional information text.");
expect(cipher.fields.length).toBe(2);
expect(cipher.fields[0].name).toBe("status");
expect(cipher.fields[0].value).toBe("active");
expect(cipher.fields[1].name).toBe("tags");
expect(cipher.fields[1].value).toBe("someTag");
});
it("should parse userTwoFa records", async () => {
const result = await importer.parse(userTwoFaData);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.name).toEqual("2FA nickname");
expect(cipher.login.username).toBeNull();
expect(cipher.login.password).toBeNull();
expect(cipher.login.totp).toBe("someTOTPSeed");
expect(cipher.notes).toEqual("Additional information field content.");
expect(cipher.fields.length).toBe(2);
expect(cipher.fields[0].name).toBe("status");
expect(cipher.fields[0].value).toBe("active");
expect(cipher.fields[1].name).toBe("tags");
expect(cipher.fields[1].value).toBe("someTag");
});
it("should parse creditCard records", async () => {
const result = await importer.parse(userCreditCardData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
const cipher = result.ciphers.shift();
expect(cipher.type).toBe(CipherType.Card);
expect(cipher.name).toBe("Visa test card");
expect(cipher.card.brand).toBe("Visa");
expect(cipher.card.cardholderName).toBe("Joe User");
expect(cipher.card.number).toBe("4111111111111111");
expect(cipher.card.code).toBe("222");
expect(cipher.card.expMonth).toBe("04");
expect(cipher.card.expYear).toBe("24");
expect(cipher.notes).toBe("This is the additional information field");
expect(cipher.fields.length).toBe(2);
expect(cipher.fields[0].name).toBe("status");
expect(cipher.fields[0].value).toBe("active");
expect(cipher.fields[1].name).toBe("tags");
expect(cipher.fields[1].value).toBe("someTag");
});
it("should parse identity records", async () => {
const result = await importer.parse(userIdentityData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("Joe User's nickname");
expect(cipher.identity.fullName).toBe("Mr Joe M User");
expect(cipher.identity.title).toBe("Mr");
expect(cipher.identity.firstName).toBe("Joe");
expect(cipher.identity.middleName).toBe("M");
expect(cipher.identity.lastName).toBe("User");
expect(cipher.identity.email).toBe("joe.user@email.com");
expect(cipher.identity.address1).toBe("1 Example House");
expect(cipher.identity.address2).toBe("Suite 300");
expect(cipher.identity.city).toBe("Portland");
expect(cipher.identity.postalCode).toBe("04101");
expect(cipher.identity.country).toBe("United States");
expect(cipher.fields.length).toBe(4);
expect(cipher.fields[0].name).toEqual("status");
expect(cipher.fields[0].value).toEqual("active");
expect(cipher.fields[1].name).toBe("tags");
expect(cipher.fields[1].value).toBe("someTag");
expect(cipher.fields[2].name).toEqual("gender");
expect(cipher.fields[2].value).toEqual("Male");
expect(cipher.fields[3].name).toEqual("number");
expect(cipher.fields[3].value).toEqual("2223334444");
});
it("should parse secureNote records", async () => {
const result = await importer.parse(userNoteData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
const cipher = result.ciphers.shift();
expect(cipher.type).toBe(CipherType.SecureNote);
expect(cipher.name).toBe("The title of a secure note");
expect(cipher.notes).toBe("The content of a secure note. Lorem ipsum, etc.");
expect(cipher.fields.length).toBe(1);
expect(cipher.fields[0].name).toBe("status");
expect(cipher.fields[0].value).toBe("active");
});
it("should parse idCard records", async () => {
const result = await importer.parse(userIdCardData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(14);
// Driver's license
const cipher = result.ciphers.shift();
expectDriversLicense(cipher);
// Passport
const cipher2 = result.ciphers.shift();
expectPassport(cipher2);
// Social Security
const cipher3 = result.ciphers.shift();
expectSocialSecurity(cipher3);
// Id Card
const cipher4 = result.ciphers.shift();
expectIdCard(cipher4);
// Tax Number
const cipher5 = result.ciphers.shift();
expectTaxNumber(cipher5);
// Bank Account
const cipher6 = result.ciphers.shift();
expectBankAccount(cipher6);
// Insurance card
const cipher7 = result.ciphers.shift();
expectInsuranceCard(cipher7);
// Health card
const cipher8 = result.ciphers.shift();
expectHealthCard(cipher8);
// Membership card
const cipher9 = result.ciphers.shift();
expectMembershipCard(cipher9);
// Database card
const cipher10 = result.ciphers.shift();
expectDatabase(cipher10);
// Outdoor license
const cipher11 = result.ciphers.shift();
expectOutdoorLicense(cipher11);
// Reward program
const cipher12 = result.ciphers.shift();
expectRewardProgram(cipher12);
// Software license
const cipher13 = result.ciphers.shift();
expectSoftwareLicense(cipher13);
// Tour visa
const cipher14 = result.ciphers.shift();
expectTourVisa(cipher14);
});
});

181
jslib/common/spec/importers/nordpassCsvImporter.spec.ts
View File

@@ -1,181 +0,0 @@
import { CipherType } from "@/jslib/common/src/enums/cipherType";
import { SecureNoteType } from "@/jslib/common/src/enums/secureNoteType";
import { NordPassCsvImporter as Importer } from "@/jslib/common/src/importers/nordpassCsvImporter";
import { CipherView } from "@/jslib/common/src/models/view/cipherView";
import { IdentityView } from "@/jslib/common/src/models/view/identityView";
import { data as creditCardData } from "./testData/nordpassCsv/nordpass.card.csv";
import { data as identityData } from "./testData/nordpassCsv/nordpass.identity.csv";
import { data as loginData } from "./testData/nordpassCsv/nordpass.login.csv";
import { data as secureNoteData } from "./testData/nordpassCsv/nordpass.secureNote.csv";
const namesTestData = [
{
title: "Given #fullName should set firstName",
fullName: "MyFirstName",
expected: Object.assign(new IdentityView(), {
firstName: "MyFirstName",
middleName: null,
lastName: null,
}),
},
{
title: "Given #fullName should set first- and lastName",
fullName: "MyFirstName MyLastName",
expected: Object.assign(new IdentityView(), {
firstName: "MyFirstName",
middleName: null,
lastName: "MyLastName",
}),
},
{
title: "Given #fullName should set first-, middle and lastName",
fullName: "MyFirstName MyMiddleName MyLastName",
expected: Object.assign(new IdentityView(), {
firstName: "MyFirstName",
middleName: "MyMiddleName",
lastName: "MyLastName",
}),
},
{
title: "Given #fullName should set first-, middle and lastName with Jr",
fullName: "MyFirstName MyMiddleName MyLastName Jr",
expected: Object.assign(new IdentityView(), {
firstName: "MyFirstName",
middleName: "MyMiddleName",
lastName: "MyLastName Jr",
}),
},
{
title: "Given #fullName should set first-, middle and lastName with Jr and III",
fullName: "MyFirstName MyMiddleName MyLastName Jr III",
expected: Object.assign(new IdentityView(), {
firstName: "MyFirstName",
middleName: "MyMiddleName",
lastName: "MyLastName Jr III",
}),
},
];
function expectLogin(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Login);
expect(cipher.name).toBe("SomeVaultItemName");
expect(cipher.notes).toBe("Some note for the VaultItem");
expect(cipher.login.uri).toBe("https://example.com");
expect(cipher.login.username).toBe("hello@bitwarden.com");
expect(cipher.login.password).toBe("someStrongPassword");
}
function expectCreditCard(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Card);
expect(cipher.name).toBe("SomeVisa");
expect(cipher.card.brand).toBe("Visa");
expect(cipher.card.cardholderName).toBe("SomeHolder");
expect(cipher.card.number).toBe("4024007103939509");
expect(cipher.card.code).toBe("123");
expect(cipher.card.expMonth).toBe("1");
expect(cipher.card.expYear).toBe("22");
}
function expectIdentity(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.name).toBe("SomeTitle");
expect(cipher.identity.fullName).toBe("MyFirstName MyMiddleName MyLastName");
expect(cipher.identity.firstName).toBe("MyFirstName");
expect(cipher.identity.middleName).toBe("MyMiddleName");
expect(cipher.identity.lastName).toBe("MyLastName");
expect(cipher.identity.email).toBe("hello@bitwarden.com");
expect(cipher.identity.phone).toBe("123456789");
expect(cipher.identity.address1).toBe("Test street 123");
expect(cipher.identity.address2).toBe("additional addressinfo");
expect(cipher.identity.postalCode).toBe("123456");
expect(cipher.identity.city).toBe("Cologne");
expect(cipher.identity.state).toBe("North-Rhine-Westphalia");
expect(cipher.identity.country).toBe("GERMANY");
expect(cipher.notes).toBe("SomeNoteToMyIdentity");
}
function expectSecureNote(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.SecureNote);
expect(cipher.name).toBe("MySuperSecureNoteTitle");
expect(cipher.secureNote.type).toBe(SecureNoteType.Generic);
expect(cipher.notes).toBe("MySuperSecureNote");
}
describe("NordPass CSV Importer", () => {
let importer: Importer;
beforeEach(() => {
importer = new Importer();
});
it("should parse login records", async () => {
const result = await importer.parse(loginData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
const cipher = result.ciphers[0];
expectLogin(cipher);
});
it("should parse credit card records", async () => {
const result = await importer.parse(creditCardData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
const cipher = result.ciphers[0];
expectCreditCard(cipher);
});
it("should parse identity records", async () => {
const result = await importer.parse(
identityData.replace("#fullName", "MyFirstName MyMiddleName MyLastName")
);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
const cipher = result.ciphers[0];
expectIdentity(cipher);
});
namesTestData.forEach((data) => {
it(data.title.replace("#fullName", data.fullName), async () => {
const result = await importer.parse(identityData.replace("#fullName", data.fullName));
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
const cipher = result.ciphers[0];
expect(cipher.identity.firstName).toBe(data.expected.firstName);
expect(cipher.identity.middleName).toBe(data.expected.middleName);
expect(cipher.identity.lastName).toBe(data.expected.lastName);
});
});
it("should parse secureNote records", async () => {
const result = await importer.parse(secureNoteData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
const cipher = result.ciphers[0];
expectSecureNote(cipher);
});
it("should parse an item and create a folder", async () => {
const result = await importer.parse(secureNoteData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.folders.length).toBe(1);
const folder = result.folders[0];
expect(folder.name).toBe("notesFolder");
});
});

527
jslib/common/spec/importers/onepassword1PifImporter.spec.ts
View File

@@ -1,527 +0,0 @@
import { FieldType } from "@/jslib/common/src/enums/fieldType";
import { OnePassword1PifImporter as Importer } from "@/jslib/common/src/importers/onepasswordImporters/onepassword1PifImporter";
const TestData: string =
"***aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee***\n" +
JSON.stringify({
uuid: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
updatedAt: 1486071244,
securityLevel: "SL5",
contentsHash: "aaaaaaaa",
title: "Imported Entry",
location: "https://www.google.com",
secureContents: {
fields: [
{
value: "user@test.net",
id: "email-input",
name: "email",
type: "T",
designation: "username",
},
{
value: "myservicepassword",
id: "password-input",
name: "password",
type: "P",
designation: "password",
},
],
sections: [
{
fields: [
{
k: "concealed",
n: "AAAAAAAAAAAABBBBBBBBBBBCCCCCCCCC",
v: "console-password-123",
t: "console password",
},
],
title: "Admin Console",
name: "admin_console",
},
],
passwordHistory: [
{
value: "old-password",
time: 1447791421,
},
],
},
URLs: [
{
label: "website",
url: "https://www.google.com",
},
],
txTimestamp: 1508941334,
createdAt: 1390426636,
typeName: "webforms.WebForm",
});
const WindowsOpVaultTestData = JSON.stringify({
category: "001",
created: 1544823719,
hmac: "NtyBmTTPOb88HV3JUKPx1xl/vcMhac9kvCfe/NtszY0=",
k: "**REMOVED LONG LINE FOR LINTER** -Kyle",
tx: 1553395669,
updated: 1553395669,
uuid: "528AB076FB5F4FBF960884B8E01619AC",
overview: {
title: "Google",
URLs: [
{
u: "google.com",
},
],
url: "google.com",
ps: 26,
ainfo: "googluser",
},
details: {
passwordHistory: [
{
value: "oldpass1",
time: 1553394449,
},
{
value: "oldpass2",
time: 1553394457,
},
{
value: "oldpass3",
time: 1553394458,
},
{
value: "oldpass4",
time: 1553394459,
},
{
value: "oldpass5",
time: 1553394460,
},
{
value: "oldpass6",
time: 1553394461,
},
],
fields: [
{
type: "T",
id: "username",
name: "username",
value: "googluser",
designation: "username",
},
{
type: "P",
id: "password",
name: "password",
value: "12345678901",
designation: "password",
},
],
notesPlain: "This is a note\r\n\r\nline1\r\nline2",
sections: [
{
title: "test",
name: "1214FD88CD30405D9EED14BEB4D61B60",
fields: [
{
k: "string",
n: "6CC3BD77482D4559A4B8BB2D360F821B",
v: "fgfg",
t: "fgggf",
},
{
k: "concealed",
n: "5CFE7BCAA1DF4578BBF7EB508959BFF3",
v: "dfgdfgfdg",
t: "pwfield",
},
],
},
],
},
});
const IdentityTestData = JSON.stringify({
uuid: "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
updatedAt: 1553365894,
securityLevel: "SL5",
contentsHash: "eeeeeeee",
title: "Test Identity",
secureContents: {
lastname: "Fritzenberger",
zip: "223344",
birthdate_dd: "11",
homephone: "+49 333 222 111",
company: "Web Inc.",
firstname: "Frank",
birthdate_mm: "3",
country: "de",
sex: "male",
sections: [
{
fields: [
{
k: "string",
inputTraits: {
autocapitalization: "Words",
},
n: "firstname",
v: "Frank",
a: {
guarded: "yes",
},
t: "first name",
},
{
k: "string",
inputTraits: {
autocapitalization: "Words",
},
n: "initial",
v: "MD",
a: {
guarded: "yes",
},
t: "initial",
},
{
k: "string",
inputTraits: {
autocapitalization: "Words",
},
n: "lastname",
v: "Fritzenberger",
a: {
guarded: "yes",
},
t: "last name",
},
{
k: "menu",
v: "male",
n: "sex",
a: {
guarded: "yes",
},
t: "sex",
},
{
k: "date",
v: 1552305660,
n: "birthdate",
a: {
guarded: "yes",
},
t: "birth date",
},
{
k: "string",
inputTraits: {
autocapitalization: "Words",
},
n: "occupation",
v: "Engineer",
a: {
guarded: "yes",
},
t: "occupation",
},
{
k: "string",
inputTraits: {
autocapitalization: "Words",
},
n: "company",
v: "Web Inc.",
a: {
guarded: "yes",
},
t: "company",
},
{
k: "string",
inputTraits: {
autocapitalization: "Words",
},
n: "department",
v: "IT",
a: {
guarded: "yes",
},
t: "department",
},
{
k: "string",
inputTraits: {
autocapitalization: "Words",
},
n: "jobtitle",
v: "Developer",
a: {
guarded: "yes",
},
t: "job title",
},
],
title: "Identification",
name: "name",
},
{
fields: [
{
k: "address",
inputTraits: {
autocapitalization: "Sentences",
},
n: "address",
v: {
street: "Mainstreet 1",
city: "Berlin",
country: "de",
zip: "223344",
},
a: {
guarded: "yes",
},
t: "address",
},
{
k: "phone",
v: "+49 001 222 333 44",
n: "defphone",
a: {
guarded: "yes",
},
t: "default phone",
},
{
k: "phone",
v: "+49 333 222 111",
n: "homephone",
a: {
guarded: "yes",
},
t: "home",
},
{
k: "phone",
n: "cellphone",
a: {
guarded: "yes",
},
t: "mobile",
},
{
k: "phone",
n: "busphone",
a: {
guarded: "yes",
},
t: "business",
},
],
title: "Address",
name: "address",
},
{
fields: [
{
k: "string",
n: "username",
a: {
guarded: "yes",
},
t: "username",
},
{
k: "string",
n: "reminderq",
t: "reminder question",
},
{
k: "string",
n: "remindera",
t: "reminder answer",
},
{
k: "string",
inputTraits: {
keyboard: "EmailAddress",
},
n: "email",
v: "test@web.de",
a: {
guarded: "yes",
},
t: "email",
},
{
k: "string",
n: "website",
inputTraits: {
keyboard: "URL",
},
t: "website",
},
{
k: "string",
n: "icq",
t: "ICQ",
},
{
k: "string",
n: "skype",
t: "skype",
},
{
k: "string",
n: "aim",
t: "AOL/AIM",
},
{
k: "string",
n: "yahoo",
t: "Yahoo",
},
{
k: "string",
n: "msn",
t: "MSN",
},
{
k: "string",
n: "forumsig",
t: "forum signature",
},
],
title: "Internet Details",
name: "internet",
},
{
title: "Related Items",
name: "linked items",
},
],
initial: "MD",
address1: "Mainstreet 1",
city: "Berlin",
jobtitle: "Developer",
occupation: "Engineer",
department: "IT",
email: "test@web.de",
birthdate_yy: "2019",
homephone_local: "+49 333 222 111",
defphone_local: "+49 001 222 333 44",
defphone: "+49 001 222 333 44",
},
txTimestamp: 1553365894,
createdAt: 1553364679,
typeName: "identities.Identity",
});
describe("1Password 1Pif Importer", () => {
it("should parse data", async () => {
const importer = new Importer();
const result = await importer.parse(TestData);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.login.username).toEqual("user@test.net");
expect(cipher.login.password).toEqual("myservicepassword");
expect(cipher.login.uris.length).toEqual(1);
const uriView = cipher.login.uris.shift();
expect(uriView.uri).toEqual("https://www.google.com");
});
it('should create concealed field as "hidden" type', async () => {
const importer = new Importer();
const result = await importer.parse(TestData);
expect(result != null).toBe(true);
const ciphers = result.ciphers;
expect(ciphers.length).toEqual(1);
const cipher = ciphers.shift();
const fields = cipher.fields;
expect(fields.length).toEqual(1);
const field = fields.shift();
expect(field.name).toEqual("console password");
expect(field.value).toEqual("console-password-123");
expect(field.type).toEqual(FieldType.Hidden);
});
it("should create identity records", async () => {
const importer = new Importer();
const result = await importer.parse(IdentityTestData);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.name).toEqual("Test Identity");
const identity = cipher.identity;
expect(identity.firstName).toEqual("Frank");
expect(identity.middleName).toEqual("MD");
expect(identity.lastName).toEqual("Fritzenberger");
expect(identity.company).toEqual("Web Inc.");
expect(identity.address1).toEqual("Mainstreet 1");
expect(identity.country).toEqual("DE");
expect(identity.city).toEqual("Berlin");
expect(identity.postalCode).toEqual("223344");
expect(identity.phone).toEqual("+49 001 222 333 44");
expect(identity.email).toEqual("test@web.de");
// remaining fields as custom fields
expect(cipher.fields.length).toEqual(6);
const fields = cipher.fields;
expect(fields[0].name).toEqual("sex");
expect(fields[0].value).toEqual("male");
expect(fields[1].name).toEqual("birth date");
expect(fields[1].value).toEqual("Mon, 11 Mar 2019 12:01:00 GMT");
expect(fields[2].name).toEqual("occupation");
expect(fields[2].value).toEqual("Engineer");
expect(fields[3].name).toEqual("department");
expect(fields[3].value).toEqual("IT");
expect(fields[4].name).toEqual("job title");
expect(fields[4].value).toEqual("Developer");
expect(fields[5].name).toEqual("home");
expect(fields[5].value).toEqual("+49 333 222 111");
});
it("should create password history", async () => {
const importer = new Importer();
const result = await importer.parse(TestData);
const cipher = result.ciphers.shift();
expect(cipher.passwordHistory.length).toEqual(1);
const ph = cipher.passwordHistory.shift();
expect(ph.password).toEqual("old-password");
expect(ph.lastUsedDate.toISOString()).toEqual("2015-11-17T20:17:01.000Z");
});
it("should create password history from windows opvault 1pif format", async () => {
const importer = new Importer();
const result = await importer.parse(WindowsOpVaultTestData);
const cipher = result.ciphers.shift();
expect(cipher.passwordHistory.length).toEqual(5);
let ph = cipher.passwordHistory.shift();
expect(ph.password).toEqual("oldpass6");
expect(ph.lastUsedDate.toISOString()).toEqual("2019-03-24T02:27:41.000Z");
ph = cipher.passwordHistory.shift();
expect(ph.password).toEqual("oldpass5");
expect(ph.lastUsedDate.toISOString()).toEqual("2019-03-24T02:27:40.000Z");
ph = cipher.passwordHistory.shift();
expect(ph.password).toEqual("oldpass4");
expect(ph.lastUsedDate.toISOString()).toEqual("2019-03-24T02:27:39.000Z");
ph = cipher.passwordHistory.shift();
expect(ph.password).toEqual("oldpass3");
expect(ph.lastUsedDate.toISOString()).toEqual("2019-03-24T02:27:38.000Z");
ph = cipher.passwordHistory.shift();
expect(ph.password).toEqual("oldpass2");
expect(ph.lastUsedDate.toISOString()).toEqual("2019-03-24T02:27:37.000Z");
});
});

689
jslib/common/spec/importers/onepassword1PuxImporter.spec.ts
View File

@@ -1,689 +0,0 @@
import { CipherType } from "@/jslib/common/src/enums/cipherType";
import { FieldType } from "@/jslib/common/src/enums/fieldType";
import { SecureNoteType } from "@/jslib/common/src/enums/secureNoteType";
import { OnePassword1PuxImporter as Importer } from "@/jslib/common/src/importers/onepasswordImporters/onepassword1PuxImporter";
import { Utils } from "@/jslib/common/src/misc/utils";
import { FieldView } from "@/jslib/common/src/models/view/fieldView";
import { APICredentialsData } from "./testData/onePassword1Pux/APICredentials";
import { BankAccountData } from "./testData/onePassword1Pux/BankAccount";
import { CreditCardData } from "./testData/onePassword1Pux/CreditCard";
import { DatabaseData } from "./testData/onePassword1Pux/Database";
import { DriversLicenseData } from "./testData/onePassword1Pux/DriversLicense";
import { EmailAccountData } from "./testData/onePassword1Pux/EmailAccount";
import { EmailFieldData } from "./testData/onePassword1Pux/Emailfield";
import { EmailFieldOnIdentityData } from "./testData/onePassword1Pux/EmailfieldOnIdentity";
import { EmailFieldOnIdentityPrefilledData } from "./testData/onePassword1Pux/EmailfieldOnIdentity_Prefilled";
import { IdentityData } from "./testData/onePassword1Pux/IdentityData";
import { LoginData } from "./testData/onePassword1Pux/LoginData";
import { MedicalRecordData } from "./testData/onePassword1Pux/MedicalRecord";
import { MembershipData } from "./testData/onePassword1Pux/Membership";
import { OnePuxExampleFile } from "./testData/onePassword1Pux/Onepux_example";
import { OutdoorLicenseData } from "./testData/onePassword1Pux/OutdoorLicense";
import { PassportData } from "./testData/onePassword1Pux/Passport";
import { PasswordData } from "./testData/onePassword1Pux/Password";
import { RewardsProgramData } from "./testData/onePassword1Pux/RewardsProgram";
import { SSNData } from "./testData/onePassword1Pux/SSN";
import { SanitizedExport } from "./testData/onePassword1Pux/SanitizedExport";
import { SecureNoteData } from "./testData/onePassword1Pux/SecureNote";
import { ServerData } from "./testData/onePassword1Pux/Server";
import { SoftwareLicenseData } from "./testData/onePassword1Pux/SoftwareLicense";
import { WirelessRouterData } from "./testData/onePassword1Pux/WirelessRouter";
function validateCustomField(fields: FieldView[], fieldName: string, expectedValue: any) {
expect(fields).toBeDefined();
const customField = fields.find((f) => f.name === fieldName);
expect(customField).toBeDefined();
expect(customField.value).toEqual(expectedValue);
}
describe("1Password 1Pux Importer", () => {
const OnePuxExampleFileJson = JSON.stringify(OnePuxExampleFile);
const LoginDataJson = JSON.stringify(LoginData);
const CreditCardDataJson = JSON.stringify(CreditCardData);
const IdentityDataJson = JSON.stringify(IdentityData);
const SecureNoteDataJson = JSON.stringify(SecureNoteData);
const SanitizedExportJson = JSON.stringify(SanitizedExport);
it("should parse login data", async () => {
const importer = new Importer();
const result = await importer.parse(LoginDataJson);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.Login);
expect(cipher.name).toEqual("eToro");
expect(cipher.login.username).toEqual("username123123123@gmail.com");
expect(cipher.login.password).toEqual("password!");
expect(cipher.login.uris.length).toEqual(1);
expect(cipher.login.uri).toEqual("https://www.fakesite.com");
expect(cipher.login.totp).toEqual("otpseed777");
// remaining fields as custom fields
expect(cipher.fields.length).toEqual(3);
validateCustomField(cipher.fields, "terms", "false");
validateCustomField(cipher.fields, "policies", "true");
validateCustomField(cipher.fields, "cyqyggt2otns6tbbqtsl6w2ceu", "username123123");
});
it("should parse notes", async () => {
const importer = new Importer();
const result = await importer.parse(OnePuxExampleFileJson);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.notes).toEqual("This is a note. *bold*! _italic_!");
});
it("should set favourite if favIndex equals 1", async () => {
const importer = new Importer();
const result = await importer.parse(OnePuxExampleFileJson);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.favorite).toBe(true);
});
it("should handle custom boolean fields", async () => {
const importer = new Importer();
const result = await importer.parse(LoginDataJson);
expect(result != null).toBe(true);
const ciphers = result.ciphers;
expect(ciphers.length).toEqual(1);
const cipher = ciphers.shift();
expect(cipher.fields[0].name).toEqual("terms");
expect(cipher.fields[0].value).toEqual("false");
expect(cipher.fields[0].type).toBe(FieldType.Boolean);
expect(cipher.fields[1].name).toEqual("policies");
expect(cipher.fields[1].value).toEqual("true");
expect(cipher.fields[1].type).toBe(FieldType.Boolean);
});
it("should add fields of type email as custom fields", async () => {
const importer = new Importer();
const EmailFieldDataJson = JSON.stringify(EmailFieldData);
const result = await importer.parse(EmailFieldDataJson);
expect(result != null).toBe(true);
const ciphers = result.ciphers;
expect(ciphers.length).toEqual(1);
const cipher = ciphers.shift();
expect(cipher.fields[0].name).toEqual("reg_email");
expect(cipher.fields[0].value).toEqual("kriddler@nullvalue.test");
expect(cipher.fields[0].type).toBe(FieldType.Text);
expect(cipher.fields[1].name).toEqual("provider");
expect(cipher.fields[1].value).toEqual("myEmailProvider");
expect(cipher.fields[1].type).toBe(FieldType.Text);
});
it('should create concealed field as "hidden" type', async () => {
const importer = new Importer();
const result = await importer.parse(OnePuxExampleFileJson);
expect(result != null).toBe(true);
const ciphers = result.ciphers;
expect(ciphers.length).toEqual(1);
const cipher = ciphers.shift();
const fields = cipher.fields;
expect(fields.length).toEqual(1);
const field = fields.shift();
expect(field.name).toEqual("PIN");
expect(field.value).toEqual("12345");
expect(field.type).toEqual(FieldType.Hidden);
});
it("should create password history", async () => {
const importer = new Importer();
const result = await importer.parse(OnePuxExampleFileJson);
const cipher = result.ciphers.shift();
expect(cipher.passwordHistory.length).toEqual(1);
const ph = cipher.passwordHistory.shift();
expect(ph.password).toEqual("12345password");
expect(ph.lastUsedDate.toISOString()).toEqual("2016-03-18T17:32:35.000Z");
});
it("should create credit card records", async () => {
const importer = new Importer();
const result = await importer.parse(CreditCardDataJson);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.name).toEqual("Parent's Credit Card");
expect(cipher.notes).toEqual("My parents' credit card.");
const card = cipher.card;
expect(card.cardholderName).toEqual("Fred Engels");
expect(card.number).toEqual("6011111111111117");
expect(card.code).toEqual("1312");
expect(card.brand).toEqual("Discover");
expect(card.expMonth).toEqual("12");
expect(card.expYear).toEqual("2099");
// remaining fields as custom fields
expect(cipher.fields.length).toEqual(12);
validateCustomField(cipher.fields, "txbzvwzpck7ejhfres3733rbpm", "card");
validateCustomField(cipher.fields, "cashLimit", "$500");
validateCustomField(cipher.fields, "creditLimit", "$1312");
validateCustomField(cipher.fields, "validFrom", "200101");
validateCustomField(cipher.fields, "bank", "Some bank");
validateCustomField(cipher.fields, "phoneLocal", "123456");
validateCustomField(cipher.fields, "phoneTollFree", "0800123456");
validateCustomField(cipher.fields, "phoneIntl", "+49123456");
validateCustomField(cipher.fields, "website", "somebank.com");
validateCustomField(cipher.fields, "pin", "1234");
validateCustomField(cipher.fields, "interest", "1%");
validateCustomField(cipher.fields, "issuenumber", "123456");
});
it("should create identity records", async () => {
const importer = new Importer();
const result = await importer.parse(IdentityDataJson);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.name).toEqual("George Engels");
const identity = cipher.identity;
expect(identity.firstName).toEqual("George");
expect(identity.middleName).toEqual("S");
expect(identity.lastName).toEqual("Engels");
expect(identity.company).toEqual("Acme Inc.");
expect(identity.address1).toEqual("1312 Main St.");
expect(identity.country).toEqual("US");
expect(identity.state).toEqual("California");
expect(identity.city).toEqual("Atlantis");
expect(identity.postalCode).toEqual("90210");
expect(identity.phone).toEqual("4565555555");
expect(identity.email).toEqual("gengels@nullvalue.test");
expect(identity.username).toEqual("gengels");
// remaining fields as custom fields
expect(cipher.fields.length).toEqual(17);
validateCustomField(cipher.fields, "sex", "male");
validateCustomField(cipher.fields, "birthdate", "Thu, 01 Jan 1981 12:01:00 GMT");
validateCustomField(cipher.fields, "occupation", "Steel Worker");
validateCustomField(cipher.fields, "department", "QA");
validateCustomField(cipher.fields, "jobtitle", "Quality Assurance Manager");
validateCustomField(cipher.fields, "homephone", "4575555555");
validateCustomField(cipher.fields, "cellphone", "4585555555");
validateCustomField(cipher.fields, "busphone", "4595555555");
validateCustomField(cipher.fields, "reminderq", "Who's a super cool guy?");
validateCustomField(cipher.fields, "remindera", "Me, buddy.");
validateCustomField(cipher.fields, "website", "cv.gengels.nullvalue.test");
validateCustomField(cipher.fields, "icq", "12345678");
validateCustomField(cipher.fields, "skype", "skypeisbad1619");
validateCustomField(cipher.fields, "aim", "aollol@lololol.aol.com");
validateCustomField(cipher.fields, "yahoo", "sk8rboi13@yah00.com");
validateCustomField(cipher.fields, "msn", "msnothankyou@msn&m&m.com");
validateCustomField(cipher.fields, "forumsig", "super cool guy");
});
it("emails fields on identity types should be added to the identity email field", async () => {
const importer = new Importer();
const EmailFieldOnIdentityDataJson = JSON.stringify(EmailFieldOnIdentityData);
const result = await importer.parse(EmailFieldOnIdentityDataJson);
expect(result != null).toBe(true);
const ciphers = result.ciphers;
expect(ciphers.length).toEqual(1);
const cipher = ciphers.shift();
const identity = cipher.identity;
expect(identity.email).toEqual("gengels@nullvalue.test");
expect(cipher.fields[0].name).toEqual("provider");
expect(cipher.fields[0].value).toEqual("myEmailProvider");
expect(cipher.fields[0].type).toBe(FieldType.Text);
});
it("emails fields on identity types should be added to custom fields if identity.email has been filled", async () => {
const importer = new Importer();
const EmailFieldOnIdentityPrefilledDataJson = JSON.stringify(EmailFieldOnIdentityPrefilledData);
const result = await importer.parse(EmailFieldOnIdentityPrefilledDataJson);
expect(result != null).toBe(true);
const ciphers = result.ciphers;
expect(ciphers.length).toEqual(1);
const cipher = ciphers.shift();
const identity = cipher.identity;
expect(identity.email).toEqual("gengels@nullvalue.test");
expect(cipher.fields[0].name).toEqual("2nd_email");
expect(cipher.fields[0].value).toEqual("kriddler@nullvalue.test");
expect(cipher.fields[0].type).toBe(FieldType.Text);
expect(cipher.fields[1].name).toEqual("provider");
expect(cipher.fields[1].value).toEqual("myEmailProvider");
expect(cipher.fields[1].type).toBe(FieldType.Text);
});
it("should parse category 005 - Password (Legacy)", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(PasswordData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.Login);
expect(cipher.name).toEqual("SuperSecret Password");
expect(cipher.notes).toEqual("SuperSecret Password Notes");
expect(cipher.login.password).toEqual("GBq[AGb]4*Si3tjwuab^");
expect(cipher.login.uri).toEqual("https://n0t.y0ur.n0rm4l.w3bs1t3");
});
it("should parse category 100 - SoftwareLicense", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(SoftwareLicenseData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.SecureNote);
expect(cipher.name).toEqual("Limux Product Key");
expect(cipher.notes).toEqual("My Software License");
expect(cipher.fields.length).toEqual(13);
validateCustomField(cipher.fields, "product_version", "5.10.1000");
validateCustomField(cipher.fields, "reg_code", "265453-13457355-847327");
validateCustomField(cipher.fields, "reg_name", "Kay Riddler");
validateCustomField(cipher.fields, "reg_email", "kriddler@nullvalue.test");
validateCustomField(cipher.fields, "company", "Riddles and Jigsaw Puzzles GmbH");
validateCustomField(
cipher.fields,
"download_link",
"https://limuxcompany.nullvalue.test/5.10.1000/isos"
);
validateCustomField(cipher.fields, "publisher_name", "Limux Software and Hardware");
validateCustomField(cipher.fields, "publisher_website", "https://limuxcompany.nullvalue.test/");
validateCustomField(cipher.fields, "retail_price", "$999");
validateCustomField(cipher.fields, "support_email", "support@nullvalue.test");
validateCustomField(cipher.fields, "order_date", "Thu, 01 Apr 2021 12:01:00 GMT");
validateCustomField(cipher.fields, "order_number", "594839");
validateCustomField(cipher.fields, "order_total", "$1086.59");
});
it("should parse category 101 - BankAccount", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(BankAccountData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.Card);
expect(cipher.name).toEqual("Bank Account");
expect(cipher.notes).toEqual("My Bank Account");
expect(cipher.card.cardholderName).toEqual("Cool Guy");
expect(cipher.fields.length).toEqual(9);
validateCustomField(cipher.fields, "bankName", "Super Credit Union");
validateCustomField(cipher.fields, "accountType", "checking");
validateCustomField(cipher.fields, "routingNo", "111000999");
validateCustomField(cipher.fields, "accountNo", "192837465918273645");
validateCustomField(cipher.fields, "swift", "123456");
validateCustomField(cipher.fields, "iban", "DE12 123456");
validateCustomField(cipher.fields, "telephonePin", "5555");
validateCustomField(cipher.fields, "branchPhone", "9399399933");
validateCustomField(cipher.fields, "branchAddress", "1 Fifth Avenue");
});
it("should parse category 102 - Database", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(DatabaseData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.Login);
expect(cipher.name).toEqual("Database");
expect(cipher.notes).toEqual("My Database");
const login = cipher.login;
expect(login.username).toEqual("cooldbuser");
expect(login.password).toEqual("^+kTjhLaN7wVPAhGU)*J");
expect(cipher.fields.length).toEqual(7);
validateCustomField(cipher.fields, "database_type", "postgresql");
validateCustomField(cipher.fields, "hostname", "my.secret.db.server");
validateCustomField(cipher.fields, "port", "1337");
validateCustomField(cipher.fields, "database", "user_database");
validateCustomField(cipher.fields, "sid", "ASDIUFU-283234");
validateCustomField(cipher.fields, "alias", "cdbu");
validateCustomField(cipher.fields, "options", "ssh");
});
it("should parse category 103 - Drivers license", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(DriversLicenseData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.name).toEqual("Michael Scarn");
expect(cipher.subTitle).toEqual("Michael Scarn");
expect(cipher.notes).toEqual("My Driver's License");
const identity = cipher.identity;
expect(identity.firstName).toEqual("Michael");
expect(identity.middleName).toBeNull();
expect(identity.lastName).toEqual("Scarn");
expect(identity.address1).toEqual("2120 Mifflin Rd.");
expect(identity.state).toEqual("Pennsylvania");
expect(identity.country).toEqual("United States");
expect(identity.licenseNumber).toEqual("12345678901");
expect(cipher.fields.length).toEqual(6);
validateCustomField(cipher.fields, "birthdate", "Sun, 01 Jan 1978 12:01:00 GMT");
validateCustomField(cipher.fields, "sex", "male");
validateCustomField(cipher.fields, "height", "5'11\"");
validateCustomField(cipher.fields, "class", "C");
validateCustomField(cipher.fields, "conditions", "B");
validateCustomField(cipher.fields, "expiry_date", "203012");
});
it("should parse category 104 - Outdoor License", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(OutdoorLicenseData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.Identity);
expect(cipher.name).toEqual("Harvest License");
expect(cipher.subTitle).toEqual("Cash Bandit");
expect(cipher.notes).toEqual("My Outdoor License");
const identity = cipher.identity;
expect(identity.firstName).toEqual("Cash");
expect(identity.middleName).toBeNull();
expect(identity.lastName).toEqual("Bandit");
expect(identity.state).toEqual("Washington");
expect(identity.country).toEqual("United States of America");
expect(cipher.fields.length).toEqual(4);
validateCustomField(cipher.fields, "valid_from", "Thu, 01 Apr 2021 12:01:00 GMT");
validateCustomField(cipher.fields, "expires", "Fri, 01 Apr 2044 12:01:00 GMT");
validateCustomField(cipher.fields, "game", "Bananas,blueberries,corn");
validateCustomField(cipher.fields, "quota", "100/each");
});
it("should parse category 105 - Membership", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(MembershipData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.Identity);
expect(cipher.name).toEqual("Library Card");
const identity = cipher.identity;
expect(identity.firstName).toEqual("George");
expect(identity.middleName).toBeNull();
expect(identity.lastName).toEqual("Engels");
expect(identity.company).toEqual("National Public Library");
expect(identity.phone).toEqual("9995555555");
expect(cipher.fields.length).toEqual(5);
validateCustomField(cipher.fields, "website", "https://npl.nullvalue.gov.test");
validateCustomField(cipher.fields, "member_since", "199901");
validateCustomField(cipher.fields, "expiry_date", "203412");
validateCustomField(cipher.fields, "membership_no", "64783862");
validateCustomField(cipher.fields, "pin", "19191");
});
it("should parse category 106 - Passport", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(PassportData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.Identity);
expect(cipher.name).toEqual("Mr. Globewide");
const identity = cipher.identity;
expect(identity.firstName).toEqual("David");
expect(identity.middleName).toBeNull();
expect(identity.lastName).toEqual("Global");
expect(identity.passportNumber).toEqual("76436847");
expect(cipher.fields.length).toEqual(8);
validateCustomField(cipher.fields, "type", "US Passport");
validateCustomField(cipher.fields, "sex", "female");
validateCustomField(cipher.fields, "nationality", "International");
validateCustomField(cipher.fields, "issuing_authority", "Department of State");
validateCustomField(cipher.fields, "birthdate", "Fri, 01 Apr 1983 12:01:00 GMT");
validateCustomField(cipher.fields, "birthplace", "A cave somewhere in Maine");
validateCustomField(cipher.fields, "issue_date", "Wed, 01 Jan 2020 12:01:00 GMT");
validateCustomField(cipher.fields, "expiry_date", "Sat, 01 Jan 2050 12:01:00 GMT");
});
it("should parse category 107 - RewardsProgram", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(RewardsProgramData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.Identity);
expect(cipher.name).toEqual("Retail Reward Thing");
const identity = cipher.identity;
expect(identity.firstName).toEqual("Chef");
expect(identity.middleName).toBeNull();
expect(identity.lastName).toEqual("Coldroom");
expect(identity.company).toEqual("Super Cool Store Co.");
expect(cipher.fields.length).toEqual(7);
validateCustomField(cipher.fields, "membership_no", "member-29813569");
validateCustomField(cipher.fields, "pin", "99913");
validateCustomField(cipher.fields, "additional_no", "additional member id");
validateCustomField(cipher.fields, "member_since", "202101");
validateCustomField(cipher.fields, "customer_service_phone", "123456");
validateCustomField(cipher.fields, "reservations_phone", "123456");
validateCustomField(cipher.fields, "website", "supercoolstore.com");
});
it("should parse category 108 - SSN", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(SSNData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.name).toEqual("SSN");
const identity = cipher.identity;
expect(identity.firstName).toEqual("Jack");
expect(identity.middleName).toBeNull();
expect(identity.lastName).toEqual("Judd");
expect(identity.ssn).toEqual("131-216-1900");
});
it("should parse category 109 - WirelessRouter", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(WirelessRouterData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.Login);
expect(cipher.name).toEqual("Wireless Router");
expect(cipher.notes).toEqual("My Wifi Router Config");
expect(cipher.login.password).toEqual("BqatGTVQ9TCN72tLbjrsHqkb");
expect(cipher.fields.length).toEqual(7);
validateCustomField(cipher.fields, "name", "pixel 2Xl");
validateCustomField(cipher.fields, "server", "127.0.0.1");
validateCustomField(cipher.fields, "airport_id", "some airportId");
validateCustomField(cipher.fields, "network_name", "some network name");
validateCustomField(cipher.fields, "wireless_security", "WPA");
validateCustomField(cipher.fields, "wireless_password", "wifipassword");
validateCustomField(cipher.fields, "disk_password", "diskpassword");
});
it("should parse category 110 - Server", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(ServerData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.Login);
expect(cipher.name).toEqual("Super Cool Server");
expect(cipher.notes).toEqual("My Server");
expect(cipher.login.username).toEqual("frankly-notsure");
expect(cipher.login.password).toEqual("*&YHJI87yjy78u");
expect(cipher.login.uri).toEqual("https://coolserver.nullvalue.test");
expect(cipher.fields.length).toEqual(7);
validateCustomField(
cipher.fields,
"admin_console_url",
"https://coolserver.nullvalue.test/admin"
);
validateCustomField(cipher.fields, "admin_console_username", "frankly-idontknowwhatimdoing");
validateCustomField(cipher.fields, "admin_console_password", "^%RY&^YUiju8iUYHJI(U");
validateCustomField(cipher.fields, "name", "Private Hosting Provider Inc.");
validateCustomField(cipher.fields, "website", "https://phpi.nullvalue.test");
validateCustomField(
cipher.fields,
"support_contact_url",
"https://phpi.nullvalue.test/support"
);
validateCustomField(cipher.fields, "support_contact_phone", "8882569382");
});
it("should parse category 111 - EmailAccount", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(EmailAccountData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.SecureNote);
expect(cipher.name).toEqual("Email Config");
expect(cipher.notes).toEqual("My Email Config");
expect(cipher.fields.length).toEqual(17);
validateCustomField(cipher.fields, "pop_type", "either");
validateCustomField(cipher.fields, "pop_username", "someuser@nullvalue.test");
validateCustomField(cipher.fields, "pop_server", "mailserver.nullvalue.test");
validateCustomField(cipher.fields, "pop_port", "587");
validateCustomField(cipher.fields, "pop_password", "u1jsf<UI*&YU&^T");
validateCustomField(cipher.fields, "pop_security", "TLS");
validateCustomField(cipher.fields, "pop_authentication", "kerberos_v5");
validateCustomField(cipher.fields, "smtp_server", "mailserver.nullvalue.test");
validateCustomField(cipher.fields, "smtp_port", "589");
validateCustomField(cipher.fields, "smtp_username", "someuser@nullvalue.test");
validateCustomField(cipher.fields, "smtp_password", "(*1674%^UIUJ*UI(IUI8u98uyy");
validateCustomField(cipher.fields, "smtp_security", "TLS");
validateCustomField(cipher.fields, "smtp_authentication", "password");
validateCustomField(cipher.fields, "provider", "Telum");
validateCustomField(cipher.fields, "provider_website", "https://telum.nullvalue.test");
validateCustomField(cipher.fields, "phone_local", "2346666666");
validateCustomField(cipher.fields, "phone_tollfree", "18005557777");
});
it("should parse category 112 - API Credentials", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(APICredentialsData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.Login);
expect(cipher.name).toEqual("API Credential");
expect(cipher.notes).toEqual("My API Credential");
expect(cipher.login.username).toEqual("apiuser@nullvalue.test");
expect(cipher.login.password).toEqual("apiapiapiapiapiapiappy");
expect(cipher.login.uri).toEqual("http://not.your.everyday.hostname");
expect(cipher.fields.length).toEqual(4);
validateCustomField(cipher.fields, "type", "jwt");
validateCustomField(cipher.fields, "filename", "filename.jwt");
validateCustomField(cipher.fields, "validFrom", "Mon, 04 Apr 2011 12:01:00 GMT");
validateCustomField(cipher.fields, "expires", "Tue, 01 Apr 2031 12:01:00 GMT");
});
it("should create secure notes", async () => {
const importer = new Importer();
const result = await importer.parse(SecureNoteDataJson);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.name).toEqual("Secure Note #1");
expect(cipher.notes).toEqual(
"This is my secure note. \n\nLorem ipsum expecto patronum. \nThe quick brown fox jumped over the lazy dog."
);
expect(cipher.secureNote.type).toEqual(SecureNoteType.Generic);
});
it("should parse category 113 - Medical Record", async () => {
const importer = new Importer();
const jsonString = JSON.stringify(MedicalRecordData);
const result = await importer.parse(jsonString);
expect(result != null).toBe(true);
const cipher = result.ciphers.shift();
expect(cipher.type).toEqual(CipherType.SecureNote);
expect(cipher.name).toEqual("Some Health Record");
expect(cipher.notes).toEqual("Some notes about my medical history");
expect(cipher.secureNote.type).toEqual(SecureNoteType.Generic);
expect(cipher.fields.length).toEqual(8);
validateCustomField(cipher.fields, "date", "Sat, 01 Jan 2022 12:01:00 GMT");
validateCustomField(cipher.fields, "location", "some hospital/clinic");
validateCustomField(cipher.fields, "healthcareprofessional", "Some Doctor");
validateCustomField(cipher.fields, "patient", "Me");
validateCustomField(cipher.fields, "reason", "unwell");
validateCustomField(cipher.fields, "medication", "Insuline");
validateCustomField(cipher.fields, "dosage", "1");
validateCustomField(cipher.fields, "notes", "multiple times a day");
});
it("should create folders", async () => {
const importer = new Importer();
const result = await importer.parse(SanitizedExportJson);
expect(result != null).toBe(true);
const folders = result.folders;
expect(folders.length).toBe(5);
expect(folders[0].name).toBe("Movies");
expect(folders[1].name).toBe("Finance");
expect(folders[2].name).toBe("Travel");
expect(folders[3].name).toBe("Education");
expect(folders[4].name).toBe("Starter Kit");
// Check that ciphers have a folder assigned to them
expect(result.ciphers.filter((c) => c.folderId === folders[0].id).length).toBeGreaterThan(0);
expect(result.ciphers.filter((c) => c.folderId === folders[1].id).length).toBeGreaterThan(0);
expect(result.ciphers.filter((c) => c.folderId === folders[2].id).length).toBeGreaterThan(0);
expect(result.ciphers.filter((c) => c.folderId === folders[3].id).length).toBeGreaterThan(0);
expect(result.ciphers.filter((c) => c.folderId === folders[4].id).length).toBeGreaterThan(0);
});
it("should create collections if part of an organization", async () => {
const importer = new Importer();
importer.organizationId = Utils.newGuid();
const result = await importer.parse(SanitizedExportJson);
expect(result != null).toBe(true);
const collections = result.collections;
expect(collections.length).toBe(5);
expect(collections[0].name).toBe("Movies");
expect(collections[1].name).toBe("Finance");
expect(collections[2].name).toBe("Travel");
expect(collections[3].name).toBe("Education");
expect(collections[4].name).toBe("Starter Kit");
});
});

74
jslib/common/spec/importers/onepasswordMacCsvImporter.spec.ts
View File

@@ -1,74 +0,0 @@
import { CipherType } from "@/jslib/common/src/enums/cipherType";
import { OnePasswordMacCsvImporter as Importer } from "@/jslib/common/src/importers/onepasswordImporters/onepasswordMacCsvImporter";
import { CipherView } from "@/jslib/common/src/models/view/cipherView";
import { data as creditCardData } from "./testData/onePasswordCsv/creditCard.mac.csv";
import { data as identityData } from "./testData/onePasswordCsv/identity.mac.csv";
import { data as multiTypeData } from "./testData/onePasswordCsv/multipleItems.mac.csv";
function expectIdentity(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.identity).toEqual(
expect.objectContaining({
firstName: "first name",
middleName: "mi",
lastName: "last name",
username: "userNam3",
company: "bitwarden",
phone: "8005555555",
email: "email@bitwarden.com",
})
);
expect(cipher.notes).toContain("address\ncity state zip\nUnited States");
}
function expectCreditCard(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Card);
expect(cipher.card).toEqual(
expect.objectContaining({
number: "4111111111111111",
code: "111",
cardholderName: "test",
expMonth: "1",
expYear: "2030",
})
);
}
describe("1Password mac CSV Importer", () => {
it("should parse identity records", async () => {
const importer = new Importer();
const result = await importer.parse(identityData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
const cipher = result.ciphers[0];
expectIdentity(cipher);
});
it("should parse credit card records", async () => {
const importer = new Importer();
const result = await importer.parse(creditCardData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
const cipher = result.ciphers[0];
expectCreditCard(cipher);
});
it("should parse csv's with multiple record type", async () => {
const importer = new Importer();
const result = await importer.parse(multiTypeData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(4);
expectIdentity(result.ciphers[1]);
expectCreditCard(result.ciphers[2]);
});
});

87
jslib/common/spec/importers/onepasswordWinCsvImporter.spec.ts
View File

@@ -1,87 +0,0 @@
import { CipherType } from "@/jslib/common/src/enums/cipherType";
import { FieldType } from "@/jslib/common/src/enums/fieldType";
import { OnePasswordWinCsvImporter as Importer } from "@/jslib/common/src/importers/onepasswordImporters/onepasswordWinCsvImporter";
import { CipherView } from "@/jslib/common/src/models/view/cipherView";
import { FieldView } from "@/jslib/common/src/models/view/fieldView";
import { data as creditCardData } from "./testData/onePasswordCsv/creditCard.windows.csv";
import { data as identityData } from "./testData/onePasswordCsv/identity.windows.csv";
import { data as multiTypeData } from "./testData/onePasswordCsv/multipleItems.windows.csv";
function expectIdentity(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Identity);
expect(cipher.identity).toEqual(
expect.objectContaining({
firstName: "first name",
middleName: "mi",
lastName: "last name",
username: "userNam3",
company: "bitwarden",
phone: "8005555555",
email: "email@bitwarden.com",
})
);
expect(cipher.fields).toEqual(
expect.arrayContaining([
Object.assign(new FieldView(), {
type: FieldType.Text,
name: "address",
value: "address city state zip us",
}),
])
);
}
function expectCreditCard(cipher: CipherView) {
expect(cipher.type).toBe(CipherType.Card);
expect(cipher.card).toEqual(
expect.objectContaining({
number: "4111111111111111",
code: "111",
cardholderName: "test",
expMonth: "1",
expYear: "1970",
})
);
}
describe("1Password windows CSV Importer", () => {
let importer: Importer;
beforeEach(() => {
importer = new Importer();
});
it("should parse identity records", async () => {
const result = await importer.parse(identityData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
const cipher = result.ciphers[0];
expectIdentity(cipher);
});
it("should parse credit card records", async () => {
const result = await importer.parse(creditCardData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(1);
const cipher = result.ciphers[0];
expectCreditCard(cipher);
});
it("should parse csv's with multiple record types", async () => {
const result = await importer.parse(multiTypeData);
expect(result).not.toBeNull();
expect(result.success).toBe(true);
expect(result.ciphers.length).toBe(4);
expectIdentity(result.ciphers[1]);
expectCreditCard(result.ciphers[2]);
});
});

74
jslib/common/spec/importers/safariCsvImporter.spec.ts
View File

@@ -1,74 +0,0 @@
import { SafariCsvImporter as Importer } from "@/jslib/common/src/importers/safariCsvImporter";
import { CipherView } from "@/jslib/common/src/models/view/cipherView";
import { LoginUriView } from "@/jslib/common/src/models/view/loginUriView";
import { LoginView } from "@/jslib/common/src/models/view/loginView";
import { data as oldSimplePasswordData } from "./testData/safariCsv/oldSimplePasswordData.csv";
import { data as simplePasswordData } from "./testData/safariCsv/simplePasswordData.csv";
const CipherData = [
{
title: "should parse URLs in new CSV format",
csv: simplePasswordData,
expected: Object.assign(new CipherView(), {
id: null,
organizationId: null,
folderId: null,
name: "example.com (example_user)",
login: Object.assign(new LoginView(), {
username: "example_user",
password: "example_p@ssword",
uris: [
Object.assign(new LoginUriView(), {
uri: "https://example.com",
}),
],
totp: "otpauth://totp/test?secret=examplesecret",
}),
notes: "Example note\nMore notes on new line",
type: 1,
}),
},
{
title: "should parse URLs in old CSV format",
csv: oldSimplePasswordData,
expected: Object.assign(new CipherView(), {
id: null,
organizationId: null,
folderId: null,
name: "example.com (example_user)",
login: Object.assign(new LoginView(), {
username: "example_user",
password: "example_p@ssword",
uris: [
Object.assign(new LoginUriView(), {
uri: "https://example.com",
}),
],
}),
type: 1,
}),
},
];
describe("Safari CSV Importer", () => {
CipherData.forEach((data) => {
it(data.title, async () => {
const importer = new Importer();
const result = await importer.parse(data.csv);
expect(result != null).toBe(true);
expect(result.ciphers.length).toBeGreaterThan(0);
const cipher = result.ciphers.shift();
let property: keyof typeof data.expected;
for (property in data.expected) {
// eslint-disable-next-line
if (data.expected.hasOwnProperty(property)) {
// eslint-disable-next-line
expect(cipher.hasOwnProperty(property)).toBe(true);
expect(cipher[property]).toEqual(data.expected[property]);
}
}
});
});
});

1
jslib/common/spec/importers/testData/bitwardenJson/empty.json.ts
View File

@@ -1 +0,0 @@
export const data = '{"encrypted":false,"folders":[],"items":[]}';

9
jslib/common/spec/importers/testData/bitwardenJson/passwordProtected.json.ts
View File

@@ -1,9 +0,0 @@
export const data = `{
"encrypted": true,
"passwordProtected": true,
"salt": "Oy0xcgVRzxQ+9NpB5GLehw==",
"kdfIterations": 100000,
"kdfType": 0,
"encKeyValidation_DO_NOT_EDIT": "2.sZs4Jc1HW9rhABzRRYR/gQ==|8kTDaDxafulnybpWoqVX8RAybhVRTr+dffNjms271Y7amQmIE1VSMwLbk+b2vxZb|IqOo6oXQtmv/Xb/GHDi42XG9c9ILePYtP5qq584VWcg=",
"data": "2.D0AXAf7G/XIwq6EC7A0Suw==|4w+m0wHRo25y1T1Syh5wdAUyF8voqEy54waMEsbnK0Nzee959w54ru5D1NntvxZL4HFqkQLyR6jCFkn5g40f+MGJgihS/wvf4NcJJfLiiFo6MEDOQNBkxw7ZBGuHiKfVuBO5u36JgzQtZ8lyFaduGxFszuF5c+URiE9PDh9jY0//poVgHKwuLZuYFIW+f7h6T+shUWK0ya11lcHn/B/CA2xiI+YiKdNZreJrwN0yslpJ/f+MrOzagvftRjt0GNkwveCtwcYUw/zFvqvibUpKeHcRiXs8SaGoHJ5RTm69FbJ7C5tnLwoVT89Af156uvRAXV7yAC4oPcbU/3TGb6hqYosvi1QNyaqG3M9gxS6+AK0C4yWuNbMLDEr+MWiw0SWLVMKQEkCZ4oM+oTCx52otW3+2V9I8Pv3KmmhkvVvE4wBdweOJeRX53Tf5ySkmpIhCfzj6JMmxO+nmTXIhWnJChr4hPVh+ixv1GQK5thIPTCMXmAtXoTIFUx1KWjS6LjOdi2hKQueVI+XZjf0qnY2vTMxRg0ZsLBA2znQTx+DSEqumORb5T/lV73pWZiCNePSAE2msOm7tep+lm4O/VCViCfXjITAY196syhOK0XnhxJvPALchZY8sYRAfuw6hHoDiVr+JUieRoI7eUrhXBp+D6Py9TL/dS/rHe+C2Zhx+xwx2NfGt+xEp8ZAOOCxgZ0UTeSA/abm0Oz7tJIK1n26acQrgbr7rMeBymAX+5L5OWlwI1hGgEBfj6W0rrbSXf3VMfaFXZ5UsXi1VhzQmU3LyWENoDeImXFQj6zMbUSfcVwLsG5Fg8Ee/kO/wJPfG5BO51+/vFqQj6AkaMEcwg5xNrObHYfQ/DMhIn7YDM2zdzbNTdhnobGkz6YRKFPCgFe3EmIEPEpeh9S3eKE9C7MQsrR8jVSiseR/FipJLsN+W7iOwzeXdwxUFlC/0a98bTKvdrbMgNi6ZVXykHY/t2UyEGpxZGTHoZwhX01kiQrwzC4/+v/676ldxPluO9GY7MtrLveCDsiyBz15u43IGHayDEBNT0rqrOKLYmfzwCWoahRLZQrSmepe/FXqgPqRfyWc/Ro+w3sT9dXUkx3B5xxWgSyABowPV48yBUSJuefhKTpqgzkU+LzhNnWHjnxJzzQ2/|IhlRjnyhIoDM85qHX/bY2zaIU5YaRO/iFVTQDd3uFDo="
}`;

2
jslib/common/spec/importers/testData/dashlaneCsv/credentials.csv.ts
View File

@@ -1,2 +0,0 @@
export const credentialsData = `username,username2,username3,title,password,note,url,category,otpSecret
jdoe,,,example.com,somePassword,some note for example.com,https://www.example.com,Entertainment,someTOTPSeed`;

6
jslib/common/spec/importers/testData/dashlaneCsv/id.csv.ts
View File

@@ -1,6 +0,0 @@
export const identityData = `type,number,name,issue_date,expiration_date,place_of_issue,state
card,123123123,John Doe,2022-1-30,2032-1-30,,
passport,123123123,John Doe,2022-1-30,2032-1-30,somewhere in Germany,
license,1234556,John Doe,2022-8-10,2022-10-10,,DC
social_security,123123123,John Doe,,,,
tax_number,123123123,,,,,`;

7
jslib/common/spec/importers/testData/dashlaneCsv/multiplePersonalInfo.csv.ts
View File

@@ -1,7 +0,0 @@
export const multiplePersonalInfoData = `type,title,first_name,middle_name,last_name,login,date_of_birth,place_of_birth,email,email_type,item_name,phone_number,address,country,state,city,zip,address_recipient,address_building,address_apartment,address_floor,address_door_code,job_title,url
name,MR,John,,Doe,jdoe,2022-01-30,world,,,,,,,,,,,,,,,,
email,,,,,,,,jdoe@example.com,personal,Johns email,,,,,,,,,,,,,
number,,,,,,,,,,John's number,+49123123123,,,,,,,,,,,,
address,,,,,,,,,,John's home address,,1 some street,de,DE-0-NW,some city,123123,John,1,1,1,123,,
website,,,,,,,,,,Website,,,,,,,,,,,,,website.com
name,Mrs,Jane,,Doe,jdoe,2022-01-30,earth,,,,,,,,,,,,,,,,`;

3
jslib/common/spec/importers/testData/dashlaneCsv/payments.csv.ts
View File

@@ -1,3 +0,0 @@
export const paymentsData = `type,account_name,account_holder,cc_number,code,expiration_month,expiration_year,routing_number,account_number,country,issuing_bank
bank,John's savings account,John Doe,,,,,routingNumber,accountNumber,US,US-ALLY
credit_card,John Doe,,41111111111111111,123,01,2023,,,US,`;

6
jslib/common/spec/importers/testData/dashlaneCsv/personalInfo.csv.ts
View File

@@ -1,6 +0,0 @@
export const personalInfoData = `type,title,first_name,middle_name,last_name,login,date_of_birth,place_of_birth,email,email_type,item_name,phone_number,address,country,state,city,zip,address_recipient,address_building,address_apartment,address_floor,address_door_code,job_title,url
name,MR,John,,Doe,jdoe,2022-01-30,world,,,,,,,,,,,,,,,,
email,,,,,,,,jdoe@example.com,personal,Johns email,,,,,,,,,,,,,
number,,,,,,,,,,John's number,+49123123123,,,,,,,,,,,,
address,,,,,,,,,,John's home address,,1 some street,de,DE-0-NW,some city,123123,John,1,1,1,123,,
website,,,,,,,,,,Website,,,,,,,,,,,,,website.com`;

2
jslib/common/spec/importers/testData/dashlaneCsv/securenotes.csv.ts
View File

@@ -1,2 +0,0 @@
export const secureNoteData = `title,note
01,test`;

4
jslib/common/spec/importers/testData/firefoxCsv/firefoxAccountsData.csv.ts
View File

@@ -1,4 +0,0 @@
export const data = `"url","username","password","httpRealm","formActionOrigin","guid","timeCreated","timeLastUsed","timePasswordChanged"
"chrome://FirefoxAccounts","bla-bla-foo-bar","{""version"":1,""accountData"":{""kSync"":""xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"",""kXCS"":""xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"",""kExtSync"":""xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"",""kExtKbHash"":""xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"",""scopedKeys"":{""https://identity.mozilla.com/apps/oldsync"":{""kid"":""xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",""k"":""xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"",""kty"":""xxx""},""sync:addon_storage"":{""kid"":""xxxxxxxxxxxxx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"",""k"":""xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"",""kty"":""xxx""}}}}","Firefox Accounts credentials",,"{d61e37fa-2bc4-469a-bd66-41fd3b0005e0}","1612345678900","1612345678900","1612345678900"
"https://example.com","foo","bar",,"","{d61e37fa-2bc4-469a-bd66-41fd3b0005e0}","1612345678900","1612345678900","1612345678900"
`;

2
jslib/common/spec/importers/testData/firefoxCsv/simplePasswordData.csv.ts
View File

@@ -1,2 +0,0 @@
export const data = `"url","username","password","httpRealm","formActionOrigin","guid","timeCreated","timeLastUsed","timePasswordChanged"
"https://example.com","foo","bar",,"","{d61e37fa-2bc4-469a-bd66-41fd3b0005e0}","1612345678900","1612345678900","1612345678900"`;

90
jslib/common/spec/importers/testData/keeperJson/testData.ts
View File

@@ -1,90 +0,0 @@
import { KeeperJsonExport } from "@/jslib/common/src/importers/keeperImporters/types/keeperJsonTypes";
export const testData: KeeperJsonExport = {
shared_folders: [
{
path: "My Customer 1",
manage_users: true,
manage_records: true,
can_edit: true,
can_share: true,
permissions: [
{
uid: "kVM96KGEoGxhskZoSTd_jw",
manage_users: true,
manage_records: true,
},
{
name: "user@mycompany.com",
manage_users: true,
manage_records: true,
},
],
},
{
path: "Testing\\My Customer 2",
manage_users: true,
manage_records: true,
can_edit: true,
can_share: true,
permissions: [
{
uid: "ih1CggiQ-3ENXcn4G0sl-g",
manage_users: true,
manage_records: true,
},
{
name: "user@mycompany.com",
manage_users: true,
manage_records: true,
},
],
},
],
records: [
{
title: "Bank Account 1",
login: "customer1234",
password: "4813fJDHF4239fdk",
login_url: "https://chase.com",
notes: "These are some notes.",
custom_fields: {
"Account Number": "123-456-789",
},
folders: [
{
folder: "Optional Private Folder 1",
},
],
},
{
title: "Bank Account 2",
login: "mybankusername",
password: "w4k4k193f$^&@#*%2",
login_url: "https://amex.com",
notes: "Some great information here.",
custom_fields: {
"Security Group": "Public",
"IP Address": "12.45.67.8",
"TFC:Keeper":
"otpauth://totp/Amazon:me@company.com?secret=JBSWY3DPEHPK3PXP&issuer=Amazon&algorithm=SHA1&digits=6&period=30",
},
folders: [
{
folder: "Optional Private Folder 1",
},
{
shared_folder: "My Customer 1",
can_edit: true,
can_share: true,
},
],
},
{
title: "Some Account",
login: "someUserName",
password: "w4k4k1wergf$^&@#*%2",
login_url: "https://example.com",
},
],
};

3
jslib/common/spec/importers/testData/mykiCsv/UserAccount.csv.ts
View File

@@ -1,3 +0,0 @@
/* eslint-disable */
export const userAccountData = `nickname,url,username,password,additionalInfo,twofaSecret,status,tags
PasswordNickname,www.google.com,user.name@email.com,abc123,This is the additional information text.,someTOTPSeed,active,someTag`;

3
jslib/common/spec/importers/testData/mykiCsv/UserCreditCard.csv.ts
View File

@@ -1,3 +0,0 @@
/* eslint-disable */
export const userCreditCardData = `nickname,status,tags,cardNumber,cardName,exp_month,exp_year,cvv,additionalInfo
Visa test card,active,someTag,4111111111111111,Joe User,04,24,222,This is the additional information field`;

16
jslib/common/spec/importers/testData/mykiCsv/UserIdCard.csv.ts
View File

@@ -1,16 +0,0 @@
/* eslint-disable */
export const userIdCardData = `nickname,status,tags,idType,idNumber,idName,idIssuanceDate,idExpirationDate,idCountry,additionalInfo
Joe User's nickname,active,someTag,Driver's License,123456,Joe M User,02/02/2022,02/02/2024,United States,Additional information
Passport ID card,active,someTag,Passport,1234567,Joe M User,03/07/2022,03/07/2028,United States,Additional information field
Social Security ID card,active,someTag,Social Security,123455678,Joe M User,03/07/2022,03/07/2028,United States,Additional information field text
ID card type ID card,active,someTag,ID Card,1234566,Joe M User,03/07/2022,03/07/2028,United States,Additional Information field text
Tax number ID card,active,someTag,Tax Number,12345678,Joe M User,03/07/2022,03/07/2028,United States,Additinoal information text field
Bank account ID card,active,someTag,Bank Account,12344556677,Joe M User,03/07/2022,03/07/2028,United States,Additional text information here
Insurance card ID card,active,someTag,Insurance Card,123456677,Joe M User,03/07/2022,03/07/2022,United States,Additional information text goes here
Health card Id card,active,someTag,Health Card,1234670,Joe M User,03/07/2022,03/07/2028,United States,More info
Membership ID card,active,someTag,Membership,12345709,Joe M User,03/07/2022,03/07/2028,United States,Add'l info
Database ID card,active,someTag,Database,12345089u,Joe M User,03/07/2022,03/07/2028,United States,Addin't info
Outdoor license ID card,active,someTag,Outdoor License,123890090,Joe M User,03/07/2022,03/07/2028,United States,Additional info
Reward program Id card,active,someTag,Reward Program,12345890b,Joe M User,03/07/2022,03/07/2028,United States,1234890
Software license ID card,active,someTag,Software License,1234567c,Joe M User,03/07/2022,03/07/2028,United States,"It seems like the fields don't change, which makes it pretty useless that they have so many ID card types."
Tour visa ID card,active,someTag,Tour Visa,123456lkhj,Joe M User,03/07/2022,03/07/2028,United States,Additional Informaion text`;

3
jslib/common/spec/importers/testData/mykiCsv/UserIdentity.csv.ts
View File

@@ -1,3 +0,0 @@
/* eslint-disable */
export const userIdentityData = `nickname,status,tags,firstName,middleName,lastName,email,firstAddressLine,secondAddressLine,title,gender,number,city,country,zipCode,additionalInfo
Joe User's nickname,active,someTag,Joe,M,User,joe.user@email.com,1 Example House,Suite 300,Mr,Male,2223334444,Portland,United States,04101,Additional information field`;

3
jslib/common/spec/importers/testData/mykiCsv/UserNote.csv.ts
View File

@@ -1,3 +0,0 @@
/* eslint-disable */
export const userNoteData = `nickname,status,content
The title of a secure note,active,"The content of a secure note. Lorem ipsum, etc."`;

3
jslib/common/spec/importers/testData/mykiCsv/UserTwofa.csv.ts
View File

@@ -1,3 +0,0 @@
/* eslint-disable */
export const userTwoFaData = `nickname,status,tags,authToken,additionalInfo
2FA nickname,active,someTag,someTOTPSeed,"Additional information field content. "`;

2
jslib/common/spec/importers/testData/nordpassCsv/nordpass.card.csv.ts
View File

@@ -1,2 +0,0 @@
export const data = `name,url,username,password,note,cardholdername,cardnumber,cvc,expirydate,zipcode,folder,full_name,phone_number,email,address1,address2,city,country,state
SomeVisa,,,,,SomeHolder,4024007103939509,123,01 / 22,12345,,,,,,,,,`;

2
jslib/common/spec/importers/testData/nordpassCsv/nordpass.identity.csv.ts
View File

@@ -1,2 +0,0 @@
export const data = `name,url,username,password,note,cardholdername,cardnumber,cvc,expirydate,zipcode,folder,full_name,phone_number,email,address1,address2,city,country,state
SomeTitle,,,,SomeNoteToMyIdentity,,,,,123456,,#fullName,123456789,hello@bitwarden.com,Test street 123,additional addressinfo,Cologne,Germany,North-Rhine-Westphalia`;

2
jslib/common/spec/importers/testData/nordpassCsv/nordpass.login.csv.ts
View File

@@ -1,2 +0,0 @@
export const data = `name,url,username,password,note,cardholdername,cardnumber,cvc,expirydate,zipcode,folder,full_name,phone_number,email,address1,address2,city,country,state
SomeVaultItemName,https://example.com,hello@bitwarden.com,someStrongPassword,Some note for the VaultItem,,,,,,SomeFolderForVaultItem,,,,,,,,`;

3
jslib/common/spec/importers/testData/nordpassCsv/nordpass.secureNote.csv.ts
View File

@@ -1,3 +0,0 @@
export const data = `name,url,username,password,note,cardholdername,cardnumber,cvc,expirydate,zipcode,folder,full_name,phone_number,email,address1,address2,city,country,state
notesFolder,,,,,,,,,,,,,,,,,,
MySuperSecureNoteTitle,,,,MySuperSecureNote,,,,,,notesFolder,,,,,,,,`;

169
jslib/common/spec/importers/testData/onePassword1Pux/APICredentials.ts
View File

@@ -1,169 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const APICredentialsData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "6nqnjdqyk5mwvqbdgbdr47oabe",
favIndex: 0,
createdAt: 1619465969,
updatedAt: 1619466052,
trashed: false,
categoryUuid: "112",
details: {
loginFields: [],
notesPlain: "My API Credential",
sections: [
{
title: "",
fields: [
{
title: "username",
id: "username",
value: {
string: "apiuser@nullvalue.test",
},
indexAtSource: 0,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "no",
capitalization: "none",
},
},
{
title: "credential",
id: "credential",
value: {
concealed: "apiapiapiapiapiapiappy",
},
indexAtSource: 1,
guarded: true,
multiline: false,
dontGenerate: true,
inputTraits: {
keyboard: "default",
correction: "no",
capitalization: "default",
},
},
{
title: "type",
id: "type",
value: {
menu: "jwt",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "filename",
id: "filename",
value: {
string: "filename.jwt",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "valid from",
id: "validFrom",
value: {
date: 1301918460,
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "expires",
id: "expires",
value: {
date: 1932811260,
},
indexAtSource: 5,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "hostname",
id: "hostname",
value: {
string: "not.your.everyday.hostname",
},
indexAtSource: 6,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "uRL",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "",
title: "API Credential",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

224
jslib/common/spec/importers/testData/onePassword1Pux/BankAccount.ts
View File

@@ -1,224 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const BankAccountData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "u2l4sjbencvsowwjuj3dfpt73q",
favIndex: 0,
createdAt: 1619466056,
updatedAt: 1619466187,
trashed: false,
categoryUuid: "101",
details: {
loginFields: [],
notesPlain: "My Bank Account",
sections: [
{
title: "",
fields: [
{
title: "bank name",
id: "bankName",
value: {
string: "Super Credit Union",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "name on account",
id: "owner",
value: {
string: "Cool Guy",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "type",
id: "accountType",
value: {
menu: "checking",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "routing number",
id: "routingNo",
value: {
string: "111000999",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numbersAndPunctuation",
correction: "default",
capitalization: "default",
},
},
{
title: "account number",
id: "accountNo",
value: {
string: "192837465918273645",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numbersAndPunctuation",
correction: "default",
capitalization: "default",
},
},
{
title: "SWIFT",
id: "swift",
value: {
string: "123456",
},
indexAtSource: 5,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numbersAndPunctuation",
correction: "default",
capitalization: "default",
},
},
{
title: "IBAN",
id: "iban",
value: {
string: "DE12 123456",
},
indexAtSource: 6,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numbersAndPunctuation",
correction: "default",
capitalization: "default",
},
},
{
title: "PIN",
id: "telephonePin",
value: {
concealed: "5555",
},
indexAtSource: 7,
guarded: false,
multiline: false,
dontGenerate: true,
inputTraits: {
keyboard: "numberPad",
correction: "default",
capitalization: "default",
},
},
],
},
{
title: "Branch Information",
name: "branchInfo",
fields: [
{
title: "phone",
id: "branchPhone",
value: {
phone: "9399399933",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "namePhonePad",
correction: "default",
capitalization: "default",
},
},
{
title: "address",
id: "branchAddress",
value: {
string: "1 Fifth Avenue",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "sentences",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "Super Credit Union",
tags: ["Finance"],
title: "Bank Account",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

343
jslib/common/spec/importers/testData/onePassword1Pux/CreditCard.ts
View File

@@ -1,343 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const CreditCardData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "vpxi2esuujz7nrbojp34rd5aja",
favIndex: 0,
createdAt: 1619465282,
updatedAt: 1619465447,
trashed: false,
categoryUuid: "002",
details: {
loginFields: [],
notesPlain: "My parents' credit card. ",
sections: [
{
title: "",
fields: [
{
title: "cardholder name",
id: "cardholder",
value: {
string: "Fred Engels",
},
indexAtSource: 0,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "type",
id: "type",
value: {
creditCardType: "discover",
},
indexAtSource: 1,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "number",
id: "ccnum",
value: {
creditCardNumber: "6011111111111117",
},
indexAtSource: 2,
guarded: true,
clipboardFilter: "0123456789",
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numberPad",
correction: "default",
capitalization: "default",
},
},
{
title: "verification number",
id: "cvv",
value: {
concealed: "1312",
},
indexAtSource: 3,
guarded: true,
multiline: false,
dontGenerate: true,
inputTraits: {
keyboard: "numberPad",
correction: "default",
capitalization: "default",
},
},
{
title: "expiry date",
id: "expiry",
value: {
monthYear: 209912,
},
indexAtSource: 4,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "valid from",
id: "validFrom",
value: {
monthYear: 200101,
},
indexAtSource: 5,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "",
id: "txbzvwzpck7ejhfres3733rbpm",
value: {
string: "card",
},
indexAtSource: 6,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
{
title: "Contact Information",
name: "contactInfo",
fields: [
{
title: "issuing bank",
id: "bank",
value: {
string: "Some bank",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "phone (local)",
id: "phoneLocal",
value: {
phone: "123456",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "namePhonePad",
correction: "default",
capitalization: "default",
},
},
{
title: "phone (toll free)",
id: "phoneTollFree",
value: {
phone: "0800123456",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "namePhonePad",
correction: "default",
capitalization: "default",
},
},
{
title: "phone (intl)",
id: "phoneIntl",
value: {
phone: "+49123456",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "namePhonePad",
correction: "default",
capitalization: "default",
},
},
{
title: "website",
id: "website",
value: {
url: "somebank.com",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
{
title: "Additional Details",
name: "details",
fields: [
{
title: "PIN",
id: "pin",
value: {
concealed: "1234",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: true,
inputTraits: {
keyboard: "numberPad",
correction: "default",
capitalization: "default",
},
},
{
title: "credit limit",
id: "creditLimit",
value: {
string: "$1312",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numbersAndPunctuation",
correction: "default",
capitalization: "default",
},
},
{
title: "cash withdrawal limit",
id: "cashLimit",
value: {
string: "$500",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numbersAndPunctuation",
correction: "default",
capitalization: "default",
},
},
{
title: "interest rate",
id: "interest",
value: {
string: "1%",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numbersAndPunctuation",
correction: "default",
capitalization: "default",
},
},
{
title: "issue number",
id: "issuenumber",
value: {
string: "123456",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "no",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "1234 **** 6789",
tags: ["Finance"],
title: "Parent's Credit Card",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

201
jslib/common/spec/importers/testData/onePassword1Pux/Database.ts
View File

@@ -1,201 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const DatabaseData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "ospvepl3ex2y6hjwwqwyvtf2sy",
favIndex: 0,
createdAt: 1619466193,
updatedAt: 1619466276,
trashed: false,
categoryUuid: "102",
details: {
loginFields: [],
notesPlain: "My Database",
sections: [
{
title: "",
fields: [
{
title: "type",
id: "database_type",
value: {
menu: "postgresql",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "server",
id: "hostname",
value: {
string: "my.secret.db.server",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "uRL",
correction: "default",
capitalization: "default",
},
},
{
title: "port",
id: "port",
value: {
string: "1337",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numberPad",
correction: "default",
capitalization: "default",
},
},
{
title: "database",
id: "database",
value: {
string: "user_database",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "no",
capitalization: "none",
},
},
{
title: "username",
id: "username",
value: {
string: "cooldbuser",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "no",
capitalization: "none",
},
},
{
title: "password",
id: "password",
value: {
concealed: "^+kTjhLaN7wVPAhGU)*J",
},
indexAtSource: 5,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "SID",
id: "sid",
value: {
string: "ASDIUFU-283234",
},
indexAtSource: 6,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "alias",
id: "alias",
value: {
string: "cdbu",
},
indexAtSource: 7,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "connection options",
id: "options",
value: {
string: "ssh",
},
indexAtSource: 8,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "my.secret.db.server",
title: "Database",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

233
jslib/common/spec/importers/testData/onePassword1Pux/DriversLicense.ts
View File

@@ -1,233 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const DriversLicenseData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "nntuge2g7s2wrlokyfhea354ay",
favIndex: 0,
createdAt: 1619466279,
updatedAt: 1619466425,
trashed: false,
categoryUuid: "103",
details: {
loginFields: [],
notesPlain: "My Driver's License",
sections: [
{
title: "",
fields: [
{
title: "full name",
id: "fullname",
value: {
string: "Michael Scarn",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "address",
id: "address",
value: {
string: "2120 Mifflin Rd.",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "sentences",
},
},
{
title: "date of birth",
id: "birthdate",
value: {
date: 252504060,
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "sex",
id: "sex",
value: {
gender: "male",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "height",
id: "height",
value: {
string: "5'11\"",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "number",
id: "number",
value: {
string: "12345678901",
},
indexAtSource: 5,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "license class",
id: "class",
value: {
string: "C",
},
indexAtSource: 6,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "conditions / restrictions",
id: "conditions",
value: {
string: "B",
},
indexAtSource: 7,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "state",
id: "state",
value: {
string: "Pennsylvania",
},
indexAtSource: 8,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "country",
id: "country",
value: {
string: "United States",
},
indexAtSource: 9,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "expiry date",
id: "expiry_date",
value: {
monthYear: 203012,
},
indexAtSource: 10,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "12345678901",
title: "Michael Scarn",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

341
jslib/common/spec/importers/testData/onePassword1Pux/EmailAccount.ts
View File

@@ -1,341 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const EmailAccountData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "p3hohdgwpt4u2ra2fc3tvzomsm",
favIndex: 0,
createdAt: 1619466428,
updatedAt: 1619466585,
trashed: false,
categoryUuid: "111",
details: {
loginFields: [],
notesPlain: "My Email Config",
sections: [
{
title: "",
fields: [
{
title: "type",
id: "pop_type",
value: {
menu: "either",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "username",
id: "pop_username",
value: {
string: "someuser@nullvalue.test",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "no",
capitalization: "none",
},
},
{
title: "server",
id: "pop_server",
value: {
string: "mailserver.nullvalue.test",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "uRL",
correction: "default",
capitalization: "default",
},
},
{
title: "port number",
id: "pop_port",
value: {
string: "587",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numberPad",
correction: "default",
capitalization: "default",
},
},
{
title: "password",
id: "pop_password",
value: {
concealed: "u1jsf<UI*&YU&^T",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "security",
id: "pop_security",
value: {
menu: "TLS",
},
indexAtSource: 5,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "auth method",
id: "pop_authentication",
value: {
menu: "kerberos_v5",
},
indexAtSource: 6,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
{
title: "SMTP",
name: "SMTP",
fields: [
{
title: "SMTP server",
id: "smtp_server",
value: {
string: "mailserver.nullvalue.test",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "uRL",
correction: "default",
capitalization: "default",
},
},
{
title: "port number",
id: "smtp_port",
value: {
string: "589",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numberPad",
correction: "default",
capitalization: "default",
},
},
{
title: "username",
id: "smtp_username",
value: {
string: "someuser@nullvalue.test",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "no",
capitalization: "none",
},
},
{
title: "password",
id: "smtp_password",
value: {
concealed: "(*1674%^UIUJ*UI(IUI8u98uyy",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "security",
id: "smtp_security",
value: {
menu: "TLS",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "auth method",
id: "smtp_authentication",
value: {
menu: "password",
},
indexAtSource: 5,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
{
title: "Contact Information",
name: "Contact Information",
fields: [
{
title: "provider",
id: "provider",
value: {
string: "Telum",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "provider's website",
id: "provider_website",
value: {
string: "https://telum.nullvalue.test",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "uRL",
correction: "default",
capitalization: "default",
},
},
{
title: "phone (local)",
id: "phone_local",
value: {
string: "2346666666",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "namePhonePad",
correction: "default",
capitalization: "default",
},
},
{
title: "phone (toll free)",
id: "phone_tollfree",
value: {
string: "18005557777",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "namePhonePad",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "someuser@nullvalue.test",
title: "Email Config",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

91
jslib/common/spec/importers/testData/onePassword1Pux/Emailfield.ts
View File

@@ -1,91 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const EmailFieldData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "47hvppiuwbanbza7bq6jpdjfxu",
favIndex: 1,
createdAt: 1619467985,
updatedAt: 1619468230,
trashed: false,
categoryUuid: "100",
details: {
loginFields: [],
notesPlain: "My Software License",
sections: [
{
title: "",
fields: [],
},
{
title: "Customer",
name: "customer",
fields: [
{
title: "registered email",
id: "reg_email",
value: {
email: {
email_address: "kriddler@nullvalue.test",
provider: "myEmailProvider",
},
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "emailAddress",
correction: "default",
capitalization: "default",
},
},
],
},
{
title: "Publisher",
name: "publisher",
fields: [],
},
{
title: "Order",
name: "order",
fields: [],
},
],
passwordHistory: [],
},
overview: {
subtitle: "5.10.1000",
title: "Limux Product Key",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

87
jslib/common/spec/importers/testData/onePassword1Pux/EmailfieldOnIdentity.ts
View File

@@ -1,87 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const EmailFieldOnIdentityData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "45mjttbbq3owgij2uis55pfrlq",
favIndex: 0,
createdAt: 1619465450,
updatedAt: 1619465789,
trashed: false,
categoryUuid: "004",
details: {
loginFields: [],
notesPlain: "",
sections: [
{
title: "Identification",
name: "name",
fields: [],
},
{
title: "Address",
name: "address",
fields: [],
},
{
title: "Internet Details",
name: "internet",
fields: [
{
title: "E-mail",
id: "E-mail",
value: {
email: {
email_address: "gengels@nullvalue.test",
provider: "myEmailProvider",
},
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "emailAddress",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "George Engels",
title: "George Engels",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

103
jslib/common/spec/importers/testData/onePassword1Pux/EmailfieldOnIdentity_Prefilled.ts
View File

@@ -1,103 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const EmailFieldOnIdentityPrefilledData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "45mjttbbq3owgij2uis55pfrlq",
favIndex: 0,
createdAt: 1619465450,
updatedAt: 1619465789,
trashed: false,
categoryUuid: "004",
details: {
loginFields: [],
notesPlain: "",
sections: [
{
title: "Identification",
name: "name",
fields: [],
},
{
title: "Address",
name: "address",
fields: [],
},
{
title: "Internet Details",
name: "internet",
fields: [
{
title: "email",
id: "email",
value: {
string: "gengels@nullvalue.test",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "emailAddress",
correction: "default",
capitalization: "default",
},
},
{
title: "2nd email",
id: "2nd_email",
value: {
email: {
email_address: "kriddler@nullvalue.test",
provider: "myEmailProvider",
},
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "emailAddress",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "George Engels",
title: "George Engels",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

476
jslib/common/spec/importers/testData/onePassword1Pux/IdentityData.ts
View File

@@ -1,476 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const IdentityData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "45mjttbbq3owgij2uis55pfrlq",
favIndex: 0,
createdAt: 1619465450,
updatedAt: 1619465789,
trashed: false,
categoryUuid: "004",
details: {
loginFields: [],
notesPlain: "",
sections: [
{
title: "Identification",
name: "name",
fields: [
{
title: "first name",
id: "firstname",
value: {
string: "George",
},
indexAtSource: 0,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "initial",
id: "initial",
value: {
string: "S",
},
indexAtSource: 1,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "last name",
id: "lastname",
value: {
string: "Engels",
},
indexAtSource: 2,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "sex",
id: "sex",
value: {
menu: "male",
},
indexAtSource: 3,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "birth date",
id: "birthdate",
value: {
date: 347198460,
},
indexAtSource: 4,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "occupation",
id: "occupation",
value: {
string: "Steel Worker",
},
indexAtSource: 5,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "company",
id: "company",
value: {
string: "Acme Inc.",
},
indexAtSource: 6,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "department",
id: "department",
value: {
string: "QA",
},
indexAtSource: 7,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "job title",
id: "jobtitle",
value: {
string: "Quality Assurance Manager",
},
indexAtSource: 8,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
],
},
{
title: "Address",
name: "address",
fields: [
{
title: "address",
id: "address",
value: {
address: {
street: "1312 Main St.",
city: "Atlantis",
country: "us",
zip: "90210",
state: "California",
},
},
indexAtSource: 0,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "sentences",
},
},
{
title: "default phone",
id: "defphone",
value: {
phone: "4565555555",
},
indexAtSource: 1,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "home",
id: "homephone",
value: {
phone: "4575555555",
},
indexAtSource: 2,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "cell",
id: "cellphone",
value: {
phone: "4585555555",
},
indexAtSource: 3,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "business",
id: "busphone",
value: {
phone: "4595555555",
},
indexAtSource: 4,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
{
title: "Internet Details",
name: "internet",
fields: [
{
title: "username",
id: "username",
value: {
string: "gengels",
},
indexAtSource: 0,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "reminder question",
id: "reminderq",
value: {
string: "Who's a super cool guy?",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "reminder answer",
id: "remindera",
value: {
string: "Me, buddy.",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "email",
id: "email",
value: {
string: "gengels@nullvalue.test",
},
indexAtSource: 3,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "emailAddress",
correction: "default",
capitalization: "default",
},
},
{
title: "website",
id: "website",
value: {
string: "cv.gengels.nullvalue.test",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "uRL",
correction: "default",
capitalization: "default",
},
},
{
title: "ICQ",
id: "icq",
value: {
string: "12345678",
},
indexAtSource: 5,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "skype",
id: "skype",
value: {
string: "skypeisbad1619",
},
indexAtSource: 6,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "AOL/AIM",
id: "aim",
value: {
string: "aollol@lololol.aol.com",
},
indexAtSource: 7,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "Yahoo",
id: "yahoo",
value: {
string: "sk8rboi13@yah00.com",
},
indexAtSource: 8,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "MSN",
id: "msn",
value: {
string: "msnothankyou@msn&m&m.com",
},
indexAtSource: 9,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "forum signature",
id: "forumsig",
value: {
string: "super cool guy",
},
indexAtSource: 10,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "George Engels",
title: "George Engels",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

135
jslib/common/spec/importers/testData/onePassword1Pux/LoginData.ts
View File

@@ -1,135 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const LoginData: ExportData = {
accounts: [
{
attrs: {
accountName: "Wendy Appleseed",
name: "Wendy Appleseed",
avatar: "profile-pic.png",
email: "wendy.c.appleseed@gmail.com",
uuid: "D4RI47B7BJDT25C2LWA7LEJLHZ",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "rr3lr6c2opoggvrete23q72ahi",
desc: "",
avatar: "pic.png",
name: "Personal",
type: "P",
},
items: [
{
uuid: "2b3hr6p5hinr7prtrj65bwmxqu",
favIndex: 0,
createdAt: 1635522833,
updatedAt: 1635522872,
trashed: false,
categoryUuid: "001",
details: {
loginFields: [
{
value: "username123123123@gmail.com",
id: "",
name: "email",
fieldType: "E",
designation: "username",
},
{
value: "password!",
id: "",
name: "password",
fieldType: "P",
designation: "password",
},
{
value: "",
id: "terms",
name: "terms",
fieldType: "C",
},
{
value: "✓",
id: "policies",
name: "policies",
fieldType: "C",
},
],
sections: [
{
title: "Saved on www.fakesite.com",
name: "Section_mlvk6wzoifml4rbs4c3rfu4e2a",
fields: [
{
title: "Create an account",
id: "cyqyggt2otns6tbbqtsl6w2ceu",
value: {
string: "username123123",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "one-time password",
id: "TOTP_564mvwqapphpsjetnnuovmuxum",
value: {
totp: "otpseed777",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [
{
value: "123uio123oiu123uiopassword",
time: 1635522872,
},
{
value: "123uio123oiu123uiopassword123",
time: 1635522854,
},
{
value: "123uio123oiu123uiopassword123123",
time: 1635522848,
},
],
},
overview: {
subtitle: "username123123@gmail.com",
urls: [
{
label: "website",
url: "https://www.fakesite.com",
},
],
title: "eToro",
url: "https://www.fakesite.com",
ps: 54,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

198
jslib/common/spec/importers/testData/onePassword1Pux/MedicalRecord.ts
View File

@@ -1,198 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const MedicalRecordData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "42mj5boh5rxq7uqjrmkslmhosu",
favIndex: 0,
createdAt: 1641220207,
updatedAt: 1641220326,
trashed: false,
categoryUuid: "113",
details: {
loginFields: [],
notesPlain: "Some notes about my medical history",
sections: [
{
title: "",
fields: [
{
title: "date",
id: "date",
value: {
date: 1641038460,
},
indexAtSource: 0,
guarded: true,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "location",
id: "location",
value: {
string: "some hospital/clinic",
},
indexAtSource: 1,
guarded: true,
multiline: false,
dontGenerate: false,
placeholder: "locationplaceholder",
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "healthcare professional",
id: "healthcareprofessional",
value: {
string: "Some Doctor",
},
indexAtSource: 2,
guarded: true,
multiline: false,
dontGenerate: false,
placeholder: "nameplaceholder",
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "patient",
id: "patient",
value: {
string: "Me",
},
indexAtSource: 3,
guarded: true,
multiline: false,
dontGenerate: false,
placeholder: "nameplaceholder",
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "reason for visit",
id: "reason",
value: {
string: "unwell",
},
indexAtSource: 4,
guarded: true,
multiline: true,
dontGenerate: false,
placeholder: "reasonplaceholder",
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "sentences",
},
},
],
},
{
title: "medication",
name: "medication",
fields: [
{
title: "medication",
id: "medication",
value: {
string: "Insuline",
},
indexAtSource: 0,
guarded: true,
multiline: false,
dontGenerate: false,
placeholder: "medicationplaceholder",
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "dosage",
id: "dosage",
value: {
string: "1",
},
indexAtSource: 1,
guarded: true,
multiline: false,
dontGenerate: false,
placeholder: "dosageplaceholder",
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "medication notes",
id: "notes",
value: {
string: "multiple times a day",
},
indexAtSource: 2,
guarded: true,
multiline: true,
dontGenerate: false,
placeholder: "notesplaceholder",
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "sentences",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "2022-01-01",
title: "Some Health Record",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

186
jslib/common/spec/importers/testData/onePassword1Pux/Membership.ts
View File

@@ -1,186 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const MembershipData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "ofdp2szoty2ujk6yv5ebn4wjr4",
favIndex: 1,
createdAt: 1619467269,
updatedAt: 1619467368,
trashed: false,
categoryUuid: "105",
details: {
loginFields: [],
notesPlain: "My Library Card",
sections: [
{
title: "",
fields: [
{
title: "group",
id: "org_name",
value: {
string: "National Public Library",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "website",
id: "website",
value: {
url: "https://npl.nullvalue.gov.test",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "telephone",
id: "phone",
value: {
phone: "9995555555",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "member name",
id: "member_name",
value: {
string: "George Engels",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "member since",
id: "member_since",
value: {
monthYear: 199901,
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "expiry date",
id: "expiry_date",
value: {
monthYear: 203412,
},
indexAtSource: 5,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "member ID",
id: "membership_no",
value: {
string: "64783862",
},
indexAtSource: 6,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "namePhonePad",
correction: "no",
capitalization: "default",
},
},
{
title: "PIN",
id: "pin",
value: {
concealed: "19191",
},
indexAtSource: 7,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numberPad",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "George Engels",
tags: ["Education"],
title: "Library Card",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

93
jslib/common/spec/importers/testData/onePassword1Pux/Onepux_example.ts
View File

@@ -1,93 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const OnePuxExampleFile: ExportData = {
accounts: [
{
attrs: {
accountName: "Wendy Appleseed",
name: "Wendy Appleseed",
avatar: "profile-pic.png",
email: "wendy.c.appleseed@gmail.com",
uuid: "D4RI47B7BJDT25C2LWA7LEJLHZ",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "rr3lr6c2opoggvrete23q72ahi",
desc: "",
avatar: "pic.png",
name: "Personal",
type: "P",
},
items: [
{
uuid: "fkruyzrldvizuqlnavfj3gltfe",
favIndex: 1,
createdAt: 1614298956,
updatedAt: 1635346445,
trashed: false,
categoryUuid: "001",
details: {
loginFields: [
{
value: "most-secure-password-ever!",
id: "",
name: "password",
fieldType: "P",
designation: "password",
},
],
notesPlain: "This is a note. *bold*! _italic_!",
sections: [
{
title: "Security",
name: "Section_oazxddhvftfknycbbmh5ntwfa4",
fields: [
{
title: "PIN",
id: "CCEF647B399604E8F6Q6C8C3W31AFD407",
value: {
concealed: "12345",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [
{
value: "12345password",
time: 1458322355,
},
],
},
overview: {
subtitle: "",
urls: [
{
label: "",
url: "https://www.dropbox.com/",
},
],
title: "Dropbox",
url: "https://www.dropbox.com/",
ps: 100,
pbe: 86.13621,
pgrng: true,
},
},
],
},
],
},
],
};

169
jslib/common/spec/importers/testData/onePassword1Pux/OutdoorLicense.ts
View File

@@ -1,169 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const OutdoorLicenseData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "6fb73t5lk7vc52h3osw3ccmguy",
favIndex: 0,
createdAt: 1619467374,
updatedAt: 1619467492,
trashed: false,
categoryUuid: "104",
details: {
loginFields: [],
notesPlain: "My Outdoor License",
sections: [
{
title: "",
fields: [
{
title: "full name",
id: "name",
value: {
string: "Cash Bandit",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "valid from",
id: "valid_from",
value: {
date: 1617278460,
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "expires",
id: "expires",
value: {
date: 2343124860,
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "approved wildlife",
id: "game",
value: {
string: "Bananas,blueberries,corn",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "maximum quota",
id: "quota",
value: {
string: "100/each",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "state",
id: "state",
value: {
string: "Washington",
},
indexAtSource: 5,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "country",
id: "country",
value: {
string: "United States of America",
},
indexAtSource: 6,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "Cash Bandit",
title: "Harvest License",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

234
jslib/common/spec/importers/testData/onePassword1Pux/Passport.ts
View File

@@ -1,234 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const PassportData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "hffila4ew2e3krfzp2tkdkdmea",
favIndex: 0,
createdAt: 1619467498,
updatedAt: 1619467655,
trashed: false,
categoryUuid: "106",
details: {
loginFields: [],
notesPlain: "My Passport",
sections: [
{
title: "",
fields: [
{
title: "type",
id: "type",
value: {
string: "US Passport",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "allCharacters",
},
},
{
title: "issuing country",
id: "issuing_country",
value: {
string: "United States of America",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "number",
id: "number",
value: {
string: "76436847",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "namePhonePad",
correction: "default",
capitalization: "default",
},
},
{
title: "full name",
id: "fullname",
value: {
string: "David Global",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "sex",
id: "sex",
value: {
gender: "female",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "nationality",
id: "nationality",
value: {
string: "International",
},
indexAtSource: 5,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "issuing authority",
id: "issuing_authority",
value: {
string: "Department of State",
},
indexAtSource: 6,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "date of birth",
id: "birthdate",
value: {
date: 418046460,
},
indexAtSource: 7,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "place of birth",
id: "birthplace",
value: {
string: "A cave somewhere in Maine",
},
indexAtSource: 8,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "issued on",
id: "issue_date",
value: {
date: 1577880060,
},
indexAtSource: 9,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "expiry date",
id: "expiry_date",
value: {
date: 2524651260,
},
indexAtSource: 10,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "76436847",
tags: ["Travel"],
title: "Mr. Globewide",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

58
jslib/common/spec/importers/testData/onePassword1Pux/Password.ts
View File

@@ -1,58 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const PasswordData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "qpdsrgpngzud3x3rbfvyrz3ane",
favIndex: 0,
createdAt: 1619465796,
updatedAt: 1619465869,
trashed: false,
categoryUuid: "005",
details: {
loginFields: [],
notesPlain: "SuperSecret Password Notes",
sections: [],
passwordHistory: [],
password: "GBq[AGb]4*Si3tjwuab^",
},
overview: {
subtitle: "April 26, 2021 2:36 PM",
urls: [
{
label: "website",
url: "https://n0t.y0ur.n0rm4l.w3bs1t3",
},
],
title: "SuperSecret Password",
url: "https://n0t.y0ur.n0rm4l.w3bs1t3",
ps: 100,
pbe: 127.500786,
pgrng: true,
},
},
],
},
],
},
],
};

209
jslib/common/spec/importers/testData/onePassword1Pux/RewardsProgram.ts
View File

@@ -1,209 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const RewardsProgramData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "3bmrdcml3tngvsr6zdlvd2xo4i",
favIndex: 0,
createdAt: 1619467659,
updatedAt: 1619467765,
trashed: false,
categoryUuid: "107",
details: {
loginFields: [],
notesPlain: "My Reward Card",
sections: [
{
title: "",
fields: [
{
title: "company name",
id: "company_name",
value: {
string: "Super Cool Store Co.",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "member name",
id: "member_name",
value: {
string: "Chef Coldroom",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "member ID",
id: "membership_no",
value: {
string: "member-29813569",
},
indexAtSource: 2,
guarded: false,
clipboardFilter:
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "no",
capitalization: "none",
},
},
{
title: "PIN",
id: "pin",
value: {
concealed: "99913",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numberPad",
correction: "default",
capitalization: "default",
},
},
],
},
{
title: "More Information",
name: "extra",
fields: [
{
title: "member ID (additional)",
id: "additional_no",
value: {
string: "additional member id",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "no",
capitalization: "none",
},
},
{
title: "member since",
id: "member_since",
value: {
monthYear: 202101,
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "customer service phone",
id: "customer_service_phone",
value: {
phone: "123456",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "namePhonePad",
correction: "default",
capitalization: "default",
},
},
{
title: "phone for reservations",
id: "reservations_phone",
value: {
phone: "123456",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "namePhonePad",
correction: "default",
capitalization: "default",
},
},
{
title: "website",
id: "website",
value: {
url: "supercoolstore.com",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "Super Cool Store Co.",
title: "Retail Reward Thing",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

89
jslib/common/spec/importers/testData/onePassword1Pux/SSN.ts
View File

@@ -1,89 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const SSNData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "vi2biozc7sjnhr5sejk74nz26i",
favIndex: 1,
createdAt: 1619467910,
updatedAt: 1619467982,
trashed: false,
categoryUuid: "108",
details: {
loginFields: [],
notesPlain: "My SSN",
sections: [
{
title: "",
fields: [
{
title: "name",
id: "name",
value: {
string: "Jack Judd",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "number",
id: "number",
value: {
concealed: "131-216-1900",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: true,
inputTraits: {
keyboard: "numbersAndPunctuation",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "Jack Judd",
title: "SSN",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

4519
jslib/common/spec/importers/testData/onePassword1Pux/SanitizedExport.ts
View File

File diff suppressed because it is too large Load Diff

52
jslib/common/spec/importers/testData/onePassword1Pux/SecureNote.ts
View File

@@ -1,52 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const SecureNoteData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "gcozv72svonjgufn4q5hnyzwmu",
favIndex: 0,
createdAt: 1619465226,
updatedAt: 1619465278,
trashed: false,
categoryUuid: "003",
details: {
loginFields: [],
notesPlain:
"This is my secure note. \n\nLorem ipsum expecto patronum. \nThe quick brown fox jumped over the lazy dog. ",
sections: [],
passwordHistory: [],
},
overview: {
subtitle: "This is my secure note. ",
title: "Secure Note #1",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

229
jslib/common/spec/importers/testData/onePassword1Pux/Server.ts
View File

@@ -1,229 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const ServerData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "35szbzswhgeq3wyblg7odmshhu",
favIndex: 0,
createdAt: 1619467769,
updatedAt: 1619467906,
trashed: false,
categoryUuid: "110",
details: {
loginFields: [],
notesPlain: "My Server",
sections: [
{
title: "",
fields: [
{
title: "URL",
id: "url",
value: {
string: "https://coolserver.nullvalue.test",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "uRL",
correction: "default",
capitalization: "default",
},
},
{
title: "username",
id: "username",
value: {
string: "frankly-notsure",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "no",
capitalization: "none",
},
},
{
title: "password",
id: "password",
value: {
concealed: "*&YHJI87yjy78u",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
{
title: "Admin Console",
name: "admin_console",
fields: [
{
title: "admin console URL",
id: "admin_console_url",
value: {
string: "https://coolserver.nullvalue.test/admin",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "uRL",
correction: "default",
capitalization: "default",
},
},
{
title: "admin console username",
id: "admin_console_username",
value: {
string: "frankly-idontknowwhatimdoing",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "no",
capitalization: "none",
},
},
{
title: "console password",
id: "admin_console_password",
value: {
concealed: "^%RY&^YUiju8iUYHJI(U",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
{
title: "Hosting Provider",
name: "hosting_provider_details",
fields: [
{
title: "name",
id: "name",
value: {
string: "Private Hosting Provider Inc.",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "website",
id: "website",
value: {
string: "https://phpi.nullvalue.test",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "uRL",
correction: "default",
capitalization: "default",
},
},
{
title: "support URL",
id: "support_contact_url",
value: {
string: "https://phpi.nullvalue.test/support",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "uRL",
correction: "default",
capitalization: "default",
},
},
{
title: "support phone",
id: "support_contact_phone",
value: {
string: "8882569382",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "namePhonePad",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "frankly-notsure",
title: "Super Cool Server",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

289
jslib/common/spec/importers/testData/onePassword1Pux/SoftwareLicense.ts
View File

@@ -1,289 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const SoftwareLicenseData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "47hvppiuwbanbza7bq6jpdjfxu",
favIndex: 1,
createdAt: 1619467985,
updatedAt: 1619468230,
trashed: false,
categoryUuid: "100",
details: {
loginFields: [],
notesPlain: "My Software License",
sections: [
{
title: "",
fields: [
{
title: "version",
id: "product_version",
value: {
string: "5.10.1000",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numbersAndPunctuation",
correction: "default",
capitalization: "default",
},
},
{
title: "license key",
id: "reg_code",
value: {
string: "265453-13457355-847327",
},
indexAtSource: 1,
guarded: true,
multiline: true,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
{
title: "Customer",
name: "customer",
fields: [
{
title: "licensed to",
id: "reg_name",
value: {
string: "Kay Riddler",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "registered email",
id: "reg_email",
value: {
email: {
email_address: "kriddler@nullvalue.test",
provider: null,
},
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "emailAddress",
correction: "default",
capitalization: "default",
},
},
{
title: "company",
id: "company",
value: {
string: "Riddles and Jigsaw Puzzles GmbH",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
],
},
{
title: "Publisher",
name: "publisher",
fields: [
{
title: "download page",
id: "download_link",
value: {
url: "https://limuxcompany.nullvalue.test/5.10.1000/isos",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "publisher",
id: "publisher_name",
value: {
string: "Limux Software and Hardware",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "website",
id: "publisher_website",
value: {
url: "https://limuxcompany.nullvalue.test/",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "retail price",
id: "retail_price",
value: {
string: "$999",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numbersAndPunctuation",
correction: "default",
capitalization: "default",
},
},
{
title: "support email",
id: "support_email",
value: {
email: {
email_address: "support@nullvalue.test",
provider: null,
},
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
{
title: "Order",
name: "order",
fields: [
{
title: "purchase date",
id: "order_date",
value: {
date: 1617278460,
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "order number",
id: "order_number",
value: {
string: "594839",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "order total",
id: "order_total",
value: {
string: "$1086.59",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "numbersAndPunctuation",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "5.10.1000",
title: "Limux Product Key",
url: "",
ps: 0,
pbe: 0.0,
pgrng: false,
},
},
],
},
],
},
],
};

182
jslib/common/spec/importers/testData/onePassword1Pux/WirelessRouter.ts
View File

@@ -1,182 +0,0 @@
import { ExportData } from "@/jslib/common/src/importers/onepasswordImporters/types/onepassword1PuxImporterTypes";
export const WirelessRouterData: ExportData = {
accounts: [
{
attrs: {
accountName: "1Password Customer",
name: "1Password Customer",
avatar: "",
email: "username123123123@gmail.com",
uuid: "TRIZ3XV4JJFRXJ3BARILLTUA6E",
domain: "https://my.1password.com/",
},
vaults: [
{
attrs: {
uuid: "pqcgbqjxr4tng2hsqt5ffrgwju",
desc: "Just test entries",
avatar: "ke7i5rxnjrh3tj6uesstcosspu.png",
name: "T's Test Vault",
type: "U",
},
items: [
{
uuid: "fnnva6qkqdc3bv3qte2npnz6l4",
favIndex: 0,
createdAt: 1577652307,
updatedAt: 1577652307,
trashed: false,
categoryUuid: "109",
details: {
loginFields: [],
notesPlain: "My Wifi Router Config",
sections: [
{
title: "",
fields: [
{
title: "base station name",
id: "name",
value: {
string: "pixel 2Xl",
},
indexAtSource: 0,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "words",
},
},
{
title: "base station password",
id: "password",
value: {
concealed: "BqatGTVQ9TCN72tLbjrsHqkb",
},
indexAtSource: 1,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "server / ip address",
id: "server",
value: {
string: "127.0.0.1",
},
indexAtSource: 2,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "uRL",
correction: "default",
capitalization: "default",
},
},
{
title: "airport id",
id: "airport_id",
value: {
string: "some airportId",
},
indexAtSource: 3,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "network name",
id: "network_name",
value: {
string: "some network name",
},
indexAtSource: 4,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "wireless security",
id: "wireless_security",
value: {
menu: "WPA",
},
indexAtSource: 5,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "wireless network password",
id: "wireless_password",
value: {
concealed: "wifipassword",
},
indexAtSource: 6,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
{
title: "attached storage password",
id: "disk_password",
value: {
concealed: "diskpassword",
},
indexAtSource: 7,
guarded: false,
multiline: false,
dontGenerate: false,
inputTraits: {
keyboard: "default",
correction: "default",
capitalization: "default",
},
},
],
},
],
passwordHistory: [],
},
overview: {
subtitle: "",
title: "Wireless Router",
url: "",
},
},
],
},
],
},
],
};

4
jslib/common/spec/importers/testData/onePasswordCsv/creditCard.mac.csv.ts
View File

@@ -1,4 +0,0 @@
/* eslint-disable */
export const data = `"account number(accountNo)","address(address)","address(branchAddress)","admin console URL(admin_console_url)","admin console username(admin_console_username)","AirPort ID(airport_id)","alias(alias)","AOL/AIM(aim)","approved wildlife(game)","attached storage password(disk_password)","auth​ method(pop_authentication)","auth​ method(smtp_authentication)","bank name(bankName)","base station name(name)","base station password(password)","birth date(birthdate)","business(busphone)","cardholder name(cardholder)","cash withdrawal limit(cashLimit)","cell(cellphone)","company name(company_name)","company(company)","conditions / restrictions(conditions)","connection options(options)","console password(admin_console_password)","country(country)","Created Date","credit limit(creditLimit)","customer service phone(customer_service_phone)","database(database)","date of birth(birthdate)","default phone(defphone)","department(department)","download page(download_link)","email(email)","expires(expires)","expiry date(expiry_date)","expiry date(expiry)","first name(firstname)","forum signature(forumsig)","full name(fullname)","full name(name)","group(org_name)","height(height)","home(homephone)","IBAN(iban)","ICQ(icq)","initial(initial)","interest rate(interest)","issue number(issuenumber)","issued on(issue_date)","issuing authority(issuing_authority)","issuing bank(bank)","issuing country(issuing_country)","job title(jobtitle)","last name(lastname)","license class(class)","license key(reg_code)","licensed to(reg_name)","maximum quota(quota)","member ID (additional)(additional_no)","member ID(membership_no)","member name(member_name)","member since(member_since)","Modified Date","MSN(msn)","name on account(owner)","name(name)","nationality(nationality)","network name(network_name)","Notes","number(ccnum)","number(number)","occupation(occupation)","order number(order_number)","order total(order_total)","Password","password(password)","password(pop_password)","password(smtp_password)","phone (intl)(phoneIntl)","phone (local)(phone_local)","phone (local)(phoneLocal)","phone (toll free)(phone_tollfree)","phone (toll free)(phoneTollFree)","phone for reserva​tions(reservations_phone)","phone(branchPhone)","PIN(pin)","PIN(telephonePin)","place of birth(birthplace)","port number(pop_port)","port number(smtp_port)","port(port)","provider's website(provider_website)","provider(provider)","publisher(publisher_name)","purchase date(order_date)","registered email(reg_email)","reminder answer(remindera)","reminder question(reminderq)","retail price(retail_price)","routing number(routingNo)","Scope","security(pop_security)","security(smtp_security)","server / IP address(server)","server(hostname)","server(pop_server)","sex(sex)","SID(sid)","skype(skype)","SMTP server(smtp_server)","state(state)","support email(support_email)","support phone(support_contact_phone)","support URL(support_contact_url)","SWIFT(swift)","Tags","telephone(phone)","Title","Type","type(accountType)","type(database_type)","type(pop_type)","type(type)","URL","URL(url)","Username","username(pop_username)","username(smtp_username)","username(username)","valid from(valid_from)","valid from(validFrom)","verification number(cvv)","version(product_version)","website(publisher_website)","website(website)","wireless network password(wireless_password)","wireless security(wireless_security)","Yahoo(yahoo)",
,,,,,,,,,,,,,,,,,"test",,,,,,,,,"1606923869",,,,,,,,,,,"01/2030",,,,,,,,,,,,,,,,,,,,,,,,,,,"1606924056",,,,,,"","4111111111111111",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"{(
)}",,"test card","Credit Card",,,,"laser",,,,,,,,,"111",,,,,,,`;

2
jslib/common/spec/importers/testData/onePasswordCsv/creditCard.windows.csv.ts
View File

@@ -1,2 +0,0 @@
export const data = `"UUID","TITLE","SCOPE","AUTOSUBMIT","1: CARDHOLDER NAME","2: NUMBER","3: VERIFICATION NUMBER","4: EXPIRY DATE","SECTION 2: SECTION_PZET7LEKRQXZUINIEGH5ABA2UY","SECTION_PZET7LEKRQXZUINIEGH5ABA2UY 1: LABEL"
"sd26pt226etnsijbl3kqzi5bmm","test card","Default","Default","test","4111111111111111","111","1/3/1970 12:23 AM","section","field (phone)"`;

7
jslib/common/spec/importers/testData/onePasswordCsv/identity.mac.csv.ts
View File

@@ -1,7 +0,0 @@
/* eslint-disable */
export const data = `"account number(accountNo)","address(address)","address(branchAddress)","admin console URL(admin_console_url)","admin console username(admin_console_username)","AirPort ID(airport_id)","alias(alias)","AOL/AIM(aim)","approved wildlife(game)","attached storage password(disk_password)","auth​ method(pop_authentication)","auth​ method(smtp_authentication)","bank name(bankName)","base station name(name)","base station password(password)","birth date(birthdate)","business(busphone)","cardholder name(cardholder)","cash withdrawal limit(cashLimit)","cell(cellphone)","company name(company_name)","company(company)","conditions / restrictions(conditions)","connection options(options)","console password(admin_console_password)","country(country)","Created Date","credit limit(creditLimit)","customer service phone(customer_service_phone)","database(database)","date of birth(birthdate)","default phone(defphone)","department(department)","download page(download_link)","email(email)","expires(expires)","expiry date(expiry_date)","expiry date(expiry)","first name(firstname)","forum signature(forumsig)","full name(fullname)","full name(name)","group(org_name)","height(height)","home(homephone)","IBAN(iban)","ICQ(icq)","initial(initial)","interest rate(interest)","issue number(issuenumber)","issued on(issue_date)","issuing authority(issuing_authority)","issuing bank(bank)","issuing country(issuing_country)","job title(jobtitle)","last name(lastname)","license class(class)","license key(reg_code)","licensed to(reg_name)","maximum quota(quota)","member ID (additional)(additional_no)","member ID(membership_no)","member name(member_name)","member since(member_since)","Modified Date","MSN(msn)","name on account(owner)","name(name)","nationality(nationality)","network name(network_name)","Notes","number(ccnum)","number(number)","occupation(occupation)","order number(order_number)","order total(order_total)","Password","password(password)","password(pop_password)","password(smtp_password)","phone (intl)(phoneIntl)","phone (local)(phone_local)","phone (local)(phoneLocal)","phone (toll free)(phone_tollfree)","phone (toll free)(phoneTollFree)","phone for reserva​tions(reservations_phone)","phone(branchPhone)","PIN(pin)","PIN(telephonePin)","place of birth(birthplace)","port number(pop_port)","port number(smtp_port)","port(port)","provider's website(provider_website)","provider(provider)","publisher(publisher_name)","purchase date(order_date)","registered email(reg_email)","reminder answer(remindera)","reminder question(reminderq)","retail price(retail_price)","routing number(routingNo)","Scope","security(pop_security)","security(smtp_security)","server / IP address(server)","server(hostname)","server(pop_server)","sex(sex)","SID(sid)","skype(skype)","SMTP server(smtp_server)","state(state)","support email(support_email)","support phone(support_contact_phone)","support URL(support_contact_url)","SWIFT(swift)","Tags","telephone(phone)","Title","Type","type(accountType)","type(database_type)","type(pop_type)","type(type)","URL","URL(url)","Username","username(pop_username)","username(smtp_username)","username(username)","valid from(valid_from)","valid from(validFrom)","verification number(cvv)","version(product_version)","website(publisher_website)","website(website)","wireless network password(wireless_password)","wireless security(wireless_security)","Yahoo(yahoo)",
,"address
city state zip
United States",,,,,,"",,,,,,,,"12/2/20","",,,"",,"bitwarden",,,,,"1606923754",,,,"12/2/20","8005555555","department",,"email@bitwarden.com",,,,"first name","",,,,,"",,"","mi",,,,,,,"job title","last name",,,,,,,,,"1607020883","",,,,,"It’s you! 🖐 Select Edit to fill in more details, like your address and contact information.",,,"occupation",,,,,,,,,,,,,,,,,,,,,,,,,"","",,,,,,,,,"",,"",,,,,,,"{(
\\"Starter Kit\\"
)}",,"Identity Item","Identity",,,,,,,"userNam3",,,"userNam3",,,,,,"",,,"",`;

2
jslib/common/spec/importers/testData/onePasswordCsv/identity.windows.csv.ts
View File

@@ -1,2 +0,0 @@
export const data = `"UUID","TITLE","SCOPE","AUTOSUBMIT","TAGS","NOTES","SECTION 1: NAME","NAME 1: FIRST NAME","NAME 2: INITIAL","NAME 3: LAST NAME","NAME 4: BIRTH DATE","NAME 5: OCCUPATION","NAME 6: COMPANY","NAME 7: DEPARTMENT","NAME 8: JOB TITLE","SECTION 2: ADDRESS","ADDRESS 1: ADDRESS","ADDRESS 2: DEFAULT PHONE","SECTION 3: INTERNET","INTERNET 1: USERNAME","INTERNET 2: EMAIL","SECTION 4: MFJQKMWEOYDZDFH4YMR7WLJKIY","MFJQKMWEOYDZDFH4YMR7WLJKIY 1: SECTION FIELD","MFJQKMWEOYDZDFH4YMR7WLJKIY 2: SECTION FIELD"
"6v56y5z4tejwg37jsettta7d7m","Identity Item","Default","Default","Starter Kit","It’s you! 🖐 Select Edit to fill in more details, like your address and contact information.","Identification","first name","mi","last name","12/2/2020 4:01 AM","occupation","bitwarden","department","job title","Address","address city state zip us","8005555555","Internet Details","userNam3","email@bitwarden.com","💡 Did you know?","1Password can fill names and addresses into webpages:","https://support.1password.com/credit-card-address-filling/"`;

15
jslib/common/spec/importers/testData/onePasswordCsv/multipleItems.mac.csv.ts
View File

@@ -1,15 +0,0 @@
/* eslint-disable */
export const data = `"account number(accountNo)","address(address)","address(branchAddress)","admin console URL(admin_console_url)","admin console username(admin_console_username)","AirPort ID(airport_id)","alias(alias)","AOL/AIM(aim)","approved wildlife(game)","attached storage password(disk_password)","auth​ method(pop_authentication)","auth​ method(smtp_authentication)","bank name(bankName)","base station name(name)","base station password(password)","birth date(birthdate)","business(busphone)","cardholder name(cardholder)","cash withdrawal limit(cashLimit)","cell(cellphone)","company name(company_name)","company(company)","conditions / restrictions(conditions)","connection options(options)","console password(admin_console_password)","country(country)","Created Date","credit limit(creditLimit)","customer service phone(customer_service_phone)","database(database)","date of birth(birthdate)","default phone(defphone)","department(department)","download page(download_link)","email(email)","expires(expires)","expiry date(expiry_date)","expiry date(expiry)","first name(firstname)","forum signature(forumsig)","full name(fullname)","full name(name)","group(org_name)","height(height)","home(homephone)","IBAN(iban)","ICQ(icq)","initial(initial)","interest rate(interest)","issue number(issuenumber)","issued on(issue_date)","issuing authority(issuing_authority)","issuing bank(bank)","issuing country(issuing_country)","job title(jobtitle)","last name(lastname)","license class(class)","license key(reg_code)","licensed to(reg_name)","maximum quota(quota)","member ID (additional)(additional_no)","member ID(membership_no)","member name(member_name)","member since(member_since)","Modified Date","MSN(msn)","name on account(owner)","name(name)","nationality(nationality)","network name(network_name)","Notes","number(ccnum)","number(number)","occupation(occupation)","order number(order_number)","order total(order_total)","Password","password(password)","password(pop_password)","password(smtp_password)","phone (intl)(phoneIntl)","phone (local)(phone_local)","phone (local)(phoneLocal)","phone (toll free)(phone_tollfree)","phone (toll free)(phoneTollFree)","phone for reserva​tions(reservations_phone)","phone(branchPhone)","PIN(pin)","PIN(telephonePin)","place of birth(birthplace)","port number(pop_port)","port number(smtp_port)","port(port)","provider's website(provider_website)","provider(provider)","publisher(publisher_name)","purchase date(order_date)","registered email(reg_email)","reminder answer(remindera)","reminder question(reminderq)","retail price(retail_price)","routing number(routingNo)","Scope","security(pop_security)","security(smtp_security)","server / IP address(server)","server(hostname)","server(pop_server)","sex(sex)","SID(sid)","skype(skype)","SMTP server(smtp_server)","state(state)","support email(support_email)","support phone(support_contact_phone)","support URL(support_contact_url)","SWIFT(swift)","Tags","telephone(phone)","Title","Type","type(accountType)","type(database_type)","type(pop_type)","type(type)","URL","URL(url)","Username","username(pop_username)","username(smtp_username)","username(username)","valid from(valid_from)","valid from(validFrom)","verification number(cvv)","version(product_version)","website(publisher_website)","website(website)","wireless network password(wireless_password)","wireless security(wireless_security)","Yahoo(yahoo)",
,,,,,,,,,,,,,,,,,,,,,,,,,,"1606923754",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"1606923754",,,,,,"Follow these steps to get started.",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"{(
\\"Starter Kit\\"
)}",,"🎉 Welcome to 1Password!","Secure Note",,,,,,,,,,,,,,,,,,,,
,"address
city state zip
United States",,,,,,,,,,,,,,"12/2/20",,,,,,"bitwarden",,,,,"1606923754",,,,"12/2/20","8005555555","department",,"email@bitwarden.com",,,,"first name",,,,,,,,,"mi",,,,,,,"job title","last name",,,,,,,,,"1607390191",,,,,,"It’s you! 🖐 Select Edit to fill in more details, like your address and contact information.",,,"occupation",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"{(
\\"Starter Kit\\"
)}",,"Identity Item","Identity",,,,,,,"userNam3",,,"userNam3",,,,,,,,,,
,,,,,,,,,,,,,,,,,"test",,,,,,,,,"1606923869",,,,,,,,,,,"01/2030",,,,,,,,,,,,,,,,,,,,,,,,,,,"1607355631",,,,,,"","4111111111111111",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"{(
)}",,"test card","Credit Card",,,,"laser",,,,,,,,,"111",,,,,,,
,,,,,,,,,,,,,,,,,,,,,,,,,,"1606923754",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"1607020972",,,,,,"You can use this login to sign in to your account on 1password.com.",,,,,,"the account's password",,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,"{(
\\"Starter Kit\\"
)}",,"1Password Account","Login",,,,,"https://my.1password.com",,"email@bitwarden.com",,,,,,,,,,,,,`;

5
jslib/common/spec/importers/testData/onePasswordCsv/multipleItems.windows.csv.ts
View File

@@ -1,5 +0,0 @@
export const data = `"UUID","TITLE","USERNAME","PASSWORD","URL","URLS","EMAIL","MASTER-PASSWORD","ACCOUNT-KEY","SCOPE","AUTOSUBMIT","TAGS","NOTES","SECTION 1: WXHDKEQREE3TH6QRFCPFPSD3AE","WXHDKEQREE3TH6QRFCPFPSD3AE 1: SECRET KEY","SECTION 1: NAME","NAME 1: FIRST NAME","NAME 2: INITIAL","NAME 3: LAST NAME","NAME 4: BIRTH DATE","NAME 5: OCCUPATION","NAME 6: COMPANY","NAME 7: DEPARTMENT","NAME 8: JOB TITLE","SECTION 2: ADDRESS","ADDRESS 1: ADDRESS","ADDRESS 2: DEFAULT PHONE","SECTION 3: INTERNET","INTERNET 1: USERNAME","INTERNET 2: EMAIL","SECTION 4: MFJQKMWEOYDZDFH4YMR7WLJKIY","MFJQKMWEOYDZDFH4YMR7WLJKIY 1: SECTION FIELD","MFJQKMWEOYDZDFH4YMR7WLJKIY 2: SECTION FIELD","1: CARDHOLDER NAME","2: NUMBER","3: VERIFICATION NUMBER","4: EXPIRY DATE","SECTION 2: SECTION_PZET7LEKRQXZUINIEGH5ABA2UY","SECTION_PZET7LEKRQXZUINIEGH5ABA2UY 1: LABEL","SECTION 1: 4PQVXPR4BMOPGC3DBMTP5U4OFY","4PQVXPR4BMOPGC3DBMTP5U4OFY 1: SECTION FIELD","4PQVXPR4BMOPGC3DBMTP5U4OFY 2: SECTION FIELD","SECTION 2: M2NTUZZBFOFTPAYXVXE6EMZ5JU","M2NTUZZBFOFTPAYXVXE6EMZ5JU 1: SECTION FIELD","M2NTUZZBFOFTPAYXVXE6EMZ5JU 2: SECTION FIELD","SECTION 3: WC3KPAWH6ZAEQB2ARJB6WYZ3DQ","WC3KPAWH6ZAEQB2ARJB6WYZ3DQ 1: SECTION FIELD","WC3KPAWH6ZAEQB2ARJB6WYZ3DQ 2: SECTION FIELD","WC3KPAWH6ZAEQB2ARJB6WYZ3DQ 3: SECTION FIELD","SECTION 4: TOHUYJEJEMGMI6GEQAZ2LJODFE","TOHUYJEJEMGMI6GEQAZ2LJODFE 1: SECTION FIELD","TOHUYJEJEMGMI6GEQAZ2LJODFE 2: SECTION FIELD","SECTION 5: O26UWJJTXRAANG3ONYYOUUJHDM","O26UWJJTXRAANG3ONYYOUUJHDM 1: SECTION FIELD","O26UWJJTXRAANG3ONYYOUUJHDM 2: WATCH VIDEOS","O26UWJJTXRAANG3ONYYOUUJHDM 3: GET SUPPORT","O26UWJJTXRAANG3ONYYOUUJHDM 4: READ THE BLOG","O26UWJJTXRAANG3ONYYOUUJHDM 5: CONTACT US"
"xjq32axcswefpcxu2mtxxqnufa","1Password Account","email@bitwarden.com","the account's password","https://my.1password.com","https://my.1password.com","email@bitwarden.com","the account's password","A3-76TR2N-NJG3TZ-9NXFX-WT8GF-6YQC9-R2659","Default","Default","Starter Kit","You can use this login to sign in to your account on 1password.com.","🔑 Secret Key","the account's secret key","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""
"6v56y5z4tejwg37jsettta7d7m","Identity Item","","","","","","","","Default","Default","Starter Kit","It’s you! 🖐 Select Edit to fill in more details, like your address and contact information.","","","Identification","first name","mi","last name","12/2/2020 4:01 AM","occupation","bitwarden","department","job title","Address","address city state zip us","8005555555","Internet Details","userNam3","email@bitwarden.com","💡 Did you know?","1Password can fill names and addresses into webpages:","https://support.1password.com/credit-card-address-filling/","","","","","","","","","","","","","","","","","","","","","","","","",""
"sd26pt226etnsijbl3kqzi5bmm","test card","","","","","","","","Default","Default","","","","","","","","","","","","","","","","","","","","","","","test","4111111111111111","111","1/3/1970 12:23 AM","section","field (phone)","","","","","","","","","","","","","","","","","","",""
"oml2sgit3yk7737kxdis65o4xq","🎉 Welcome to 1Password!","","","","","","","","Default","Default","Starter Kit","Follow these steps to get started.","","","","","","","","","","","","","","","","","","","","","","","","","","","1️⃣ Get the apps","https://1password.com/downloads","Install 1Password everywhere you need your passwords.","2️⃣ Get 1Password in your browser","https://1password.com/downloads/#browsers","Install 1Password in your browser to save and fill passwords.","3️⃣ Save your first password","1. Sign in to your favorite website.","2. 1Password will ask to save your username and password.","3. Click Save Login.","4️⃣ Fill passwords and more","https://support.1password.com/explore/extension/","Save and fill passwords, credit cards, and addresses.","📚 Learn 1Password","Check out our videos and articles:","https://youtube.com/1PasswordVideos","https://support.1password.com/","https://blog.1password.com/","https://support.1password.com/contact-us/"`;

2
jslib/common/spec/importers/testData/safariCsv/oldSimplePasswordData.csv.ts
View File

@@ -1,2 +0,0 @@
export const data = `Title,Url,Username,Password
example.com (example_user),https://example.com,example_user,example_p@ssword`;

3
jslib/common/spec/importers/testData/safariCsv/simplePasswordData.csv.ts
View File

@@ -1,3 +0,0 @@
export const data = `Title,URL,Username,Password,Notes,OTPAuth
example.com (example_user),https://example.com,example_user,example_p@ssword,"Example note
More notes on new line",otpauth://totp/test?secret=examplesecret`;

63
jslib/common/spec/importers/testData/safeInCloud/testData.xml.ts
View File

@@ -1,63 +0,0 @@
/* eslint-disable */
export const data = `
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<database> <!-- LABELS -->
<label name="Business" id="1"></label>
<label name="Samples" id="3"></label>
<label name="Web Accounts" id="4" type="web_accounts"></label> <!-- TEMPLATES -->
<card title="Web Account" id="102" symbol="web_site" color="gray" template="true" autofill="on">
<field name="Login" type="login" autofill="username"></field>
<field name="Password" type="password" autofill="current-password"></field>
<field name="Website" type="website" autofill="url"></field>
<field name="One-time password" type="one_time_password" autofill="one-time-code"></field>
</card>
<card title="Note (Sample)" id="206" symbol="note" color="yellow" type="note" autofill="off">
<notes>This is a sample note.</notes>
<label_id>3</label_id>
</card>
<ghost id="2" time_stamp="1615910263225"></ghost>
<card title="Visa Card (Sample)" id="205" symbol="visa" color="0xff3f5ca8" autofill="on" time_stamp="1615910280931">
<field name="Number" type="number" autofill="cc-number">5555123456789000</field>
<field name="Owner" type="text" autofill="cc-name">John Smith</field>
<field name="Expires" type="expiry" autofill="cc-exp">01/23</field>
<field name="CVV" type="pin" autofill="cc-csc">555</field>
<field name="PIN" type="pin" autofill="off">1111</field>
<field name="Blocking" type="phone" autofill="off">555-0153</field>
<label_id>1</label_id>
</card>
<card title="Facebook (Sample)" id="301" symbol="f" color="0xff3f5ca8" autofill="on" deleted="true" time_stamp="1615910298700">
<field name="Login" type="login" autofill="username">john555@gmail.com</field>
<field name="Password" type="password" autofill="current-password">early91*Fail*</field>
<field name="Website" type="website" autofill="url">https://www.facebook.com</field>
<label_id>3</label_id>
</card>
<card title="Google (Sample)" id="300" symbol="g" color="blue" autofill="on" prev_stamp="1615910345167" time_stamp="1615910386722">
<field name="Email" type="login" autofill="username">john555@gmail.com</field>
<field name="Password" type="password" score="4" hash="5c76cb4d2fd87820be94530315581e14" autofill="current-password">plain79{Area{</field>
<field name="Website" type="website" autofill="url">https://www.google.com</field>
<label_id>3</label_id>
<field type="one_time_password" name="One-time password" history="{&quot;1615910350891&quot;:&quot;&quot;}" autofill="one-time-code">thisisanotp</field>
<field type="secret" name="2FA-Reset" history="{&quot;1615910350891&quot;:&quot;&quot;}" autofill="off">thisshouldbehidden</field>
</card>
<card title="Passport (Sample)" id="203" symbol="passport" color="purple" autofill="off" time_stamp="1615910424608">
<field name="Number" type="number" autofill="off">555111111</field>
<field name="Name" type="text" autofill="off">John Smith</field>
<field name="Birthday" type="date" autofill="off">05/05/1980</field>
<field name="Issued" type="date" autofill="off">01/01/2018</field>
<field name="Expires" type="expiry" autofill="off" score="1830380399000" hash="52f13d61109f06e642f86caf5e140474">01/01/2028</field>
<label_id>3</label_id>
<notes>This is a note attached to a card</notes>
</card>
<card title="Twitter (Sample)" id="302" symbol="t" color="blue" autofill="off" time_stamp="1615910462627">
<field name="Login" type="login" autofill="username">john555@gmail.com</field>
<field name="Website" type="website" autofill="url">https://twitter.com</field>
<label_id>3</label_id>
<field type="password" name="Secret login data" autofill="username" history="{&quot;1615910438286&quot;:&quot;&quot;}" score="0" hash="f9f910baf9c2cfb4f640e2d231f4a39b">shouldbepassword</field>
</card>
<card title="Laptop (Sample)" id="303" symbol="laptop" color="gray" autofill="off" star="false" prev_stamp="1615910472161" time_stamp="1615910473734">
<field name="Login" type="login" autofill="username">john555</field>
<field name="Password" type="password" autofill="current-password">Save63\apple\</field>
<label_id>3</label_id>
</card>
</database>
`;

209
jslib/common/spec/services/export.service.spec.ts
View File

@@ -1,209 +0,0 @@
import { Arg, Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
import { ApiService } from "@/jslib/common/src/abstractions/api.service";
import { CipherService } from "@/jslib/common/src/abstractions/cipher.service";
import { CryptoService } from "@/jslib/common/src/abstractions/crypto.service";
import { CryptoFunctionService } from "@/jslib/common/src/abstractions/cryptoFunction.service";
import { FolderService } from "@/jslib/common/src/abstractions/folder.service";
import { CipherType } from "@/jslib/common/src/enums/cipherType";
import { KdfType } from "@/jslib/common/src/enums/kdfType";
import { Utils } from "@/jslib/common/src/misc/utils";
import { Cipher } from "@/jslib/common/src/models/domain/cipher";
import { EncString } from "@/jslib/common/src/models/domain/encString";
import { Login } from "@/jslib/common/src/models/domain/login";
import { CipherWithIds as CipherExport } from "@/jslib/common/src/models/export/cipherWithIds";
import { CipherView } from "@/jslib/common/src/models/view/cipherView";
import { LoginView } from "@/jslib/common/src/models/view/loginView";
import { ExportService } from "@/jslib/common/src/services/export.service";
import { BuildTestObject, GetUniqueString } from "../utils";
const UserCipherViews = [
generateCipherView(false),
generateCipherView(false),
generateCipherView(true),
];
const UserCipherDomains = [
generateCipherDomain(false),
generateCipherDomain(false),
generateCipherDomain(true),
];
function generateCipherView(deleted: boolean) {
return BuildTestObject(
{
id: GetUniqueString("id"),
notes: GetUniqueString("notes"),
type: CipherType.Login,
login: BuildTestObject<LoginView>(
{
username: GetUniqueString("username"),
password: GetUniqueString("password"),
},
LoginView
),
collectionIds: null,
deletedDate: deleted ? new Date() : null,
},
CipherView
);
}
function generateCipherDomain(deleted: boolean) {
return BuildTestObject(
{
id: GetUniqueString("id"),
notes: new EncString(GetUniqueString("notes")),
type: CipherType.Login,
login: BuildTestObject<Login>(
{
username: new EncString(GetUniqueString("username")),
password: new EncString(GetUniqueString("password")),
},
Login
),
collectionIds: null,
deletedDate: deleted ? new Date() : null,
},
Cipher
);
}
function expectEqualCiphers(ciphers: CipherView[] | Cipher[], jsonResult: string) {
const actual = JSON.stringify(JSON.parse(jsonResult).items);
const items: CipherExport[] = [];
ciphers.forEach((c: CipherView | Cipher) => {
const item = new CipherExport();
item.build(c);
items.push(item);
});
expect(actual).toEqual(JSON.stringify(items));
}
describe("ExportService", () => {
let exportService: ExportService;
let apiService: SubstituteOf<ApiService>;
let cryptoFunctionService: SubstituteOf<CryptoFunctionService>;
let cipherService: SubstituteOf<CipherService>;
let folderService: SubstituteOf<FolderService>;
let cryptoService: SubstituteOf<CryptoService>;
beforeEach(() => {
apiService = Substitute.for<ApiService>();
cryptoFunctionService = Substitute.for<CryptoFunctionService>();
cipherService = Substitute.for<CipherService>();
folderService = Substitute.for<FolderService>();
cryptoService = Substitute.for<CryptoService>();
folderService.getAllDecrypted().resolves([]);
folderService.getAll().resolves([]);
exportService = new ExportService(
folderService,
cipherService,
apiService,
cryptoService,
cryptoFunctionService
);
});
it("exports unecrypted user ciphers", async () => {
cipherService.getAllDecrypted().resolves(UserCipherViews.slice(0, 1));
const actual = await exportService.getExport("json");
expectEqualCiphers(UserCipherViews.slice(0, 1), actual);
});
it("exports encrypted json user ciphers", async () => {
cipherService.getAll().resolves(UserCipherDomains.slice(0, 1));
const actual = await exportService.getExport("encrypted_json");
expectEqualCiphers(UserCipherDomains.slice(0, 1), actual);
});
it("does not unecrypted export trashed user items", async () => {
cipherService.getAllDecrypted().resolves(UserCipherViews);
const actual = await exportService.getExport("json");
expectEqualCiphers(UserCipherViews.slice(0, 2), actual);
});
it("does not encrypted export trashed user items", async () => {
cipherService.getAll().resolves(UserCipherDomains);
const actual = await exportService.getExport("encrypted_json");
expectEqualCiphers(UserCipherDomains.slice(0, 2), actual);
});
describe("password protected export", () => {
let exportString: string;
let exportObject: any;
let mac: SubstituteOf<EncString>;
let data: SubstituteOf<EncString>;
const password = "password";
const salt = "salt";
describe("export json object", () => {
beforeEach(async () => {
mac = Substitute.for<EncString>();
data = Substitute.for<EncString>();
mac.encryptedString.returns("mac");
data.encryptedString.returns("encData");
jest.spyOn(Utils, "fromBufferToB64").mockReturnValue(salt);
cipherService.getAllDecrypted().resolves(UserCipherViews.slice(0, 1));
exportString = await exportService.getPasswordProtectedExport(password);
exportObject = JSON.parse(exportString);
});
it("specifies it is encrypted", () => {
expect(exportObject.encrypted).toBe(true);
});
it("specifies it's password protected", () => {
expect(exportObject.passwordProtected).toBe(true);
});
it("specifies salt", () => {
expect(exportObject.salt).toEqual("salt");
});
it("specifies kdfIterations", () => {
expect(exportObject.kdfIterations).toEqual(100000);
});
it("has kdfType", () => {
expect(exportObject.kdfType).toEqual(KdfType.PBKDF2_SHA256);
});
it("has a mac property", async () => {
cryptoService.encrypt(Arg.any(), Arg.any()).resolves(mac);
exportString = await exportService.getPasswordProtectedExport(password);
exportObject = JSON.parse(exportString);
expect(exportObject.encKeyValidation_DO_NOT_EDIT).toEqual(mac.encryptedString);
});
it("has data property", async () => {
cryptoService.encrypt(Arg.any(), Arg.any()).resolves(data);
exportString = await exportService.getPasswordProtectedExport(password);
exportObject = JSON.parse(exportString);
expect(exportObject.data).toEqual(data.encryptedString);
});
it("encrypts the data property", async () => {
const unencrypted = await exportService.getExport();
expect(exportObject.data).not.toEqual(unencrypted);
});
});
});
});

72
jslib/common/spec/services/import.service.spec.ts
View File

@@ -1,72 +0,0 @@
import { Substitute, SubstituteOf } from "@fluffy-spoon/substitute";
import { ApiService } from "@/jslib/common/src/abstractions/api.service";
import { CipherService } from "@/jslib/common/src/abstractions/cipher.service";
import { CollectionService } from "@/jslib/common/src/abstractions/collection.service";
import { CryptoService } from "@/jslib/common/src/abstractions/crypto.service";
import { FolderService } from "@/jslib/common/src/abstractions/folder.service";
import { I18nService } from "@/jslib/common/src/abstractions/i18n.service";
import { PlatformUtilsService } from "@/jslib/common/src/abstractions/platformUtils.service";
import { BitwardenPasswordProtectedImporter } from "@/jslib/common/src/importers/bitwardenPasswordProtectedImporter";
import { Importer } from "@/jslib/common/src/importers/importer";
import { Utils } from "@/jslib/common/src/misc/utils";
import { ImportService } from "@/jslib/common/src/services/import.service";
describe("ImportService", () => {
let importService: ImportService;
let cipherService: SubstituteOf<CipherService>;
let folderService: SubstituteOf<FolderService>;
let apiService: SubstituteOf<ApiService>;
let i18nService: SubstituteOf<I18nService>;
let collectionService: SubstituteOf<CollectionService>;
let platformUtilsService: SubstituteOf<PlatformUtilsService>;
let cryptoService: SubstituteOf<CryptoService>;
beforeEach(() => {
cipherService = Substitute.for<CipherService>();
folderService = Substitute.for<FolderService>();
apiService = Substitute.for<ApiService>();
i18nService = Substitute.for<I18nService>();
collectionService = Substitute.for<CollectionService>();
platformUtilsService = Substitute.for<PlatformUtilsService>();
cryptoService = Substitute.for<CryptoService>();
importService = new ImportService(
cipherService,
folderService,
apiService,
i18nService,
collectionService,
platformUtilsService,
cryptoService
);
});
describe("getImporterInstance", () => {
describe("Get bitPasswordProtected importer", () => {
let importer: Importer;
const organizationId = Utils.newGuid();
const password = Utils.newGuid();
beforeEach(() => {
importer = importService.getImporter(
"bitwardenpasswordprotected",
organizationId,
password
);
});
it("returns an instance of BitwardenPasswordProtectedImporter", () => {
expect(importer).toBeInstanceOf(BitwardenPasswordProtectedImporter);
});
it("has the appropriate organization Id", () => {
expect(importer.organizationId).toEqual(organizationId);
});
it("has the appropriate password", () => {
expect(Object.entries(importer)).toEqual(expect.arrayContaining([["password", password]]));
});
});
});
});

11
jslib/common/src/abstractions/export.service.ts
View File

@@ -1,11 +0,0 @@
import { EventView } from "../models/view/eventView";
export type ExportFormat = "csv" | "json" | "encrypted_json";
export abstract class ExportService {
getExport: (format?: ExportFormat, organizationId?: string) => Promise<string>;
getPasswordProtectedExport: (password: string, organizationId?: string) => Promise<string>;
getOrganizationExport: (organizationId: string, format?: ExportFormat) => Promise<string>;
getEventExport: (events: EventView[]) => Promise<string>;
getFileName: (prefix?: string, extension?: string) => string;
}

19
jslib/common/src/abstractions/import.service.ts
View File

@@ -1,19 +0,0 @@
import { ImportOption, ImportType } from "../enums/importOptions";
import { ImportError } from "../importers/importError";
import { Importer } from "../importers/importer";
export abstract class ImportService {
featuredImportOptions: readonly ImportOption[];
regularImportOptions: readonly ImportOption[];
getImportOptions: () => ImportOption[];
import: (
importer: Importer,
fileContents: string,
organizationId?: string
) => Promise<ImportError>;
getImporter: (
format: ImportType | "bitwardenpasswordprotected",
organizationId: string,
password?: string
) => Importer;
}

74
jslib/common/src/enums/importOptions.ts
View File

@@ -1,74 +0,0 @@
export interface ImportOption {
id: string;
name: string;
}
export const featuredImportOptions = [
{ id: "bitwardenjson", name: "Bitwarden (json)" },
{ id: "bitwardencsv", name: "Bitwarden (csv)" },
{ id: "chromecsv", name: "Chrome (csv)" },
{ id: "dashlanecsv", name: "Dashlane (csv)" },
{ id: "firefoxcsv", name: "Firefox (csv)" },
{ id: "keepass2xml", name: "KeePass 2 (xml)" },
{ id: "lastpasscsv", name: "LastPass (csv)" },
{ id: "safaricsv", name: "Safari and macOS (csv)" },
{ id: "1password1pux", name: "1Password (1pux)" },
] as const;
export const regularImportOptions = [
{ id: "keepassxcsv", name: "KeePassX (csv)" },
{ id: "1password1pif", name: "1Password (1pif)" },
{ id: "1passwordwincsv", name: "1Password 6 and 7 Windows (csv)" },
{ id: "1passwordmaccsv", name: "1Password 6 and 7 Mac (csv)" },
{ id: "dashlanejson", name: "Dashlane (json)" },
{ id: "roboformcsv", name: "RoboForm (csv)" },
{ id: "keepercsv", name: "Keeper (csv)" },
// Temporarily remove this option for the Feb release
// { id: "keeperjson", name: "Keeper (json)" },
{ id: "enpasscsv", name: "Enpass (csv)" },
{ id: "enpassjson", name: "Enpass (json)" },
{ id: "safeincloudxml", name: "SafeInCloud (xml)" },
{ id: "pwsafexml", name: "Password Safe (xml)" },
{ id: "stickypasswordxml", name: "Sticky Password (xml)" },
{ id: "msecurecsv", name: "mSecure (csv)" },
{ id: "truekeycsv", name: "True Key (csv)" },
{ id: "passwordbossjson", name: "Password Boss (json)" },
{ id: "zohovaultcsv", name: "Zoho Vault (csv)" },
{ id: "splashidcsv", name: "SplashID (csv)" },
{ id: "passworddragonxml", name: "Password Dragon (xml)" },
{ id: "padlockcsv", name: "Padlock (csv)" },
{ id: "passboltcsv", name: "Passbolt (csv)" },
{ id: "clipperzhtml", name: "Clipperz (html)" },
{ id: "aviracsv", name: "Avira (csv)" },
{ id: "saferpasscsv", name: "SaferPass (csv)" },
{ id: "upmcsv", name: "Universal Password Manager (csv)" },
{ id: "ascendocsv", name: "Ascendo DataVault (csv)" },
{ id: "meldiumcsv", name: "Meldium (csv)" },
{ id: "passkeepcsv", name: "PassKeep (csv)" },
{ id: "operacsv", name: "Opera (csv)" },
{ id: "vivaldicsv", name: "Vivaldi (csv)" },
{ id: "gnomejson", name: "GNOME Passwords and Keys/Seahorse (json)" },
{ id: "blurcsv", name: "Blur (csv)" },
{ id: "passwordagentcsv", name: "Password Agent (csv)" },
{ id: "passpackcsv", name: "Passpack (csv)" },
{ id: "passmanjson", name: "Passman (json)" },
{ id: "avastcsv", name: "Avast Passwords (csv)" },
{ id: "avastjson", name: "Avast Passwords (json)" },
{ id: "fsecurefsk", name: "F-Secure KEY (fsk)" },
{ id: "kasperskytxt", name: "Kaspersky Password Manager (txt)" },
{ id: "remembearcsv", name: "RememBear (csv)" },
{ id: "passwordwallettxt", name: "PasswordWallet (txt)" },
{ id: "mykicsv", name: "Myki (csv)" },
{ id: "securesafecsv", name: "SecureSafe (csv)" },
{ id: "logmeoncecsv", name: "LogMeOnce (csv)" },
{ id: "blackberrycsv", name: "BlackBerry Password Keeper (csv)" },
{ id: "buttercupcsv", name: "Buttercup (csv)" },
{ id: "codebookcsv", name: "Codebook (csv)" },
{ id: "encryptrcsv", name: "Encryptr (csv)" },
{ id: "yoticsv", name: "Yoti (csv)" },
{ id: "nordpasscsv", name: "Nordpass (csv)" },
] as const;
export type ImportType =
| (typeof featuredImportOptions)[number]["id"]
| (typeof regularImportOptions)[number]["id"];

59
jslib/common/src/importers/ascendoCsvImporter.ts
View File

@@ -1,59 +0,0 @@
import { ImportResult } from "../models/domain/importResult";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class AscendoCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, false);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
results.forEach((value) => {
if (value.length < 2) {
return;
}
const cipher = this.initLoginCipher();
cipher.notes = this.getValueOrDefault(value[value.length - 1]);
cipher.name = this.getValueOrDefault(value[0], "--");
if (value.length > 2 && value.length % 2 === 0) {
for (let i = 0; i < value.length - 2; i += 2) {
const val: string = value[i + 2];
const field: string = value[i + 1];
if (this.isNullOrWhitespace(val) || this.isNullOrWhitespace(field)) {
continue;
}
const fieldLower = field.toLowerCase();
if (cipher.login.password == null && this.passwordFieldNames.indexOf(fieldLower) > -1) {
cipher.login.password = this.getValueOrDefault(val);
} else if (
cipher.login.username == null &&
this.usernameFieldNames.indexOf(fieldLower) > -1
) {
cipher.login.username = this.getValueOrDefault(val);
} else if (
(cipher.login.uris == null || cipher.login.uris.length === 0) &&
this.uriFieldNames.indexOf(fieldLower) > -1
) {
cipher.login.uris = this.makeUriArray(val);
} else {
this.processKvp(cipher, field, val);
}
}
}
this.convertToNoteIfNeeded(cipher);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
result.success = true;
return Promise.resolve(result);
}
}

28
jslib/common/src/importers/avastCsvImporter.ts
View File

@@ -1,28 +0,0 @@
import { ImportResult } from "../models/domain/importResult";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class AvastCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, true);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
results.forEach((value) => {
const cipher = this.initLoginCipher();
cipher.name = this.getValueOrDefault(value.name);
cipher.login.uris = this.makeUriArray(value.web);
cipher.login.password = this.getValueOrDefault(value.password);
cipher.login.username = this.getValueOrDefault(value.login);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
result.success = true;
return Promise.resolve(result);
}
}

68
jslib/common/src/importers/avastJsonImporter.ts
View File

@@ -1,68 +0,0 @@
import { CipherType } from "../enums/cipherType";
import { SecureNoteType } from "../enums/secureNoteType";
import { ImportResult } from "../models/domain/importResult";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class AvastJsonImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = JSON.parse(data);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
if (results.logins != null) {
results.logins.forEach((value: any) => {
const cipher = this.initLoginCipher();
cipher.name = this.getValueOrDefault(value.custName);
cipher.notes = this.getValueOrDefault(value.note);
cipher.login.uris = this.makeUriArray(value.url);
cipher.login.password = this.getValueOrDefault(value.pwd);
cipher.login.username = this.getValueOrDefault(value.loginName);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
}
if (results.notes != null) {
results.notes.forEach((value: any) => {
const cipher = this.initLoginCipher();
cipher.type = CipherType.SecureNote;
cipher.secureNote.type = SecureNoteType.Generic;
cipher.name = this.getValueOrDefault(value.label);
cipher.notes = this.getValueOrDefault(value.text);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
}
if (results.cards != null) {
results.cards.forEach((value: any) => {
const cipher = this.initLoginCipher();
cipher.type = CipherType.Card;
cipher.name = this.getValueOrDefault(value.custName);
cipher.notes = this.getValueOrDefault(value.note);
cipher.card.cardholderName = this.getValueOrDefault(value.holderName);
cipher.card.number = this.getValueOrDefault(value.cardNumber);
cipher.card.code = this.getValueOrDefault(value.cvv);
cipher.card.brand = this.getCardBrand(cipher.card.number);
if (value.expirationDate != null) {
if (value.expirationDate.month != null) {
cipher.card.expMonth = value.expirationDate.month + "";
}
if (value.expirationDate.year != null) {
cipher.card.expYear = value.expirationDate.year + "";
}
}
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
}
result.success = true;
return Promise.resolve(result);
}
}

41
jslib/common/src/importers/aviraCsvImporter.ts
View File

@@ -1,41 +0,0 @@
import { ImportResult } from "../models/domain/importResult";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class AviraCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, true);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
results.forEach((value) => {
const cipher = this.initLoginCipher();
cipher.name = this.getValueOrDefault(
value.name,
this.getValueOrDefault(this.nameFromUrl(value.website), "--")
);
cipher.login.uris = this.makeUriArray(value.website);
cipher.login.password = this.getValueOrDefault(value.password);
if (
this.isNullOrWhitespace(value.username) &&
!this.isNullOrWhitespace(value.secondary_username)
) {
cipher.login.username = value.secondary_username;
} else {
cipher.login.username = this.getValueOrDefault(value.username);
cipher.notes = this.getValueOrDefault(value.secondary_username);
}
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
result.success = true;
return Promise.resolve(result);
}
}

466
jslib/common/src/importers/baseImporter.ts
View File

@@ -1,466 +0,0 @@
import * as papa from "papaparse";
import { LogService } from "../abstractions/log.service";
import { CipherType } from "../enums/cipherType";
import { FieldType } from "../enums/fieldType";
import { SecureNoteType } from "../enums/secureNoteType";
import { Utils } from "../misc/utils";
import { ImportResult } from "../models/domain/importResult";
import { CipherView } from "../models/view/cipherView";
import { CollectionView } from "../models/view/collectionView";
import { FieldView } from "../models/view/fieldView";
import { FolderView } from "../models/view/folderView";
import { LoginUriView } from "../models/view/loginUriView";
import { LoginView } from "../models/view/loginView";
import { SecureNoteView } from "../models/view/secureNoteView";
import { ConsoleLogService } from "../services/consoleLog.service";
export abstract class BaseImporter {
organizationId: string = null;
protected logService: LogService = new ConsoleLogService(false);
protected newLineRegex = /(?:\r\n|\r|\n)/;
protected passwordFieldNames = [
"password",
"pass word",
"passphrase",
"pass phrase",
"pass",
"code",
"code word",
"codeword",
"secret",
"secret word",
"personpwd",
"key",
"keyword",
"key word",
"keyphrase",
"key phrase",
"form_pw",
"wppassword",
"pin",
"pwd",
"pw",
"pword",
"passwd",
"p",
"serial",
"serial#",
"license key",
"reg #",
// Non-English names
"passwort",
];
protected usernameFieldNames = [
"user",
"name",
"user name",
"username",
"login name",
"email",
"e-mail",
"id",
"userid",
"user id",
"login",
"form_loginname",
"wpname",
"mail",
"loginid",
"login id",
"log",
"personlogin",
"first name",
"last name",
"card#",
"account #",
"member",
"member #",
// Non-English names
"nom",
"benutzername",
];
protected notesFieldNames = [
"note",
"notes",
"comment",
"comments",
"memo",
"description",
"free form",
"freeform",
"free text",
"freetext",
"free",
// Non-English names
"kommentar",
];
protected uriFieldNames: string[] = [
"url",
"hyper link",
"hyperlink",
"link",
"host",
"hostname",
"host name",
"server",
"address",
"hyper ref",
"href",
"web",
"website",
"web site",
"site",
"web-site",
"uri",
// Non-English names
"ort",
"adresse",
];
protected parseCsvOptions = {
encoding: "UTF-8",
skipEmptyLines: false,
};
protected get organization() {
return this.organizationId != null;
}
protected parseXml(data: string): Document {
const parser = new DOMParser();
const doc = parser.parseFromString(data, "application/xml");
return doc != null && doc.querySelector("parsererror") == null ? doc : null;
}
protected parseCsv(data: string, header: boolean, options: any = {}): any[] {
const parseOptions: papa.ParseConfig<string> = Object.assign(
{ header: header },
this.parseCsvOptions,
options
);
data = this.splitNewLine(data).join("\n").trim();
const result = papa.parse(data, parseOptions);
if (result.errors != null && result.errors.length > 0) {
result.errors.forEach((e) => {
if (e.row != null) {
this.logService.warning("Error parsing row " + e.row + ": " + e.message);
}
});
}
return result.data && result.data.length > 0 ? result.data : null;
}
protected parseSingleRowCsv(rowData: string) {
if (this.isNullOrWhitespace(rowData)) {
return null;
}
const parsedRow = this.parseCsv(rowData, false);
if (parsedRow != null && parsedRow.length > 0 && parsedRow[0].length > 0) {
return parsedRow[0];
}
return null;
}
protected makeUriArray(uri: string | string[]): LoginUriView[] {
if (uri == null) {
return null;
}
if (typeof uri === "string") {
const loginUri = new LoginUriView();
loginUri.uri = this.fixUri(uri);
if (this.isNullOrWhitespace(loginUri.uri)) {
return null;
}
loginUri.match = null;
return [loginUri];
}
if (uri.length > 0) {
const returnArr: LoginUriView[] = [];
uri.forEach((u) => {
const loginUri = new LoginUriView();
loginUri.uri = this.fixUri(u);
if (this.isNullOrWhitespace(loginUri.uri)) {
return;
}
loginUri.match = null;
returnArr.push(loginUri);
});
return returnArr.length === 0 ? null : returnArr;
}
return null;
}
protected fixUri(uri: string) {
if (uri == null) {
return null;
}
uri = uri.trim();
if (uri.indexOf("://") === -1 && uri.indexOf(".") >= 0) {
uri = "http://" + uri;
}
if (uri.length > 1000) {
return uri.substring(0, 1000);
}
return uri;
}
protected nameFromUrl(url: string) {
const hostname = Utils.getHostname(url);
if (this.isNullOrWhitespace(hostname)) {
return null;
}
return hostname.startsWith("www.") ? hostname.replace("www.", "") : hostname;
}
protected isNullOrWhitespace(str: string): boolean {
return Utils.isNullOrWhitespace(str);
}
protected getValueOrDefault(str: string, defaultValue: string = null): string {
if (this.isNullOrWhitespace(str)) {
return defaultValue;
}
return str;
}
protected splitNewLine(str: string): string[] {
return str.split(this.newLineRegex);
}
// ref https://stackoverflow.com/a/5911300
protected getCardBrand(cardNum: string) {
if (this.isNullOrWhitespace(cardNum)) {
return null;
}
// Visa
let re = new RegExp("^4");
if (cardNum.match(re) != null) {
return "Visa";
}
// Mastercard
// Updated for Mastercard 2017 BINs expansion
if (
/^(5[1-5][0-9]{14}|2(22[1-9][0-9]{12}|2[3-9][0-9]{13}|[3-6][0-9]{14}|7[0-1][0-9]{13}|720[0-9]{12}))$/.test(
cardNum
)
) {
return "Mastercard";
}
// AMEX
re = new RegExp("^3[47]");
if (cardNum.match(re) != null) {
return "Amex";
}
// Discover
re = new RegExp(
"^(6011|622(12[6-9]|1[3-9][0-9]|[2-8][0-9]{2}|9[0-1][0-9]|92[0-5]|64[4-9])|65)"
);
if (cardNum.match(re) != null) {
return "Discover";
}
// Diners
re = new RegExp("^36");
if (cardNum.match(re) != null) {
return "Diners Club";
}
// Diners - Carte Blanche
re = new RegExp("^30[0-5]");
if (cardNum.match(re) != null) {
return "Diners Club";
}
// JCB
re = new RegExp("^35(2[89]|[3-8][0-9])");
if (cardNum.match(re) != null) {
return "JCB";
}
// Visa Electron
re = new RegExp("^(4026|417500|4508|4844|491(3|7))");
if (cardNum.match(re) != null) {
return "Visa";
}
return null;
}
protected setCardExpiration(cipher: CipherView, expiration: string): boolean {
if (!this.isNullOrWhitespace(expiration)) {
expiration = expiration.replace(/\s/g, "");
const parts = expiration.split("/");
if (parts.length === 2) {
let month: string = null;
let year: string = null;
if (parts[0].length === 1 || parts[0].length === 2) {
month = parts[0];
if (month.length === 2 && month[0] === "0") {
month = month.substr(1, 1);
}
}
if (parts[1].length === 2 || parts[1].length === 4) {
year = month.length === 2 ? "20" + parts[1] : parts[1];
}
if (month != null && year != null) {
cipher.card.expMonth = month;
cipher.card.expYear = year;
return true;
}
}
}
return false;
}
protected moveFoldersToCollections(result: ImportResult) {
result.folderRelationships.forEach((r) => result.collectionRelationships.push(r));
result.collections = result.folders.map((f) => {
const collection = new CollectionView();
collection.name = f.name;
return collection;
});
result.folderRelationships = [];
result.folders = [];
}
protected querySelectorDirectChild(parentEl: Element, query: string) {
const els = this.querySelectorAllDirectChild(parentEl, query);
return els.length === 0 ? null : els[0];
}
protected querySelectorAllDirectChild(parentEl: Element, query: string) {
return Array.from(parentEl.querySelectorAll(query)).filter((el) => el.parentNode === parentEl);
}
protected initLoginCipher() {
const cipher = new CipherView();
cipher.favorite = false;
cipher.notes = "";
cipher.fields = [];
cipher.login = new LoginView();
cipher.type = CipherType.Login;
return cipher;
}
protected cleanupCipher(cipher: CipherView) {
if (cipher == null) {
return;
}
if (cipher.type !== CipherType.Login) {
cipher.login = null;
}
if (this.isNullOrWhitespace(cipher.name)) {
cipher.name = "--";
}
if (this.isNullOrWhitespace(cipher.notes)) {
cipher.notes = null;
} else {
cipher.notes = cipher.notes.trim();
}
if (cipher.fields != null && cipher.fields.length === 0) {
cipher.fields = null;
}
}
protected processKvp(
cipher: CipherView,
key: string,
value: string,
type: FieldType = FieldType.Text
) {
if (this.isNullOrWhitespace(value)) {
return;
}
if (this.isNullOrWhitespace(key)) {
key = "";
}
if (value.length > 200 || value.trim().search(this.newLineRegex) > -1) {
if (cipher.notes == null) {
cipher.notes = "";
}
cipher.notes += key + ": " + this.splitNewLine(value).join("\n") + "\n";
} else {
if (cipher.fields == null) {
cipher.fields = [];
}
const field = new FieldView();
field.type = type;
field.name = key;
field.value = value;
cipher.fields.push(field);
}
}
protected processFolder(result: ImportResult, folderName: string) {
let folderIndex = result.folders.length;
const hasFolder = !this.isNullOrWhitespace(folderName);
let addFolder = hasFolder;
if (hasFolder) {
for (let i = 0; i < result.folders.length; i++) {
if (result.folders[i].name === folderName) {
addFolder = false;
folderIndex = i;
break;
}
}
}
if (addFolder) {
const f = new FolderView();
f.name = folderName;
result.folders.push(f);
}
if (hasFolder) {
result.folderRelationships.push([result.ciphers.length, folderIndex]);
}
}
protected convertToNoteIfNeeded(cipher: CipherView) {
if (
cipher.type === CipherType.Login &&
this.isNullOrWhitespace(cipher.login.username) &&
this.isNullOrWhitespace(cipher.login.password) &&
(cipher.login.uris == null || cipher.login.uris.length === 0)
) {
cipher.type = CipherType.SecureNote;
cipher.secureNote = new SecureNoteView();
cipher.secureNote.type = SecureNoteType.Generic;
}
}
protected processFullName(cipher: CipherView, fullName: string) {
if (this.isNullOrWhitespace(fullName)) {
return;
}
const nameParts = fullName.split(" ");
if (nameParts.length > 0) {
cipher.identity.firstName = this.getValueOrDefault(nameParts[0]);
}
if (nameParts.length === 2) {
cipher.identity.lastName = this.getValueOrDefault(nameParts[1]);
} else if (nameParts.length >= 3) {
cipher.identity.middleName = this.getValueOrDefault(nameParts[1]);
cipher.identity.lastName = nameParts.slice(2, nameParts.length).join(" ");
}
}
}

120
jslib/common/src/importers/bitwardenCsvImporter.ts
View File

@@ -1,120 +0,0 @@
import { CipherRepromptType } from "../enums/cipherRepromptType";
import { CipherType } from "../enums/cipherType";
import { FieldType } from "../enums/fieldType";
import { SecureNoteType } from "../enums/secureNoteType";
import { ImportResult } from "../models/domain/importResult";
import { CipherView } from "../models/view/cipherView";
import { CollectionView } from "../models/view/collectionView";
import { FieldView } from "../models/view/fieldView";
import { LoginView } from "../models/view/loginView";
import { SecureNoteView } from "../models/view/secureNoteView";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class BitwardenCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, true);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
results.forEach((value) => {
if (this.organization && !this.isNullOrWhitespace(value.collections)) {
const collections = (value.collections as string).split(",");
collections.forEach((col) => {
let addCollection = true;
let collectionIndex = result.collections.length;
for (let i = 0; i < result.collections.length; i++) {
if (result.collections[i].name === col) {
addCollection = false;
collectionIndex = i;
break;
}
}
if (addCollection) {
const collection = new CollectionView();
collection.name = col;
result.collections.push(collection);
}
result.collectionRelationships.push([result.ciphers.length, collectionIndex]);
});
} else if (!this.organization) {
this.processFolder(result, value.folder);
}
const cipher = new CipherView();
cipher.favorite =
!this.organization && this.getValueOrDefault(value.favorite, "0") !== "0" ? true : false;
cipher.type = CipherType.Login;
cipher.notes = this.getValueOrDefault(value.notes);
cipher.name = this.getValueOrDefault(value.name, "--");
try {
cipher.reprompt = parseInt(
this.getValueOrDefault(value.reprompt, CipherRepromptType.None.toString()),
10
);
} catch (e) {
// eslint-disable-next-line
console.error("Unable to parse reprompt value", e);
cipher.reprompt = CipherRepromptType.None;
}
if (!this.isNullOrWhitespace(value.fields)) {
const fields = this.splitNewLine(value.fields);
for (let i = 0; i < fields.length; i++) {
if (this.isNullOrWhitespace(fields[i])) {
continue;
}
const delimPosition = fields[i].lastIndexOf(": ");
if (delimPosition === -1) {
continue;
}
if (cipher.fields == null) {
cipher.fields = [];
}
const field = new FieldView();
field.name = fields[i].substr(0, delimPosition);
field.value = null;
field.type = FieldType.Text;
if (fields[i].length > delimPosition + 2) {
field.value = fields[i].substr(delimPosition + 2);
}
cipher.fields.push(field);
}
}
const valueType = value.type != null ? value.type.toLowerCase() : null;
switch (valueType) {
case "note":
cipher.type = CipherType.SecureNote;
cipher.secureNote = new SecureNoteView();
cipher.secureNote.type = SecureNoteType.Generic;
break;
default: {
cipher.type = CipherType.Login;
cipher.login = new LoginView();
cipher.login.totp = this.getValueOrDefault(value.login_totp || value.totp);
cipher.login.username = this.getValueOrDefault(value.login_username || value.username);
cipher.login.password = this.getValueOrDefault(value.login_password || value.password);
const uris = this.parseSingleRowCsv(value.login_uri || value.uri);
cipher.login.uris = this.makeUriArray(uris);
break;
}
}
result.ciphers.push(cipher);
});
result.success = true;
return Promise.resolve(result);
}
}

179
jslib/common/src/importers/bitwardenJsonImporter.ts
View File

@@ -1,179 +0,0 @@
import { CryptoService } from "../abstractions/crypto.service";
import { I18nService } from "../abstractions/i18n.service";
import { EncString } from "../models/domain/encString";
import { ImportResult } from "../models/domain/importResult";
import { CipherWithIds } from "../models/export/cipherWithIds";
import { CollectionWithId } from "../models/export/collectionWithId";
import { FolderWithId } from "../models/export/folderWithId";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class BitwardenJsonImporter extends BaseImporter implements Importer {
private results: any;
private result: ImportResult;
constructor(protected cryptoService: CryptoService, protected i18nService: I18nService) {
super();
}
async parse(data: string): Promise<ImportResult> {
this.result = new ImportResult();
this.results = JSON.parse(data);
if (this.results == null || this.results.items == null) {
if (this.results?.passwordProtected) {
this.result.success = false;
this.result.missingPassword = true;
this.result.errorMessage = this.i18nService.t("importPasswordRequired");
return this.result;
}
this.result.success = false;
return this.result;
}
if (this.results.encrypted) {
await this.parseEncrypted();
} else {
this.parseDecrypted();
}
return this.result;
}
private async parseEncrypted() {
if (this.results.encKeyValidation_DO_NOT_EDIT != null) {
const orgKey = await this.cryptoService.getOrgKey(this.organizationId);
const encKeyValidation = new EncString(this.results.encKeyValidation_DO_NOT_EDIT);
const encKeyValidationDecrypt = await this.cryptoService.decryptToUtf8(
encKeyValidation,
orgKey
);
if (encKeyValidationDecrypt === null) {
this.result.success = false;
this.result.errorMessage = this.i18nService.t("importEncKeyError");
return;
}
}
const groupingsMap = new Map<string, number>();
if (this.organization && this.results.collections != null) {
for (const c of this.results.collections as CollectionWithId[]) {
const collection = CollectionWithId.toDomain(c);
if (collection != null) {
collection.id = null;
collection.organizationId = this.organizationId;
const view = await collection.decrypt();
groupingsMap.set(c.id, this.result.collections.length);
this.result.collections.push(view);
}
}
} else if (!this.organization && this.results.folders != null) {
for (const f of this.results.folders as FolderWithId[]) {
const folder = FolderWithId.toDomain(f);
if (folder != null) {
folder.id = null;
const view = await folder.decrypt();
groupingsMap.set(f.id, this.result.folders.length);
this.result.folders.push(view);
}
}
}
for (const c of this.results.items as CipherWithIds[]) {
const cipher = CipherWithIds.toDomain(c);
// reset ids incase they were set for some reason
cipher.id = null;
cipher.folderId = null;
cipher.organizationId = this.organizationId;
cipher.collectionIds = null;
// make sure password history is limited
if (cipher.passwordHistory != null && cipher.passwordHistory.length > 5) {
cipher.passwordHistory = cipher.passwordHistory.slice(0, 5);
}
if (!this.organization && c.folderId != null && groupingsMap.has(c.folderId)) {
this.result.folderRelationships.push([
this.result.ciphers.length,
groupingsMap.get(c.folderId),
]);
} else if (this.organization && c.collectionIds != null) {
c.collectionIds.forEach((cId) => {
if (groupingsMap.has(cId)) {
this.result.collectionRelationships.push([
this.result.ciphers.length,
groupingsMap.get(cId),
]);
}
});
}
const view = await cipher.decrypt();
this.cleanupCipher(view);
this.result.ciphers.push(view);
}
this.result.success = true;
}
private parseDecrypted() {
const groupingsMap = new Map<string, number>();
if (this.organization && this.results.collections != null) {
this.results.collections.forEach((c: CollectionWithId) => {
const collection = CollectionWithId.toView(c);
if (collection != null) {
collection.id = null;
collection.organizationId = null;
groupingsMap.set(c.id, this.result.collections.length);
this.result.collections.push(collection);
}
});
} else if (!this.organization && this.results.folders != null) {
this.results.folders.forEach((f: FolderWithId) => {
const folder = FolderWithId.toView(f);
if (folder != null) {
folder.id = null;
groupingsMap.set(f.id, this.result.folders.length);
this.result.folders.push(folder);
}
});
}
this.results.items.forEach((c: CipherWithIds) => {
const cipher = CipherWithIds.toView(c);
// reset ids incase they were set for some reason
cipher.id = null;
cipher.folderId = null;
cipher.organizationId = null;
cipher.collectionIds = null;
// make sure password history is limited
if (cipher.passwordHistory != null && cipher.passwordHistory.length > 5) {
cipher.passwordHistory = cipher.passwordHistory.slice(0, 5);
}
if (!this.organization && c.folderId != null && groupingsMap.has(c.folderId)) {
this.result.folderRelationships.push([
this.result.ciphers.length,
groupingsMap.get(c.folderId),
]);
} else if (this.organization && c.collectionIds != null) {
c.collectionIds.forEach((cId) => {
if (groupingsMap.has(cId)) {
this.result.collectionRelationships.push([
this.result.ciphers.length,
groupingsMap.get(cId),
]);
}
});
}
this.cleanupCipher(cipher);
this.result.ciphers.push(cipher);
});
this.result.success = true;
}
}

81
jslib/common/src/importers/bitwardenPasswordProtectedImporter.ts
View File

@@ -1,81 +0,0 @@
import { CryptoService } from "../abstractions/crypto.service";
import { I18nService } from "../abstractions/i18n.service";
import { KdfType } from "../enums/kdfType";
import { EncString } from "../models/domain/encString";
import { ImportResult } from "../models/domain/importResult";
import { SymmetricCryptoKey } from "../models/domain/symmetricCryptoKey";
import { BitwardenJsonImporter } from "./bitwardenJsonImporter";
import { Importer } from "./importer";
interface BitwardenPasswordProtectedFileFormat {
encrypted: boolean;
passwordProtected: boolean;
salt: string;
kdfIterations: number;
kdfType: number;
encKeyValidation_DO_NOT_EDIT: string;
data: string;
}
export class BitwardenPasswordProtectedImporter extends BitwardenJsonImporter implements Importer {
private key: SymmetricCryptoKey;
constructor(cryptoService: CryptoService, i18nService: I18nService, private password: string) {
super(cryptoService, i18nService);
}
async parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const parsedData = JSON.parse(data);
if (this.cannotParseFile(parsedData)) {
result.success = false;
return result;
}
if (!(await this.checkPassword(parsedData))) {
result.success = false;
result.errorMessage = this.i18nService.t("importEncKeyError");
return result;
}
const encData = new EncString(parsedData.data);
const clearTextData = await this.cryptoService.decryptToUtf8(encData, this.key);
return await super.parse(clearTextData);
}
private async checkPassword(jdoc: BitwardenPasswordProtectedFileFormat): Promise<boolean> {
this.key = await this.cryptoService.makePinKey(
this.password,
jdoc.salt,
KdfType.PBKDF2_SHA256,
jdoc.kdfIterations
);
const encKeyValidation = new EncString(jdoc.encKeyValidation_DO_NOT_EDIT);
const encKeyValidationDecrypt = await this.cryptoService.decryptToUtf8(
encKeyValidation,
this.key
);
if (encKeyValidationDecrypt === null) {
return false;
}
return true;
}
private cannotParseFile(jdoc: BitwardenPasswordProtectedFileFormat): boolean {
return (
!jdoc ||
!jdoc.encrypted ||
!jdoc.passwordProtected ||
!jdoc.salt ||
!jdoc.kdfIterations ||
typeof jdoc.kdfIterations !== "number" ||
jdoc.kdfType == null ||
KdfType[jdoc.kdfType] == null ||
!jdoc.encKeyValidation_DO_NOT_EDIT ||
!jdoc.data
);
}
}

36
jslib/common/src/importers/blackBerryCsvImporter.ts
View File

@@ -1,36 +0,0 @@
import { ImportResult } from "../models/domain/importResult";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class BlackBerryCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, true);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
results.forEach((value) => {
if (value.grouping === "list") {
return;
}
const cipher = this.initLoginCipher();
cipher.favorite = value.fav === "1";
cipher.name = this.getValueOrDefault(value.name);
cipher.notes = this.getValueOrDefault(value.extra);
if (value.grouping !== "note") {
cipher.login.uris = this.makeUriArray(value.url);
cipher.login.password = this.getValueOrDefault(value.password);
cipher.login.username = this.getValueOrDefault(value.username);
}
this.convertToNoteIfNeeded(cipher);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
result.success = true;
return Promise.resolve(result);
}
}

41
jslib/common/src/importers/blurCsvImporter.ts
View File

@@ -1,41 +0,0 @@
import { ImportResult } from "../models/domain/importResult";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class BlurCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, true);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
results.forEach((value) => {
if (value.label === "null") {
value.label = null;
}
const cipher = this.initLoginCipher();
cipher.name = this.getValueOrDefault(
value.label,
this.getValueOrDefault(this.nameFromUrl(value.domain), "--")
);
cipher.login.uris = this.makeUriArray(value.domain);
cipher.login.password = this.getValueOrDefault(value.password);
if (this.isNullOrWhitespace(value.email) && !this.isNullOrWhitespace(value.username)) {
cipher.login.username = value.username;
} else {
cipher.login.username = this.getValueOrDefault(value.email);
cipher.notes = this.getValueOrDefault(value.username);
}
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
result.success = true;
return Promise.resolve(result);
}
}

50
jslib/common/src/importers/buttercupCsvImporter.ts
View File

@@ -1,50 +0,0 @@
import { ImportResult } from "../models/domain/importResult";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
const OfficialProps = ["!group_id", "!group_name", "title", "username", "password", "URL", "id"];
export class ButtercupCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, true);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
results.forEach((value) => {
this.processFolder(result, this.getValueOrDefault(value["!group_name"]));
const cipher = this.initLoginCipher();
cipher.name = this.getValueOrDefault(value.title, "--");
cipher.login.username = this.getValueOrDefault(value.username);
cipher.login.password = this.getValueOrDefault(value.password);
cipher.login.uris = this.makeUriArray(value.URL);
let processingCustomFields = false;
for (const prop in value) {
// eslint-disable-next-line
if (value.hasOwnProperty(prop)) {
if (!processingCustomFields && OfficialProps.indexOf(prop) === -1) {
processingCustomFields = true;
}
if (processingCustomFields) {
this.processKvp(cipher, prop, value[prop]);
}
}
}
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
if (this.organization) {
this.moveFoldersToCollections(result);
}
result.success = true;
return Promise.resolve(result);
}
}

28
jslib/common/src/importers/chromeCsvImporter.ts
View File

@@ -1,28 +0,0 @@
import { ImportResult } from "../models/domain/importResult";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class ChromeCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, true);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
results.forEach((value) => {
const cipher = this.initLoginCipher();
cipher.name = this.getValueOrDefault(value.name, "--");
cipher.login.username = this.getValueOrDefault(value.username);
cipher.login.password = this.getValueOrDefault(value.password);
cipher.login.uris = this.makeUriArray(value.url);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
result.success = true;
return Promise.resolve(result);
}
}

88
jslib/common/src/importers/clipperzHtmlImporter.ts
View File

@@ -1,88 +0,0 @@
import { ImportResult } from "../models/domain/importResult";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class ClipperzHtmlImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const doc = this.parseXml(data);
if (doc == null) {
result.success = false;
return Promise.resolve(result);
}
const textarea = doc.querySelector("textarea");
if (textarea == null || this.isNullOrWhitespace(textarea.textContent)) {
result.errorMessage = "Missing textarea.";
result.success = false;
return Promise.resolve(result);
}
const entries = JSON.parse(textarea.textContent);
entries.forEach((entry: any) => {
const cipher = this.initLoginCipher();
if (!this.isNullOrWhitespace(entry.label)) {
cipher.name = entry.label.split(" ")[0];
}
if (entry.data != null && !this.isNullOrWhitespace(entry.data.notes)) {
cipher.notes = entry.data.notes.split("\\n").join("\n");
}
if (entry.currentVersion != null && entry.currentVersion.fields != null) {
for (const property in entry.currentVersion.fields) {
// eslint-disable-next-line
if (!entry.currentVersion.fields.hasOwnProperty(property)) {
continue;
}
const field = entry.currentVersion.fields[property];
const actionType = field.actionType != null ? field.actionType.toLowerCase() : null;
switch (actionType) {
case "password":
cipher.login.password = this.getValueOrDefault(field.value);
break;
case "email":
case "username":
case "user":
case "name":
cipher.login.username = this.getValueOrDefault(field.value);
break;
case "url":
cipher.login.uris = this.makeUriArray(field.value);
break;
default: {
const labelLower = field.label != null ? field.label.toLowerCase() : null;
if (
cipher.login.password == null &&
this.passwordFieldNames.indexOf(labelLower) > -1
) {
cipher.login.password = this.getValueOrDefault(field.value);
} else if (
cipher.login.username == null &&
this.usernameFieldNames.indexOf(labelLower) > -1
) {
cipher.login.username = this.getValueOrDefault(field.value);
} else if (
(cipher.login.uris == null || cipher.login.uris.length === 0) &&
this.uriFieldNames.indexOf(labelLower) > -1
) {
cipher.login.uris = this.makeUriArray(field.value);
} else {
this.processKvp(cipher, field.label, field.value);
}
break;
}
}
}
}
this.convertToNoteIfNeeded(cipher);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
result.success = true;
return Promise.resolve(result);
}
}

47
jslib/common/src/importers/codebookCsvImporter.ts
View File

@@ -1,47 +0,0 @@
import { ImportResult } from "../models/domain/importResult";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class CodebookCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, true);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
results.forEach((value) => {
this.processFolder(result, this.getValueOrDefault(value.Category));
const cipher = this.initLoginCipher();
cipher.favorite = this.getValueOrDefault(value.Favorite) === "True";
cipher.name = this.getValueOrDefault(value.Entry, "--");
cipher.notes = this.getValueOrDefault(value.Note);
cipher.login.username = this.getValueOrDefault(value.Username, value.Email);
cipher.login.password = this.getValueOrDefault(value.Password);
cipher.login.totp = this.getValueOrDefault(value.TOTP);
cipher.login.uris = this.makeUriArray(value.Website);
if (!this.isNullOrWhitespace(value.Username)) {
this.processKvp(cipher, "Email", value.Email);
}
this.processKvp(cipher, "Phone", value.Phone);
this.processKvp(cipher, "PIN", value.PIN);
this.processKvp(cipher, "Account", value.Account);
this.processKvp(cipher, "Date", value.Date);
this.convertToNoteIfNeeded(cipher);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
if (this.organization) {
this.moveFoldersToCollections(result);
}
result.success = true;
return Promise.resolve(result);
}
}

271
jslib/common/src/importers/dashlaneImporters/dashlaneCsvImporter.ts
View File

@@ -1,271 +0,0 @@
import { CipherType } from "../../enums/cipherType";
import { SecureNoteType } from "../../enums/secureNoteType";
import { ImportResult } from "../../models/domain/importResult";
import { CardView } from "../../models/view/cardView";
import { CipherView } from "../../models/view/cipherView";
import { IdentityView } from "../../models/view/identityView";
import { LoginView } from "../../models/view/loginView";
import { BaseImporter } from "../baseImporter";
import { Importer } from "../importer";
import {
CredentialsRecord,
IdRecord,
PaymentsRecord,
PersonalInformationRecord,
SecureNoteRecord,
} from "./types/dashlaneCsvTypes";
const _mappedCredentialsColums = new Set([
"title",
"note",
"username",
"password",
"url",
"otpSecret",
"category",
]);
const _mappedPersonalInfoAsIdentiyColumns = new Set([
"type",
"title",
"first_name",
"middle_name",
"last_name",
"login",
"email",
"phone_number",
"address",
"country",
"state",
"city",
"zip",
// Skip item_name as we already have set a combined name
"item_name",
]);
const _mappedSecureNoteColumns = new Set(["title", "note"]);
export class DashlaneCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, true);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
if (results[0].type != null && results[0].title != null) {
const personalRecords = results as PersonalInformationRecord[];
// If personalRecords has only one "name" then create an Identity-Cipher
if (personalRecords.filter((x) => x.type === "name").length === 1) {
const cipher = this.initLoginCipher();
cipher.type = CipherType.Identity;
cipher.identity = new IdentityView();
results.forEach((row) => {
this.parsePersonalInformationRecordAsIdentity(cipher, row);
});
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
result.success = true;
return Promise.resolve(result);
}
}
results.forEach((row) => {
const cipher = this.initLoginCipher();
const rowKeys = Object.keys(row);
if (rowKeys[0] === "username") {
this.processFolder(result, row.category);
this.parseCredentialsRecord(cipher, row);
}
if (rowKeys[0] === "type" && rowKeys[1] === "account_name") {
this.parsePaymentRecord(cipher, row);
}
if (rowKeys[0] === "type" && rowKeys[1] === "number") {
this.parseIdRecord(cipher, row);
}
if ((rowKeys[0] === "type") != null && rowKeys[1] === "title") {
this.parsePersonalInformationRecord(cipher, row);
}
if (rowKeys[0] === "title" && rowKeys[1] === "note") {
this.parseSecureNoteRecords(cipher, row);
}
this.convertToNoteIfNeeded(cipher);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
if (this.organization) {
this.moveFoldersToCollections(result);
}
result.success = true;
return Promise.resolve(result);
}
parseCredentialsRecord(cipher: CipherView, row: CredentialsRecord) {
cipher.type = CipherType.Login;
cipher.login = new LoginView();
cipher.name = row.title;
cipher.notes = row.note;
cipher.login.username = row.username;
cipher.login.password = row.password;
cipher.login.totp = row.otpSecret;
cipher.login.uris = this.makeUriArray(row.url);
this.importUnmappedFields(cipher, row, _mappedCredentialsColums);
}
parsePaymentRecord(cipher: CipherView, row: PaymentsRecord) {
cipher.type = CipherType.Card;
cipher.card = new CardView();
cipher.name = row.account_name;
let mappedValues: string[] = [];
switch (row.type) {
case "credit_card":
cipher.card.cardholderName = row.account_name;
cipher.card.number = row.cc_number;
cipher.card.brand = this.getCardBrand(cipher.card.number);
cipher.card.code = row.code;
cipher.card.expMonth = row.expiration_month;
cipher.card.expYear = row.expiration_year.substring(2, 4);
// If you add more mapped fields please extend this
mappedValues = [
"account_name",
"account_holder",
"cc_number",
"code",
"expiration_month",
"expiration_year",
];
break;
case "bank":
cipher.card.cardholderName = row.account_holder;
cipher.card.number = row.account_number;
// If you add more mapped fields please extend this
mappedValues = ["account_name", "account_holder", "account_number"];
break;
default:
break;
}
this.importUnmappedFields(cipher, row, new Set(mappedValues));
}
parseIdRecord(cipher: CipherView, row: IdRecord) {
cipher.type = CipherType.Identity;
cipher.identity = new IdentityView();
const mappedValues: string[] = ["name", "number"];
switch (row.type) {
case "card":
cipher.name = `${row.name} ${row.type}`;
this.processFullName(cipher, row.name);
cipher.identity.licenseNumber = row.number;
break;
case "passport":
cipher.name = `${row.name} ${row.type}`;
this.processFullName(cipher, row.name);
cipher.identity.passportNumber = row.number;
break;
case "license":
cipher.name = `${row.name} ${row.type}`;
this.processFullName(cipher, row.name);
cipher.identity.licenseNumber = row.number;
cipher.identity.state = row.state;
mappedValues.push("state");
break;
case "social_security":
cipher.name = `${row.name} ${row.type}`;
this.processFullName(cipher, row.name);
cipher.identity.ssn = row.number;
break;
case "tax_number":
cipher.name = row.type;
cipher.identity.licenseNumber = row.number;
break;
default:
break;
}
// If you add more mapped fields please extend this
this.importUnmappedFields(cipher, row, new Set(mappedValues));
}
parsePersonalInformationRecord(cipher: CipherView, row: PersonalInformationRecord) {
cipher.type = CipherType.SecureNote;
cipher.secureNote.type = SecureNoteType.Generic;
if (row.type === "name") {
cipher.name = `${row.title} ${row.first_name} ${row.middle_name} ${row.last_name}`
.replace(" ", " ")
.trim();
} else {
cipher.name = row.item_name;
}
const dataRow = row as any;
Object.keys(row).forEach((key) => {
this.processKvp(cipher, key, dataRow[key]);
});
}
parsePersonalInformationRecordAsIdentity(cipher: CipherView, row: PersonalInformationRecord) {
switch (row.type) {
case "name":
this.processFullName(cipher, `${row.first_name} ${row.middle_name} ${row.last_name}`);
cipher.identity.title = row.title;
cipher.name = cipher.identity.fullName;
cipher.identity.username = row.login;
break;
case "email":
cipher.identity.email = row.email;
break;
case "number":
cipher.identity.phone = row.phone_number;
break;
case "address":
cipher.identity.address1 = row.address;
cipher.identity.city = row.city;
cipher.identity.postalCode = row.zip;
cipher.identity.state = row.state;
cipher.identity.country = row.country;
break;
default:
break;
}
this.importUnmappedFields(cipher, row, _mappedPersonalInfoAsIdentiyColumns);
}
parseSecureNoteRecords(cipher: CipherView, row: SecureNoteRecord) {
cipher.type = CipherType.SecureNote;
cipher.secureNote.type = SecureNoteType.Generic;
cipher.name = row.title;
cipher.notes = row.note;
this.importUnmappedFields(cipher, row, _mappedSecureNoteColumns);
}
importUnmappedFields(cipher: CipherView, row: any, mappedValues: Set<string>) {
const unmappedFields = Object.keys(row).filter((x) => !mappedValues.has(x));
unmappedFields.forEach((key) => {
const item = row as any;
this.processKvp(cipher, key, item[key]);
});
}
}

171
jslib/common/src/importers/dashlaneImporters/dashlaneJsonImporter.ts
View File

@@ -1,171 +0,0 @@
import { CipherType } from "../../enums/cipherType";
import { SecureNoteType } from "../../enums/secureNoteType";
import { ImportResult } from "../../models/domain/importResult";
import { CardView } from "../../models/view/cardView";
import { CipherView } from "../../models/view/cipherView";
import { IdentityView } from "../../models/view/identityView";
import { SecureNoteView } from "../../models/view/secureNoteView";
import { BaseImporter } from "../baseImporter";
import { Importer } from "../importer";
const HandledResults = new Set([
"ADDRESS",
"AUTHENTIFIANT",
"BANKSTATEMENT",
"IDCARD",
"IDENTITY",
"PAYMENTMEANS_CREDITCARD",
"PAYMENTMEAN_PAYPAL",
"EMAIL",
]);
export class DashlaneJsonImporter extends BaseImporter implements Importer {
private result: ImportResult;
parse(data: string): Promise<ImportResult> {
this.result = new ImportResult();
const results = JSON.parse(data);
if (results == null || results.length === 0) {
this.result.success = false;
return Promise.resolve(this.result);
}
if (results.ADDRESS != null) {
this.processAddress(results.ADDRESS);
}
if (results.AUTHENTIFIANT != null) {
this.processAuth(results.AUTHENTIFIANT);
}
if (results.BANKSTATEMENT != null) {
this.processNote(results.BANKSTATEMENT, "BankAccountName");
}
if (results.IDCARD != null) {
this.processNote(results.IDCARD, "Fullname");
}
if (results.PAYMENTMEANS_CREDITCARD != null) {
this.processCard(results.PAYMENTMEANS_CREDITCARD);
}
if (results.IDENTITY != null) {
this.processIdentity(results.IDENTITY);
}
for (const key in results) {
// eslint-disable-next-line
if (results.hasOwnProperty(key) && !HandledResults.has(key)) {
this.processNote(results[key], null, "Generic Note");
}
}
this.result.success = true;
return Promise.resolve(this.result);
}
private processAuth(results: any[]) {
results.forEach((credential: any) => {
const cipher = this.initLoginCipher();
cipher.name = this.getValueOrDefault(credential.title);
cipher.login.username = this.getValueOrDefault(
credential.login,
this.getValueOrDefault(credential.secondaryLogin)
);
if (this.isNullOrWhitespace(cipher.login.username)) {
cipher.login.username = this.getValueOrDefault(credential.email);
} else if (!this.isNullOrWhitespace(credential.email)) {
cipher.notes = "Email: " + credential.email + "\n";
}
cipher.login.password = this.getValueOrDefault(credential.password);
cipher.login.uris = this.makeUriArray(credential.domain);
cipher.notes += this.getValueOrDefault(credential.note, "");
this.convertToNoteIfNeeded(cipher);
this.cleanupCipher(cipher);
this.result.ciphers.push(cipher);
});
}
private processIdentity(results: any[]) {
results.forEach((obj: any) => {
const cipher = new CipherView();
cipher.identity = new IdentityView();
cipher.type = CipherType.Identity;
cipher.name = this.getValueOrDefault(obj.fullName, "");
const nameParts = cipher.name.split(" ");
if (nameParts.length > 0) {
cipher.identity.firstName = this.getValueOrDefault(nameParts[0]);
}
if (nameParts.length === 2) {
cipher.identity.lastName = this.getValueOrDefault(nameParts[1]);
} else if (nameParts.length === 3) {
cipher.identity.middleName = this.getValueOrDefault(nameParts[1]);
cipher.identity.lastName = this.getValueOrDefault(nameParts[2]);
}
cipher.identity.username = this.getValueOrDefault(obj.pseudo);
this.cleanupCipher(cipher);
this.result.ciphers.push(cipher);
});
}
private processAddress(results: any[]) {
results.forEach((obj: any) => {
const cipher = new CipherView();
cipher.identity = new IdentityView();
cipher.type = CipherType.Identity;
cipher.name = this.getValueOrDefault(obj.addressName);
cipher.identity.address1 = this.getValueOrDefault(obj.addressFull);
cipher.identity.city = this.getValueOrDefault(obj.city);
cipher.identity.state = this.getValueOrDefault(obj.state);
cipher.identity.postalCode = this.getValueOrDefault(obj.zipcode);
cipher.identity.country = this.getValueOrDefault(obj.country);
if (cipher.identity.country != null) {
cipher.identity.country = cipher.identity.country.toUpperCase();
}
this.cleanupCipher(cipher);
this.result.ciphers.push(cipher);
});
}
private processCard(results: any[]) {
results.forEach((obj: any) => {
const cipher = new CipherView();
cipher.card = new CardView();
cipher.type = CipherType.Card;
cipher.name = this.getValueOrDefault(obj.bank);
cipher.card.number = this.getValueOrDefault(obj.cardNumber);
cipher.card.brand = this.getCardBrand(cipher.card.number);
cipher.card.cardholderName = this.getValueOrDefault(obj.owner);
if (!this.isNullOrWhitespace(cipher.card.brand)) {
if (this.isNullOrWhitespace(cipher.name)) {
cipher.name = cipher.card.brand;
} else {
cipher.name += " - " + cipher.card.brand;
}
}
this.cleanupCipher(cipher);
this.result.ciphers.push(cipher);
});
}
private processNote(results: any[], nameProperty: string, name: string = null) {
results.forEach((obj: any) => {
const cipher = new CipherView();
cipher.secureNote = new SecureNoteView();
cipher.type = CipherType.SecureNote;
cipher.secureNote.type = SecureNoteType.Generic;
if (name != null) {
cipher.name = name;
} else {
cipher.name = this.getValueOrDefault(obj[nameProperty]);
}
for (const key in obj) {
// eslint-disable-next-line
if (obj.hasOwnProperty(key) && key !== nameProperty) {
this.processKvp(cipher, key, obj[key].toString());
}
}
this.cleanupCipher(cipher);
this.result.ciphers.push(cipher);
});
}
}

68
jslib/common/src/importers/dashlaneImporters/types/dashlaneCsvTypes.ts
View File

@@ -1,68 +0,0 @@
// tslint:disable
export class CredentialsRecord {
username: string;
username2: string;
username3: string;
title: string;
password: string;
note: string;
url: string;
category: string;
otpSecret: string;
}
export class PaymentsRecord {
type: string;
account_name: string;
account_holder: string;
cc_number: string;
code: string;
expiration_month: string;
expiration_year: string;
routing_number: string;
account_number: string;
country: string;
issuing_bank: string;
}
export class IdRecord {
type: string;
number: string;
name: string;
issue_date: string;
expiration_date: string;
place_of_issue: string;
state: string;
}
export class PersonalInformationRecord {
type: string;
title: string;
first_name: string;
middle_name: string;
last_name: string;
login: string;
date_of_birth: string;
place_of_birth: string;
email: string;
email_type: string;
item_name: string;
phone_number: string;
address: string;
country: string;
state: string;
city: string;
zip: string;
address_recipient: string;
address_building: string;
address_apartment: string;
address_floor: string;
address_door_code: string;
job_title: string;
url: string;
}
export class SecureNoteRecord {
title: string;
note: string;
}

60
jslib/common/src/importers/encryptrCsvImporter.ts
View File

@@ -1,60 +0,0 @@
import { CipherType } from "../enums/cipherType";
import { ImportResult } from "../models/domain/importResult";
import { CardView } from "../models/view/cardView";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class EncryptrCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, true);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
results.forEach((value) => {
const cipher = this.initLoginCipher();
cipher.name = this.getValueOrDefault(value.Label, "--");
cipher.notes = this.getValueOrDefault(value.Notes);
const text = this.getValueOrDefault(value.Text);
if (!this.isNullOrWhitespace(text)) {
if (this.isNullOrWhitespace(cipher.notes)) {
cipher.notes = text;
} else {
cipher.notes += "\n\n" + text;
}
}
const type = value["Entry Type"];
if (type === "Password") {
cipher.login.username = this.getValueOrDefault(value.Username);
cipher.login.password = this.getValueOrDefault(value.Password);
cipher.login.uris = this.makeUriArray(value["Site URL"]);
} else if (type === "Credit Card") {
cipher.type = CipherType.Card;
cipher.card = new CardView();
cipher.card.cardholderName = this.getValueOrDefault(value["Name on card"]);
cipher.card.number = this.getValueOrDefault(value["Card Number"]);
cipher.card.brand = this.getCardBrand(cipher.card.number);
cipher.card.code = this.getValueOrDefault(value.CVV);
const expiry = this.getValueOrDefault(value.Expiry);
if (!this.isNullOrWhitespace(expiry)) {
const expParts = expiry.split("/");
if (expParts.length > 1) {
cipher.card.expMonth = parseInt(expParts[0], null).toString();
cipher.card.expYear = (2000 + parseInt(expParts[1], null)).toString();
}
}
}
this.convertToNoteIfNeeded(cipher);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
result.success = true;
return Promise.resolve(result);
}
}

133
jslib/common/src/importers/enpassCsvImporter.ts
View File

@@ -1,133 +0,0 @@
import { CipherType } from "../enums/cipherType";
import { SecureNoteType } from "../enums/secureNoteType";
import { ImportResult } from "../models/domain/importResult";
import { CardView } from "../models/view/cardView";
import { SecureNoteView } from "../models/view/secureNoteView";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class EnpassCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, false);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
let firstRow = true;
results.forEach((value) => {
if (value.length < 2 || (firstRow && (value[0] === "Title" || value[0] === "title"))) {
firstRow = false;
return;
}
const cipher = this.initLoginCipher();
cipher.notes = this.getValueOrDefault(value[value.length - 1]);
cipher.name = this.getValueOrDefault(value[0], "--");
if (
value.length === 2 ||
(!this.containsField(value, "username") &&
!this.containsField(value, "password") &&
!this.containsField(value, "email") &&
!this.containsField(value, "url"))
) {
cipher.type = CipherType.SecureNote;
cipher.secureNote = new SecureNoteView();
cipher.secureNote.type = SecureNoteType.Generic;
}
if (
this.containsField(value, "cardholder") &&
this.containsField(value, "number") &&
this.containsField(value, "expiry date")
) {
cipher.type = CipherType.Card;
cipher.card = new CardView();
}
if (value.length > 2 && value.length % 2 === 0) {
for (let i = 0; i < value.length - 2; i += 2) {
const fieldValue: string = value[i + 2];
if (this.isNullOrWhitespace(fieldValue)) {
continue;
}
const fieldName: string = value[i + 1];
const fieldNameLower = fieldName.toLowerCase();
if (cipher.type === CipherType.Login) {
if (
fieldNameLower === "url" &&
(cipher.login.uris == null || cipher.login.uris.length === 0)
) {
cipher.login.uris = this.makeUriArray(fieldValue);
continue;
} else if (
(fieldNameLower === "username" || fieldNameLower === "email") &&
this.isNullOrWhitespace(cipher.login.username)
) {
cipher.login.username = fieldValue;
continue;
} else if (
fieldNameLower === "password" &&
this.isNullOrWhitespace(cipher.login.password)
) {
cipher.login.password = fieldValue;
continue;
} else if (fieldNameLower === "totp" && this.isNullOrWhitespace(cipher.login.totp)) {
cipher.login.totp = fieldValue;
continue;
}
} else if (cipher.type === CipherType.Card) {
if (
fieldNameLower === "cardholder" &&
this.isNullOrWhitespace(cipher.card.cardholderName)
) {
cipher.card.cardholderName = fieldValue;
continue;
} else if (fieldNameLower === "number" && this.isNullOrWhitespace(cipher.card.number)) {
cipher.card.number = fieldValue;
cipher.card.brand = this.getCardBrand(fieldValue);
continue;
} else if (fieldNameLower === "cvc" && this.isNullOrWhitespace(cipher.card.code)) {
cipher.card.code = fieldValue;
continue;
} else if (
fieldNameLower === "expiry date" &&
this.isNullOrWhitespace(cipher.card.expMonth) &&
this.isNullOrWhitespace(cipher.card.expYear)
) {
if (this.setCardExpiration(cipher, fieldValue)) {
continue;
}
} else if (fieldNameLower === "type") {
// Skip since brand was determined from number above
continue;
}
}
this.processKvp(cipher, fieldName, fieldValue);
}
}
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
result.success = true;
return Promise.resolve(result);
}
private containsField(fields: any[], name: string) {
if (fields == null || name == null) {
return false;
}
return (
fields.filter((f) => !this.isNullOrWhitespace(f) && f.toLowerCase() === name.toLowerCase())
.length > 0
);
}
}

191
jslib/common/src/importers/enpassJsonImporter.ts
View File

@@ -1,191 +0,0 @@
import { CipherType } from "../enums/cipherType";
import { FieldType } from "../enums/fieldType";
import { ImportResult } from "../models/domain/importResult";
import { CardView } from "../models/view/cardView";
import { CipherView } from "../models/view/cipherView";
import { FolderView } from "../models/view/folderView";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class EnpassJsonImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = JSON.parse(data);
if (results == null || results.items == null || results.items.length === 0) {
result.success = false;
return Promise.resolve(result);
}
const foldersMap = new Map<string, string>();
const foldersIndexMap = new Map<string, number>();
const folderTree = this.buildFolderTree(results.folders);
this.flattenFolderTree(null, folderTree, foldersMap);
foldersMap.forEach((val, key) => {
foldersIndexMap.set(key, result.folders.length);
const f = new FolderView();
f.name = val;
result.folders.push(f);
});
results.items.forEach((item: any) => {
if (item.folders != null && item.folders.length > 0 && foldersIndexMap.has(item.folders[0])) {
result.folderRelationships.push([
result.ciphers.length,
foldersIndexMap.get(item.folders[0]),
]);
}
const cipher = this.initLoginCipher();
cipher.name = this.getValueOrDefault(item.title);
cipher.favorite = item.favorite > 0;
if (item.template_type != null && item.fields != null && item.fields.length > 0) {
if (
item.template_type.indexOf("login.") === 0 ||
item.template_type.indexOf("password.") === 0
) {
this.processLogin(cipher, item.fields);
} else if (item.template_type.indexOf("creditcard.") === 0) {
this.processCard(cipher, item.fields);
} else if (
item.template_type.indexOf("identity.") < 0 &&
item.fields.some((f: any) => f.type === "password" && !this.isNullOrWhitespace(f.value))
) {
this.processLogin(cipher, item.fields);
} else {
this.processNote(cipher, item.fields);
}
}
cipher.notes += "\n" + this.getValueOrDefault(item.note, "");
this.convertToNoteIfNeeded(cipher);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
result.success = true;
return Promise.resolve(result);
}
private processLogin(cipher: CipherView, fields: any[]) {
const urls: string[] = [];
fields.forEach((field: any) => {
if (this.isNullOrWhitespace(field.value) || field.type === "section") {
return;
}
if (
(field.type === "username" || field.type === "email") &&
this.isNullOrWhitespace(cipher.login.username)
) {
cipher.login.username = field.value;
} else if (field.type === "password" && this.isNullOrWhitespace(cipher.login.password)) {
cipher.login.password = field.value;
} else if (field.type === "totp" && this.isNullOrWhitespace(cipher.login.totp)) {
cipher.login.totp = field.value;
} else if (field.type === "url") {
urls.push(field.value);
} else {
this.processKvp(
cipher,
field.label,
field.value,
field.sensitive === 1 ? FieldType.Hidden : FieldType.Text
);
}
});
cipher.login.uris = this.makeUriArray(urls);
}
private processCard(cipher: CipherView, fields: any[]) {
cipher.card = new CardView();
cipher.type = CipherType.Card;
fields.forEach((field: any) => {
if (
this.isNullOrWhitespace(field.value) ||
field.type === "section" ||
field.type === "ccType"
) {
return;
}
if (field.type === "ccName" && this.isNullOrWhitespace(cipher.card.cardholderName)) {
cipher.card.cardholderName = field.value;
} else if (field.type === "ccNumber" && this.isNullOrWhitespace(cipher.card.number)) {
cipher.card.number = field.value;
cipher.card.brand = this.getCardBrand(cipher.card.number);
} else if (field.type === "ccCvc" && this.isNullOrWhitespace(cipher.card.code)) {
cipher.card.code = field.value;
} else if (field.type === "ccExpiry" && this.isNullOrWhitespace(cipher.card.expYear)) {
if (!this.setCardExpiration(cipher, field.value)) {
this.processKvp(
cipher,
field.label,
field.value,
field.sensitive === 1 ? FieldType.Hidden : FieldType.Text
);
}
} else {
this.processKvp(
cipher,
field.label,
field.value,
field.sensitive === 1 ? FieldType.Hidden : FieldType.Text
);
}
});
}
private processNote(cipher: CipherView, fields: any[]) {
fields.forEach((field: any) => {
if (this.isNullOrWhitespace(field.value) || field.type === "section") {
return;
}
this.processKvp(
cipher,
field.label,
field.value,
field.sensitive === 1 ? FieldType.Hidden : FieldType.Text
);
});
}
private buildFolderTree(folders: any[]): any[] {
if (folders == null) {
return [];
}
const folderTree: any[] = [];
const map = new Map<string, any>([]);
folders.forEach((obj: any) => {
map.set(obj.uuid, obj);
obj.children = [];
});
folders.forEach((obj: any) => {
if (obj.parent_uuid != null && obj.parent_uuid !== "" && map.has(obj.parent_uuid)) {
map.get(obj.parent_uuid).children.push(obj);
} else {
folderTree.push(obj);
}
});
return folderTree;
}
private flattenFolderTree(titlePrefix: string, tree: any[], map: Map<string, string>) {
if (tree == null) {
return;
}
tree.forEach((f: any) => {
if (f.title != null && f.title.trim() !== "") {
let title = f.title.trim();
if (titlePrefix != null && titlePrefix.trim() !== "") {
title = titlePrefix + "/" + title;
}
map.set(f.uuid, title);
if (f.children != null && f.children.length !== 0) {
this.flattenFolderTree(title, f.children, map);
}
}
});
}
}

33
jslib/common/src/importers/firefoxCsvImporter.ts
View File

@@ -1,33 +0,0 @@
import { ImportResult } from "../models/domain/importResult";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class FirefoxCsvImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = this.parseCsv(data, true);
if (results == null) {
result.success = false;
return Promise.resolve(result);
}
results
.filter((value) => {
return value.url !== "chrome://FirefoxAccounts";
})
.forEach((value) => {
const cipher = this.initLoginCipher();
const url = this.getValueOrDefault(value.url, this.getValueOrDefault(value.hostname));
cipher.name = this.getValueOrDefault(this.nameFromUrl(url), "--");
cipher.login.username = this.getValueOrDefault(value.username);
cipher.login.password = this.getValueOrDefault(value.password);
cipher.login.uris = this.makeUriArray(url);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
result.success = true;
return Promise.resolve(result);
}
}

59
jslib/common/src/importers/fsecureFskImporter.ts
View File

@@ -1,59 +0,0 @@
import { CipherType } from "../enums/cipherType";
import { ImportResult } from "../models/domain/importResult";
import { CardView } from "../models/view/cardView";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class FSecureFskImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = JSON.parse(data);
if (results == null || results.data == null) {
result.success = false;
return Promise.resolve(result);
}
for (const key in results.data) {
// eslint-disable-next-line
if (!results.data.hasOwnProperty(key)) {
continue;
}
const value = results.data[key];
const cipher = this.initLoginCipher();
cipher.name = this.getValueOrDefault(value.service);
cipher.notes = this.getValueOrDefault(value.notes);
if (value.style === "website" || value.style === "globe") {
cipher.login.username = this.getValueOrDefault(value.username);
cipher.login.password = this.getValueOrDefault(value.password);
cipher.login.uris = this.makeUriArray(value.url);
} else if (value.style === "creditcard") {
cipher.type = CipherType.Card;
cipher.card = new CardView();
cipher.card.cardholderName = this.getValueOrDefault(value.username);
cipher.card.number = this.getValueOrDefault(value.creditNumber);
cipher.card.brand = this.getCardBrand(cipher.card.number);
cipher.card.code = this.getValueOrDefault(value.creditCvv);
if (!this.isNullOrWhitespace(value.creditExpiry)) {
if (!this.setCardExpiration(cipher, value.creditExpiry)) {
this.processKvp(cipher, "Expiration", value.creditExpiry);
}
}
if (!this.isNullOrWhitespace(value.password)) {
this.processKvp(cipher, "PIN", value.password);
}
} else {
continue;
}
this.convertToNoteIfNeeded(cipher);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
}
result.success = true;
return Promise.resolve(result);
}
}

71
jslib/common/src/importers/gnomeJsonImporter.ts
View File

@@ -1,71 +0,0 @@
import { ImportResult } from "../models/domain/importResult";
import { BaseImporter } from "./baseImporter";
import { Importer } from "./importer";
export class GnomeJsonImporter extends BaseImporter implements Importer {
parse(data: string): Promise<ImportResult> {
const result = new ImportResult();
const results = JSON.parse(data);
if (results == null || Object.keys(results).length === 0) {
result.success = false;
return Promise.resolve(result);
}
for (const keyRing in results) {
if (
!results.hasOwnProperty(keyRing) || // eslint-disable-line
this.isNullOrWhitespace(keyRing) ||
results[keyRing].length === 0
) {
continue;
}
results[keyRing].forEach((value: any) => {
if (
this.isNullOrWhitespace(value.display_name) ||
value.display_name.indexOf("http") !== 0
) {
return;
}
this.processFolder(result, keyRing);
const cipher = this.initLoginCipher();
cipher.name = value.display_name.replace("http://", "").replace("https://", "");
if (cipher.name.length > 30) {
cipher.name = cipher.name.substring(0, 30);
}
cipher.login.password = this.getValueOrDefault(value.secret);
cipher.login.uris = this.makeUriArray(value.display_name);
if (value.attributes != null) {
cipher.login.username =
value.attributes != null
? this.getValueOrDefault(value.attributes.username_value)
: null;
for (const attr in value.attributes) {
if (
!value.attributes.hasOwnProperty(attr) || // eslint-disable-line
attr === "username_value" ||
attr === "xdg:schema"
) {
continue;
}
this.processKvp(cipher, attr, value.attributes[attr]);
}
}
this.convertToNoteIfNeeded(cipher);
this.cleanupCipher(cipher);
result.ciphers.push(cipher);
});
}
if (this.organization) {
this.moveFoldersToCollections(result);
}
result.success = true;
return Promise.resolve(result);
}
}

5
jslib/common/src/importers/importError.ts
View File

@@ -1,5 +0,0 @@
export class ImportError extends Error {
constructor(message?: string, public passwordRequired: boolean = false) {
super(message);
}
}

6
jslib/common/src/importers/importer.ts
View File

@@ -1,6 +0,0 @@
import { ImportResult } from "../models/domain/importResult";
export interface Importer {
organizationId: string;
parse(data: string): Promise<ImportResult>;
}

Some files were not shown because too many files have changed in this diff Show More