@@ -25,6 +25,7 @@ import DropboxPage from "./DropboxPage.vue";
import DrivePage from "./DrivePage.vue";
import StorageSyncConfPage from "./StorageSyncConfPage.vue";
import PrefrencesPage from "./PrefrencesPage.vue";
+import LoadingPage from "./LoadingPage.vue";
export default Vue.extend({
computed: {
@@ -48,7 +49,8 @@ export default Vue.extend({
DropboxPage,
DrivePage,
PrefrencesPage,
- StorageSyncConfPage
+ StorageSyncConfPage,
+ LoadingPage
}
});
diff --git a/src/definitions/module-interface.d.ts b/src/definitions/module-interface.d.ts
index 75b1dffeb..6d9322947 100644
--- a/src/definitions/module-interface.d.ts
+++ b/src/definitions/module-interface.d.ts
@@ -43,6 +43,7 @@ interface StyleState {
slideout: Boolean;
fadein: Boolean;
fadeout: Boolean;
+ show: Boolean;
qrfadein: Boolean;
qrfadeout: Boolean;
notificationFadein: Boolean;
diff --git a/src/definitions/otp.d.ts b/src/definitions/otp.d.ts
index bbabe91b5..0cdb96be6 100644
--- a/src/definitions/otp.d.ts
+++ b/src/definitions/otp.d.ts
@@ -9,18 +9,19 @@ interface IOTPEntry {
counter: number;
code: string;
period: number;
- create(encryption: IEncryption): Promise
;
- update(encryption: IEncryption): Promise;
- next(encryption: IEncryption): Promise;
- applyEncryption(encryption: IEncryption): void;
+ create(): Promise;
+ update(): Promise;
+ next(): Promise;
+ applyEncryption(encryption: IEncryption): Promise;
+ changeEncryption(encryption: IEncryption): Promise;
delete(): Promise;
generate(): void;
+ rehash(encryption: IEncryption): Promise;
}
interface IEncryption {
- getEncryptedSecret(entry: IOTPEntry): string;
getEncryptedString(data: string): string;
- getDecryptedSecret(entry: OTPStorage): string | null;
+ getDecryptedSecret(entry: OTPStorage): Promise;
getEncryptionStatus(): boolean;
updateEncryptionPassword(password: string): void;
}
diff --git a/src/import.ts b/src/import.ts
index 2fd827d72..f7feaa25e 100644
--- a/src/import.ts
+++ b/src/import.ts
@@ -5,6 +5,7 @@ import { loadI18nMessages } from "./store/i18n";
import { Encryption } from "./models/encryption";
import { EntryStorage } from "./models/storage";
import * as CryptoJS from "crypto-js";
+import { argon } from "./models/argon";
async function init() {
// i18n
@@ -12,7 +13,15 @@ async function init() {
// Load entries to global
const encryption = new Encryption(await getCachedPassphrase());
- Vue.prototype.$entries = await EntryStorage.get(encryption);
+ const entries = await EntryStorage.get();
+
+ if (encryption.getEncryptionStatus()) {
+ for (const entry of entries) {
+ await entry.applyEncryption(encryption);
+ }
+ }
+
+ Vue.prototype.$entries = entries;
Vue.prototype.$encryption = encryption;
const instance = new Vue({
@@ -88,7 +97,7 @@ export function decryptBackupData(
return decryptedbackupData;
}
-export function getEntryDataFromOTPAuthPerLine(importCode: string) {
+export async function getEntryDataFromOTPAuthPerLine(importCode: string) {
const lines = importCode.split("\n");
const exportData: { [hash: string]: OTPStorage } = {};
for (let item of lines) {
@@ -153,7 +162,7 @@ export function getEntryDataFromOTPAuthPerLine(importCode: string) {
) {
continue;
} else {
- const hash = CryptoJS.MD5(secret).toString();
+ const hash = await argon.hash(secret);
if (
!/^[2-7a-z]+=*$/i.test(secret) &&
/^[0-9a-f]+$/i.test(secret) &&
diff --git a/src/models/argon.ts b/src/models/argon.ts
new file mode 100644
index 000000000..718cefac4
--- /dev/null
+++ b/src/models/argon.ts
@@ -0,0 +1,30 @@
+import * as argon2 from "argon2-browser";
+
+export class argon {
+ static async hash(value: string) {
+ const salt = window.crypto.getRandomValues(new Uint8Array(16));
+ const hash = await argon2.hash({
+ pass: value,
+ salt,
+ mem: 1024 * 8,
+ type: argon2.ArgonType.Argon2id
+ });
+
+ return hash.encoded;
+ }
+
+ static compareHash(hash: string, value: string) {
+ return new Promise((resolve: (value: boolean) => void) => {
+ argon2
+ .verify({
+ pass: value,
+ encoded: hash
+ })
+ .then(() => resolve(true))
+ .catch((e: { message: string; code: number }) => {
+ console.error("Error decoding hash", e);
+ resolve(false);
+ });
+ });
+ }
+}
diff --git a/src/models/backup.ts b/src/models/backup.ts
index 8a9cefb44..b9ed7ba8c 100644
--- a/src/models/backup.ts
+++ b/src/models/backup.ts
@@ -12,7 +12,7 @@ export class Dropbox implements BackupProvider {
// Encrypt by default if user hasn't set yet
localStorage.dropboxEncrypted = "true";
}
- const exportData = await EntryStorage.getExport(
+ const exportData = await EntryStorage.backupGetExport(
encryption,
localStorage.dropboxEncrypted === "true"
);
@@ -335,7 +335,7 @@ export class Drive implements BackupProvider {
if (localStorage.driveEncrypted === undefined) {
localStorage.driveEncrypted = "true";
}
- const exportData = await EntryStorage.getExport(
+ const exportData = await EntryStorage.backupGetExport(
encryption,
localStorage.driveEncrypted === "true"
);
diff --git a/src/models/encryption.ts b/src/models/encryption.ts
index 1ccc79472..37b3969af 100644
--- a/src/models/encryption.ts
+++ b/src/models/encryption.ts
@@ -1,4 +1,5 @@
import * as CryptoJS from "crypto-js";
+import { argon } from "./argon";
export class Encryption implements IEncryption {
private password: string;
@@ -7,23 +8,6 @@ export class Encryption implements IEncryption {
this.password = password;
}
- getEncryptedSecret(entry: IOTPEntry): string {
- if (entry.encSecret) {
- return entry.encSecret;
- } else if (entry.secret) {
- if (!this.password) {
- // Not encrypted, give unencrypted.
- return entry.secret;
- } else {
- // Not encrypted and password is set, encrypt.
- return CryptoJS.AES.encrypt(entry.secret, this.password).toString();
- }
- } else {
- console.error(entry);
- throw new Error("Invalid entry");
- }
- }
-
getEncryptedString(data: string): string {
if (!this.password) {
return data;
@@ -32,13 +16,9 @@ export class Encryption implements IEncryption {
}
}
- getDecryptedSecret(entry: { secret: string; hash: string }): string | null {
+ async getDecryptedSecret(entry: { secret: string; hash: string }) {
try {
- if (entry.hash === CryptoJS.MD5(entry.secret).toString()) {
- return entry.secret;
- }
-
- let decryptedSecret = CryptoJS.AES.decrypt(
+ const decryptedSecret = CryptoJS.AES.decrypt(
entry.secret,
this.password
).toString(CryptoJS.enc.Utf8);
@@ -51,12 +31,6 @@ export class Encryption implements IEncryption {
return null;
}
- if (entry.hash === CryptoJS.MD5(decryptedSecret).toString()) {
- return decryptedSecret;
- }
-
- decryptedSecret = decryptedSecret.replace(/ /g, "");
-
if (
!/^[a-z2-7]+=*$/i.test(decryptedSecret) &&
!/^[0-9a-f]+$/i.test(decryptedSecret) &&
@@ -67,8 +41,23 @@ export class Encryption implements IEncryption {
return null;
}
+ if (
+ /^\$argon2(?:d|i|di|id)\$v=(\d+)\$m=(\d+),t=(\d+),p=(\d+)\$([A-Za-z0-9+/=]+)\$([A-Za-z0-9+/=]*)$/.test(
+ entry.hash
+ )
+ ) {
+ if (await argon.compareHash(entry.hash, decryptedSecret)) {
+ return decryptedSecret;
+ }
+ } else if (entry.hash === CryptoJS.MD5(decryptedSecret).toString()) {
+ return decryptedSecret;
+ }
+
console.warn(
- `Account ${entry.hash} may have secret ${decryptedSecret}, but hash did not match.`
+ `Account ${entry.hash} may have secret ${decryptedSecret.replace(
+ / /g,
+ ""
+ )}, but hash did not match.`
);
return null;
} catch (error) {
diff --git a/src/models/otp.ts b/src/models/otp.ts
index bfacd5e75..12e73a880 100644
--- a/src/models/otp.ts
+++ b/src/models/otp.ts
@@ -1,6 +1,8 @@
import { Encryption } from "./encryption";
import { KeyUtilities } from "./key-utilities";
import { EntryStorage } from "./storage";
+import { argon } from "./argon";
+import * as CryptoJS from "crypto-js";
export enum OTPType {
totp = 1,
@@ -23,28 +25,34 @@ export class OTPEntry implements IOTPEntry {
period: number;
code = "••••••";
- constructor(entry: {
- account: string;
- encrypted: boolean;
- hash: string;
- index: number;
- issuer: string;
- secret: string;
- type: OTPType;
- counter: number;
- period?: number;
- }) {
+ constructor(
+ entry: {
+ account: string;
+ encrypted: boolean;
+ hash: string;
+ index: number;
+ issuer: string;
+ secret: string;
+ type: OTPType;
+ counter: number;
+ period?: number;
+ },
+ encryption?: Encryption
+ ) {
this.type = entry.type;
this.index = entry.index;
this.issuer = entry.issuer;
+ this.account = entry.account;
if (entry.encrypted) {
this.encSecret = entry.secret;
this.secret = null;
} else {
this.secret = entry.secret;
this.encSecret = null;
+ if (encryption && encryption.getEncryptionStatus()) {
+ this.encSecret = encryption.getEncryptedString(this.secret);
+ }
}
- this.account = entry.account;
this.hash = entry.hash;
this.counter = entry.counter;
if (this.type === OTPType.totp && entry.period) {
@@ -57,20 +65,38 @@ export class OTPEntry implements IOTPEntry {
}
}
- async create(encryption: Encryption) {
- await EntryStorage.add(encryption, this);
+ async create() {
+ await EntryStorage.add(this);
return;
}
- async update(encryption: Encryption) {
- await EntryStorage.update(encryption, this);
+ async update() {
+ await EntryStorage.update(this);
return;
}
- applyEncryption(encryption: Encryption) {
+ async changeEncryption(encryption: Encryption) {
+ if (!this.secret) {
+ return;
+ }
+
+ if (encryption.getEncryptionStatus()) {
+ this.encSecret = encryption.getEncryptedString(this.secret);
+ } else {
+ this.encSecret = null;
+ }
+
+ await this.update();
+ return;
+ }
+
+ async applyEncryption(encryption: Encryption) {
const secret = this.encSecret ? this.encSecret : null;
if (secret) {
- this.secret = encryption.getDecryptedSecret({ hash: this.hash, secret });
+ this.secret = await encryption.getDecryptedSecret({
+ hash: this.hash,
+ secret
+ });
if (this.type !== OTPType.hotp && this.type !== OTPType.hhex) {
this.generate();
}
@@ -83,18 +109,34 @@ export class OTPEntry implements IOTPEntry {
return;
}
- async next(encryption: Encryption) {
+ async next() {
if (this.type !== OTPType.hotp && this.type !== OTPType.hhex) {
return;
}
this.generate();
if (this.secret !== null) {
this.counter++;
- await this.update(encryption);
+ await this.update();
}
return;
}
+ async rehash() {
+ const secret = this.secret;
+ if (!secret) {
+ return;
+ }
+
+ if (this.hash !== CryptoJS.MD5(secret).toString()) {
+ return;
+ }
+
+ const newHash = await argon.hash(secret);
+ await this.delete();
+ this.hash = newHash;
+ await this.create();
+ }
+
generate() {
if (!this.secret && !this.encSecret) {
this.code = "Invalid";
diff --git a/src/models/storage.ts b/src/models/storage.ts
index 7e7a88730..931dd142d 100644
--- a/src/models/storage.ts
+++ b/src/models/storage.ts
@@ -1,7 +1,6 @@
-import * as CryptoJS from "crypto-js";
-
import { Encryption } from "./encryption";
import { OTPEntry, OTPType } from "./otp";
+import { argon } from "./argon";
export class BrowserStorage {
private static async getStorageLocation() {
@@ -90,18 +89,32 @@ export class BrowserStorage {
export class EntryStorage {
private static getOTPStorageFromEntry(
- encryption: Encryption,
- entry: OTPEntry
+ entry: OTPEntry,
+ unencrypted?: boolean
): OTPStorage {
+ let secret: string;
+ if (entry.encSecret) {
+ secret = entry.encSecret;
+ } else if (entry.secret) {
+ secret = entry.secret;
+ } else {
+ secret = "";
+ console.warn("Invalid entry", entry);
+ }
+
+ if (unencrypted && entry.secret) {
+ secret = entry.secret;
+ }
+
const storageItem: OTPStorage = {
account: entry.account,
- encrypted: encryption.getEncryptionStatus(),
+ encrypted: Boolean(entry.encSecret),
hash: entry.hash,
index: entry.index,
issuer: entry.issuer,
type: OTPType[entry.type],
counter: entry.counter, // TODO: Make this optional for non HOTP accounts
- secret: encryption.getEncryptedSecret(entry)
+ secret
};
if (entry.period && entry.period !== 30) {
@@ -134,8 +147,11 @@ export class EntryStorage {
return newData;
}
- /* tslint:disable-next-line:no-any */
- private static isOTPStorage(entry: any) {
+ private static isOTPStorage(entry: unknown) {
+ if (typeof entry !== "object") {
+ return false;
+ }
+
if (!entry || !entry.hasOwnProperty("secret")) {
return false;
}
@@ -178,14 +194,39 @@ export class EntryStorage {
);
}
- static getExport(encryption: Encryption, encrypted?: boolean) {
+ static getExport(data: IOTPEntry[], encrypted?: boolean) {
+ try {
+ let exportData: { [hash: string]: OTPStorage } = {};
+ for (const entry of data) {
+ if (!encrypted) {
+ if (!entry.secret) {
+ // Not unencrypted
+ } else {
+ exportData[entry.hash] = this.getOTPStorageFromEntry(
+ entry as OTPEntry,
+ true
+ );
+ }
+ } else {
+ exportData[entry.hash] = this.getOTPStorageFromEntry(
+ entry as OTPEntry
+ );
+ }
+ }
+ return exportData;
+ } catch (error) {
+ return error;
+ }
+ }
+
+ static backupGetExport(encryption: Encryption, encrypted?: boolean) {
return new Promise(
(
resolve: (value: { [hash: string]: OTPStorage }) => void,
reject: (reason: Error) => void
) => {
try {
- BrowserStorage.get((_data: { [hash: string]: OTPStorage }) => {
+ BrowserStorage.get(async (_data: { [hash: string]: OTPStorage }) => {
for (const hash of Object.keys(_data)) {
if (!this.isValidEntry(_data, hash)) {
delete _data[hash];
@@ -194,7 +235,7 @@ export class EntryStorage {
if (!encrypted) {
// decrypt the data to export
if (_data[hash].encrypted) {
- const decryptedSecret = encryption.getDecryptedSecret(
+ const decryptedSecret = await encryption.getDecryptedSecret(
_data[hash]
);
if (
@@ -226,7 +267,7 @@ export class EntryStorage {
return new Promise(
(resolve: () => void, reject: (reason: Error) => void) => {
try {
- BrowserStorage.get((_data: { [hash: string]: OTPStorage }) => {
+ BrowserStorage.get(async (_data: { [hash: string]: OTPStorage }) => {
for (const hash of Object.keys(data)) {
// never trust data import from user
// we do not support encrypted data import any longer
@@ -284,9 +325,14 @@ export class EntryStorage {
data[hash].type = OTPType[OTPType.hhex];
}
- const _hash = CryptoJS.MD5(data[hash].secret).toString();
- // not a valid hash
- if (!/^[0-9a-f]{32}$/.test(hash)) {
+ const _hash = await argon.hash(data[hash].secret);
+
+ // not a valid / old hash
+ if (
+ !/^\$argon2(?:d|i|di|id)\$v=(\d+)\$m=(\d+),t=(\d+),p=(\d+)\$([A-Za-z0-9+/=]+)\$([A-Za-z0-9+/=]*)$/.test(
+ hash
+ )
+ ) {
data[_hash] = data[hash];
data[_hash].hash = _hash;
delete data[hash];
@@ -315,28 +361,22 @@ export class EntryStorage {
);
}
- static add(encryption: Encryption, entry: OTPEntry) {
+ static add(entry: OTPEntry) {
return new Promise(
(resolve: () => void, reject: (reason: Error) => void) => {
try {
- BrowserStorage.get((_data: { [hash: string]: OTPStorage }) => {
- if (_data.hasOwnProperty(entry.hash)) {
- throw new Error("The specific entry has already existed.");
- }
- const storageItem = this.getOTPStorageFromEntry(encryption, entry);
- _data[entry.hash] = storageItem;
- _data = this.ensureUniqueIndex(_data);
- BrowserStorage.set(_data, resolve);
- });
- return;
+ BrowserStorage.set(
+ { [entry.hash]: this.getOTPStorageFromEntry(entry) },
+ resolve
+ );
} catch (error) {
- return reject(error);
+ reject(error);
}
}
);
}
- static update(encryption: Encryption, entry: OTPEntry) {
+ static update(entry: OTPEntry) {
return new Promise(
(resolve: () => void, reject: (reason: Error) => void) => {
try {
@@ -344,7 +384,7 @@ export class EntryStorage {
if (!_data.hasOwnProperty(entry.hash)) {
throw new Error("Entry to change does not exist.");
}
- const storageItem = this.getOTPStorageFromEntry(encryption, entry);
+ const storageItem = this.getOTPStorageFromEntry(entry);
_data[entry.hash] = storageItem;
_data = this.ensureUniqueIndex(_data);
BrowserStorage.set(_data, resolve);
@@ -357,16 +397,13 @@ export class EntryStorage {
);
}
- static set(encryption: Encryption, entries: OTPEntry[]) {
+ static set(entries: OTPEntry[]) {
return new Promise(
(resolve: () => void, reject: (reason: Error) => void) => {
try {
BrowserStorage.get((_data: { [hash: string]: OTPStorage }) => {
entries.forEach(entry => {
- const storageItem = this.getOTPStorageFromEntry(
- encryption,
- entry
- );
+ const storageItem = this.getOTPStorageFromEntry(entry);
_data[entry.hash] = storageItem;
});
_data = this.ensureUniqueIndex(_data);
@@ -380,7 +417,7 @@ export class EntryStorage {
);
}
- static get(encryption: Encryption) {
+ static get() {
return new Promise(
(
resolve: (value: OTPEntry[]) => void,
@@ -389,21 +426,19 @@ export class EntryStorage {
try {
BrowserStorage.get(async (_data: { [hash: string]: OTPStorage }) => {
const data: OTPEntry[] = [];
+
for (const hash of Object.keys(_data)) {
if (!this.isValidEntry(_data, hash)) {
continue;
}
const entryData = _data[hash];
- let needMigrate = false;
if (!entryData.hash) {
entryData.hash = hash;
- needMigrate = true;
}
if (!entryData.type) {
entryData.type = OTPType[OTPType.totp];
- needMigrate = true;
}
let type: OTPType;
@@ -421,7 +456,6 @@ export class EntryStorage {
// and save it
type = OTPType.totp;
entryData.type = OTPType[OTPType.totp];
- needMigrate = true;
}
let period = 30;
@@ -444,26 +478,23 @@ export class EntryStorage {
counter: entryData.counter,
period
});
- entry.applyEncryption(encryption);
- data.push(entry);
- if (entry.secret !== null && !/^[0-9a-f]{32}$/.test(hash)) {
- const _hash = CryptoJS.MD5(entry.secret).toString();
- if (hash !== _hash) {
- console.warn("Invalid hash:", entry);
- }
- }
- }
+ data.push(entry);
- data.sort((a, b) => {
- return a.index - b.index;
- });
+ data.sort((a, b) => {
+ return a.index - b.index;
+ });
- for (let i = 0; i < data.length; i++) {
- if (data[i].index !== i) {
- const exportData = await this.getExport(encryption);
- await this.import(encryption, exportData);
- break;
+ if (
+ entry.secret !== null &&
+ !(
+ /^[0-9a-f]{32}$/.test(hash) ||
+ /^\$argon2(?:d|i|di|id)\$v=(\d+)\$m=(\d+),t=(\d+),p=(\d+)\$([A-Za-z0-9+/=]+)\$([A-Za-z0-9+/=]*)$/.test(
+ hash
+ )
+ )
+ ) {
+ console.warn("Invalid hash:", entry);
}
}
diff --git a/src/popup.ts b/src/popup.ts
index 775d73210..0f92ab5df 100644
--- a/src/popup.ts
+++ b/src/popup.ts
@@ -16,6 +16,7 @@ import { Menu } from "./store/Menu";
import { Notification } from "./store/Notification";
import { Qr } from "./store/Qr";
import { Dropbox, Drive } from "./models/backup";
+import { EntryStorage } from "./models/storage";
async function init() {
// Add globals
@@ -53,8 +54,22 @@ async function init() {
// Prompt for password if needed
if (instance.$store.state.accounts.shouldShowPassphrase) {
- instance.$store.commit("style/showInfo");
- instance.$store.commit("currentView/changeView", "EnterPasswordPage");
+ instance.$store.commit("style/showInfo", true);
+ // If we have cached password, use that
+ if (instance.$store.state.accounts.encryption.getEncryptionStatus()) {
+ instance.$store.commit("currentView/changeView", "LoadingPage");
+ for (const entry of instance.$store.state.accounts.entries) {
+ await entry.applyEncryption(instance.$store.state.accounts.encryption);
+ }
+ instance.$store.commit(
+ "accounts/updateExport",
+ await EntryStorage.getExport(instance.$store.state.accounts.entries)
+ );
+ instance.$store.commit("accounts/updateCodes");
+ instance.$store.commit("style/hideInfo", true);
+ } else {
+ instance.$store.commit("currentView/changeView", "EnterPasswordPage");
+ }
}
// Set document title
diff --git a/src/store/Accounts.ts b/src/store/Accounts.ts
index dfff8d064..209c3f800 100644
--- a/src/store/Accounts.ts
+++ b/src/store/Accounts.ts
@@ -11,9 +11,7 @@ export class Accounts implements IModule {
let shouldShowPassphrase = cachedPassphrase
? false
: await EntryStorage.hasEncryptedEntry();
- const entries = shouldShowPassphrase
- ? []
- : await this.getEntries(encryption);
+ const entries = shouldShowPassphrase ? [] : await this.getEntries();
for (let i = 0; i < entries.length; i++) {
if (entries[i].code === "Encrypted") {
@@ -34,8 +32,8 @@ export class Accounts implements IModule {
filter: true,
siteName: await this.getSiteName(),
showSearch: false,
- exportData: await EntryStorage.getExport(encryption),
- exportEncData: await EntryStorage.getExport(encryption, true)
+ exportData: await EntryStorage.getExport(entries),
+ exportEncData: await EntryStorage.getExport(entries, true)
},
getters: {
shouldFilter(
@@ -116,12 +114,6 @@ export class Accounts implements IModule {
},
loadCodes(state: AccountsState, newCodes: IOTPEntry[]) {
state.entries = newCodes;
-
- if (state.encryption.getEncryptionStatus()) {
- for (const entry of state.entries) {
- entry.applyEncryption(state.encryption);
- }
- }
},
moveCode(state: AccountsState, opts: { from: number; to: number }) {
state.entries.splice(
@@ -150,6 +142,39 @@ export class Accounts implements IModule {
}
},
actions: {
+ deleteCode: async (
+ state: ActionContext,
+ hash: string
+ ) => {
+ const index = state.state.entries.findIndex(
+ entry => entry.hash === hash
+ );
+ if (index > -1) {
+ state.state.entries.splice(index, 1);
+ }
+ state.commit(
+ "updateExport",
+ await EntryStorage.getExport(state.state.entries)
+ );
+ state.commit(
+ "updateEncExport",
+ await EntryStorage.getExport(state.state.entries, true)
+ );
+ },
+ addCode: async (
+ state: ActionContext,
+ entry: IOTPEntry
+ ) => {
+ state.state.entries.unshift(entry);
+ state.commit(
+ "updateExport",
+ await EntryStorage.getExport(state.state.entries)
+ );
+ state.commit(
+ "updateEncExport",
+ await EntryStorage.getExport(state.state.entries, true)
+ );
+ },
applyPassphrase: async (
state: ActionContext,
password: string
@@ -158,9 +183,32 @@ export class Accounts implements IModule {
return;
}
+ state.commit("currentView/changeView", "LoadingPage", { root: true });
+
state.state.encryption.updateEncryptionPassword(password);
await state.dispatch("updateEntries");
- state.commit("style/hideInfo", null, { root: true });
+
+ // Migrate old hashes to argon2
+ if (state.state.encryption.getEncryptionStatus()) {
+ let changedHash = false;
+
+ for (const entry of state.state.entries) {
+ if (
+ !/^\$argon2(?:d|i|di|id)\$v=(\d+)\$m=(\d+),t=(\d+),p=(\d+)\$([A-Za-z0-9+/=]+)\$([A-Za-z0-9+/=]*)$/.test(
+ entry.hash
+ )
+ ) {
+ await entry.rehash(state.state.encryption);
+ changedHash = true;
+ }
+ }
+
+ if (changedHash) {
+ await state.dispatch("updateEntries");
+ }
+ }
+
+ state.commit("style/hideInfo", true, { root: true });
if (!state.getters.currentlyEncrypted) {
document.cookie = "passphrase=" + password;
@@ -175,39 +223,41 @@ export class Accounts implements IModule {
state: ActionContext,
password: string
) => {
- await EntryStorage.import(
- new Encryption(password),
- await EntryStorage.getExport(state.state.encryption as Encryption)
- );
-
state.state.encryption.updateEncryptionPassword(password);
+
document.cookie = "passphrase=" + password;
chrome.runtime.sendMessage({
action: "cachePassphrase",
value: password
});
+ for (const entry of state.state.entries) {
+ await entry.changeEncryption(state.state.encryption);
+ }
+
await state.dispatch("updateEntries");
// remove cached passphrase in old version
localStorage.removeItem("encodedPhrase");
},
updateEntries: async (state: ActionContext) => {
- state.commit(
- "loadCodes",
- await this.getEntries(state.state.encryption as Encryption)
- );
+ const entries = await this.getEntries();
+
+ if (state.state.encryption.getEncryptionStatus()) {
+ for (const entry of entries) {
+ await entry.applyEncryption(state.state.encryption as Encryption);
+ }
+ }
+
+ state.commit("loadCodes", entries);
state.commit("updateCodes");
state.commit(
"updateExport",
- await EntryStorage.getExport(state.state.encryption as Encryption)
+ await EntryStorage.getExport(state.state.entries)
);
state.commit(
"updateEncExport",
- await EntryStorage.getExport(
- state.state.encryption as Encryption,
- true
- )
+ await EntryStorage.getExport(state.state.entries, true)
);
return;
},
@@ -379,8 +429,8 @@ export class Accounts implements IModule {
);
}
- private async getEntries(encryption: Encryption) {
- const otpEntries = await EntryStorage.get(encryption);
+ private async getEntries() {
+ const otpEntries = await EntryStorage.get();
return otpEntries;
}
diff --git a/src/store/Style.ts b/src/store/Style.ts
index 993bb3237..21a6002f8 100644
--- a/src/store/Style.ts
+++ b/src/store/Style.ts
@@ -9,6 +9,7 @@ export class Style implements IModule {
slideout: false, // menu
fadein: false, // info
fadeout: false, // info
+ show: false, // info
qrfadein: false,
qrfadeout: false,
notificationFadein: false,
@@ -28,13 +29,21 @@ export class Style implements IModule {
state.style.slideout = false;
}, 200);
},
- showInfo(state: StyleState) {
- state.style.fadein = true;
- state.style.fadeout = false;
+ showInfo(state: StyleState, noAnimate?: boolean) {
+ if (noAnimate) {
+ state.style.show = true;
+ } else {
+ state.style.fadein = true;
+ state.style.fadeout = false;
+ }
},
- hideInfo(state: StyleState) {
- state.style.fadein = false;
- state.style.fadeout = true;
+ hideInfo(state: StyleState, noAnimate?: boolean) {
+ if (noAnimate) {
+ state.style.show = false;
+ } else {
+ state.style.fadein = false;
+ state.style.fadeout = true;
+ }
setTimeout(() => {
state.style.fadeout = false;
}, 200);
diff --git a/webpack.config.js b/webpack.config.js
index 450109374..aaf0d809f 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -1,25 +1,35 @@
-const path = require('path');
-const VueLoaderPlugin = require('vue-loader/lib/plugin');
-const ForkTsCheckerWebpackPlugin = require('fork-ts-checker-webpack-plugin');
+const path = require("path");
+const VueLoaderPlugin = require("vue-loader/lib/plugin");
+const ForkTsCheckerWebpackPlugin = require("fork-ts-checker-webpack-plugin");
module.exports = {
- mode: 'development',
- devtool: 'source-map',
+ mode: "development",
+ devtool: "source-map",
entry: {
- background: './src/background.ts',
- content: './src/content.ts',
- popup: './src/popup.ts',
- import: './src/import.ts',
- qr: './src/qr.ts',
- qrdebug: './src/qrdebug.ts',
- test: './src/test/test.ts'
+ background: "./src/background.ts",
+ content: "./src/content.ts",
+ popup: "./src/popup.ts",
+ import: "./src/import.ts",
+ qr: "./src/qr.ts",
+ qrdebug: "./src/qrdebug.ts",
+ test: "./src/test/test.ts"
+ },
+ // For argon2-browser
+ node: {
+ fs: "empty"
},
module: {
rules: [
+ {
+ // argon2-browser overrides
+ test: /\.wasm$/,
+ loader: "base64-loader",
+ type: "javascript/auto"
+ },
{
test: /\.tsx?$/,
- loader: 'ts-loader',
- options: {
+ loader: "ts-loader",
+ options: {
appendTsSuffixTo: [/\.vue$/],
transpileOnly: true
},
@@ -27,38 +37,35 @@ module.exports = {
},
{
test: /\.vue$/,
- loader: 'vue-loader'
+ loader: "vue-loader"
},
{
test: /\.svg$/,
- loader: 'vue-svg-loader'
+ loader: "vue-svg-loader"
}
]
},
plugins: [
new VueLoaderPlugin(),
- new ForkTsCheckerWebpackPlugin(
- {
- vue: true
- }
- )
+ new ForkTsCheckerWebpackPlugin({
+ vue: true
+ })
],
resolve: {
extensions: [
- '.mjs',
- '.js',
- '.jsx',
- '.vue',
- '.json',
- '.wasm',
- '.ts',
- '.tsx'
+ ".mjs",
+ ".js",
+ ".jsx",
+ ".vue",
+ ".json",
+ ".wasm",
+ ".ts",
+ ".tsx"
],
- modules: [
- 'node_modules'
- ]
+ modules: ["node_modules"]
},
output: {
- path: path.resolve(__dirname, 'dist')
+ path: path.resolve(__dirname, "dist"),
+ publicPath: "/dist/"
}
};