bitwarden-estensione-browser/src/background/runtime.background.ts

443 lines
18 KiB
TypeScript
Raw Normal View History

2018-01-09 20:26:20 +01:00
import { CipherType } from 'jslib/enums';
2018-01-24 19:27:58 +01:00
import { CipherView } from 'jslib/models/view/cipherView';
import { LoginUriView } from 'jslib/models/view/loginUriView';
2018-01-24 19:27:58 +01:00
import { LoginView } from 'jslib/models/view/loginView';
import { ConstantsService } from 'jslib/services/constants.service';
2018-01-09 20:26:20 +01:00
2018-04-11 20:52:49 +02:00
import { I18nService } from 'jslib/abstractions/i18n.service';
2018-01-26 16:48:32 +01:00
import { Analytics } from 'jslib/misc';
2018-01-09 20:26:20 +01:00
import {
2018-01-10 05:05:46 +01:00
CipherService,
StorageService,
2018-01-09 20:26:20 +01:00
} from 'jslib/abstractions';
2017-12-07 21:36:24 +01:00
2018-01-12 17:09:30 +01:00
import { BrowserApi } from '../browser/browserApi';
2017-12-07 21:36:24 +01:00
import MainBackground from './main.background';
2018-01-11 20:45:27 +01:00
import { AutofillService } from '../services/abstractions/autofill.service';
2018-04-10 20:20:03 +02:00
import BrowserPlatformUtilsService from '../services/browserPlatformUtils.service';
2018-01-05 22:30:15 +01:00
2018-04-23 19:04:11 +02:00
import { Utils } from 'jslib/misc/utils';
export default class RuntimeBackground {
private runtime: any;
2018-04-06 17:48:45 +02:00
private autofillTimeout: any;
2017-12-07 21:36:24 +01:00
private pageDetailsToAutoFill: any[] = [];
private isSafari: boolean;
private onInstalledReason: string = null;
2017-12-07 21:36:24 +01:00
constructor(private main: MainBackground, private autofillService: AutofillService,
2018-04-10 20:20:03 +02:00
private cipherService: CipherService, private platformUtilsService: BrowserPlatformUtilsService,
2018-04-11 20:52:49 +02:00
private storageService: StorageService, private i18nService: I18nService, private analytics: Analytics) {
this.isSafari = this.platformUtilsService.isSafari();
this.runtime = this.isSafari ? safari.application : chrome.runtime;
// onInstalled listener must be wired up before anything else, so we do it in the ctor
if (!this.isSafari) {
this.runtime.onInstalled.addListener((details: any) => {
this.onInstalledReason = details.reason;
});
}
}
async init() {
2017-12-07 21:36:24 +01:00
if (!this.runtime) {
return;
}
if (this.isSafari) {
// Reload the popup when it's opened
this.runtime.addEventListener('popover', (event: any) => {
const win: Window = event.target.contentWindow;
2018-01-13 03:20:49 +01:00
let href = win.location.href;
if (href.indexOf('#') > -1) {
href = href.substr(0, href.indexOf('#'));
}
2018-01-12 19:27:40 +01:00
if (win.location.toString() === href) {
2018-01-12 18:41:51 +01:00
win.location.reload();
} else {
win.location.href = href;
}
}, true);
2017-12-07 21:46:56 +01:00
}
2018-01-16 06:03:17 +01:00
await this.checkOnInstalled();
2018-01-12 21:29:01 +01:00
BrowserApi.messageListener(async (msg: any, sender: any, sendResponse: any) => {
2018-01-12 21:20:19 +01:00
await this.processMessage(msg, sender, sendResponse);
});
}
2017-12-07 21:36:24 +01:00
2018-01-14 00:16:19 +01:00
async processMessage(msg: any, sender: any, sendResponse: any) {
2018-01-12 21:20:19 +01:00
switch (msg.command) {
case 'loggedIn':
case 'unlocked':
case 'locked':
await this.main.setIcon();
2018-03-04 04:48:38 +01:00
await this.main.refreshBadgeAndMenu(msg.command === 'locked');
2018-01-12 21:20:19 +01:00
break;
case 'logout':
await this.main.logout(msg.expired);
break;
case 'syncCompleted':
if (msg.successfully) {
setTimeout(async () => await this.main.refreshBadgeAndMenu(), 2000);
}
break;
2018-01-18 22:17:58 +01:00
case 'openPopup':
await this.main.openPopup();
break;
2018-04-10 20:20:03 +02:00
case 'showDialogResolve':
this.platformUtilsService.resolveDialogPromise(msg.dialogId, msg.confirmed);
break;
2018-01-13 16:13:31 +01:00
case 'bgGetDataForTab':
await this.getDataForTab(sender.tab, msg.responseCommand);
break;
2018-01-12 21:20:19 +01:00
case 'bgOpenNotificationBar':
await BrowserApi.tabSendMessageData(sender.tab, 'openNotificationBar', msg.data);
break;
case 'bgCloseNotificationBar':
await BrowserApi.tabSendMessageData(sender.tab, 'closeNotificationBar');
break;
case 'bgAdjustNotificationBar':
await BrowserApi.tabSendMessageData(sender.tab, 'adjustNotificationBar', msg.data);
break;
case 'bgCollectPageDetails':
this.main.collectPageDetailsForContentScript(sender.tab, msg.sender, sender.frameId);
break;
case 'bgAddLogin':
await this.addLogin(msg.login, sender.tab);
break;
2018-08-01 05:24:11 +02:00
case 'bgChangedPassword':
await this.changedPassword(msg.data, sender.tab);
break;
2018-01-12 21:20:19 +01:00
case 'bgAddClose':
2018-08-01 05:24:11 +02:00
case 'bgChangeClose':
this.removeTabFromNotificationQueue(sender.tab);
2018-01-12 21:20:19 +01:00
break;
case 'bgAddSave':
await this.saveAddLogin(sender.tab);
break;
2018-08-01 05:24:11 +02:00
case 'bgChangeSave':
await this.saveChangePassword(sender.tab);
break;
2018-01-12 21:20:19 +01:00
case 'bgNeverSave':
await this.saveNever(sender.tab);
break;
case 'bgUpdateContextMenu':
await this.main.refreshBadgeAndMenu();
break;
case 'collectPageDetailsResponse':
switch (msg.sender) {
case 'notificationBar':
const forms = this.autofillService.getFormsWithPasswordFields(msg.details);
await BrowserApi.tabSendMessageData(msg.tab, 'notificationBarPageDetails', {
details: msg.details,
forms: forms,
});
break;
case 'autofiller':
case 'autofill_cmd':
const totpCode = await this.autofillService.doAutoFillForLastUsedLogin([{
2018-01-12 21:20:19 +01:00
frameId: sender.frameId,
tab: msg.tab,
details: msg.details,
}], msg.sender === 'autofill_cmd');
if (totpCode !== null && !this.platformUtilsService.isFirefox()) {
this.platformUtilsService.copyToClipboard(totpCode);
}
2018-01-12 21:20:19 +01:00
break;
case 'contextMenu':
clearTimeout(this.autofillTimeout);
this.pageDetailsToAutoFill.push({
frameId: sender.frameId,
tab: msg.tab,
details: msg.details,
});
this.autofillTimeout = setTimeout(async () => await this.autofillPage(), 300);
break;
default:
break;
}
break;
default:
break;
}
}
2017-12-07 21:36:24 +01:00
private async autofillPage() {
const totpCode = await this.autofillService.doAutoFill({
2017-12-07 21:36:24 +01:00
cipher: this.main.loginToAutoFill,
pageDetails: this.pageDetailsToAutoFill,
});
if (totpCode !== null && !this.platformUtilsService.isFirefox()) {
this.platformUtilsService.copyToClipboard(totpCode);
}
2017-12-07 21:36:24 +01:00
// reset
this.main.loginToAutoFill = null;
this.pageDetailsToAutoFill = [];
}
private async saveAddLogin(tab: any) {
2018-08-01 05:24:11 +02:00
for (let i = this.main.notificationQueue.length - 1; i >= 0; i--) {
const queueMessage = this.main.notificationQueue[i];
if (queueMessage.tabId !== tab.id || queueMessage.type !== 'addLogin') {
2017-12-07 21:36:24 +01:00
continue;
}
2018-01-05 22:30:15 +01:00
const tabDomain = this.platformUtilsService.getDomain(tab.url);
2018-08-01 05:24:11 +02:00
if (tabDomain != null && tabDomain !== queueMessage.domain) {
2017-12-07 21:36:24 +01:00
continue;
}
2018-08-01 05:24:11 +02:00
this.main.notificationQueue.splice(i, 1);
BrowserApi.tabSendMessageData(tab, 'closeNotificationBar');
2017-12-07 21:36:24 +01:00
2018-01-24 19:27:58 +01:00
const loginModel = new LoginView();
const loginUri = new LoginUriView();
2018-08-01 05:24:11 +02:00
loginUri.uri = queueMessage.uri;
loginModel.uris = [loginUri];
2018-08-01 05:24:11 +02:00
loginModel.username = queueMessage.username;
loginModel.password = queueMessage.password;
2018-01-24 19:27:58 +01:00
const model = new CipherView();
2018-08-01 05:24:11 +02:00
model.name = Utils.getHostname(queueMessage.uri) || queueMessage.domain;
2018-01-24 19:27:58 +01:00
model.type = CipherType.Login;
model.login = loginModel;
2017-12-07 21:36:24 +01:00
2018-01-24 19:27:58 +01:00
const cipher = await this.cipherService.encrypt(model);
2017-12-07 21:36:24 +01:00
await this.cipherService.saveWithServer(cipher);
2018-01-19 22:19:24 +01:00
this.analytics.ga('send', {
2017-12-07 21:36:24 +01:00
hitType: 'event',
eventAction: 'Added Login from Notification Bar',
});
}
}
2018-08-01 05:24:11 +02:00
private async saveChangePassword(tab: any) {
for (let i = this.main.notificationQueue.length - 1; i >= 0; i--) {
const queueMessage = this.main.notificationQueue[i];
if (queueMessage.tabId !== tab.id || queueMessage.type !== 'changePassword') {
continue;
}
const tabDomain = this.platformUtilsService.getDomain(tab.url);
if (tabDomain != null && tabDomain !== queueMessage.domain) {
continue;
}
this.main.notificationQueue.splice(i, 1);
BrowserApi.tabSendMessageData(tab, 'closeNotificationBar');
2018-08-01 05:24:11 +02:00
const cipher = await this.cipherService.get(queueMessage.cipherId);
if (cipher != null && cipher.type === CipherType.Login) {
const model = await cipher.decrypt();
model.login.password = queueMessage.newPassword;
const newCipher = await this.cipherService.encrypt(model);
await this.cipherService.saveWithServer(newCipher);
this.analytics.ga('send', {
hitType: 'event',
eventAction: 'Changed Password from Notification Bar',
});
}
}
}
2017-12-07 21:36:24 +01:00
private async saveNever(tab: any) {
2018-08-01 05:24:11 +02:00
for (let i = this.main.notificationQueue.length - 1; i >= 0; i--) {
const queueMessage = this.main.notificationQueue[i];
if (queueMessage.tabId !== tab.id || queueMessage.type !== 'addLogin') {
2017-12-07 21:36:24 +01:00
continue;
}
2018-01-05 22:30:15 +01:00
const tabDomain = this.platformUtilsService.getDomain(tab.url);
2018-08-01 05:24:11 +02:00
if (tabDomain != null && tabDomain !== queueMessage.domain) {
2017-12-07 21:36:24 +01:00
continue;
}
2018-08-01 05:24:11 +02:00
this.main.notificationQueue.splice(i, 1);
BrowserApi.tabSendMessageData(tab, 'closeNotificationBar');
2018-04-23 19:04:11 +02:00
const hostname = Utils.getHostname(tab.url);
2017-12-07 21:36:24 +01:00
await this.cipherService.saveNeverDomain(hostname);
}
}
private async addLogin(loginInfo: any, tab: any) {
2018-01-05 22:30:15 +01:00
const loginDomain = this.platformUtilsService.getDomain(loginInfo.url);
2017-12-07 21:36:24 +01:00
if (loginDomain == null) {
return;
}
const ciphers = await this.cipherService.getAllDecryptedForUrl(loginInfo.url);
2018-08-06 19:37:29 +02:00
const usernameMatches = ciphers.filter((c) => c.login.username === loginInfo.username);
if (usernameMatches.length === 0) {
2018-08-01 05:24:11 +02:00
// remove any old messages for this tab
this.removeTabFromNotificationQueue(tab);
this.main.notificationQueue.push({
type: 'addLogin',
2017-12-07 21:36:24 +01:00
username: loginInfo.username,
password: loginInfo.password,
domain: loginDomain,
uri: loginInfo.url,
tabId: tab.id,
expires: new Date((new Date()).getTime() + 30 * 60000), // 30 minutes
});
2018-08-01 05:24:11 +02:00
await this.main.checkNotificationQueue(tab);
2018-08-06 19:37:29 +02:00
} else if (usernameMatches.length === 1 && usernameMatches[0].login.password !== loginInfo.password) {
this.addChangedPasswordToQueue(usernameMatches[0].id, loginDomain, loginInfo.password, tab);
2018-08-01 05:24:11 +02:00
}
}
2017-12-07 21:36:24 +01:00
2018-08-01 05:24:11 +02:00
private async changedPassword(changeData: any, tab: any) {
const loginDomain = this.platformUtilsService.getDomain(changeData.url);
if (loginDomain == null) {
return;
}
const ciphers = await this.cipherService.getAllDecryptedForUrl(changeData.url);
2018-08-06 19:37:29 +02:00
const passwordMatches = ciphers.filter((c) => c.login.password === changeData.currentPassword);
if (passwordMatches.length === 1) {
this.addChangedPasswordToQueue(passwordMatches[0].id, loginDomain, changeData.newPassword, tab);
2017-12-07 21:36:24 +01:00
}
}
2018-08-06 19:37:29 +02:00
private async addChangedPasswordToQueue(cipherId: string, loginDomain: string, newPassword: string, tab: any) {
// remove any old messages for this tab
this.removeTabFromNotificationQueue(tab);
this.main.notificationQueue.push({
type: 'changePassword',
cipherId: cipherId,
newPassword: newPassword,
domain: loginDomain,
tabId: tab.id,
expires: new Date((new Date()).getTime() + 30 * 60000), // 30 minutes
});
await this.main.checkNotificationQueue(tab);
}
2018-08-01 05:24:11 +02:00
private removeTabFromNotificationQueue(tab: any) {
for (let i = this.main.notificationQueue.length - 1; i >= 0; i--) {
if (this.main.notificationQueue[i].tabId === tab.id) {
this.main.notificationQueue.splice(i, 1);
2017-12-07 21:36:24 +01:00
}
}
}
2018-01-16 06:03:17 +01:00
private async checkOnInstalled() {
if (this.isSafari) {
2018-02-16 21:50:23 +01:00
const installedVersion = await this.storageService.get<string>(ConstantsService.installedVersionKey);
2018-01-16 06:03:17 +01:00
if (installedVersion == null) {
this.onInstalledReason = 'install';
2018-01-16 06:03:17 +01:00
} else if (BrowserApi.getApplicationVersion() !== installedVersion) {
this.onInstalledReason = 'update';
2018-01-16 06:03:17 +01:00
}
if (this.onInstalledReason != null) {
2018-02-16 21:50:23 +01:00
await this.storageService.save(ConstantsService.installedVersionKey,
BrowserApi.getApplicationVersion());
2018-01-16 06:03:17 +01:00
}
}
2018-01-16 06:03:17 +01:00
setTimeout(async () => {
if (this.onInstalledReason != null) {
if (this.onInstalledReason === 'install') {
BrowserApi.createNewTab('https://bitwarden.com/browser-start/');
2018-01-18 04:42:31 +01:00
await this.setDefaultSettings();
2018-01-19 17:42:35 +01:00
} else if (this.onInstalledReason === 'update') {
await this.reseedStorage();
2018-01-16 06:03:17 +01:00
}
2018-01-19 22:19:24 +01:00
this.analytics.ga('send', {
2018-01-19 17:42:35 +01:00
hitType: 'event',
eventAction: 'onInstalled ' + this.onInstalledReason,
});
this.onInstalledReason = null;
}
2018-01-19 17:42:35 +01:00
}, 100);
}
private async reseedStorage() {
if (!this.platformUtilsService.isChrome() && !this.platformUtilsService.isVivaldi() &&
!this.platformUtilsService.isOpera()) {
return;
}
const currentLockOption = await this.storageService.get<number>(ConstantsService.lockOptionKey);
if (currentLockOption == null) {
return;
}
const reseed124Key = 'reseededStorage124';
2018-01-19 17:46:32 +01:00
const reseeded124 = await this.storageService.get<boolean>(reseed124Key);
2018-01-19 17:42:35 +01:00
if (reseeded124) {
return;
}
const getStorage = (): Promise<any> => new Promise((resolve) => {
chrome.storage.local.get(null, (o: any) => resolve(o));
});
const clearStorage = (): Promise<void> => new Promise((resolve) => {
chrome.storage.local.clear(() => resolve());
});
const storage = await getStorage();
await clearStorage();
for (const key in storage) {
if (!storage.hasOwnProperty(key)) {
continue;
}
await this.storageService.save(key, storage[key]);
}
await this.storageService.save(reseed124Key, true);
2018-01-16 06:03:17 +01:00
}
2018-01-18 04:42:31 +01:00
private async setDefaultSettings() {
// Default lock options to "on restart".
const currentLockOption = await this.storageService.get<number>(ConstantsService.lockOptionKey);
if (currentLockOption == null) {
await this.storageService.save(ConstantsService.lockOptionKey, -1);
}
}
2018-01-13 16:13:31 +01:00
private async getDataForTab(tab: any, responseCommand: string) {
2018-01-13 21:09:05 +01:00
const responseData: any = {};
2018-01-13 16:13:31 +01:00
if (responseCommand === 'notificationBarDataResponse') {
2018-01-13 21:09:05 +01:00
responseData.neverDomains = await this.storageService.get<any>(ConstantsService.neverDomainsKey);
responseData.disabledAddLoginNotification = await this.storageService.get<boolean>(
2018-01-13 16:13:31 +01:00
ConstantsService.disableAddLoginNotificationKey);
responseData.disabledChangedPasswordNotification = await this.storageService.get<boolean>(
ConstantsService.disableChangedPasswordNotificationKey);
2018-01-13 16:13:31 +01:00
} else if (responseCommand === 'autofillerAutofillOnPageLoadEnabledResponse') {
2018-01-13 21:09:05 +01:00
responseData.autofillEnabled = await this.storageService.get<boolean>(
2018-01-13 16:13:31 +01:00
ConstantsService.enableAutoFillOnPageLoadKey);
2018-01-13 21:09:05 +01:00
} else if (responseCommand === 'notificationBarFrameDataResponse') {
responseData.i18n = {
2018-04-11 20:52:49 +02:00
appName: this.i18nService.t('appName'),
close: this.i18nService.t('close'),
yes: this.i18nService.t('yes'),
never: this.i18nService.t('never'),
notificationAddSave: this.i18nService.t('notificationAddSave'),
notificationNeverSave: this.i18nService.t('notificationNeverSave'),
notificationAddDesc: this.i18nService.t('notificationAddDesc'),
2018-08-01 05:24:11 +02:00
notificationChangeSave: this.i18nService.t('notificationChangeSave'),
notificationChangeDesc: this.i18nService.t('notificationChangeDesc'),
2018-01-13 21:09:05 +01:00
};
2018-01-13 16:13:31 +01:00
}
2018-01-13 21:09:05 +01:00
await BrowserApi.tabSendMessageData(tab, responseCommand, responseData);
2018-01-13 16:13:31 +01:00
}
}