@@ -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 094e6d053..df0658eea 100644
--- a/src/definitions/module-interface.d.ts
+++ b/src/definitions/module-interface.d.ts
@@ -4,7 +4,7 @@ interface IModule {
interface VuexConstructor {
state?: {
- [key: string]: Object | Function;
+ [key: string]: any;
};
mutations?: {
[key: string]: Function;
@@ -44,6 +44,7 @@ interface StyleState {
slideout: Boolean;
fadein: Boolean;
fadeout: Boolean;
+ show: Boolean;
qrfadein: Boolean;
qrfadeout: Boolean;
notificationFadein: Boolean;
@@ -66,6 +67,8 @@ interface AccountsState {
showSearch: Boolean;
exportData: { [k: string]: IOTPEntry };
exportEncData: { [k: string]: IOTPEntry };
+ key: { enc: string; hash: string } | null;
+ wrongPassword: Boolean;
}
interface NotificationState {
diff --git a/src/definitions/otp.d.ts b/src/definitions/otp.d.ts
index bbabe91b5..634db0957 100644
--- a/src/definitions/otp.d.ts
+++ b/src/definitions/otp.d.ts
@@ -9,16 +9,17 @@ interface IOTPEntry {
counter: number;
code: string;
period: number;
- create(encryption: IEncryption): Promise
;
- update(encryption: IEncryption): Promise;
- next(encryption: IEncryption): Promise;
+ create(): Promise;
+ update(): Promise;
+ next(): Promise;
applyEncryption(encryption: IEncryption): void;
+ changeEncryption(encryption: IEncryption): Promise;
delete(): Promise;
generate(): void;
+ genUUID(): Promise;
}
interface IEncryption {
- getEncryptedSecret(entry: IOTPEntry): string;
getEncryptedString(data: string): string;
getDecryptedSecret(entry: OTPStorage): string | null;
getEncryptionStatus(): boolean;
diff --git a/src/import.ts b/src/import.ts
index 874abee3c..a51466041 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 * as uuid from "uuid/v4";
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({
@@ -78,7 +87,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) {
@@ -143,7 +152,7 @@ export function getEntryDataFromOTPAuthPerLine(importCode: string) {
) {
continue;
} else {
- const hash = CryptoJS.MD5(secret).toString();
+ const hash = await uuid();
if (
!/^[2-7a-z]+=*$/i.test(secret) &&
/^[0-9a-f]+$/i.test(secret) &&
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..5fa187946 100644
--- a/src/models/encryption.ts
+++ b/src/models/encryption.ts
@@ -7,23 +7,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 +15,9 @@ export class Encryption implements IEncryption {
}
}
- getDecryptedSecret(entry: { secret: string; hash: string }): string | null {
+ 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 +30,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,10 +40,7 @@ export class Encryption implements IEncryption {
return null;
}
- console.warn(
- `Account ${entry.hash} may have secret ${decryptedSecret}, but hash did not match.`
- );
- return null;
+ return decryptedSecret;
} catch (error) {
return null;
}
diff --git a/src/models/otp.ts b/src/models/otp.ts
index fab005ca6..5ff146534 100644
--- a/src/models/otp.ts
+++ b/src/models/otp.ts
@@ -1,6 +1,7 @@
import { Encryption } from "./encryption";
import { KeyUtilities } from "./key-utilities";
import { EntryStorage } from "./storage";
+import * as uuid from "uuid/v4";
export enum OTPType {
totp = 1,
@@ -28,29 +29,40 @@ 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;
+ index: number;
+ issuer: string;
+ secret: string;
+ type: OTPType;
+ counter: number;
+ period?: number;
+ hash?: string;
+ },
+ 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);
+ }
+ }
+
+ if (entry.hash) {
+ this.hash = entry.hash;
+ } else {
+ this.hash = uuid(); // UUID
}
- this.account = entry.account;
- this.hash = entry.hash;
this.counter = entry.counter;
if (this.type === OTPType.totp && entry.period) {
this.period = entry.period;
@@ -62,20 +74,38 @@ export class OTPEntry implements IOTPEntry {
}
}
- async create(encryption: Encryption) {
- await EntryStorage.add(encryption, this);
+ async create() {
+ await EntryStorage.add(this);
+ return;
+ }
+
+ async update() {
+ await EntryStorage.update(this);
return;
}
- async update(encryption: Encryption) {
- await EntryStorage.update(encryption, this);
+ 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;
}
applyEncryption(encryption: Encryption) {
const secret = this.encSecret ? this.encSecret : null;
if (secret) {
- this.secret = encryption.getDecryptedSecret({ hash: this.hash, secret });
+ this.secret = encryption.getDecryptedSecret({
+ hash: this.hash,
+ secret
+ });
if (this.type !== OTPType.hotp && this.type !== OTPType.hhex) {
this.generate();
}
@@ -88,18 +118,24 @@ 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 genUUID() {
+ await this.delete();
+ this.hash = uuid();
+ await this.create();
+ }
+
generate() {
if (!this.secret && !this.encSecret) {
this.code = CodeState.Invalid;
diff --git a/src/models/storage.ts b/src/models/storage.ts
index 7e7a88730..28e830a9d 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 * as uuid from "uuid/v4";
export class BrowserStorage {
private static async getStorageLocation() {
@@ -54,16 +53,45 @@ export class BrowserStorage {
}
/* tslint:disable-next-line:no-any */
+ // TODO: promise this
static async get(callback: (items: { [key: string]: any }) => void) {
const storageLocation = await this.getStorageLocation();
+ const removeKey = function(items: { [key: string]: any }): void {
+ delete items.key;
+ callback(items);
+ };
+
if (storageLocation === "local") {
- chrome.storage.local.get(callback);
+ chrome.storage.local.get(removeKey);
} else if (storageLocation === "sync") {
- chrome.storage.sync.get(callback);
+ chrome.storage.sync.get(removeKey);
}
return;
}
+ static getKey() {
+ return new Promise(
+ async (resolve: (key: { enc: string; hash: string } | null) => void) => {
+ const storageLocation = await this.getStorageLocation();
+ const callback = function(items: { [key: string]: any }): void {
+ if (typeof items.key === "object") {
+ resolve(items.key);
+ } else {
+ resolve(null);
+ }
+ return;
+ };
+
+ if (storageLocation === "local") {
+ chrome.storage.local.get(callback);
+ } else if (storageLocation === "sync") {
+ chrome.storage.sync.get(callback);
+ }
+ return;
+ }
+ );
+ }
+
static async set(data: object, callback?: (() => void) | undefined) {
const storageLocation = await this.getStorageLocation();
if (storageLocation === "local") {
@@ -86,22 +114,62 @@ export class BrowserStorage {
}
return;
}
+
+ // Use for Chrome only.
+ // https://github.com/Authenticator-Extension/Authenticator/issues/412
+ static async clearLogs() {
+ const storageLocation = await this.getStorageLocation();
+ await new Promise((resolve: () => void) => {
+ if (storageLocation === "local") {
+ chrome.storage.local.get(data => {
+ chrome.storage.local.clear(() => {
+ chrome.storage.local.set(data, () => {
+ resolve();
+ });
+ });
+ });
+ } else if (storageLocation === "sync") {
+ chrome.storage.sync.get(data => {
+ chrome.storage.sync.clear(() => {
+ chrome.storage.sync.set(data, () => {
+ resolve();
+ });
+ });
+ });
+ }
+ });
+ return;
+ }
}
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 +202,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 +249,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];
@@ -212,6 +308,7 @@ export class EntryStorage {
}
}
}
+ Object.assign(_data, await BrowserStorage.getKey());
return resolve(_data);
});
return;
@@ -226,7 +323,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,15 +381,18 @@ 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)) {
+ // not a valid / old hash
+ if (
+ !/^[a-f0-9]{8}-?[a-f0-9]{4}-?4[a-f0-9]{3}-?[89ab][a-f0-9]{3}-?[a-f0-9]{12}$/.test(
+ hash
+ )
+ ) {
+ const _hash = await uuid();
+
data[_hash] = data[hash];
data[_hash].hash = _hash;
delete data[hash];
- }
- if (data[_hash]) {
data[_hash].secret = encryption.getEncryptedString(
data[_hash].secret
);
@@ -315,28 +415,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 +438,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 +451,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 +471,7 @@ export class EntryStorage {
);
}
- static get(encryption: Encryption) {
+ static get() {
return new Promise(
(
resolve: (value: OTPEntry[]) => void,
@@ -389,21 +480,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 +510,6 @@ export class EntryStorage {
// and save it
type = OTPType.totp;
entryData.type = OTPType[OTPType.totp];
- needMigrate = true;
}
let period = 30;
@@ -444,27 +532,12 @@ 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.sort((a, b) => {
- return a.index - b.index;
- });
+ data.push(entry);
- 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;
- }
+ data.sort((a, b) => {
+ return a.index - b.index;
+ });
}
return resolve(data);
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 499802dc2..fa6094178 100644
--- a/src/store/Accounts.ts
+++ b/src/store/Accounts.ts
@@ -1,4 +1,4 @@
-import { EntryStorage } from "../models/storage";
+import { EntryStorage, BrowserStorage } from "../models/storage";
import { Encryption } from "../models/encryption";
import * as CryptoJS from "crypto-js";
import { OTPType, CodeState } from "../models/otp";
@@ -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 === CodeState.Encrypted) {
@@ -34,8 +32,10 @@ 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),
+ key: await BrowserStorage.getKey(),
+ wrongPassword: false
},
getters: {
shouldFilter(
@@ -116,12 +116,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(
@@ -147,9 +141,51 @@ export class Accounts implements IModule {
exportData: { [k: string]: IOTPEntry }
) {
state.exportEncData = exportData;
+ },
+ updateKeyExport(
+ state: AccountsState,
+ key: { enc: string; hash: string } | null
+ ) {
+ state.key = key;
+ },
+ wrongPassword(state: AccountsState) {
+ state.wrongPassword = true;
}
},
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,55 +194,198 @@ export class Accounts implements IModule {
return;
}
- state.state.encryption.updateEncryptionPassword(password);
- await state.dispatch("updateEntries");
- state.commit("style/hideInfo", null, { root: true });
+ state.commit("currentView/changeView", "LoadingPage", { root: true });
- if (!state.getters.currentlyEncrypted) {
- chrome.runtime.sendMessage({
- action: "cachePassphrase",
- value: password
+ const encKey = await BrowserStorage.getKey();
+ if (!encKey) {
+ // --- migrate to key
+ // verify current password
+ state.state.encryption.updateEncryptionPassword(password);
+ await state.dispatch("updateEntries");
+
+ if (state.getters.currentlyEncrypted) {
+ state.commit("style/hideInfo", true, { root: true });
+ return;
+ }
+ // gen key
+ const randomKey = crypto.getRandomValues(new Uint32Array(30));
+ const wordArray = CryptoJS.lib.WordArray.create(randomKey);
+ const encKey = CryptoJS.AES.encrypt(wordArray, password).toString();
+ const encKeyHash = await new Promise(
+ (resolve: (value: string) => void) => {
+ const iframe = document.getElementById("argon-sandbox");
+ const message = {
+ action: "hash",
+ value: wordArray.toString()
+ };
+ if (iframe) {
+ window.addEventListener("message", response => {
+ resolve(response.data.response);
+ });
+ //@ts-ignore
+ iframe.contentWindow.postMessage(message, "*");
+ }
+ }
+ );
+
+ if (!encKeyHash) {
+ state.commit("style/hideInfo", true, { root: true });
+ return;
+ }
+
+ // store key
+ await BrowserStorage.set({
+ key: { enc: encKey, hash: encKeyHash }
});
+ // change entry encryption to key and remove old hash
+ for (const entry of state.state.entries) {
+ await entry.changeEncryption(
+ new Encryption(wordArray.toString())
+ );
+ await entry.genUUID();
+ }
+
+ state.state.encryption.updateEncryptionPassword(
+ wordArray.toString()
+ );
+ await state.dispatch("updateEntries");
+ } else {
+ // --- decrypt using key
+ const key = CryptoJS.AES.decrypt(encKey.enc, password).toString();
+ const isCorrectPassword = await new Promise(
+ (resolve: (value: string) => void) => {
+ const iframe = document.getElementById("argon-sandbox");
+ const message = {
+ action: "verify",
+ value: key,
+ hash: encKey.hash
+ };
+ if (iframe) {
+ window.addEventListener("message", response => {
+ resolve(response.data.response);
+ });
+ //@ts-ignore
+ iframe.contentWindow.postMessage(message, "*");
+ }
+ }
+ );
+
+ if (!isCorrectPassword) {
+ state.commit("wrongPassword");
+ state.commit("currentView/changeView", "EnterPasswordPage", {
+ root: true
+ });
+ return;
+ }
+
+ state.state.encryption.updateEncryptionPassword(key);
+ await state.dispatch("updateEntries");
+
+ if (!state.getters.currentlyEncrypted) {
+ chrome.runtime.sendMessage({
+ action: "cachePassphrase",
+ value: key
+ });
+ }
}
+ state.commit("style/hideInfo", true, { root: true });
return;
},
changePassphrase: async (
state: ActionContext,
password: string
) => {
- await EntryStorage.import(
- new Encryption(password),
- await EntryStorage.getExport(state.state.encryption as Encryption)
- );
+ if (password) {
+ const randomKey = crypto.getRandomValues(new Uint32Array(30));
+ const wordArray = CryptoJS.lib.WordArray.create(randomKey);
+ const encKey = CryptoJS.AES.encrypt(wordArray, password).toString();
+ const encKeyHash = await new Promise(
+ (resolve: (value: string) => void) => {
+ const iframe = document.getElementById("argon-sandbox");
+ const message = {
+ action: "hash",
+ value: wordArray.toString()
+ };
+ if (iframe) {
+ window.addEventListener("message", response => {
+ resolve(response.data.response);
+ });
+ //@ts-ignore
+ iframe.contentWindow.postMessage(message, "*");
+ }
+ }
+ );
+
+ if (!encKeyHash) {
+ return;
+ }
- state.state.encryption.updateEncryptionPassword(password);
- chrome.runtime.sendMessage({
- action: "cachePassphrase",
- value: password
- });
+ // store key
+ await BrowserStorage.set({
+ key: { enc: encKey, hash: encKeyHash }
+ });
+ // change entry encryption and regen hash
+ for (const entry of state.state.entries) {
+ await entry.changeEncryption(
+ new Encryption(wordArray.toString())
+ );
+ await entry.genUUID();
+ }
+
+ state.state.encryption.updateEncryptionPassword(
+ wordArray.toString()
+ );
+
+ await state.dispatch("updateEntries");
+
+ // https://github.com/Authenticator-Extension/Authenticator/issues/412
+ if (navigator.userAgent.indexOf("Chrome") !== -1) {
+ await BrowserStorage.clearLogs();
+ }
- await state.dispatch("updateEntries");
+ chrome.runtime.sendMessage({
+ action: "cachePassphrase",
+ value: wordArray.toString()
+ });
+ } else {
+ for (const entry of state.state.entries) {
+ await entry.changeEncryption(new Encryption(""));
+ }
+
+ state.state.encryption.updateEncryptionPassword("");
+
+ BrowserStorage.remove("key");
+
+ await state.dispatch("updateEntries");
+
+ chrome.runtime.sendMessage({
+ action: "lock"
+ });
+ }
// 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)
);
+ state.commit("updateKeyExport", await BrowserStorage.getKey());
return;
},
clearFilter: (state: ActionContext) => {
@@ -350,20 +529,18 @@ export class Accounts implements IModule {
}
private getCachedPassphrase() {
- return new Promise(
- (resolve: (value: string) => void, reject: (reason: Error) => void) => {
- chrome.runtime.sendMessage(
- { action: "passphrase" },
- (passphrase: string) => {
- return resolve(passphrase);
- }
- );
- }
- );
+ return new Promise((resolve: (value: string) => void) => {
+ chrome.runtime.sendMessage(
+ { action: "passphrase" },
+ (passphrase: string) => {
+ return resolve(passphrase);
+ }
+ );
+ });
}
- 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/view/argon.html b/view/argon.html
new file mode 100644
index 000000000..eb1dc47ac
--- /dev/null
+++ b/view/argon.html
@@ -0,0 +1,7 @@
+
+
+
+
+
+
+
diff --git a/view/popup.html b/view/popup.html
index 2b4c75747..e1ad783f8 100644
--- a/view/popup.html
+++ b/view/popup.html
@@ -3,13 +3,19 @@
-
+
+