- +
- - - - - - - - - - - - - - - + + + + +
+ {{ "accountLimitReached" | i18n }} +
+ {{ "setYourPinCode" | i18n }} +
{{ "newAroundHere" | i18n }} - {{ "createAccount" | i18n }} + {{ "createAccount" | i18n }}
+ {{ + fido2Data.isFido2Session + ? ("yourPasskeyIsLocked" | i18n) + : ("yourVaultIsLocked" | i18n) + }} +
{{ "yourVaultIsLocked" | i18n }}
- {{ "logOut" | i18n }} -
- {{ "awaitDesktop" | i18n }} -
+ {{ "logOut" | i18n }} +
+ {{ "awaitDesktop" | i18n }} +
{{ "loginInitiated" | i18n }}
{{ "uncheckIfPublicDevice" | i18n }}
{{ "loggingInAs" | i18n }} {{ data.userEmail }}
{{ "notificationSentDevice" | i18n }}
+ {{ "fingerprintMatchInfo" | i18n }} +
+ {{ fingerprintPhrase }} +
{{ fingerprintPhrase }}
{{ "adminApprovalRequested" | i18n }}
{{ "adminApprovalRequestSentToAdmins" | i18n }}
{{ "youWillBeNotifiedOnceApproved" | i18n }}
{{ "logInInitiated" | i18n }}
- {{ "fingerprintMatchInfo" | i18n }} -
- {{ fingerprintPhrase }} -
{{ "convertOrganizationEncryptionDesc" | i18n : organization.name }}
{{ "convertOrganizationEncryptionDesc" | i18n: organization.name }}
+ {{ "orgPermissionsUpdatedMustSetPassword" | i18n }} +
{{ "orgRequiresYouToSetPassword" | i18n }}
{{ "insertYubiKey" | i18n }}
{{ "webAuthnNewTab" | i18n }}
+ {{ "duoRequiredForAccount" | i18n }} +
+ {{ "popoutTheExtensionToCompleteLogin" | i18n }} +
{{ "launchDuoAndFollowStepsToFinishLoggingIn" | i18n }}
{{ "noTwoStepProviders" | i18n }}
{{ "noTwoStepProviders2" | i18n }}
- - {{ "useAnotherTwoStepMethod" | i18n }} + + + {{ "launchDuo" | i18n }} -
{{ "sendVerificationCodeEmailAgain" | i18n }} diff --git a/apps/browser/src/auth/popup/two-factor.component.ts b/apps/browser/src/auth/popup/two-factor.component.ts index 21a2bd42f8..98363bc93c 100644 --- a/apps/browser/src/auth/popup/two-factor.component.ts +++ b/apps/browser/src/auth/popup/two-factor.component.ts @@ -1,16 +1,23 @@ -import { Component } from "@angular/core"; +import { Component, Inject } from "@angular/core"; import { ActivatedRoute, Router } from "@angular/router"; -import { first } from "rxjs/operators"; +import { Subject, Subscription, firstValueFrom } from "rxjs"; +import { filter, first, takeUntil } from "rxjs/operators"; import { TwoFactorComponent as BaseTwoFactorComponent } from "@bitwarden/angular/auth/components/two-factor.component"; -import { DialogServiceAbstraction, SimpleDialogType } from "@bitwarden/angular/services/dialog"; +import { WINDOW } from "@bitwarden/angular/services/injection-tokens"; +import { + LoginStrategyServiceAbstraction, + LoginEmailServiceAbstraction, + UserDecryptionOptionsServiceAbstraction, +} from "@bitwarden/auth/common"; import { ApiService } from "@bitwarden/common/abstractions/api.service"; -import { AuthService } from "@bitwarden/common/auth/abstractions/auth.service"; -import { LoginService } from "@bitwarden/common/auth/abstractions/login.service"; +import { AccountService } from "@bitwarden/common/auth/abstractions/account.service"; +import { InternalMasterPasswordServiceAbstraction } from "@bitwarden/common/auth/abstractions/master-password.service.abstraction"; +import { SsoLoginServiceAbstraction } from "@bitwarden/common/auth/abstractions/sso-login.service.abstraction"; import { TwoFactorService } from "@bitwarden/common/auth/abstractions/two-factor.service"; import { TwoFactorProviderType } from "@bitwarden/common/auth/enums/two-factor-provider-type"; import { AppIdService } from "@bitwarden/common/platform/abstractions/app-id.service"; -import { BroadcasterService } from "@bitwarden/common/platform/abstractions/broadcaster.service"; +import { ConfigService } from "@bitwarden/common/platform/abstractions/config/config.service"; import { EnvironmentService } from "@bitwarden/common/platform/abstractions/environment.service"; import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service"; import { LogService } from "@bitwarden/common/platform/abstractions/log.service"; @@ -18,57 +25,82 @@ import { MessagingService } from "@bitwarden/common/platform/abstractions/messag import { PlatformUtilsService } from "@bitwarden/common/platform/abstractions/platform-utils.service"; import { StateService } from "@bitwarden/common/platform/abstractions/state.service"; import { SyncService } from "@bitwarden/common/vault/abstractions/sync/sync.service.abstraction"; +import { DialogService } from "@bitwarden/components"; import { BrowserApi } from "../../platform/browser/browser-api"; -import { PopupUtilsService } from "../../popup/services/popup-utils.service"; +import { ZonedMessageListenerService } from "../../platform/browser/zoned-message-listener.service"; +import BrowserPopupUtils from "../../platform/popup/browser-popup-utils"; -const BroadcasterSubscriptionId = "TwoFactorComponent"; +import { closeTwoFactorAuthPopout } from "./utils/auth-popout-window"; @Component({ selector: "app-two-factor", templateUrl: "two-factor.component.html", }) export class TwoFactorComponent extends BaseTwoFactorComponent { - showNewWindowMessage = false; + private destroy$ = new Subject(); + inPopout = BrowserPopupUtils.inPopout(window); constructor( - authService: AuthService, + loginStrategyService: LoginStrategyServiceAbstraction, router: Router, i18nService: I18nService, apiService: ApiService, platformUtilsService: PlatformUtilsService, private syncService: SyncService, environmentService: EnvironmentService, - private broadcasterService: BroadcasterService, - private popupUtilsService: PopupUtilsService, stateService: StateService, route: ActivatedRoute, private messagingService: MessagingService, logService: LogService, twoFactorService: TwoFactorService, appIdService: AppIdService, - loginService: LoginService, - private dialogService: DialogServiceAbstraction + loginEmailService: LoginEmailServiceAbstraction, + userDecryptionOptionsService: UserDecryptionOptionsServiceAbstraction, + configService: ConfigService, + ssoLoginService: SsoLoginServiceAbstraction, + private dialogService: DialogService, + masterPasswordService: InternalMasterPasswordServiceAbstraction, + accountService: AccountService, + @Inject(WINDOW) protected win: Window, + private browserMessagingApi: ZonedMessageListenerService, ) { super( - authService, + loginStrategyService, router, i18nService, apiService, platformUtilsService, - window, + win, environmentService, stateService, route, logService, twoFactorService, appIdService, - loginService + loginEmailService, + userDecryptionOptionsService, + ssoLoginService, + configService, + masterPasswordService, + accountService, ); - super.onSuccessfulLogin = () => { - this.loginService.clearValues(); - return syncService.fullSync(true); + super.onSuccessfulLogin = async () => { + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + syncService.fullSync(true); }; + + super.onSuccessfulLoginTde = async () => { + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + syncService.fullSync(true); + }; + + super.onSuccessfulLoginTdeNavigate = async () => { + this.win.close(); + }; + super.successRoute = "/tabs/vault"; // FIXME: Chromium 110 has broken WebAuthn support in extensions via an iframe this.webAuthnNewTab = true; @@ -80,6 +112,8 @@ export class TwoFactorComponent extends BaseTwoFactorComponent { this.selectedProviderType = TwoFactorProviderType.WebAuthn; this.token = this.route.snapshot.paramMap.get("webAuthnResponse"); super.onSuccessfulLogin = async () => { + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises this.syncService.fullSync(true); this.messagingService.send("reloadPopup"); window.close(); @@ -102,26 +136,30 @@ export class TwoFactorComponent extends BaseTwoFactorComponent { if ( this.selectedProviderType === TwoFactorProviderType.Email && - this.popupUtilsService.inPopup(window) + BrowserPopupUtils.inPopup(window) ) { const confirmed = await this.dialogService.openSimpleDialog({ title: { key: "warning" }, content: { key: "popup2faCloseMessage" }, - type: SimpleDialogType.WARNING, + type: "warning", }); if (confirmed) { - this.popupUtilsService.popOut(window); + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + BrowserPopupUtils.openCurrentPagePopout(window); } } // eslint-disable-next-line rxjs-angular/prefer-takeuntil, rxjs/no-async-subscribe this.route.queryParams.pipe(first()).subscribe(async (qParams) => { if (qParams.sso === "true") { - super.onSuccessfulLogin = () => { + super.onSuccessfulLogin = async () => { // This is not awaited so we don't pause the application while the sync is happening. // This call is executed by the service that lives in the background script so it will continue // the sync even if this tab closes. - const syncPromise = this.syncService.fullSync(true); + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + this.syncService.fullSync(true); // Force sidebars (FF && Opera) to reload while exempting current window // because we are just going to close the current window. @@ -129,16 +167,15 @@ export class TwoFactorComponent extends BaseTwoFactorComponent { // We don't need this window anymore because the intent is for the user to be left // on the web vault screen which tells them to continue in the browser extension (sidebar or popup) - BrowserApi.closeBitwardenExtensionTab(); - - return syncPromise; + await closeTwoFactorAuthPopout(); }; } }); } async ngOnDestroy() { - this.broadcasterService.unsubscribe(BroadcasterSubscriptionId); + this.destroy$.next(); + this.destroy$.complete(); if (this.selectedProviderType === TwoFactorProviderType.WebAuthn && (await this.isLinux())) { document.body.classList.remove("linux-webauthn"); @@ -152,13 +189,59 @@ export class TwoFactorComponent extends BaseTwoFactorComponent { if (sso) { // We must persist this so when the user returns to the 2FA comp, the // proper onSuccessfulLogin logic is executed. + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises this.router.navigate(["2fa-options"], { queryParams: { sso: true } }); } else { + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises this.router.navigate(["2fa-options"]); } } + async popoutCurrentPage() { + await BrowserPopupUtils.openCurrentPagePopout(window); + } + async isLinux() { return (await BrowserApi.getPlatformInfo()).os === "linux"; } + + duoResultSubscription: Subscription; + protected override setupDuoResultListener() { + if (!this.duoResultSubscription) { + this.duoResultSubscription = this.browserMessagingApi + .messageListener$() + .pipe( + filter((msg: any) => msg.command === "duoResult"), + takeUntil(this.destroy$), + ) + .subscribe((msg: { command: string; code: string; state: string }) => { + this.token = msg.code + "|" + msg.state; + // This floating promise is intentional. We don't need to await the submit + awaiting in a subscription is not recommended. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + this.submit(); + }); + } + } + + override async launchDuoFrameless() { + const duoHandOffMessage = { + title: this.i18nService.t("youSuccessfullyLoggedIn"), + message: this.i18nService.t("youMayCloseThisWindow"), + isCountdown: false, + }; + + // we're using the connector here as a way to set a cookie with translations + // before continuing to the duo frameless url + const env = await firstValueFrom(this.environmentService.environment$); + const launchUrl = + env.getWebVaultUrl() + + "/duo-redirect-connector.html" + + "?duoFramelessUrl=" + + encodeURIComponent(this.duoFramelessUrl) + + "&handOffMessage=" + + encodeURIComponent(JSON.stringify(duoHandOffMessage)); + this.platformUtilsService.launchUri(launchUrl); + } } diff --git a/apps/browser/src/auth/popup/update-temp-password.component.ts b/apps/browser/src/auth/popup/update-temp-password.component.ts index f7d952b97f..465bc3f703 100644 --- a/apps/browser/src/auth/popup/update-temp-password.component.ts +++ b/apps/browser/src/auth/popup/update-temp-password.component.ts @@ -1,9 +1,29 @@ import { Component } from "@angular/core"; +import { firstValueFrom } from "rxjs"; import { UpdateTempPasswordComponent as BaseUpdateTempPasswordComponent } from "@bitwarden/angular/auth/components/update-temp-password.component"; +import { postLogoutMessageListener$ } from "./utils/post-logout-message-listener"; + @Component({ selector: "app-update-temp-password", templateUrl: "update-temp-password.component.html", }) -export class UpdateTempPasswordComponent extends BaseUpdateTempPasswordComponent {} +export class UpdateTempPasswordComponent extends BaseUpdateTempPasswordComponent { + onSuccessfulChangePassword: () => Promise = this.doOnSuccessfulChangePassword.bind(this); + + private async doOnSuccessfulChangePassword() { + // start listening for "switchAccountFinish" or "doneLoggingOut" + const messagePromise = firstValueFrom(postLogoutMessageListener$); + this.messagingService.send("logout"); + // wait for messages + const command = await messagePromise; + + // doneLoggingOut already has a message handler that will navigate us + if (command === "switchAccountFinish") { + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + this.router.navigate(["/"]); + } + } +} diff --git a/apps/browser/src/auth/popup/utils/auth-popout-window.spec.ts b/apps/browser/src/auth/popup/utils/auth-popout-window.spec.ts new file mode 100644 index 0000000000..9e7d69fad9 --- /dev/null +++ b/apps/browser/src/auth/popup/utils/auth-popout-window.spec.ts @@ -0,0 +1,118 @@ +import { createChromeTabMock } from "../../../autofill/spec/autofill-mocks"; +import { BrowserApi } from "../../../platform/browser/browser-api"; +import BrowserPopupUtils from "../../../platform/popup/browser-popup-utils"; + +import { + AuthPopoutType, + openUnlockPopout, + closeUnlockPopout, + openSsoAuthResultPopout, + openTwoFactorAuthPopout, + closeTwoFactorAuthPopout, +} from "./auth-popout-window"; + +describe("AuthPopoutWindow", () => { + const openPopoutSpy = jest.spyOn(BrowserPopupUtils, "openPopout").mockImplementation(); + const sendMessageDataSpy = jest.spyOn(BrowserApi, "tabSendMessageData").mockImplementation(); + const closeSingleActionPopoutSpy = jest + .spyOn(BrowserPopupUtils, "closeSingleActionPopout") + .mockImplementation(); + + afterEach(() => { + jest.clearAllMocks(); + }); + + describe("openUnlockPopout", () => { + let senderTab: chrome.tabs.Tab; + + beforeEach(() => { + senderTab = { windowId: 1 } as chrome.tabs.Tab; + }); + + it("opens a single action popup that allows the user to unlock the extension and sends a `bgUnlockPopoutOpened` message", async () => { + jest.spyOn(BrowserApi, "tabsQuery").mockResolvedValue([]); + + await openUnlockPopout(senderTab); + + expect(openPopoutSpy).toHaveBeenCalledWith("popup/index.html", { + singleActionKey: AuthPopoutType.unlockExtension, + senderWindowId: 1, + }); + expect(sendMessageDataSpy).toHaveBeenCalledWith(senderTab, "bgUnlockPopoutOpened", { + skipNotification: false, + }); + }); + + it("sends an indication that the presenting the notification bar for unlocking the extension should be skipped", async () => { + await openUnlockPopout(senderTab, true); + + expect(sendMessageDataSpy).toHaveBeenCalledWith(senderTab, "bgUnlockPopoutOpened", { + skipNotification: true, + }); + }); + + it("closes any existing popup window types that are open to the unlock extension route", async () => { + const unlockTab = createChromeTabMock({ + url: chrome.runtime.getURL("popup/index.html#/lock"), + }); + jest.spyOn(BrowserApi, "tabsQuery").mockResolvedValue([unlockTab]); + jest.spyOn(BrowserApi, "removeWindow"); + const senderTab = { windowId: 1 } as chrome.tabs.Tab; + + await openUnlockPopout(senderTab); + + expect(BrowserApi.tabsQuery).toHaveBeenCalledWith({ windowType: "popup" }); + expect(BrowserApi.removeWindow).toHaveBeenCalledWith(unlockTab.windowId); + }); + + it("closes any existing popup window types that are open to the login extension route", async () => { + const loginTab = createChromeTabMock({ + url: chrome.runtime.getURL("popup/index.html#/home"), + }); + jest.spyOn(BrowserApi, "tabsQuery").mockResolvedValue([loginTab]); + jest.spyOn(BrowserApi, "removeWindow"); + const senderTab = { windowId: 1 } as chrome.tabs.Tab; + + await openUnlockPopout(senderTab); + + expect(BrowserApi.removeWindow).toHaveBeenCalledWith(loginTab.windowId); + }); + }); + + describe("closeUnlockPopout", () => { + it("closes the unlock extension popout window", async () => { + await closeUnlockPopout(); + + expect(closeSingleActionPopoutSpy).toHaveBeenCalledWith(AuthPopoutType.unlockExtension); + }); + }); + + describe("openSsoAuthResultPopout", () => { + it("opens a window that facilitates presentation of the results for SSO authentication", async () => { + await openSsoAuthResultPopout({ code: "code", state: "state" }); + + expect(openPopoutSpy).toHaveBeenCalledWith("popup/index.html#/sso?code=code&state=state", { + singleActionKey: AuthPopoutType.ssoAuthResult, + }); + }); + }); + + describe("openTwoFactorAuthPopout", () => { + it("opens a window that facilitates two factor authentication", async () => { + await openTwoFactorAuthPopout({ data: "data", remember: "remember" }); + + expect(openPopoutSpy).toHaveBeenCalledWith( + "popup/index.html#/2fa;webAuthnResponse=data;remember=remember", + { singleActionKey: AuthPopoutType.twoFactorAuth }, + ); + }); + }); + + describe("closeTwoFactorAuthPopout", () => { + it("closes the two-factor authentication window", async () => { + await closeTwoFactorAuthPopout(); + + expect(closeSingleActionPopoutSpy).toHaveBeenCalledWith(AuthPopoutType.twoFactorAuth); + }); + }); +}); diff --git a/apps/browser/src/auth/popup/utils/auth-popout-window.ts b/apps/browser/src/auth/popup/utils/auth-popout-window.ts new file mode 100644 index 0000000000..b3807cf713 --- /dev/null +++ b/apps/browser/src/auth/popup/utils/auth-popout-window.ts @@ -0,0 +1,90 @@ +import { BrowserApi } from "../../../platform/browser/browser-api"; +import BrowserPopupUtils from "../../../platform/popup/browser-popup-utils"; + +const AuthPopoutType = { + unlockExtension: "auth_unlockExtension", + ssoAuthResult: "auth_ssoAuthResult", + twoFactorAuth: "auth_twoFactorAuth", +} as const; +const extensionUnlockUrls = new Set([ + chrome.runtime.getURL("popup/index.html#/lock"), + chrome.runtime.getURL("popup/index.html#/home"), +]); + +/** + * Opens a window that facilitates unlocking / logging into the extension. + * + * @param senderTab - Used to determine the windowId of the sender. + * @param skipNotification - Used to determine whether to show the unlock notification. + */ +async function openUnlockPopout(senderTab: chrome.tabs.Tab, skipNotification = false) { + const existingPopoutWindowTabs = await BrowserApi.tabsQuery({ windowType: "popup" }); + existingPopoutWindowTabs.forEach((tab) => { + if (extensionUnlockUrls.has(tab.url)) { + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + BrowserApi.removeWindow(tab.windowId); + } + }); + + await BrowserPopupUtils.openPopout("popup/index.html", { + singleActionKey: AuthPopoutType.unlockExtension, + senderWindowId: senderTab.windowId, + }); + await BrowserApi.tabSendMessageData(senderTab, "bgUnlockPopoutOpened", { skipNotification }); +} + +/** + * Closes the unlock popout window. + */ +async function closeUnlockPopout() { + await BrowserPopupUtils.closeSingleActionPopout(AuthPopoutType.unlockExtension); +} + +/** + * Opens a window that facilitates presenting the results for SSO authentication. + * + * @param resultData - The result data from the SSO authentication. + */ +async function openSsoAuthResultPopout(resultData: { code: string; state: string }) { + const { code, state } = resultData; + const authResultUrl = `popup/index.html#/sso?code=${encodeURIComponent( + code, + )}&state=${encodeURIComponent(state)}`; + + await BrowserPopupUtils.openPopout(authResultUrl, { + singleActionKey: AuthPopoutType.ssoAuthResult, + }); +} + +/** + * Opens a window that facilitates two-factor authentication. + * + * @param twoFactorAuthData - The data from the two-factor authentication. + */ +async function openTwoFactorAuthPopout(twoFactorAuthData: { data: string; remember: string }) { + const { data, remember } = twoFactorAuthData; + const params = + `webAuthnResponse=${encodeURIComponent(data)};` + `remember=${encodeURIComponent(remember)}`; + const twoFactorUrl = `popup/index.html#/2fa;${params}`; + + await BrowserPopupUtils.openPopout(twoFactorUrl, { + singleActionKey: AuthPopoutType.twoFactorAuth, + }); +} + +/** + * Closes the two-factor authentication popout window. + */ +async function closeTwoFactorAuthPopout() { + await BrowserPopupUtils.closeSingleActionPopout(AuthPopoutType.twoFactorAuth); +} + +export { + AuthPopoutType, + openUnlockPopout, + closeUnlockPopout, + openSsoAuthResultPopout, + openTwoFactorAuthPopout, + closeTwoFactorAuthPopout, +}; diff --git a/apps/browser/src/auth/popup/utils/post-logout-message-listener.ts b/apps/browser/src/auth/popup/utils/post-logout-message-listener.ts new file mode 100644 index 0000000000..1f6b805316 --- /dev/null +++ b/apps/browser/src/auth/popup/utils/post-logout-message-listener.ts @@ -0,0 +1,24 @@ +import { filter, map, throwError, timeout } from "rxjs"; + +import { fromChromeEvent } from "../../../platform/browser/from-chrome-event"; + +/** + * Listens to `switchAccountFinish` and `doneLoggingOut` messages and returns which message was heard. + * + * @example + * ```ts + * const messagePromise = firstValueFrom(postLogoutMessageListener$); + * this.messagingService.send("logout"); + * const message = await messagePromise; + * ``` + */ +export const postLogoutMessageListener$ = fromChromeEvent< + [message?: { command: "switchAccountFinish" | "doneLoggingOut" }] +>(chrome.runtime.onMessage).pipe( + map(([message]) => message?.command), + filter((command) => command === "switchAccountFinish" || command === "doneLoggingOut"), + timeout({ + first: 60_000, + with: () => throwError(() => new Error("Did not receive message from logout.")), + }), +); diff --git a/apps/browser/src/autofill/background/abstractions/notification.background.ts b/apps/browser/src/autofill/background/abstractions/notification.background.ts new file mode 100644 index 0000000000..e01e2c5c02 --- /dev/null +++ b/apps/browser/src/autofill/background/abstractions/notification.background.ts @@ -0,0 +1,135 @@ +import { NeverDomains } from "@bitwarden/common/models/domain/domain-service"; +import { ServerConfig } from "@bitwarden/common/platform/abstractions/config/server-config"; +import { FolderView } from "@bitwarden/common/vault/models/view/folder.view"; + +import { NotificationQueueMessageTypes } from "../../enums/notification-queue-message-type.enum"; +import AutofillPageDetails from "../../models/autofill-page-details"; + +interface NotificationQueueMessage { + type: NotificationQueueMessageTypes; + domain: string; + tab: chrome.tabs.Tab; + expires: Date; + wasVaultLocked: boolean; +} + +interface AddChangePasswordQueueMessage extends NotificationQueueMessage { + type: "change"; + cipherId: string; + newPassword: string; +} + +interface AddLoginQueueMessage extends NotificationQueueMessage { + type: "add"; + username: string; + password: string; + uri: string; +} + +interface AddUnlockVaultQueueMessage extends NotificationQueueMessage { + type: "unlock"; +} + +interface AddRequestFilelessImportQueueMessage extends NotificationQueueMessage { + type: "fileless-import"; + importType?: string; +} + +type NotificationQueueMessageItem = + | AddLoginQueueMessage + | AddChangePasswordQueueMessage + | AddUnlockVaultQueueMessage + | AddRequestFilelessImportQueueMessage; + +type LockedVaultPendingNotificationsData = { + commandToRetry: { + message: { + command: string; + contextMenuOnClickData?: chrome.contextMenus.OnClickData; + folder?: string; + edit?: boolean; + }; + sender: chrome.runtime.MessageSender; + }; + target: string; +}; + +type AdjustNotificationBarMessageData = { + height: number; +}; + +type ChangePasswordMessageData = { + currentPassword: string; + newPassword: string; + url: string; +}; + +type AddLoginMessageData = { + username: string; + password: string; + url: string; +}; + +type UnlockVaultMessageData = { + skipNotification?: boolean; +}; + +type NotificationBackgroundExtensionMessage = { + [key: string]: any; + command: string; + data?: Partial & + Partial & + Partial & + Partial; + login?: AddLoginMessageData; + folder?: string; + edit?: boolean; + details?: AutofillPageDetails; + tab?: chrome.tabs.Tab; + sender?: string; + notificationType?: string; +}; + +type SaveOrUpdateCipherResult = undefined | { error: string }; + +type BackgroundMessageParam = { message: NotificationBackgroundExtensionMessage }; +type BackgroundSenderParam = { sender: chrome.runtime.MessageSender }; +type BackgroundOnMessageHandlerParams = BackgroundMessageParam & BackgroundSenderParam; + +type NotificationBackgroundExtensionMessageHandlers = { + [key: string]: CallableFunction; + unlockCompleted: ({ message, sender }: BackgroundOnMessageHandlerParams) => Promise; + bgGetFolderData: ({ message, sender }: BackgroundOnMessageHandlerParams) => Promise; + bgCloseNotificationBar: ({ sender }: BackgroundSenderParam) => Promise; + bgAdjustNotificationBar: ({ message, sender }: BackgroundOnMessageHandlerParams) => Promise; + bgAddLogin: ({ message, sender }: BackgroundOnMessageHandlerParams) => Promise; + bgChangedPassword: ({ message, sender }: BackgroundOnMessageHandlerParams) => Promise; + bgRemoveTabFromNotificationQueue: ({ sender }: BackgroundSenderParam) => void; + bgSaveCipher: ({ message, sender }: BackgroundOnMessageHandlerParams) => void; + bgNeverSave: ({ sender }: BackgroundSenderParam) => Promise; + bgUnlockPopoutOpened: ({ message, sender }: BackgroundOnMessageHandlerParams) => Promise; + bgReopenUnlockPopout: ({ sender }: BackgroundSenderParam) => Promise; + checkNotificationQueue: ({ sender }: BackgroundSenderParam) => Promise; + collectPageDetailsResponse: ({ message }: BackgroundMessageParam) => Promise; + bgGetEnableChangedPasswordPrompt: () => Promise; + bgGetEnableAddedLoginPrompt: () => Promise; + bgGetExcludedDomains: () => Promise; + bgGetActiveUserServerConfig: () => Promise; + getWebVaultUrlForNotification: () => Promise; +}; + +export { + AddChangePasswordQueueMessage, + AddLoginQueueMessage, + AddUnlockVaultQueueMessage, + AddRequestFilelessImportQueueMessage, + NotificationQueueMessageItem, + LockedVaultPendingNotificationsData, + AdjustNotificationBarMessageData, + ChangePasswordMessageData, + UnlockVaultMessageData, + AddLoginMessageData, + SaveOrUpdateCipherResult, + NotificationBackgroundExtensionMessage, + NotificationBackgroundExtensionMessageHandlers, +}; diff --git a/apps/browser/src/autofill/background/abstractions/overlay.background.ts b/apps/browser/src/autofill/background/abstractions/overlay.background.ts new file mode 100644 index 0000000000..1ceeed60a9 --- /dev/null +++ b/apps/browser/src/autofill/background/abstractions/overlay.background.ts @@ -0,0 +1,129 @@ +import { CipherType } from "@bitwarden/common/vault/enums"; +import { CipherRepromptType } from "@bitwarden/common/vault/enums/cipher-reprompt-type"; + +import AutofillPageDetails from "../../models/autofill-page-details"; + +import { LockedVaultPendingNotificationsData } from "./notification.background"; + +type WebsiteIconData = { + imageEnabled: boolean; + image: string; + fallbackImage: string; + icon: string; +}; + +type OverlayAddNewItemMessage = { + login?: { + uri?: string; + hostname: string; + username: string; + password: string; + }; +}; + +type OverlayBackgroundExtensionMessage = { + [key: string]: any; + command: string; + tab?: chrome.tabs.Tab; + sender?: string; + details?: AutofillPageDetails; + overlayElement?: string; + display?: string; + data?: LockedVaultPendingNotificationsData; +} & OverlayAddNewItemMessage; + +type OverlayPortMessage = { + [key: string]: any; + command: string; + direction?: string; + overlayCipherId?: string; +}; + +type FocusedFieldData = { + focusedFieldStyles: Partial; + focusedFieldRects: Partial; +}; + +type OverlayCipherData = { + id: string; + name: string; + type: CipherType; + reprompt: CipherRepromptType; + favorite: boolean; + icon: { imageEnabled: boolean; image: string; fallbackImage: string; icon: string }; + login?: { username: string }; + card?: string; +}; + +type BackgroundMessageParam = { + message: OverlayBackgroundExtensionMessage; +}; +type BackgroundSenderParam = { + sender: chrome.runtime.MessageSender; +}; +type BackgroundOnMessageHandlerParams = BackgroundMessageParam & BackgroundSenderParam; + +type OverlayBackgroundExtensionMessageHandlers = { + [key: string]: CallableFunction; + openAutofillOverlay: () => void; + autofillOverlayElementClosed: ({ message }: BackgroundMessageParam) => void; + autofillOverlayAddNewVaultItem: ({ message, sender }: BackgroundOnMessageHandlerParams) => void; + getAutofillOverlayVisibility: () => void; + checkAutofillOverlayFocused: () => void; + focusAutofillOverlayList: () => void; + updateAutofillOverlayPosition: ({ message }: BackgroundMessageParam) => void; + updateAutofillOverlayHidden: ({ message }: BackgroundMessageParam) => void; + updateFocusedFieldData: ({ message }: BackgroundMessageParam) => void; + collectPageDetailsResponse: ({ message, sender }: BackgroundOnMessageHandlerParams) => void; + unlockCompleted: ({ message }: BackgroundMessageParam) => void; + addEditCipherSubmitted: () => void; + deletedCipher: () => void; +}; + +type PortMessageParam = { + message: OverlayPortMessage; +}; +type PortConnectionParam = { + port: chrome.runtime.Port; +}; +type PortOnMessageHandlerParams = PortMessageParam & PortConnectionParam; + +type OverlayButtonPortMessageHandlers = { + [key: string]: CallableFunction; + overlayButtonClicked: ({ port }: PortConnectionParam) => void; + closeAutofillOverlay: ({ port }: PortConnectionParam) => void; + forceCloseAutofillOverlay: ({ port }: PortConnectionParam) => void; + overlayPageBlurred: () => void; + redirectOverlayFocusOut: ({ message, port }: PortOnMessageHandlerParams) => void; +}; + +type OverlayListPortMessageHandlers = { + [key: string]: CallableFunction; + checkAutofillOverlayButtonFocused: () => void; + forceCloseAutofillOverlay: ({ port }: PortConnectionParam) => void; + overlayPageBlurred: () => void; + unlockVault: ({ port }: PortConnectionParam) => void; + fillSelectedListItem: ({ message, port }: PortOnMessageHandlerParams) => void; + addNewVaultItem: ({ port }: PortConnectionParam) => void; + viewSelectedCipher: ({ message, port }: PortOnMessageHandlerParams) => void; + redirectOverlayFocusOut: ({ message, port }: PortOnMessageHandlerParams) => void; +}; + +interface OverlayBackground { + init(): Promise; + removePageDetails(tabId: number): void; + updateOverlayCiphers(): void; +} + +export { + WebsiteIconData, + OverlayBackgroundExtensionMessage, + OverlayPortMessage, + FocusedFieldData, + OverlayCipherData, + OverlayAddNewItemMessage, + OverlayBackgroundExtensionMessageHandlers, + OverlayButtonPortMessageHandlers, + OverlayListPortMessageHandlers, + OverlayBackground, +}; diff --git a/apps/browser/src/autofill/background/context-menus.background.ts b/apps/browser/src/autofill/background/context-menus.background.ts index bc26353cbd..8d65e1c8c6 100644 --- a/apps/browser/src/autofill/background/context-menus.background.ts +++ b/apps/browser/src/autofill/background/context-menus.background.ts @@ -1,7 +1,8 @@ -import LockedVaultPendingNotificationsItem from "../../background/models/lockedVaultPendingNotificationsItem"; import { BrowserApi } from "../../platform/browser/browser-api"; import { ContextMenuClickedHandler } from "../browser/context-menu-clicked-handler"; +import { LockedVaultPendingNotificationsData } from "./abstractions/notification.background"; + export default class ContextMenusBackground { private contextMenus: typeof chrome.contextMenus; @@ -15,24 +16,30 @@ export default class ContextMenusBackground { } this.contextMenus.onClicked.addListener((info, tab) => - this.contextMenuClickedHandler.run(info, tab) + this.contextMenuClickedHandler.run(info, tab), ); BrowserApi.messageListener( "contextmenus.background", - async ( - msg: { command: string; data: LockedVaultPendingNotificationsItem }, + ( + msg: { command: string; data: LockedVaultPendingNotificationsData }, sender: chrome.runtime.MessageSender, - sendResponse: any ) => { if (msg.command === "unlockCompleted" && msg.data.target === "contextmenus.background") { - await this.contextMenuClickedHandler.cipherAction( - msg.data.commandToRetry.msg.data, - msg.data.commandToRetry.sender.tab - ); - await BrowserApi.tabSendMessageData(sender.tab, "closeNotificationBar"); + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + this.contextMenuClickedHandler + .cipherAction( + msg.data.commandToRetry.message.contextMenuOnClickData, + msg.data.commandToRetry.sender.tab, + ) + .then(() => { + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + BrowserApi.tabSendMessageData(sender.tab, "closeNotificationBar"); + }); } - } + }, ); } } diff --git a/apps/browser/src/autofill/background/notification.background.spec.ts b/apps/browser/src/autofill/background/notification.background.spec.ts new file mode 100644 index 0000000000..93750ece07 --- /dev/null +++ b/apps/browser/src/autofill/background/notification.background.spec.ts @@ -0,0 +1,1373 @@ +import { mock } from "jest-mock-extended"; +import { BehaviorSubject, firstValueFrom } from "rxjs"; + +import { PolicyService } from "@bitwarden/common/admin-console/services/policy/policy.service"; +import { AuthenticationStatus } from "@bitwarden/common/auth/enums/authentication-status"; +import { AuthService } from "@bitwarden/common/auth/services/auth.service"; +import { DomainSettingsService } from "@bitwarden/common/autofill/services/domain-settings.service"; +import { UserNotificationSettingsService } from "@bitwarden/common/autofill/services/user-notification-settings.service"; +import { ConfigService } from "@bitwarden/common/platform/abstractions/config/config.service"; +import { EnvironmentService } from "@bitwarden/common/platform/abstractions/environment.service"; +import { LogService } from "@bitwarden/common/platform/abstractions/log.service"; +import { SelfHostedEnvironment } from "@bitwarden/common/platform/services/default-environment.service"; +import { ThemeStateService } from "@bitwarden/common/platform/theming/theme-state.service"; +import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view"; +import { FolderView } from "@bitwarden/common/vault/models/view/folder.view"; +import { CipherService } from "@bitwarden/common/vault/services/cipher.service"; +import { FolderService } from "@bitwarden/common/vault/services/folder/folder.service"; + +import { BrowserApi } from "../../platform/browser/browser-api"; +import { DefaultBrowserStateService } from "../../platform/services/default-browser-state.service"; +import { NotificationQueueMessageType } from "../enums/notification-queue-message-type.enum"; +import { FormData } from "../services/abstractions/autofill.service"; +import AutofillService from "../services/autofill.service"; +import { createAutofillPageDetailsMock, createChromeTabMock } from "../spec/autofill-mocks"; +import { flushPromises, sendExtensionRuntimeMessage } from "../spec/testing-utils"; + +import { + AddChangePasswordQueueMessage, + AddLoginQueueMessage, + AddUnlockVaultQueueMessage, + LockedVaultPendingNotificationsData, + NotificationBackgroundExtensionMessage, +} from "./abstractions/notification.background"; +import NotificationBackground from "./notification.background"; + +jest.mock("rxjs", () => { + const rxjs = jest.requireActual("rxjs"); + const { firstValueFrom } = rxjs; + return { + ...rxjs, + firstValueFrom: jest.fn(firstValueFrom), + }; +}); + +describe("NotificationBackground", () => { + let notificationBackground: NotificationBackground; + const autofillService = mock(); + const cipherService = mock(); + const authService = mock(); + const policyService = mock(); + const folderService = mock(); + const stateService = mock(); + const userNotificationSettingsService = mock(); + const domainSettingsService = mock(); + const environmentService = mock(); + const logService = mock(); + const themeStateService = mock(); + const configService = mock(); + + beforeEach(() => { + notificationBackground = new NotificationBackground( + autofillService, + cipherService, + authService, + policyService, + folderService, + stateService, + userNotificationSettingsService, + domainSettingsService, + environmentService, + logService, + themeStateService, + configService, + ); + }); + + afterEach(() => { + jest.clearAllMocks(); + }); + + describe("convertAddLoginQueueMessageToCipherView", () => { + it("returns a cipher view when passed an `AddLoginQueueMessage`", () => { + const message: AddLoginQueueMessage = { + type: "add", + username: "test", + password: "password", + uri: "https://example.com", + domain: "", + tab: createChromeTabMock(), + expires: new Date(), + wasVaultLocked: false, + }; + const cipherView = notificationBackground["convertAddLoginQueueMessageToCipherView"](message); + + expect(cipherView.name).toEqual("example.com"); + expect(cipherView.login).toEqual({ + autofillOnPageLoad: null, + fido2Credentials: null, + password: message.password, + passwordRevisionDate: null, + totp: null, + uris: [ + { + _canLaunch: null, + _domain: null, + _host: null, + _hostname: null, + _uri: message.uri, + match: null, + }, + ], + username: message.username, + }); + }); + + it("returns a cipher view assigned to an existing folder id", () => { + const folderId = "folder-id"; + const message: AddLoginQueueMessage = { + type: "add", + username: "test", + password: "password", + uri: "https://example.com", + domain: "example.com", + tab: createChromeTabMock(), + expires: new Date(), + wasVaultLocked: false, + }; + const cipherView = notificationBackground["convertAddLoginQueueMessageToCipherView"]( + message, + folderId, + ); + + expect(cipherView.folderId).toEqual(folderId); + }); + }); + + describe("notification bar extension message handlers", () => { + beforeEach(async () => { + await notificationBackground.init(); + }); + + it("ignores messages whose command does not match the expected handlers", () => { + const message: NotificationBackgroundExtensionMessage = { command: "unknown" }; + jest.spyOn(notificationBackground as any, "handleSaveCipherMessage"); + + sendExtensionRuntimeMessage(message); + + expect(notificationBackground["handleSaveCipherMessage"]).not.toHaveBeenCalled(); + }); + + describe("unlockCompleted message handler", () => { + it("sends a `closeNotificationBar` message if the retryCommand is for `autofill_login", async () => { + const sender = mock({ tab: { id: 1 } }); + const message: NotificationBackgroundExtensionMessage = { + command: "unlockCompleted", + data: { + commandToRetry: { message: { command: "autofill_login" } }, + } as LockedVaultPendingNotificationsData, + }; + jest.spyOn(BrowserApi, "tabSendMessageData").mockImplementation(); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(BrowserApi.tabSendMessageData).toHaveBeenCalledWith( + sender.tab, + "closeNotificationBar", + ); + }); + + it("triggers a retryHandler if the message target is `notification.background` and a handler exists", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "unlockCompleted", + data: { + commandToRetry: { message: { command: "bgSaveCipher" } }, + target: "notification.background", + } as LockedVaultPendingNotificationsData, + }; + jest.spyOn(notificationBackground as any, "handleSaveCipherMessage").mockImplementation(); + + sendExtensionRuntimeMessage(message); + await flushPromises(); + + expect(notificationBackground["handleSaveCipherMessage"]).toHaveBeenCalledWith( + message.data.commandToRetry.message, + message.data.commandToRetry.sender, + ); + }); + }); + + describe("bgGetFolderData message handler", () => { + it("returns a list of folders", async () => { + const folderView = mock({ id: "folder-id" }); + const folderViews = [folderView]; + const message: NotificationBackgroundExtensionMessage = { + command: "bgGetFolderData", + }; + jest.spyOn(notificationBackground as any, "getFolderData"); + (firstValueFrom as jest.Mock).mockResolvedValueOnce(folderViews); + + sendExtensionRuntimeMessage(message); + await flushPromises(); + + expect(notificationBackground["getFolderData"]).toHaveBeenCalled(); + expect(firstValueFrom).toHaveBeenCalled(); + }); + }); + + describe("bgCloseNotificationBar message handler", () => { + it("sends a `closeNotificationBar` message to the sender tab", async () => { + const sender = mock({ tab: { id: 1 } }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgCloseNotificationBar", + }; + jest.spyOn(BrowserApi, "tabSendMessageData").mockImplementation(); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(BrowserApi.tabSendMessageData).toHaveBeenCalledWith( + sender.tab, + "closeNotificationBar", + ); + }); + }); + + describe("bgAdjustNotificationBar message handler", () => { + it("sends a `adjustNotificationBar` message to the sender tab", async () => { + const sender = mock({ tab: { id: 1 } }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgAdjustNotificationBar", + data: { height: 100 }, + }; + jest.spyOn(BrowserApi, "tabSendMessageData").mockImplementation(); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(BrowserApi.tabSendMessageData).toHaveBeenCalledWith( + sender.tab, + "adjustNotificationBar", + message.data, + ); + }); + }); + + describe("bgAddLogin message handler", () => { + let tab: chrome.tabs.Tab; + let sender: chrome.runtime.MessageSender; + let getAuthStatusSpy: jest.SpyInstance; + let getEnableAddedLoginPromptSpy: jest.SpyInstance; + let getEnableChangedPasswordPromptSpy: jest.SpyInstance; + let pushAddLoginToQueueSpy: jest.SpyInstance; + let pushChangePasswordToQueueSpy: jest.SpyInstance; + let getAllDecryptedForUrlSpy: jest.SpyInstance; + + beforeEach(() => { + tab = createChromeTabMock(); + sender = mock({ tab }); + getAuthStatusSpy = jest.spyOn(authService, "getAuthStatus"); + getEnableAddedLoginPromptSpy = jest.spyOn( + notificationBackground as any, + "getEnableAddedLoginPrompt", + ); + getEnableChangedPasswordPromptSpy = jest.spyOn( + notificationBackground as any, + "getEnableChangedPasswordPrompt", + ); + pushAddLoginToQueueSpy = jest.spyOn(notificationBackground as any, "pushAddLoginToQueue"); + pushChangePasswordToQueueSpy = jest.spyOn( + notificationBackground as any, + "pushChangePasswordToQueue", + ); + getAllDecryptedForUrlSpy = jest.spyOn(cipherService, "getAllDecryptedForUrl"); + }); + + it("skips attempting to add the login if the user is logged out", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgAddLogin", + login: { username: "test", password: "password", url: "https://example.com" }, + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.LoggedOut); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(getEnableAddedLoginPromptSpy).not.toHaveBeenCalled(); + expect(pushAddLoginToQueueSpy).not.toHaveBeenCalled(); + }); + + it("skips attempting to add the login if the login data does not contain a valid url", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgAddLogin", + login: { username: "test", password: "password", url: "" }, + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Locked); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(getEnableAddedLoginPromptSpy).not.toHaveBeenCalled(); + expect(pushAddLoginToQueueSpy).not.toHaveBeenCalled(); + }); + + it("skips attempting to add the login if the user with a locked vault has disabled the login notification", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgAddLogin", + login: { username: "test", password: "password", url: "https://example.com" }, + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Locked); + getEnableAddedLoginPromptSpy.mockReturnValueOnce(false); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(getEnableAddedLoginPromptSpy).toHaveBeenCalled(); + expect(getAllDecryptedForUrlSpy).not.toHaveBeenCalled(); + expect(pushAddLoginToQueueSpy).not.toHaveBeenCalled(); + expect(pushChangePasswordToQueueSpy).not.toHaveBeenCalled(); + }); + + it("skips attempting to add the login if the user with an unlocked vault has disabled the login notification", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgAddLogin", + login: { username: "test", password: "password", url: "https://example.com" }, + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Unlocked); + getEnableAddedLoginPromptSpy.mockReturnValueOnce(false); + getAllDecryptedForUrlSpy.mockResolvedValueOnce([]); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(getEnableAddedLoginPromptSpy).toHaveBeenCalled(); + expect(getAllDecryptedForUrlSpy).toHaveBeenCalled(); + expect(pushAddLoginToQueueSpy).not.toHaveBeenCalled(); + expect(pushChangePasswordToQueueSpy).not.toHaveBeenCalled(); + }); + + it("skips attempting to change the password for an existing login if the user has disabled changing the password notification", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgAddLogin", + login: { username: "test", password: "password", url: "https://example.com" }, + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Unlocked); + getEnableAddedLoginPromptSpy.mockReturnValueOnce(true); + getEnableChangedPasswordPromptSpy.mockReturnValueOnce(false); + getAllDecryptedForUrlSpy.mockResolvedValueOnce([ + mock({ login: { username: "test", password: "oldPassword" } }), + ]); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(getEnableAddedLoginPromptSpy).toHaveBeenCalled(); + expect(getAllDecryptedForUrlSpy).toHaveBeenCalled(); + expect(getEnableChangedPasswordPromptSpy).toHaveBeenCalled(); + expect(pushAddLoginToQueueSpy).not.toHaveBeenCalled(); + expect(pushChangePasswordToQueueSpy).not.toHaveBeenCalled(); + }); + + it("skips attempting to change the password for an existing login if the password has not changed", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgAddLogin", + login: { username: "test", password: "password", url: "https://example.com" }, + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Unlocked); + getEnableAddedLoginPromptSpy.mockReturnValueOnce(true); + getAllDecryptedForUrlSpy.mockResolvedValueOnce([ + mock({ login: { username: "test", password: "password" } }), + ]); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(getEnableAddedLoginPromptSpy).toHaveBeenCalled(); + expect(getAllDecryptedForUrlSpy).toHaveBeenCalled(); + expect(pushAddLoginToQueueSpy).not.toHaveBeenCalled(); + expect(pushChangePasswordToQueueSpy).not.toHaveBeenCalled(); + }); + + it("adds the login to the queue if the user has a locked account", async () => { + const login = { username: "test", password: "password", url: "https://example.com" }; + const message: NotificationBackgroundExtensionMessage = { command: "bgAddLogin", login }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Locked); + getEnableAddedLoginPromptSpy.mockReturnValueOnce(true); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(pushAddLoginToQueueSpy).toHaveBeenCalledWith("example.com", login, sender.tab, true); + }); + + it("adds the login to the queue if the user has an unlocked account and the login is new", async () => { + const login = { + username: undefined, + password: "password", + url: "https://example.com", + } as any; + const message: NotificationBackgroundExtensionMessage = { command: "bgAddLogin", login }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Unlocked); + getEnableAddedLoginPromptSpy.mockReturnValueOnce(true); + getAllDecryptedForUrlSpy.mockResolvedValueOnce([ + mock({ login: { username: "anotherTestUsername", password: "password" } }), + ]); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(pushAddLoginToQueueSpy).toHaveBeenCalledWith("example.com", login, sender.tab); + }); + + it("adds a change password message to the queue if the user has changed an existing cipher's password", async () => { + const login = { username: "tEsT", password: "password", url: "https://example.com" }; + const message: NotificationBackgroundExtensionMessage = { command: "bgAddLogin", login }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Unlocked); + getEnableAddedLoginPromptSpy.mockResolvedValueOnce(true); + getEnableChangedPasswordPromptSpy.mockResolvedValueOnce(true); + getAllDecryptedForUrlSpy.mockResolvedValueOnce([ + mock({ + id: "cipher-id", + login: { username: "test", password: "oldPassword" }, + }), + ]); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(pushChangePasswordToQueueSpy).toHaveBeenCalledWith( + "cipher-id", + "example.com", + login.password, + sender.tab, + ); + }); + }); + + describe("bgChangedPassword message handler", () => { + let tab: chrome.tabs.Tab; + let sender: chrome.runtime.MessageSender; + let getAuthStatusSpy: jest.SpyInstance; + let pushChangePasswordToQueueSpy: jest.SpyInstance; + let getAllDecryptedForUrlSpy: jest.SpyInstance; + + beforeEach(() => { + tab = createChromeTabMock(); + sender = mock({ tab }); + getAuthStatusSpy = jest.spyOn(authService, "getAuthStatus"); + pushChangePasswordToQueueSpy = jest.spyOn( + notificationBackground as any, + "pushChangePasswordToQueue", + ); + getAllDecryptedForUrlSpy = jest.spyOn(cipherService, "getAllDecryptedForUrl"); + }); + + it("skips attempting to add the change password message to the queue if the passed url is not valid", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgChangedPassword", + data: { newPassword: "newPassword", currentPassword: "currentPassword", url: "" }, + }; + + sendExtensionRuntimeMessage(message); + await flushPromises(); + + expect(pushChangePasswordToQueueSpy).not.toHaveBeenCalled(); + }); + + it("adds a change password message to the queue if the user does not have an unlocked account", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgChangedPassword", + data: { + newPassword: "newPassword", + currentPassword: "currentPassword", + url: "https://example.com", + }, + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Locked); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(pushChangePasswordToQueueSpy).toHaveBeenCalledWith( + null, + "example.com", + message.data.newPassword, + sender.tab, + true, + ); + }); + + it("skips adding a change password message to the queue if the multiple ciphers exist for the passed URL and the current password is not found within the list of ciphers", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgChangedPassword", + data: { + newPassword: "newPassword", + currentPassword: "currentPassword", + url: "https://example.com", + }, + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Unlocked); + getAllDecryptedForUrlSpy.mockResolvedValueOnce([ + mock({ login: { username: "test", password: "password" } }), + ]); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(getAllDecryptedForUrlSpy).toHaveBeenCalled(); + expect(pushChangePasswordToQueueSpy).not.toHaveBeenCalled(); + }); + + it("skips adding a change password message if more than one existing cipher is found with a matching password ", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgChangedPassword", + data: { + newPassword: "newPassword", + currentPassword: "currentPassword", + url: "https://example.com", + }, + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Unlocked); + getAllDecryptedForUrlSpy.mockResolvedValueOnce([ + mock({ login: { username: "test", password: "password" } }), + mock({ login: { username: "test2", password: "password" } }), + ]); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(getAllDecryptedForUrlSpy).toHaveBeenCalled(); + expect(pushChangePasswordToQueueSpy).not.toHaveBeenCalled(); + }); + + it("adds a change password message to the queue if a single cipher matches the passed current password", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgChangedPassword", + data: { + newPassword: "newPassword", + currentPassword: "currentPassword", + url: "https://example.com", + }, + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Unlocked); + getAllDecryptedForUrlSpy.mockResolvedValueOnce([ + mock({ + id: "cipher-id", + login: { username: "test", password: "currentPassword" }, + }), + ]); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(pushChangePasswordToQueueSpy).toHaveBeenCalledWith( + "cipher-id", + "example.com", + message.data.newPassword, + sender.tab, + ); + }); + + it("skips adding a change password message if no current password is passed in the message and more than one cipher is found for a url", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgChangedPassword", + data: { + newPassword: "newPassword", + url: "https://example.com", + }, + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Unlocked); + getAllDecryptedForUrlSpy.mockResolvedValueOnce([ + mock({ login: { username: "test", password: "password" } }), + mock({ login: { username: "test2", password: "password" } }), + ]); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(getAllDecryptedForUrlSpy).toHaveBeenCalled(); + expect(pushChangePasswordToQueueSpy).not.toHaveBeenCalled(); + }); + + it("adds a change password message to the queue if no current password is passed with the message, but a single cipher is matched for the uri", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgChangedPassword", + data: { + newPassword: "newPassword", + url: "https://example.com", + }, + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Unlocked); + getAllDecryptedForUrlSpy.mockResolvedValueOnce([ + mock({ + id: "cipher-id", + login: { username: "test", password: "password" }, + }), + ]); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(pushChangePasswordToQueueSpy).toHaveBeenCalledWith( + "cipher-id", + "example.com", + message.data.newPassword, + sender.tab, + ); + }); + }); + + describe("bgRemoveTabFromNotificationQueue message handler", () => { + it("splices a notification queue item based on the passed tab", async () => { + const tab = createChromeTabMock({ id: 2 }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgRemoveTabFromNotificationQueue", + }; + const removeTabFromNotificationQueueSpy = jest.spyOn( + notificationBackground as any, + "removeTabFromNotificationQueue", + ); + const firstQueueMessage = mock({ + tab: createChromeTabMock({ id: 1 }), + }); + const secondQueueMessage = mock({ tab }); + const thirdQueueMessage = mock({ + tab: createChromeTabMock({ id: 3 }), + }); + notificationBackground["notificationQueue"] = [ + firstQueueMessage, + secondQueueMessage, + thirdQueueMessage, + ]; + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(removeTabFromNotificationQueueSpy).toHaveBeenCalledWith(tab); + expect(notificationBackground["notificationQueue"]).toEqual([ + firstQueueMessage, + thirdQueueMessage, + ]); + }); + }); + + describe("bgSaveCipher message handler", () => { + let getAuthStatusSpy: jest.SpyInstance; + let tabSendMessageDataSpy: jest.SpyInstance; + let openUnlockPopoutSpy: jest.SpyInstance; + + beforeEach(() => { + getAuthStatusSpy = jest.spyOn(authService, "getAuthStatus"); + tabSendMessageDataSpy = jest.spyOn(BrowserApi, "tabSendMessageData").mockImplementation(); + openUnlockPopoutSpy = jest + .spyOn(notificationBackground as any, "openUnlockPopout") + .mockImplementation(); + }); + + it("skips saving the cipher and opens an unlock popout if the extension is not unlocked", async () => { + const sender = mock({ tab: { id: 1 } }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgSaveCipher", + edit: false, + folder: "folder-id", + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Locked); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(tabSendMessageDataSpy).toHaveBeenCalledWith( + sender.tab, + "addToLockedVaultPendingNotifications", + { + commandToRetry: { message, sender }, + target: "notification.background", + }, + ); + expect(openUnlockPopoutSpy).toHaveBeenCalledWith(sender.tab); + }); + + describe("saveOrUpdateCredentials", () => { + let getDecryptedCipherByIdSpy: jest.SpyInstance; + let getAllDecryptedForUrlSpy: jest.SpyInstance; + let updatePasswordSpy: jest.SpyInstance; + let convertAddLoginQueueMessageToCipherViewSpy: jest.SpyInstance; + let tabSendMessageSpy: jest.SpyInstance; + let editItemSpy: jest.SpyInstance; + let setAddEditCipherInfoSpy: jest.SpyInstance; + let openAddEditVaultItemPopoutSpy: jest.SpyInstance; + let createWithServerSpy: jest.SpyInstance; + let updateWithServerSpy: jest.SpyInstance; + let folderExistsSpy: jest.SpyInstance; + let cipherEncryptSpy: jest.SpyInstance; + + beforeEach(() => { + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Unlocked); + getDecryptedCipherByIdSpy = jest.spyOn( + notificationBackground as any, + "getDecryptedCipherById", + ); + getAllDecryptedForUrlSpy = jest.spyOn(cipherService, "getAllDecryptedForUrl"); + updatePasswordSpy = jest.spyOn(notificationBackground as any, "updatePassword"); + convertAddLoginQueueMessageToCipherViewSpy = jest.spyOn( + notificationBackground as any, + "convertAddLoginQueueMessageToCipherView", + ); + tabSendMessageSpy = jest.spyOn(BrowserApi, "tabSendMessage").mockImplementation(); + editItemSpy = jest.spyOn(notificationBackground as any, "editItem"); + setAddEditCipherInfoSpy = jest.spyOn(stateService, "setAddEditCipherInfo"); + openAddEditVaultItemPopoutSpy = jest.spyOn( + notificationBackground as any, + "openAddEditVaultItemPopout", + ); + createWithServerSpy = jest.spyOn(cipherService, "createWithServer"); + updateWithServerSpy = jest.spyOn(cipherService, "updateWithServer"); + folderExistsSpy = jest.spyOn(notificationBackground as any, "folderExists"); + cipherEncryptSpy = jest.spyOn(cipherService, "encrypt"); + }); + + it("skips saving the cipher if the notification queue does not have a tab that is related to the sender", async () => { + const sender = mock({ tab: { id: 2 } }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgSaveCipher", + edit: false, + folder: "folder-id", + }; + notificationBackground["notificationQueue"] = [ + mock({ + tab: createChromeTabMock({ id: 1 }), + }), + ]; + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(updatePasswordSpy).not.toHaveBeenCalled(); + expect(editItemSpy).not.toHaveBeenCalled(); + expect(createWithServerSpy).not.toHaveBeenCalled(); + }); + + it("skips saving the cipher if the notification queue does not contain an AddLogin or ChangePassword type", async () => { + const tab = createChromeTabMock({ id: 1 }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgSaveCipher", + edit: false, + folder: "folder-id", + }; + notificationBackground["notificationQueue"] = [ + mock({ + tab, + type: NotificationQueueMessageType.UnlockVault, + }), + ]; + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(updatePasswordSpy).not.toHaveBeenCalled(); + expect(editItemSpy).not.toHaveBeenCalled(); + expect(createWithServerSpy).not.toHaveBeenCalled(); + }); + + it("skips saving the cipher if the notification queue message has a different domain than the passed tab", () => { + const tab = createChromeTabMock({ id: 1, url: "https://example.com" }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgSaveCipher", + edit: false, + folder: "folder-id", + }; + notificationBackground["notificationQueue"] = [ + mock({ + type: NotificationQueueMessageType.AddLogin, + tab, + domain: "another.com", + }), + ]; + + sendExtensionRuntimeMessage(message, sender); + expect(updatePasswordSpy).not.toHaveBeenCalled(); + expect(editItemSpy).not.toHaveBeenCalled(); + expect(createWithServerSpy).not.toHaveBeenCalled(); + }); + + it("updates the password if the notification message type is for ChangePassword", async () => { + const tab = createChromeTabMock({ id: 1, url: "https://example.com" }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgSaveCipher", + edit: false, + folder: "folder-id", + }; + const queueMessage = mock({ + type: NotificationQueueMessageType.ChangePassword, + tab, + domain: "example.com", + newPassword: "newPassword", + }); + notificationBackground["notificationQueue"] = [queueMessage]; + const cipherView = mock(); + getDecryptedCipherByIdSpy.mockResolvedValueOnce(cipherView); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(editItemSpy).not.toHaveBeenCalled(); + expect(createWithServerSpy).not.toHaveBeenCalled(); + expect(updatePasswordSpy).toHaveBeenCalledWith( + cipherView, + queueMessage.newPassword, + message.edit, + sender.tab, + ); + expect(updateWithServerSpy).toHaveBeenCalled(); + expect(tabSendMessageSpy).toHaveBeenCalledWith(sender.tab, { + command: "saveCipherAttemptCompleted", + }); + }); + + it("updates the cipher password if the queue message was locked and an existing cipher has the same username as the message", async () => { + const tab = createChromeTabMock({ id: 1, url: "https://example.com" }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgSaveCipher", + edit: false, + folder: "folder-id", + }; + const queueMessage = mock({ + type: NotificationQueueMessageType.AddLogin, + tab, + domain: "example.com", + username: "test", + password: "updated-password", + wasVaultLocked: true, + }); + notificationBackground["notificationQueue"] = [queueMessage]; + const cipherView = mock({ + login: { username: "test", password: "old-password" }, + }); + getAllDecryptedForUrlSpy.mockResolvedValueOnce([cipherView]); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(updatePasswordSpy).toHaveBeenCalledWith( + cipherView, + queueMessage.password, + message.edit, + sender.tab, + ); + expect(editItemSpy).not.toHaveBeenCalled(); + expect(createWithServerSpy).not.toHaveBeenCalled(); + }); + + it("opens an editItem window and closes the notification bar if the edit value is within the passed message when attempting to update an existing cipher", async () => { + const tab = createChromeTabMock({ id: 1, url: "https://example.com" }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgSaveCipher", + edit: true, + folder: "folder-id", + }; + const queueMessage = mock({ + type: NotificationQueueMessageType.ChangePassword, + tab, + domain: "example.com", + newPassword: "newPassword", + }); + notificationBackground["notificationQueue"] = [queueMessage]; + const cipherView = mock(); + getDecryptedCipherByIdSpy.mockResolvedValueOnce(cipherView); + setAddEditCipherInfoSpy.mockResolvedValue(undefined); + openAddEditVaultItemPopoutSpy.mockResolvedValue(undefined); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(updatePasswordSpy).toHaveBeenCalledWith( + cipherView, + queueMessage.newPassword, + message.edit, + sender.tab, + ); + expect(editItemSpy).toHaveBeenCalled(); + expect(updateWithServerSpy).not.toHaveBeenCalled(); + expect(tabSendMessageSpy).toHaveBeenCalledWith(sender.tab, { + command: "closeNotificationBar", + }); + expect(tabSendMessageSpy).toHaveBeenCalledWith(sender.tab, { + command: "editedCipher", + }); + expect(setAddEditCipherInfoSpy).toHaveBeenCalledWith({ + cipher: cipherView, + collectionIds: cipherView.collectionIds, + }); + expect(openAddEditVaultItemPopoutSpy).toHaveBeenCalledWith(sender.tab, { + cipherId: cipherView.id, + }); + }); + + it("opens an editItem window and closes the notification bar if the edit value is within the passed message when attempting to save the cipher", async () => { + const tab = createChromeTabMock({ id: 1, url: "https://example.com" }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgSaveCipher", + edit: true, + folder: "folder-id", + }; + const queueMessage = mock({ + type: NotificationQueueMessageType.AddLogin, + tab, + domain: "example.com", + username: "test", + password: "password", + wasVaultLocked: false, + }); + notificationBackground["notificationQueue"] = [queueMessage]; + const cipherView = mock({ + login: { username: "test", password: "password" }, + }); + folderExistsSpy.mockResolvedValueOnce(true); + convertAddLoginQueueMessageToCipherViewSpy.mockReturnValueOnce(cipherView); + editItemSpy.mockResolvedValueOnce(undefined); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(updatePasswordSpy).not.toHaveBeenCalled(); + expect(convertAddLoginQueueMessageToCipherViewSpy).toHaveBeenCalledWith( + queueMessage, + message.folder, + ); + expect(editItemSpy).toHaveBeenCalledWith(cipherView, sender.tab); + expect(tabSendMessageSpy).toHaveBeenCalledWith(sender.tab, { + command: "closeNotificationBar", + }); + expect(createWithServerSpy).not.toHaveBeenCalled(); + }); + + it("creates the cipher within the server and sends an `saveCipherAttemptCompleted` and `addedCipher` message to the sender tab", async () => { + const tab = createChromeTabMock({ id: 1, url: "https://example.com" }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgSaveCipher", + edit: false, + folder: "folder-id", + }; + const queueMessage = mock({ + type: NotificationQueueMessageType.AddLogin, + tab, + domain: "example.com", + username: "test", + password: "password", + wasVaultLocked: false, + }); + notificationBackground["notificationQueue"] = [queueMessage]; + const cipherView = mock({ + login: { username: "test", password: "password" }, + }); + folderExistsSpy.mockResolvedValueOnce(false); + convertAddLoginQueueMessageToCipherViewSpy.mockReturnValueOnce(cipherView); + editItemSpy.mockResolvedValueOnce(undefined); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(convertAddLoginQueueMessageToCipherViewSpy).toHaveBeenCalledWith( + queueMessage, + null, + ); + expect(cipherEncryptSpy).toHaveBeenCalledWith(cipherView); + expect(createWithServerSpy).toHaveBeenCalled(); + expect(tabSendMessageSpy).toHaveBeenCalledWith(sender.tab, { + command: "saveCipherAttemptCompleted", + }); + expect(tabSendMessageSpy).toHaveBeenCalledWith(sender.tab, { command: "addedCipher" }); + }); + + it("sends an error message within the `saveCipherAttemptCompleted` message if the cipher cannot be saved to the server", async () => { + const tab = createChromeTabMock({ id: 1, url: "https://example.com" }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgSaveCipher", + edit: false, + folder: "folder-id", + }; + const queueMessage = mock({ + type: NotificationQueueMessageType.AddLogin, + tab, + domain: "example.com", + username: "test", + password: "password", + wasVaultLocked: false, + }); + notificationBackground["notificationQueue"] = [queueMessage]; + const cipherView = mock({ + login: { username: "test", password: "password" }, + }); + folderExistsSpy.mockResolvedValueOnce(true); + convertAddLoginQueueMessageToCipherViewSpy.mockReturnValueOnce(cipherView); + editItemSpy.mockResolvedValueOnce(undefined); + const errorMessage = "fetch error"; + createWithServerSpy.mockImplementation(() => { + throw new Error(errorMessage); + }); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(cipherEncryptSpy).toHaveBeenCalledWith(cipherView); + expect(createWithServerSpy).toThrow(errorMessage); + expect(tabSendMessageSpy).not.toHaveBeenCalledWith(sender.tab, { + command: "addedCipher", + }); + expect(tabSendMessageDataSpy).toHaveBeenCalledWith( + sender.tab, + "saveCipherAttemptCompleted", + { + error: errorMessage, + }, + ); + }); + + it("sends an error message within the `saveCipherAttemptCompleted` message if the cipher cannot be updated within the server", async () => { + const tab = createChromeTabMock({ id: 1, url: "https://example.com" }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgSaveCipher", + edit: false, + folder: "folder-id", + }; + const queueMessage = mock({ + type: NotificationQueueMessageType.ChangePassword, + tab, + domain: "example.com", + newPassword: "newPassword", + }); + notificationBackground["notificationQueue"] = [queueMessage]; + const cipherView = mock(); + getDecryptedCipherByIdSpy.mockResolvedValueOnce(cipherView); + const errorMessage = "fetch error"; + updateWithServerSpy.mockImplementation(() => { + throw new Error(errorMessage); + }); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(updateWithServerSpy).toThrow(errorMessage); + expect(tabSendMessageDataSpy).toHaveBeenCalledWith( + sender.tab, + "saveCipherAttemptCompleted", + { + error: errorMessage, + }, + ); + }); + }); + }); + + describe("bgNeverSave message handler", () => { + let tabSendMessageDataSpy: jest.SpyInstance; + + beforeEach(() => { + tabSendMessageDataSpy = jest.spyOn(BrowserApi, "tabSendMessageData"); + }); + + it("skips saving the domain as a never value if the passed tab does not exist within the notification queue", async () => { + const tab = createChromeTabMock({ id: 2 }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { command: "bgNeverSave" }; + notificationBackground["notificationQueue"] = [ + mock({ + tab: createChromeTabMock({ id: 1 }), + }), + mock({ + tab: createChromeTabMock({ id: 3 }), + }), + ]; + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(tabSendMessageDataSpy).not.toHaveBeenCalled(); + }); + + it("skips saving the domain as a never value if the tab does not contain an addLogin message within the NotificationQueue", async () => { + const tab = createChromeTabMock({ id: 2 }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { command: "bgNeverSave" }; + notificationBackground["notificationQueue"] = [ + mock({ type: NotificationQueueMessageType.UnlockVault, tab }), + ]; + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(tabSendMessageDataSpy).not.toHaveBeenCalled(); + }); + + it("skips saving the domain as a never value if the tab url does not match the queue message domain", async () => { + const tab = createChromeTabMock({ id: 2, url: "https://example.com" }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { command: "bgNeverSave" }; + notificationBackground["notificationQueue"] = [ + mock({ + type: NotificationQueueMessageType.AddLogin, + tab, + domain: "another.com", + }), + ]; + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(tabSendMessageDataSpy).not.toHaveBeenCalled(); + }); + + it("saves the tabs domain as a never value and closes the notification bar", async () => { + const tab = createChromeTabMock({ id: 2, url: "https://example.com" }); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { command: "bgNeverSave" }; + const firstNotification = mock({ + type: NotificationQueueMessageType.AddLogin, + tab, + domain: "example.com", + }); + const secondNotification = mock({ + type: NotificationQueueMessageType.AddLogin, + tab: createChromeTabMock({ id: 3 }), + domain: "another.com", + }); + notificationBackground["notificationQueue"] = [firstNotification, secondNotification]; + jest.spyOn(cipherService, "saveNeverDomain").mockImplementation(); + jest.spyOn(BrowserApi, "tabSendMessageData").mockImplementation(); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(tabSendMessageDataSpy).toHaveBeenCalledWith(tab, "closeNotificationBar"); + expect(cipherService.saveNeverDomain).toHaveBeenCalledWith("example.com"); + expect(notificationBackground["notificationQueue"]).toEqual([secondNotification]); + }); + }); + + describe("collectPageDetailsResponse", () => { + let tabSendMessageDataSpy: jest.SpyInstance; + + beforeEach(() => { + tabSendMessageDataSpy = jest.spyOn(BrowserApi, "tabSendMessageData"); + }); + + it("skips sending the `notificationBarPageDetails` message if the message sender is not `notificationBar`", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "collectPageDetailsResponse", + sender: "not-notificationBar", + }; + + sendExtensionRuntimeMessage(message); + await flushPromises(); + + expect(tabSendMessageDataSpy).not.toHaveBeenCalled(); + }); + + it("sends a `notificationBarPageDetails` message with the forms with password fields", async () => { + const tab = createChromeTabMock(); + const message: NotificationBackgroundExtensionMessage = { + command: "collectPageDetailsResponse", + sender: "notificationBar", + details: createAutofillPageDetailsMock(), + tab, + }; + const formData = [mock()]; + jest.spyOn(autofillService, "getFormsWithPasswordFields").mockReturnValueOnce(formData); + + sendExtensionRuntimeMessage(message); + await flushPromises(); + + expect(tabSendMessageDataSpy).toHaveBeenCalledWith( + message.tab, + "notificationBarPageDetails", + { + details: message.details, + forms: formData, + }, + ); + }); + }); + + describe("bgUnlockPopoutOpened message handler", () => { + let getAuthStatusSpy: jest.SpyInstance; + let pushUnlockVaultToQueueSpy: jest.SpyInstance; + + beforeEach(() => { + getAuthStatusSpy = jest.spyOn(authService, "getAuthStatus"); + pushUnlockVaultToQueueSpy = jest.spyOn( + notificationBackground as any, + "pushUnlockVaultToQueue", + ); + }); + + it("skips pushing the unlock vault message to the queue if the message indicates that the notification should be skipped", async () => { + const tabMock = createChromeTabMock(); + const sender = mock({ tab: tabMock }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgUnlockPopoutOpened", + data: { skipNotification: true }, + }; + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).not.toHaveBeenCalled(); + expect(pushUnlockVaultToQueueSpy).not.toHaveBeenCalled(); + }); + + it("skips pushing the unlock vault message to the queue if the auth status is not `Locked`", async () => { + const tabMock = createChromeTabMock(); + const sender = mock({ tab: tabMock }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgUnlockPopoutOpened", + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.LoggedOut); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(pushUnlockVaultToQueueSpy).not.toHaveBeenCalled(); + }); + + it("skips pushing the unlock vault message to the queue if the notification queue already has an item", async () => { + const tabMock = createChromeTabMock(); + const sender = mock({ tab: tabMock }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgUnlockPopoutOpened", + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Locked); + notificationBackground["notificationQueue"] = [mock()]; + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(pushUnlockVaultToQueueSpy).not.toHaveBeenCalled(); + }); + + it("sends an unlock vault message to the queue if the user has a locked vault", async () => { + const tabMock = createChromeTabMock({ url: "https://example.com" }); + const sender = mock({ tab: tabMock }); + const message: NotificationBackgroundExtensionMessage = { + command: "bgUnlockPopoutOpened", + }; + getAuthStatusSpy.mockResolvedValueOnce(AuthenticationStatus.Locked); + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(pushUnlockVaultToQueueSpy).toHaveBeenCalledWith("example.com", sender.tab); + }); + }); + + describe("checkNotificationQueue", () => { + let doNotificationQueueCheckSpy: jest.SpyInstance; + let getTabFromCurrentWindowSpy: jest.SpyInstance; + + beforeEach(() => { + doNotificationQueueCheckSpy = jest.spyOn( + notificationBackground as any, + "doNotificationQueueCheck", + ); + getTabFromCurrentWindowSpy = jest.spyOn(BrowserApi, "getTabFromCurrentWindow"); + }); + + it("skips checking the notification queue if the queue does not contain any items", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "checkNotificationQueue", + }; + notificationBackground["notificationQueue"] = []; + + sendExtensionRuntimeMessage(message); + await flushPromises(); + + expect(doNotificationQueueCheckSpy).not.toHaveBeenCalled(); + }); + + it("checks the notification queue for the sender tab", async () => { + const tab = createChromeTabMock(); + const sender = mock({ tab }); + const message: NotificationBackgroundExtensionMessage = { + command: "checkNotificationQueue", + }; + notificationBackground["notificationQueue"] = [ + mock({ tab }), + mock({ tab: createChromeTabMock({ id: 2 }) }), + ]; + + sendExtensionRuntimeMessage(message, sender); + await flushPromises(); + + expect(doNotificationQueueCheckSpy).toHaveBeenCalledWith(tab); + }); + + it("checks the notification queue for the current tab if the sender does not send a tab", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "checkNotificationQueue", + }; + const currenTab = createChromeTabMock({ id: 2 }); + notificationBackground["notificationQueue"] = [ + mock({ tab: currenTab }), + ]; + getTabFromCurrentWindowSpy.mockResolvedValueOnce(currenTab); + + sendExtensionRuntimeMessage(message, mock({ tab: null })); + await flushPromises(); + + expect(getTabFromCurrentWindowSpy).toHaveBeenCalledWith(); + expect(doNotificationQueueCheckSpy).toHaveBeenCalledWith(currenTab); + }); + }); + + describe("bgReopenUnlockPopout message handler", () => { + it("opens the unlock popout window", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "bgReopenUnlockPopout", + }; + const openUnlockWindowSpy = jest.spyOn(notificationBackground as any, "openUnlockPopout"); + + sendExtensionRuntimeMessage(message); + await flushPromises(); + + expect(openUnlockWindowSpy).toHaveBeenCalled(); + }); + }); + + describe("getWebVaultUrlForNotification", () => { + it("returns the web vault url", async () => { + const message: NotificationBackgroundExtensionMessage = { + command: "getWebVaultUrlForNotification", + }; + const env = new SelfHostedEnvironment({ webVault: "https://example.com" }); + + Object.defineProperty(environmentService, "environment$", { + configurable: true, + get: () => null, + }); + + const environmentServiceSpy = jest + .spyOn(environmentService as any, "environment$", "get") + .mockReturnValue(new BehaviorSubject(env).asObservable()); + + sendExtensionRuntimeMessage(message); + await flushPromises(); + + expect(environmentServiceSpy).toHaveBeenCalled(); + }); + }); + }); +}); diff --git a/apps/browser/src/autofill/background/notification.background.ts b/apps/browser/src/autofill/background/notification.background.ts index 1cb006fa3a..74e6147505 100644 --- a/apps/browser/src/autofill/background/notification.background.ts +++ b/apps/browser/src/autofill/background/notification.background.ts @@ -4,31 +4,71 @@ import { PolicyService } from "@bitwarden/common/admin-console/abstractions/poli import { PolicyType } from "@bitwarden/common/admin-console/enums"; import { AuthService } from "@bitwarden/common/auth/abstractions/auth.service"; import { AuthenticationStatus } from "@bitwarden/common/auth/enums/authentication-status"; -import { ThemeType } from "@bitwarden/common/enums"; +import { NOTIFICATION_BAR_LIFESPAN_MS } from "@bitwarden/common/autofill/constants"; +import { DomainSettingsService } from "@bitwarden/common/autofill/services/domain-settings.service"; +import { UserNotificationSettingsServiceAbstraction } from "@bitwarden/common/autofill/services/user-notification-settings.service"; +import { NeverDomains } from "@bitwarden/common/models/domain/domain-service"; +import { ConfigService } from "@bitwarden/common/platform/abstractions/config/config.service"; +import { ServerConfig } from "@bitwarden/common/platform/abstractions/config/server-config"; import { EnvironmentService } from "@bitwarden/common/platform/abstractions/environment.service"; +import { LogService } from "@bitwarden/common/platform/abstractions/log.service"; import { Utils } from "@bitwarden/common/platform/misc/utils"; +import { ThemeStateService } from "@bitwarden/common/platform/theming/theme-state.service"; import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service"; import { FolderService } from "@bitwarden/common/vault/abstractions/folder/folder.service.abstraction"; -import { CipherType } from "@bitwarden/common/vault/enums/cipher-type"; +import { CipherType } from "@bitwarden/common/vault/enums"; import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view"; +import { LoginUriView } from "@bitwarden/common/vault/models/view/login-uri.view"; +import { LoginView } from "@bitwarden/common/vault/models/view/login.view"; -import AddUnlockVaultQueueMessage from "../../background/models/add-unlock-vault-queue-message"; -import AddChangePasswordQueueMessage from "../../background/models/addChangePasswordQueueMessage"; -import AddLoginQueueMessage from "../../background/models/addLoginQueueMessage"; -import AddLoginRuntimeMessage from "../../background/models/addLoginRuntimeMessage"; -import ChangePasswordRuntimeMessage from "../../background/models/changePasswordRuntimeMessage"; -import LockedVaultPendingNotificationsItem from "../../background/models/lockedVaultPendingNotificationsItem"; -import { NotificationQueueMessageType } from "../../background/models/notificationQueueMessageType"; +import { openUnlockPopout } from "../../auth/popup/utils/auth-popout-window"; import { BrowserApi } from "../../platform/browser/browser-api"; import { BrowserStateService } from "../../platform/services/abstractions/browser-state.service"; +import { openAddEditVaultItemPopout } from "../../vault/popup/utils/vault-popout-window"; +import { NotificationQueueMessageType } from "../enums/notification-queue-message-type.enum"; import { AutofillService } from "../services/abstractions/autofill.service"; +import { + AddChangePasswordQueueMessage, + AddLoginQueueMessage, + AddRequestFilelessImportQueueMessage, + AddUnlockVaultQueueMessage, + ChangePasswordMessageData, + AddLoginMessageData, + NotificationQueueMessageItem, + LockedVaultPendingNotificationsData, + NotificationBackgroundExtensionMessage, + NotificationBackgroundExtensionMessageHandlers, +} from "./abstractions/notification.background"; +import { OverlayBackgroundExtensionMessage } from "./abstractions/overlay.background"; + export default class NotificationBackground { - private notificationQueue: ( - | AddLoginQueueMessage - | AddChangePasswordQueueMessage - | AddUnlockVaultQueueMessage - )[] = []; + private openUnlockPopout = openUnlockPopout; + private openAddEditVaultItemPopout = openAddEditVaultItemPopout; + private notificationQueue: NotificationQueueMessageItem[] = []; + private readonly extensionMessageHandlers: NotificationBackgroundExtensionMessageHandlers = { + unlockCompleted: ({ message, sender }) => this.handleUnlockCompleted(message, sender), + bgGetFolderData: () => this.getFolderData(), + bgCloseNotificationBar: ({ sender }) => this.handleCloseNotificationBarMessage(sender), + bgAdjustNotificationBar: ({ message, sender }) => + this.handleAdjustNotificationBarMessage(message, sender), + bgAddLogin: ({ message, sender }) => this.addLogin(message, sender), + bgChangedPassword: ({ message, sender }) => this.changedPassword(message, sender), + bgRemoveTabFromNotificationQueue: ({ sender }) => + this.removeTabFromNotificationQueue(sender.tab), + bgSaveCipher: ({ message, sender }) => this.handleSaveCipherMessage(message, sender), + bgNeverSave: ({ sender }) => this.saveNever(sender.tab), + collectPageDetailsResponse: ({ message }) => + this.handleCollectPageDetailsResponseMessage(message), + bgUnlockPopoutOpened: ({ message, sender }) => this.unlockVault(message, sender.tab), + checkNotificationQueue: ({ sender }) => this.checkNotificationQueue(sender.tab), + bgReopenUnlockPopout: ({ sender }) => this.openUnlockPopout(sender.tab), + bgGetEnableChangedPasswordPrompt: () => this.getEnableChangedPasswordPrompt(), + bgGetEnableAddedLoginPrompt: () => this.getEnableAddedLoginPrompt(), + bgGetExcludedDomains: () => this.getExcludedDomains(), + bgGetActiveUserServerConfig: () => this.getActiveUserServerConfig(), + getWebVaultUrlForNotification: () => this.getWebVaultUrl(), + }; constructor( private autofillService: AutofillService, @@ -37,7 +77,12 @@ export default class NotificationBackground { private policyService: PolicyService, private folderService: FolderService, private stateService: BrowserStateService, - private environmentService: EnvironmentService + private userNotificationSettingsService: UserNotificationSettingsServiceAbstraction, + private domainSettingsService: DomainSettingsService, + private environmentService: EnvironmentService, + private logService: LogService, + private themeStateService: ThemeStateService, + private configService: ConfigService, ) {} async init() { @@ -45,87 +90,45 @@ export default class NotificationBackground { return; } - BrowserApi.messageListener( - "notification.background", - async (msg: any, sender: chrome.runtime.MessageSender) => { - await this.processMessage(msg, sender); - } - ); + this.setupExtensionMessageListener(); this.cleanupNotificationQueue(); } - async processMessage(msg: any, sender: chrome.runtime.MessageSender) { - switch (msg.command) { - case "unlockCompleted": - await this.handleUnlockCompleted(msg.data, sender); - break; - case "bgGetDataForTab": - await this.getDataForTab(sender.tab, msg.responseCommand); - break; - case "bgCloseNotificationBar": - await BrowserApi.tabSendMessageData(sender.tab, "closeNotificationBar"); - break; - case "bgAdjustNotificationBar": - await BrowserApi.tabSendMessageData(sender.tab, "adjustNotificationBar", msg.data); - break; - case "bgAddLogin": - await this.addLogin(msg.login, sender.tab); - break; - case "bgChangedPassword": - await this.changedPassword(msg.data, sender.tab); - break; - case "bgAddClose": - case "bgChangeClose": - this.removeTabFromNotificationQueue(sender.tab); - break; - case "bgAddSave": - case "bgChangeSave": - if ((await this.authService.getAuthStatus()) < AuthenticationStatus.Unlocked) { - const retryMessage: LockedVaultPendingNotificationsItem = { - commandToRetry: { - msg: { - command: msg, - }, - sender: sender, - }, - target: "notification.background", - }; - await BrowserApi.tabSendMessageData( - sender.tab, - "addToLockedVaultPendingNotifications", - retryMessage - ); - await BrowserApi.tabSendMessageData(sender.tab, "promptForLogin"); - return; - } - await this.saveOrUpdateCredentials(sender.tab, msg.edit, msg.folder); - break; - case "bgNeverSave": - await this.saveNever(sender.tab); - 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; - } - default: - break; - } - break; - case "promptForLogin": - await this.unlockVault(sender.tab); - break; - default: - break; - } + /** + * Gets the enableChangedPasswordPrompt setting from the user notification settings service. + */ + async getEnableChangedPasswordPrompt(): Promise { + return await firstValueFrom(this.userNotificationSettingsService.enableChangedPasswordPrompt$); } + /** + * Gets the enableAddedLoginPrompt setting from the user notification settings service. + */ + async getEnableAddedLoginPrompt(): Promise { + return await firstValueFrom(this.userNotificationSettingsService.enableAddedLoginPrompt$); + } + + /** + * Gets the neverDomains setting from the domain settings service. + */ + async getExcludedDomains(): Promise { + return await firstValueFrom(this.domainSettingsService.neverDomains$); + } + + /** + * Gets the active user server config from the config service. + */ + async getActiveUserServerConfig(): Promise { + return await firstValueFrom(this.configService.serverConfig$); + } + + /** + * Checks the notification queue for any messages that need to be sent to the + * specified tab. If no tab is specified, the current tab will be used. + * + * @param tab - The tab to check the notification queue for + */ async checkNotificationQueue(tab: chrome.tabs.Tab = null): Promise { if (this.notificationQueue.length === 0) { return; @@ -145,136 +148,135 @@ export default class NotificationBackground { private cleanupNotificationQueue() { for (let i = this.notificationQueue.length - 1; i >= 0; i--) { if (this.notificationQueue[i].expires < new Date()) { + BrowserApi.tabSendMessageData(this.notificationQueue[i].tab, "closeNotificationBar").catch( + (error) => this.logService.error(error), + ); this.notificationQueue.splice(i, 1); } } - setTimeout(() => this.cleanupNotificationQueue(), 2 * 60 * 1000); // check every 2 minutes + setTimeout(() => this.cleanupNotificationQueue(), 30000); // check every 30 seconds } private async doNotificationQueueCheck(tab: chrome.tabs.Tab): Promise { - if (tab == null) { + const tabDomain = Utils.getDomain(tab?.url); + if (!tabDomain) { return; } - const tabDomain = Utils.getDomain(tab.url); - if (tabDomain == null) { - return; - } - - for (let i = 0; i < this.notificationQueue.length; i++) { - if ( - this.notificationQueue[i].tabId !== tab.id || - this.notificationQueue[i].domain !== tabDomain - ) { - continue; - } - - if (this.notificationQueue[i].type === NotificationQueueMessageType.AddLogin) { - BrowserApi.tabSendMessageData(tab, "openNotificationBar", { - type: "add", - typeData: { - isVaultLocked: this.notificationQueue[i].wasVaultLocked, - theme: await this.getCurrentTheme(), - removeIndividualVault: await this.removeIndividualVault(), - webVaultURL: await this.environmentService.getWebVaultUrl(), - }, - }); - } else if (this.notificationQueue[i].type === NotificationQueueMessageType.ChangePassword) { - BrowserApi.tabSendMessageData(tab, "openNotificationBar", { - type: "change", - typeData: { - isVaultLocked: this.notificationQueue[i].wasVaultLocked, - theme: await this.getCurrentTheme(), - webVaultURL: await this.environmentService.getWebVaultUrl(), - }, - }); - } else if (this.notificationQueue[i].type === NotificationQueueMessageType.UnlockVault) { - BrowserApi.tabSendMessageData(tab, "openNotificationBar", { - type: "unlock", - typeData: { - isVaultLocked: this.notificationQueue[i].wasVaultLocked, - theme: await this.getCurrentTheme(), - }, - }); - } - break; + const queueMessage = this.notificationQueue.find( + (message) => message.tab.id === tab.id && message.domain === tabDomain, + ); + if (queueMessage) { + await this.sendNotificationQueueMessage(tab, queueMessage); } } - private async getCurrentTheme() { - const theme = await this.stateService.getTheme(); + private async sendNotificationQueueMessage( + tab: chrome.tabs.Tab, + notificationQueueMessage: NotificationQueueMessageItem, + ) { + const notificationType = notificationQueueMessage.type; - if (theme !== ThemeType.System) { - return theme; + const typeData: Record = { + isVaultLocked: notificationQueueMessage.wasVaultLocked, + theme: await firstValueFrom(this.themeStateService.selectedTheme$), + }; + + switch (notificationType) { + case NotificationQueueMessageType.AddLogin: + typeData.removeIndividualVault = await this.removeIndividualVault(); + break; + case NotificationQueueMessageType.RequestFilelessImport: + typeData.importType = ( + notificationQueueMessage as AddRequestFilelessImportQueueMessage + ).importType; + break; } - return window.matchMedia("(prefers-color-scheme: dark)").matches - ? ThemeType.Dark - : ThemeType.Light; + await BrowserApi.tabSendMessageData(tab, "openNotificationBar", { + type: notificationType, + typeData, + }); } + /** + * Removes any login messages from the notification queue that + * are associated with the specified tab. + * + * @param tab - The tab to remove messages for + */ private removeTabFromNotificationQueue(tab: chrome.tabs.Tab) { for (let i = this.notificationQueue.length - 1; i >= 0; i--) { - if (this.notificationQueue[i].tabId === tab.id) { + if (this.notificationQueue[i].tab.id === tab.id) { this.notificationQueue.splice(i, 1); } } } - private async addLogin(loginInfo: AddLoginRuntimeMessage, tab: chrome.tabs.Tab) { + /** + * Adds a login message to the notification queue, prompting the user to save + * the login if it does not already exist in the vault. If the cipher exists + * but the password has changed, the user will be prompted to update the password. + * + * @param message - The message to add to the queue + * @param sender - The contextual sender of the message + */ + private async addLogin( + message: NotificationBackgroundExtensionMessage, + sender: chrome.runtime.MessageSender, + ) { const authStatus = await this.authService.getAuthStatus(); if (authStatus === AuthenticationStatus.LoggedOut) { return; } + const loginInfo = message.login; + const normalizedUsername = loginInfo.username ? loginInfo.username.toLowerCase() : ""; const loginDomain = Utils.getDomain(loginInfo.url); if (loginDomain == null) { return; } - let normalizedUsername = loginInfo.username; - if (normalizedUsername != null) { - normalizedUsername = normalizedUsername.toLowerCase(); - } + const addLoginIsEnabled = await this.getEnableAddedLoginPrompt(); - const disabledAddLogin = await this.stateService.getDisableAddLoginNotification(); if (authStatus === AuthenticationStatus.Locked) { - if (disabledAddLogin) { - return; + if (addLoginIsEnabled) { + await this.pushAddLoginToQueue(loginDomain, loginInfo, sender.tab, true); } - this.pushAddLoginToQueue(loginDomain, loginInfo, tab, true); return; } const ciphers = await this.cipherService.getAllDecryptedForUrl(loginInfo.url); const usernameMatches = ciphers.filter( - (c) => c.login.username != null && c.login.username.toLowerCase() === normalizedUsername + (c) => c.login.username != null && c.login.username.toLowerCase() === normalizedUsername, ); - if (usernameMatches.length === 0) { - if (disabledAddLogin) { - return; - } + if (addLoginIsEnabled && usernameMatches.length === 0) { + await this.pushAddLoginToQueue(loginDomain, loginInfo, sender.tab); + return; + } - this.pushAddLoginToQueue(loginDomain, loginInfo, tab); - } else if ( + const changePasswordIsEnabled = await this.getEnableChangedPasswordPrompt(); + + if ( + changePasswordIsEnabled && usernameMatches.length === 1 && usernameMatches[0].login.password !== loginInfo.password ) { - const disabledChangePassword = - await this.stateService.getDisableChangedPasswordNotification(); - if (disabledChangePassword) { - return; - } - this.pushChangePasswordToQueue(usernameMatches[0].id, loginDomain, loginInfo.password, tab); + await this.pushChangePasswordToQueue( + usernameMatches[0].id, + loginDomain, + loginInfo.password, + sender.tab, + ); } } private async pushAddLoginToQueue( loginDomain: string, - loginInfo: AddLoginRuntimeMessage, + loginInfo: AddLoginMessageData, tab: chrome.tabs.Tab, - isVaultLocked = false + isVaultLocked = false, ) { // remove any old messages for this tab this.removeTabFromNotificationQueue(tab); @@ -284,22 +286,39 @@ export default class NotificationBackground { password: loginInfo.password, domain: loginDomain, uri: loginInfo.url, - tabId: tab.id, - expires: new Date(new Date().getTime() + 5 * 60000), // 5 minutes + tab: tab, + expires: new Date(new Date().getTime() + NOTIFICATION_BAR_LIFESPAN_MS), wasVaultLocked: isVaultLocked, }; this.notificationQueue.push(message); await this.checkNotificationQueue(tab); } - private async changedPassword(changeData: ChangePasswordRuntimeMessage, tab: chrome.tabs.Tab) { + /** + * Adds a change password message to the notification queue, prompting the user + * to update the password for a login that has changed. + * + * @param message - The message to add to the queue + * @param sender - The contextual sender of the message + */ + private async changedPassword( + message: NotificationBackgroundExtensionMessage, + sender: chrome.runtime.MessageSender, + ) { + const changeData = message.data as ChangePasswordMessageData; const loginDomain = Utils.getDomain(changeData.url); if (loginDomain == null) { return; } if ((await this.authService.getAuthStatus()) < AuthenticationStatus.Unlocked) { - this.pushChangePasswordToQueue(null, loginDomain, changeData.newPassword, tab, true); + await this.pushChangePasswordToQueue( + null, + loginDomain, + changeData.newPassword, + sender.tab, + true, + ); return; } @@ -307,7 +326,7 @@ export default class NotificationBackground { const ciphers = await this.cipherService.getAllDecryptedForUrl(changeData.url); if (changeData.currentPassword != null) { const passwordMatches = ciphers.filter( - (c) => c.login.password === changeData.currentPassword + (c) => c.login.password === changeData.currentPassword, ); if (passwordMatches.length === 1) { id = passwordMatches[0].id; @@ -316,22 +335,70 @@ export default class NotificationBackground { id = ciphers[0].id; } if (id != null) { - this.pushChangePasswordToQueue(id, loginDomain, changeData.newPassword, tab); + await this.pushChangePasswordToQueue(id, loginDomain, changeData.newPassword, sender.tab); } } - private async unlockVault(tab: chrome.tabs.Tab) { + /** + * Sends the page details to the notification bar. Will query all + * forms with a password field and pass them to the notification bar. + * + * @param message - The extension message + */ + private async handleCollectPageDetailsResponseMessage( + message: NotificationBackgroundExtensionMessage, + ) { + if (message.sender !== "notificationBar") { + return; + } + + const forms = this.autofillService.getFormsWithPasswordFields(message.details); + await BrowserApi.tabSendMessageData(message.tab, "notificationBarPageDetails", { + details: message.details, + forms: forms, + }); + } + + /** + * Sets up a notification to unlock the vault when the user + * attempts to autofill a cipher while the vault is locked. + * + * @param message - Extension message, determines if the notification should be skipped + * @param tab - The tab that the message was sent from + */ + private async unlockVault(message: NotificationBackgroundExtensionMessage, tab: chrome.tabs.Tab) { + if (message.data?.skipNotification) { + return; + } + const currentAuthStatus = await this.authService.getAuthStatus(); if (currentAuthStatus !== AuthenticationStatus.Locked || this.notificationQueue.length) { return; } const loginDomain = Utils.getDomain(tab.url); - if (!loginDomain) { + if (loginDomain) { + await this.pushUnlockVaultToQueue(loginDomain, tab); + } + } + + /** + * Sets up a notification to request a fileless import when the user + * attempts to trigger an import from a third party website. + * + * @param tab - The tab that we are sending the notification to + * @param importType - The type of import that is being requested + */ + async requestFilelessImport(tab: chrome.tabs.Tab, importType: string) { + const currentAuthStatus = await this.authService.getAuthStatus(); + if (currentAuthStatus !== AuthenticationStatus.Unlocked || this.notificationQueue.length) { return; } - this.pushUnlockVaultToQueue(loginDomain, tab); + const loginDomain = Utils.getDomain(tab.url); + if (loginDomain) { + await this.pushRequestFilelessImportToQueue(loginDomain, tab, importType); + } } private async pushChangePasswordToQueue( @@ -339,7 +406,7 @@ export default class NotificationBackground { loginDomain: string, newPassword: string, tab: chrome.tabs.Tab, - isVaultLocked = false + isVaultLocked = false, ) { // remove any old messages for this tab this.removeTabFromNotificationQueue(tab); @@ -348,8 +415,8 @@ export default class NotificationBackground { cipherId: cipherId, newPassword: newPassword, domain: loginDomain, - tabId: tab.id, - expires: new Date(new Date().getTime() + 5 * 60000), // 5 minutes + tab: tab, + expires: new Date(new Date().getTime() + NOTIFICATION_BAR_LIFESPAN_MS), wasVaultLocked: isVaultLocked, }; this.notificationQueue.push(message); @@ -361,19 +428,88 @@ export default class NotificationBackground { const message: AddUnlockVaultQueueMessage = { type: NotificationQueueMessageType.UnlockVault, domain: loginDomain, - tabId: tab.id, + tab: tab, expires: new Date(new Date().getTime() + 0.5 * 60000), // 30 seconds wasVaultLocked: true, }; + await this.sendNotificationQueueMessage(tab, message); + } + + /** + * Pushes a request to start a fileless import to the notification queue. + * This will display a notification bar to the user, prompting them to + * start the import. + * + * @param loginDomain - The domain of the tab that we are sending the notification to + * @param tab - The tab that we are sending the notification to + * @param importType - The type of import that is being requested + */ + private async pushRequestFilelessImportToQueue( + loginDomain: string, + tab: chrome.tabs.Tab, + importType?: string, + ) { + this.removeTabFromNotificationQueue(tab); + const message: AddRequestFilelessImportQueueMessage = { + type: NotificationQueueMessageType.RequestFilelessImport, + domain: loginDomain, + tab, + expires: new Date(new Date().getTime() + 0.5 * 60000), // 30 seconds + wasVaultLocked: false, + importType, + }; this.notificationQueue.push(message); await this.checkNotificationQueue(tab); this.removeTabFromNotificationQueue(tab); } + /** + * Saves a cipher based on the message sent from the notification bar. If the vault + * is locked, the message will be added to the notification queue and the unlock + * popout will be opened. + * + * @param message - The extension message + * @param sender - The contextual sender of the message + */ + private async handleSaveCipherMessage( + message: NotificationBackgroundExtensionMessage, + sender: chrome.runtime.MessageSender, + ) { + if ((await this.authService.getAuthStatus()) < AuthenticationStatus.Unlocked) { + await BrowserApi.tabSendMessageData(sender.tab, "addToLockedVaultPendingNotifications", { + commandToRetry: { + message: { + command: message.command, + edit: message.edit, + folder: message.folder, + }, + sender: sender, + }, + target: "notification.background", + } as LockedVaultPendingNotificationsData); + await this.openUnlockPopout(sender.tab); + return; + } + + await this.saveOrUpdateCredentials(sender.tab, message.edit, message.folder); + } + + /** + * Saves or updates credentials based on the message within the + * notification queue that is associated with the specified tab. + * + * @param tab - The tab to save or update credentials for + * @param edit - Identifies if the credentials should be edited or simply added + * @param folderId - The folder to add the cipher to + */ private async saveOrUpdateCredentials(tab: chrome.tabs.Tab, edit: boolean, folderId?: string) { for (let i = this.notificationQueue.length - 1; i >= 0; i--) { const queueMessage = this.notificationQueue[i]; - if (queueMessage.tabId !== tab.id || !(queueMessage.type in NotificationQueueMessageType)) { + if ( + queueMessage.tab.id !== tab.id || + (queueMessage.type !== NotificationQueueMessageType.AddLogin && + queueMessage.type !== NotificationQueueMessageType.ChangePassword) + ) { continue; } @@ -383,7 +519,6 @@ export default class NotificationBackground { } this.notificationQueue.splice(i, 1); - BrowserApi.tabSendMessageData(tab, "closeNotificationBar"); if (queueMessage.type === NotificationQueueMessageType.ChangePassword) { const cipherView = await this.getDecryptedCipherById(queueMessage.cipherId); @@ -391,65 +526,93 @@ export default class NotificationBackground { return; } - if (queueMessage.type === NotificationQueueMessageType.AddLogin) { - // If the vault was locked, check if a cipher needs updating instead of creating a new one - if (queueMessage.wasVaultLocked) { - const allCiphers = await this.cipherService.getAllDecryptedForUrl(queueMessage.uri); - const existingCipher = allCiphers.find( - (c) => - c.login.username != null && c.login.username.toLowerCase() === queueMessage.username - ); + // If the vault was locked, check if a cipher needs updating instead of creating a new one + if (queueMessage.wasVaultLocked) { + const allCiphers = await this.cipherService.getAllDecryptedForUrl(queueMessage.uri); + const existingCipher = allCiphers.find( + (c) => + c.login.username != null && c.login.username.toLowerCase() === queueMessage.username, + ); - if (existingCipher != null) { - await this.updatePassword(existingCipher, queueMessage.password, edit, tab); - return; - } - } - - folderId = (await this.folderExists(folderId)) ? folderId : null; - const newCipher = AddLoginQueueMessage.toCipherView(queueMessage, folderId); - - if (edit) { - await this.editItem(newCipher, tab); + if (existingCipher != null) { + await this.updatePassword(existingCipher, queueMessage.password, edit, tab); return; } + } - const cipher = await this.cipherService.encrypt(newCipher); + folderId = (await this.folderExists(folderId)) ? folderId : null; + const newCipher = this.convertAddLoginQueueMessageToCipherView(queueMessage, folderId); + + if (edit) { + await this.editItem(newCipher, tab); + await BrowserApi.tabSendMessage(tab, { command: "closeNotificationBar" }); + return; + } + + const cipher = await this.cipherService.encrypt(newCipher); + try { await this.cipherService.createWithServer(cipher); - BrowserApi.tabSendMessageData(tab, "addedCipher"); + await BrowserApi.tabSendMessage(tab, { command: "saveCipherAttemptCompleted" }); + await BrowserApi.tabSendMessage(tab, { command: "addedCipher" }); + } catch (error) { + await BrowserApi.tabSendMessageData(tab, "saveCipherAttemptCompleted", { + error: String(error.message), + }); } } } + /** + * Handles updating an existing cipher's password. If the cipher + * is being edited, a popup will be opened to allow the user to + * edit the cipher. + * + * @param cipherView - The cipher to update + * @param newPassword - The new password to update the cipher with + * @param edit - Identifies if the cipher should be edited or simply updated + * @param tab - The tab that the message was sent from + */ private async updatePassword( cipherView: CipherView, newPassword: string, edit: boolean, - tab: chrome.tabs.Tab + tab: chrome.tabs.Tab, ) { cipherView.login.password = newPassword; if (edit) { await this.editItem(cipherView, tab); - BrowserApi.tabSendMessage(tab, "editedCipher"); + await BrowserApi.tabSendMessage(tab, { command: "closeNotificationBar" }); + await BrowserApi.tabSendMessage(tab, { command: "editedCipher" }); return; } const cipher = await this.cipherService.encrypt(cipherView); - await this.cipherService.updateWithServer(cipher); - // We've only updated the password, no need to broadcast editedCipher message - return; + try { + // We've only updated the password, no need to broadcast editedCipher message + await this.cipherService.updateWithServer(cipher); + await BrowserApi.tabSendMessage(tab, { command: "saveCipherAttemptCompleted" }); + } catch (error) { + await BrowserApi.tabSendMessageData(tab, "saveCipherAttemptCompleted", { + error: String(error.message), + }); + } } + /** + * Sets the add/edit cipher info in the state service + * and opens the add/edit vault item popout. + * + * @param cipherView - The cipher to edit + * @param senderTab - The tab that the message was sent from + */ private async editItem(cipherView: CipherView, senderTab: chrome.tabs.Tab) { await this.stateService.setAddEditCipherInfo({ cipher: cipherView, collectionIds: cipherView.collectionIds, }); - await BrowserApi.tabSendMessageData(senderTab, "openAddEditCipher", { - cipherId: cipherView.id, - }); + await this.openAddEditVaultItemPopout(senderTab, { cipherId: cipherView.id }); } private async folderExists(folderId: string) { @@ -464,16 +627,21 @@ export default class NotificationBackground { private async getDecryptedCipherById(cipherId: string) { const cipher = await this.cipherService.get(cipherId); if (cipher != null && cipher.type === CipherType.Login) { - return await cipher.decrypt(); + return await cipher.decrypt(await this.cipherService.getKeyForCipherKeyDecryption(cipher)); } return null; } + /** + * Saves the current tab's domain to the never save list. + * + * @param tab - The tab that sent the neverSave message + */ private async saveNever(tab: chrome.tabs.Tab) { for (let i = this.notificationQueue.length - 1; i >= 0; i--) { const queueMessage = this.notificationQueue[i]; if ( - queueMessage.tabId !== tab.id || + queueMessage.tab.id !== tab.id || queueMessage.type !== NotificationQueueMessageType.AddLogin ) { continue; @@ -485,33 +653,46 @@ export default class NotificationBackground { } this.notificationQueue.splice(i, 1); - BrowserApi.tabSendMessageData(tab, "closeNotificationBar"); + await BrowserApi.tabSendMessageData(tab, "closeNotificationBar"); const hostname = Utils.getHostname(tab.url); await this.cipherService.saveNeverDomain(hostname); } } - private async getDataForTab(tab: chrome.tabs.Tab, responseCommand: string) { - const responseData: any = {}; - if (responseCommand === "notificationBarGetFoldersList") { - responseData.folders = await firstValueFrom(this.folderService.folderViews$); - } + /** + * Returns the first value found from the folder service's folderViews$ observable. + */ + private async getFolderData() { + return await firstValueFrom(this.folderService.folderViews$); + } - await BrowserApi.tabSendMessageData(tab, responseCommand, responseData); + private async getWebVaultUrl(): Promise { + const env = await firstValueFrom(this.environmentService.environment$); + return env.getWebVaultUrl(); } private async removeIndividualVault(): Promise { return await firstValueFrom( - this.policyService.policyAppliesToActiveUser$(PolicyType.PersonalOwnership) + this.policyService.policyAppliesToActiveUser$(PolicyType.PersonalOwnership), ); } + /** + * Handles the unlockCompleted extension message. Will close the notification bar + * after an attempted autofill action, and retry the autofill action if the message + * contains a follow-up command. + * + * @param message - The extension message + * @param sender - The contextual sender of the message + */ private async handleUnlockCompleted( - messageData: LockedVaultPendingNotificationsItem, - sender: chrome.runtime.MessageSender + message: NotificationBackgroundExtensionMessage, + sender: chrome.runtime.MessageSender, ): Promise { - if (messageData.commandToRetry.msg.command === "autofill_login") { + const messageData = message.data as LockedVaultPendingNotificationsData; + const retryCommand = messageData.commandToRetry.message.command; + if (retryCommand === "autofill_login") { await BrowserApi.tabSendMessageData(sender.tab, "closeNotificationBar"); } @@ -519,9 +700,89 @@ export default class NotificationBackground { return; } - await this.processMessage( - messageData.commandToRetry.msg.command, - messageData.commandToRetry.sender - ); + const retryHandler: CallableFunction | undefined = this.extensionMessageHandlers[retryCommand]; + if (retryHandler) { + retryHandler({ + message: messageData.commandToRetry.message, + sender: messageData.commandToRetry.sender, + }); + } } + + /** + * Sends a message back to the sender tab which + * triggers closure of the notification bar. + * + * @param sender - The contextual sender of the message + */ + private async handleCloseNotificationBarMessage(sender: chrome.runtime.MessageSender) { + await BrowserApi.tabSendMessageData(sender.tab, "closeNotificationBar"); + } + + /** + * Sends a message back to the sender tab which triggers + * an CSS adjustment of the notification bar. + * + * @param message - The extension message + * @param sender - The contextual sender of the message + */ + private async handleAdjustNotificationBarMessage( + message: NotificationBackgroundExtensionMessage, + sender: chrome.runtime.MessageSender, + ) { + await BrowserApi.tabSendMessageData(sender.tab, "adjustNotificationBar", message.data); + } + + /** + * Accepts a login queue message and converts it into a + * login uri view, login view, and cipher view. + * + * @param message - The message to convert to a cipher view + * @param folderId - The folder to add the cipher to + */ + private convertAddLoginQueueMessageToCipherView( + message: AddLoginQueueMessage, + folderId?: string, + ): CipherView { + const uriView = new LoginUriView(); + uriView.uri = message.uri; + + const loginView = new LoginView(); + loginView.uris = [uriView]; + loginView.username = message.username; + loginView.password = message.password; + + const cipherView = new CipherView(); + cipherView.name = (Utils.getHostname(message.uri) || message.domain).replace(/^www\./, ""); + cipherView.folderId = folderId; + cipherView.type = CipherType.Login; + cipherView.login = loginView; + + return cipherView; + } + + private setupExtensionMessageListener() { + BrowserApi.messageListener("notification.background", this.handleExtensionMessage); + } + + private handleExtensionMessage = ( + message: OverlayBackgroundExtensionMessage, + sender: chrome.runtime.MessageSender, + sendResponse: (response?: any) => void, + ) => { + const handler: CallableFunction | undefined = this.extensionMessageHandlers[message?.command]; + if (!handler) { + return; + } + + const messageResponse = handler({ message, sender }); + if (!messageResponse) { + return; + } + + Promise.resolve(messageResponse) + .then((response) => sendResponse(response)) + .catch((error) => this.logService.error(error)); + return true; + }; } diff --git a/apps/browser/src/autofill/background/overlay.background.spec.ts b/apps/browser/src/autofill/background/overlay.background.spec.ts new file mode 100644 index 0000000000..2599c1825e --- /dev/null +++ b/apps/browser/src/autofill/background/overlay.background.spec.ts @@ -0,0 +1,1418 @@ +import { mock, mockReset } from "jest-mock-extended"; +import { BehaviorSubject, of } from "rxjs"; + +import { AuthenticationStatus } from "@bitwarden/common/auth/enums/authentication-status"; +import { AuthService } from "@bitwarden/common/auth/services/auth.service"; +import { + SHOW_AUTOFILL_BUTTON, + AutofillOverlayVisibility, +} from "@bitwarden/common/autofill/constants"; +import { AutofillSettingsService } from "@bitwarden/common/autofill/services/autofill-settings.service"; +import { + DefaultDomainSettingsService, + DomainSettingsService, +} from "@bitwarden/common/autofill/services/domain-settings.service"; +import { + EnvironmentService, + Region, +} from "@bitwarden/common/platform/abstractions/environment.service"; +import { ThemeType } from "@bitwarden/common/platform/enums"; +import { Utils } from "@bitwarden/common/platform/misc/utils"; +import { CloudEnvironment } from "@bitwarden/common/platform/services/default-environment.service"; +import { I18nService } from "@bitwarden/common/platform/services/i18n.service"; +import { ThemeStateService } from "@bitwarden/common/platform/theming/theme-state.service"; +import { + FakeStateProvider, + FakeAccountService, + mockAccountServiceWith, +} from "@bitwarden/common/spec"; +import { UserId } from "@bitwarden/common/types/guid"; +import { CipherType } from "@bitwarden/common/vault/enums"; +import { CipherRepromptType } from "@bitwarden/common/vault/enums/cipher-reprompt-type"; +import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view"; +import { CipherService } from "@bitwarden/common/vault/services/cipher.service"; + +import { BrowserApi } from "../../platform/browser/browser-api"; +import { DefaultBrowserStateService } from "../../platform/services/default-browser-state.service"; +import { BrowserPlatformUtilsService } from "../../platform/services/platform-utils/browser-platform-utils.service"; +import { AutofillService } from "../services/abstractions/autofill.service"; +import { + createAutofillPageDetailsMock, + createChromeTabMock, + createFocusedFieldDataMock, + createPageDetailMock, + createPortSpyMock, +} from "../spec/autofill-mocks"; +import { flushPromises, sendExtensionRuntimeMessage, sendPortMessage } from "../spec/testing-utils"; +import { + AutofillOverlayElement, + AutofillOverlayPort, + RedirectFocusDirection, +} from "../utils/autofill-overlay.enum"; + +import OverlayBackground from "./overlay.background"; + +describe("OverlayBackground", () => { + const mockUserId = Utils.newGuid() as UserId; + const accountService: FakeAccountService = mockAccountServiceWith(mockUserId); + const fakeStateProvider: FakeStateProvider = new FakeStateProvider(accountService); + let domainSettingsService: DomainSettingsService; + let buttonPortSpy: chrome.runtime.Port; + let listPortSpy: chrome.runtime.Port; + let overlayBackground: OverlayBackground; + const cipherService = mock(); + const autofillService = mock(); + const authService = mock(); + + const environmentService = mock(); + environmentService.environment$ = new BehaviorSubject( + new CloudEnvironment({ + key: Region.US, + domain: "bitwarden.com", + urls: { icons: "https://icons.bitwarden.com/" }, + }), + ); + const stateService = mock(); + const autofillSettingsService = mock(); + const i18nService = mock(); + const platformUtilsService = mock(); + const themeStateService = mock(); + const initOverlayElementPorts = async (options = { initList: true, initButton: true }) => { + const { initList, initButton } = options; + if (initButton) { + await overlayBackground["handlePortOnConnect"](createPortSpyMock(AutofillOverlayPort.Button)); + buttonPortSpy = overlayBackground["overlayButtonPort"]; + } + + if (initList) { + await overlayBackground["handlePortOnConnect"](createPortSpyMock(AutofillOverlayPort.List)); + listPortSpy = overlayBackground["overlayListPort"]; + } + + return { buttonPortSpy, listPortSpy }; + }; + + beforeEach(() => { + domainSettingsService = new DefaultDomainSettingsService(fakeStateProvider); + overlayBackground = new OverlayBackground( + cipherService, + autofillService, + authService, + environmentService, + domainSettingsService, + stateService, + autofillSettingsService, + i18nService, + platformUtilsService, + themeStateService, + ); + + jest + .spyOn(overlayBackground as any, "getOverlayVisibility") + .mockResolvedValue(AutofillOverlayVisibility.OnFieldFocus); + + themeStateService.selectedTheme$ = of(ThemeType.Light); + domainSettingsService.showFavicons$ = of(true); + + void overlayBackground.init(); + }); + + afterEach(() => { + jest.clearAllMocks(); + mockReset(cipherService); + }); + + describe("removePageDetails", () => { + it("removes the page details for a specific tab from the pageDetailsForTab object", () => { + const tabId = 1; + const frameId = 2; + overlayBackground["pageDetailsForTab"][tabId] = new Map([[frameId, createPageDetailMock()]]); + overlayBackground.removePageDetails(tabId); + + expect(overlayBackground["pageDetailsForTab"][tabId]).toBeUndefined(); + }); + }); + + describe("init", () => { + it("sets up the extension message listeners, get the overlay's visibility settings, and get the user's auth status", async () => { + overlayBackground["setupExtensionMessageListeners"] = jest.fn(); + overlayBackground["getOverlayVisibility"] = jest.fn(); + overlayBackground["getAuthStatus"] = jest.fn(); + + await overlayBackground.init(); + + expect(overlayBackground["setupExtensionMessageListeners"]).toHaveBeenCalled(); + expect(overlayBackground["getOverlayVisibility"]).toHaveBeenCalled(); + expect(overlayBackground["getAuthStatus"]).toHaveBeenCalled(); + }); + }); + + describe("updateOverlayCiphers", () => { + const url = "https://jest-testing-website.com"; + const tab = createChromeTabMock({ url }); + const cipher1 = mock({ + id: "id-1", + localData: { lastUsedDate: 222 }, + name: "name-1", + type: CipherType.Login, + login: { username: "username-1", uri: url }, + }); + const cipher2 = mock({ + id: "id-2", + localData: { lastUsedDate: 111 }, + name: "name-2", + type: CipherType.Login, + login: { username: "username-2", uri: url }, + }); + + beforeEach(() => { + overlayBackground["userAuthStatus"] = AuthenticationStatus.Unlocked; + }); + + it("ignores updating the overlay ciphers if the user's auth status is not unlocked", async () => { + overlayBackground["userAuthStatus"] = AuthenticationStatus.Locked; + jest.spyOn(BrowserApi, "getTabFromCurrentWindowId"); + jest.spyOn(cipherService, "getAllDecryptedForUrl"); + + await overlayBackground.updateOverlayCiphers(); + + expect(BrowserApi.getTabFromCurrentWindowId).not.toHaveBeenCalled(); + expect(cipherService.getAllDecryptedForUrl).not.toHaveBeenCalled(); + }); + + it("ignores updating the overlay ciphers if the tab is undefined", async () => { + jest.spyOn(BrowserApi, "getTabFromCurrentWindowId").mockResolvedValueOnce(undefined); + jest.spyOn(cipherService, "getAllDecryptedForUrl"); + + await overlayBackground.updateOverlayCiphers(); + + expect(BrowserApi.getTabFromCurrentWindowId).toHaveBeenCalled(); + expect(cipherService.getAllDecryptedForUrl).not.toHaveBeenCalled(); + }); + + it("queries all ciphers for the given url, sort them by last used, and format them for usage in the overlay", async () => { + jest.spyOn(BrowserApi, "getTabFromCurrentWindowId").mockResolvedValueOnce(tab); + cipherService.getAllDecryptedForUrl.mockResolvedValue([cipher1, cipher2]); + cipherService.sortCiphersByLastUsedThenName.mockReturnValue(-1); + jest.spyOn(BrowserApi, "tabSendMessageData").mockImplementation(); + jest.spyOn(overlayBackground as any, "getOverlayCipherData"); + + await overlayBackground.updateOverlayCiphers(); + + expect(BrowserApi.getTabFromCurrentWindowId).toHaveBeenCalled(); + expect(cipherService.getAllDecryptedForUrl).toHaveBeenCalledWith(url); + expect(overlayBackground["cipherService"].sortCiphersByLastUsedThenName).toHaveBeenCalled(); + expect(overlayBackground["overlayLoginCiphers"]).toStrictEqual( + new Map([ + ["overlay-cipher-0", cipher2], + ["overlay-cipher-1", cipher1], + ]), + ); + expect(overlayBackground["getOverlayCipherData"]).toHaveBeenCalled(); + }); + + it("posts an `updateOverlayListCiphers` message to the overlay list port, and send a `updateIsOverlayCiphersPopulated` message to the tab indicating that the list of ciphers is populated", async () => { + overlayBackground["overlayListPort"] = mock(); + cipherService.getAllDecryptedForUrl.mockResolvedValue([cipher1, cipher2]); + cipherService.sortCiphersByLastUsedThenName.mockReturnValue(-1); + jest.spyOn(BrowserApi, "getTabFromCurrentWindowId").mockResolvedValueOnce(tab); + jest.spyOn(BrowserApi, "tabSendMessageData").mockImplementation(); + + await overlayBackground.updateOverlayCiphers(); + + expect(overlayBackground["overlayListPort"].postMessage).toHaveBeenCalledWith({ + command: "updateOverlayListCiphers", + ciphers: [ + { + card: null, + favorite: cipher2.favorite, + icon: { + fallbackImage: "images/bwi-globe.png", + icon: "bwi-globe", + image: "https://icons.bitwarden.com//jest-testing-website.com/icon.png", + imageEnabled: true, + }, + id: "overlay-cipher-0", + login: { + username: "username-2", + }, + name: "name-2", + reprompt: cipher2.reprompt, + type: 1, + }, + { + card: null, + favorite: cipher1.favorite, + icon: { + fallbackImage: "images/bwi-globe.png", + icon: "bwi-globe", + image: "https://icons.bitwarden.com//jest-testing-website.com/icon.png", + imageEnabled: true, + }, + id: "overlay-cipher-1", + login: { + username: "username-1", + }, + name: "name-1", + reprompt: cipher1.reprompt, + type: 1, + }, + ], + }); + expect(BrowserApi.tabSendMessageData).toHaveBeenCalledWith( + tab, + "updateIsOverlayCiphersPopulated", + { isOverlayCiphersPopulated: true }, + ); + }); + }); + + describe("getOverlayCipherData", () => { + const url = "https://jest-testing-website.com"; + const cipher1 = mock({ + id: "id-1", + localData: { lastUsedDate: 222 }, + name: "name-1", + type: CipherType.Login, + login: { username: "username-1", uri: url }, + }); + const cipher2 = mock({ + id: "id-2", + localData: { lastUsedDate: 111 }, + name: "name-2", + type: CipherType.Login, + login: { username: "username-2", uri: url }, + }); + const cipher3 = mock({ + id: "id-3", + localData: { lastUsedDate: 333 }, + name: "name-3", + type: CipherType.Card, + card: { subTitle: "Visa, *6789" }, + }); + const cipher4 = mock({ + id: "id-4", + localData: { lastUsedDate: 444 }, + name: "name-4", + type: CipherType.Card, + card: { subTitle: "Mastercard, *1234" }, + }); + + it("formats and returns the cipher data", async () => { + overlayBackground["overlayLoginCiphers"] = new Map([ + ["overlay-cipher-0", cipher2], + ["overlay-cipher-1", cipher1], + ["overlay-cipher-2", cipher3], + ["overlay-cipher-3", cipher4], + ]); + + const overlayCipherData = await overlayBackground["getOverlayCipherData"](); + + expect(overlayCipherData).toStrictEqual([ + { + card: null, + favorite: cipher2.favorite, + icon: { + fallbackImage: "images/bwi-globe.png", + icon: "bwi-globe", + image: "https://icons.bitwarden.com//jest-testing-website.com/icon.png", + imageEnabled: true, + }, + id: "overlay-cipher-0", + login: { + username: "username-2", + }, + name: "name-2", + reprompt: cipher2.reprompt, + type: 1, + }, + { + card: null, + favorite: cipher1.favorite, + icon: { + fallbackImage: "images/bwi-globe.png", + icon: "bwi-globe", + image: "https://icons.bitwarden.com//jest-testing-website.com/icon.png", + imageEnabled: true, + }, + id: "overlay-cipher-1", + login: { + username: "username-1", + }, + name: "name-1", + reprompt: cipher1.reprompt, + type: 1, + }, + { + card: "Visa, *6789", + favorite: cipher3.favorite, + icon: { + fallbackImage: "", + icon: "bwi-credit-card", + image: undefined, + imageEnabled: true, + }, + id: "overlay-cipher-2", + login: null, + name: "name-3", + reprompt: cipher3.reprompt, + type: 3, + }, + { + card: "Mastercard, *1234", + favorite: cipher4.favorite, + icon: { + fallbackImage: "", + icon: "bwi-credit-card", + image: undefined, + imageEnabled: true, + }, + id: "overlay-cipher-3", + login: null, + name: "name-4", + reprompt: cipher4.reprompt, + type: 3, + }, + ]); + }); + }); + + describe("getAuthStatus", () => { + it("will update the user's auth status but will not update the overlay ciphers", async () => { + const authStatus = AuthenticationStatus.Unlocked; + overlayBackground["userAuthStatus"] = AuthenticationStatus.Unlocked; + jest.spyOn(overlayBackground["authService"], "getAuthStatus").mockResolvedValue(authStatus); + jest.spyOn(overlayBackground as any, "updateOverlayButtonAuthStatus").mockImplementation(); + jest.spyOn(overlayBackground as any, "updateOverlayCiphers").mockImplementation(); + + const status = await overlayBackground["getAuthStatus"](); + + expect(overlayBackground["authService"].getAuthStatus).toHaveBeenCalled(); + expect(overlayBackground["updateOverlayButtonAuthStatus"]).not.toHaveBeenCalled(); + expect(overlayBackground["updateOverlayCiphers"]).not.toHaveBeenCalled(); + expect(overlayBackground["userAuthStatus"]).toBe(authStatus); + expect(status).toBe(authStatus); + }); + + it("will update the user's auth status and update the overlay ciphers if the status has been modified", async () => { + const authStatus = AuthenticationStatus.Unlocked; + overlayBackground["userAuthStatus"] = AuthenticationStatus.LoggedOut; + jest.spyOn(overlayBackground["authService"], "getAuthStatus").mockResolvedValue(authStatus); + jest.spyOn(overlayBackground as any, "updateOverlayButtonAuthStatus").mockImplementation(); + jest.spyOn(overlayBackground as any, "updateOverlayCiphers").mockImplementation(); + + await overlayBackground["getAuthStatus"](); + + expect(overlayBackground["authService"].getAuthStatus).toHaveBeenCalled(); + expect(overlayBackground["updateOverlayButtonAuthStatus"]).toHaveBeenCalled(); + expect(overlayBackground["updateOverlayCiphers"]).toHaveBeenCalled(); + expect(overlayBackground["userAuthStatus"]).toBe(authStatus); + }); + }); + + describe("updateOverlayButtonAuthStatus", () => { + it("will send a message to the button port with the user's auth status", () => { + overlayBackground["overlayButtonPort"] = mock(); + jest.spyOn(overlayBackground["overlayButtonPort"], "postMessage"); + + overlayBackground["updateOverlayButtonAuthStatus"](); + + expect(overlayBackground["overlayButtonPort"].postMessage).toHaveBeenCalledWith({ + command: "updateOverlayButtonAuthStatus", + authStatus: overlayBackground["userAuthStatus"], + }); + }); + }); + + describe("getTranslations", () => { + it("will query the overlay page translations if they have not been queried", () => { + overlayBackground["overlayPageTranslations"] = undefined; + jest.spyOn(overlayBackground as any, "getTranslations"); + jest.spyOn(overlayBackground["i18nService"], "translate").mockImplementation((key) => key); + jest.spyOn(BrowserApi, "getUILanguage").mockReturnValue("en"); + + const translations = overlayBackground["getTranslations"](); + + expect(overlayBackground["getTranslations"]).toHaveBeenCalled(); + const translationKeys = [ + "opensInANewWindow", + "bitwardenOverlayButton", + "toggleBitwardenVaultOverlay", + "bitwardenVault", + "unlockYourAccountToViewMatchingLogins", + "unlockAccount", + "fillCredentialsFor", + "partialUsername", + "view", + "noItemsToShow", + "newItem", + "addNewVaultItem", + ]; + translationKeys.forEach((key) => { + expect(overlayBackground["i18nService"].translate).toHaveBeenCalledWith(key); + }); + expect(translations).toStrictEqual({ + locale: "en", + opensInANewWindow: "opensInANewWindow", + buttonPageTitle: "bitwardenOverlayButton", + toggleBitwardenVaultOverlay: "toggleBitwardenVaultOverlay", + listPageTitle: "bitwardenVault", + unlockYourAccount: "unlockYourAccountToViewMatchingLogins", + unlockAccount: "unlockAccount", + fillCredentialsFor: "fillCredentialsFor", + partialUsername: "partialUsername", + view: "view", + noItemsToShow: "noItemsToShow", + newItem: "newItem", + addNewVaultItem: "addNewVaultItem", + }); + }); + }); + + describe("setupExtensionMessageListeners", () => { + it("will set up onMessage and onConnect listeners", () => { + overlayBackground["setupExtensionMessageListeners"](); + + // eslint-disable-next-line + expect(chrome.runtime.onMessage.addListener).toHaveBeenCalled(); + expect(chrome.runtime.onConnect.addListener).toHaveBeenCalled(); + }); + }); + + describe("handleExtensionMessage", () => { + it("will return early if the message command is not present within the extensionMessageHandlers", () => { + const message = { + command: "not-a-command", + }; + const sender = mock({ tab: { id: 1 } }); + const sendResponse = jest.fn(); + + const returnValue = overlayBackground["handleExtensionMessage"]( + message, + sender, + sendResponse, + ); + + expect(returnValue).toBe(undefined); + expect(sendResponse).not.toHaveBeenCalled(); + }); + + it("will trigger the message handler and return undefined if the message does not have a response", () => { + const message = { + command: "autofillOverlayElementClosed", + }; + const sender = mock({ tab: { id: 1 } }); + const sendResponse = jest.fn(); + jest.spyOn(overlayBackground as any, "overlayElementClosed"); + + const returnValue = overlayBackground["handleExtensionMessage"]( + message, + sender, + sendResponse, + ); + + expect(returnValue).toBe(undefined); + expect(sendResponse).not.toHaveBeenCalled(); + expect(overlayBackground["overlayElementClosed"]).toHaveBeenCalledWith(message); + }); + + it("will return a response if the message handler returns a response", async () => { + const message = { + command: "openAutofillOverlay", + }; + const sender = mock({ tab: { id: 1 } }); + const sendResponse = jest.fn(); + jest.spyOn(overlayBackground as any, "getTranslations").mockReturnValue("translations"); + + const returnValue = overlayBackground["handleExtensionMessage"]( + message, + sender, + sendResponse, + ); + + expect(returnValue).toBe(true); + }); + + describe("extension message handlers", () => { + beforeEach(() => { + jest + .spyOn(overlayBackground as any, "getAuthStatus") + .mockResolvedValue(AuthenticationStatus.Unlocked); + }); + + describe("openAutofillOverlay message handler", () => { + it("opens the autofill overlay by sending a message to the current tab", async () => { + const sender = mock({ tab: { id: 1 } }); + jest.spyOn(BrowserApi, "getTabFromCurrentWindowId").mockResolvedValueOnce(sender.tab); + jest.spyOn(BrowserApi, "tabSendMessageData").mockImplementation(); + + sendExtensionRuntimeMessage({ command: "openAutofillOverlay" }); + await flushPromises(); + + expect(BrowserApi.tabSendMessageData).toHaveBeenCalledWith( + sender.tab, + "openAutofillOverlay", + { + isFocusingFieldElement: false, + isOpeningFullOverlay: false, + authStatus: AuthenticationStatus.Unlocked, + }, + ); + }); + }); + + describe("autofillOverlayElementClosed message handler", () => { + beforeEach(async () => { + await initOverlayElementPorts(); + }); + + it("disconnects the button element port", () => { + sendExtensionRuntimeMessage({ + command: "autofillOverlayElementClosed", + overlayElement: AutofillOverlayElement.Button, + }); + + expect(buttonPortSpy.disconnect).toHaveBeenCalled(); + expect(overlayBackground["overlayButtonPort"]).toBeNull(); + }); + + it("disconnects the list element port", () => { + sendExtensionRuntimeMessage({ + command: "autofillOverlayElementClosed", + overlayElement: AutofillOverlayElement.List, + }); + + expect(listPortSpy.disconnect).toHaveBeenCalled(); + expect(overlayBackground["overlayListPort"]).toBeNull(); + }); + }); + + describe("autofillOverlayAddNewVaultItem message handler", () => { + let sender: chrome.runtime.MessageSender; + beforeEach(() => { + sender = mock({ tab: { id: 1 } }); + jest + .spyOn(overlayBackground["stateService"], "setAddEditCipherInfo") + .mockImplementation(); + jest.spyOn(overlayBackground as any, "openAddEditVaultItemPopout").mockImplementation(); + }); + + it("will not open the add edit popout window if the message does not have a login cipher provided", () => { + sendExtensionRuntimeMessage({ command: "autofillOverlayAddNewVaultItem" }, sender); + + expect(overlayBackground["stateService"].setAddEditCipherInfo).not.toHaveBeenCalled(); + expect(overlayBackground["openAddEditVaultItemPopout"]).not.toHaveBeenCalled(); + }); + + it("will open the add edit popout window after creating a new cipher", async () => { + jest.spyOn(BrowserApi, "sendMessage"); + + sendExtensionRuntimeMessage( + { + command: "autofillOverlayAddNewVaultItem", + login: { + uri: "https://tacos.com", + hostname: "", + username: "username", + password: "password", + }, + }, + sender, + ); + await flushPromises(); + + expect(overlayBackground["stateService"].setAddEditCipherInfo).toHaveBeenCalled(); + expect(BrowserApi.sendMessage).toHaveBeenCalledWith( + "inlineAutofillMenuRefreshAddEditCipher", + ); + expect(overlayBackground["openAddEditVaultItemPopout"]).toHaveBeenCalled(); + }); + }); + + describe("getAutofillOverlayVisibility message handler", () => { + beforeEach(() => { + jest + .spyOn(overlayBackground as any, "getOverlayVisibility") + .mockResolvedValue(AutofillOverlayVisibility.OnFieldFocus); + }); + + it("will set the overlayVisibility property", async () => { + sendExtensionRuntimeMessage({ command: "getAutofillOverlayVisibility" }); + await flushPromises(); + + expect(await overlayBackground["getOverlayVisibility"]()).toBe( + AutofillOverlayVisibility.OnFieldFocus, + ); + }); + + it("returns the overlayVisibility property", async () => { + const sendMessageSpy = jest.fn(); + + sendExtensionRuntimeMessage( + { command: "getAutofillOverlayVisibility" }, + undefined, + sendMessageSpy, + ); + await flushPromises(); + + expect(sendMessageSpy).toHaveBeenCalledWith(AutofillOverlayVisibility.OnFieldFocus); + }); + }); + + describe("checkAutofillOverlayFocused message handler", () => { + beforeEach(async () => { + await initOverlayElementPorts(); + }); + + it("will check if the overlay list is focused if the list port is open", () => { + sendExtensionRuntimeMessage({ command: "checkAutofillOverlayFocused" }); + + expect(listPortSpy.postMessage).toHaveBeenCalledWith({ + command: "checkAutofillOverlayListFocused", + }); + expect(buttonPortSpy.postMessage).not.toHaveBeenCalledWith({ + command: "checkAutofillOverlayButtonFocused", + }); + }); + + it("will check if the overlay button is focused if the list port is not open", () => { + overlayBackground["overlayListPort"] = undefined; + + sendExtensionRuntimeMessage({ command: "checkAutofillOverlayFocused" }); + + expect(buttonPortSpy.postMessage).toHaveBeenCalledWith({ + command: "checkAutofillOverlayButtonFocused", + }); + expect(listPortSpy.postMessage).not.toHaveBeenCalledWith({ + command: "checkAutofillOverlayListFocused", + }); + }); + }); + + describe("focusAutofillOverlayList message handler", () => { + it("will send a `focusOverlayList` message to the overlay list port", async () => { + await initOverlayElementPorts({ initList: true, initButton: false }); + + sendExtensionRuntimeMessage({ command: "focusAutofillOverlayList" }); + + expect(listPortSpy.postMessage).toHaveBeenCalledWith({ command: "focusOverlayList" }); + }); + }); + + describe("updateAutofillOverlayPosition message handler", () => { + beforeEach(async () => { + await overlayBackground["handlePortOnConnect"]( + createPortSpyMock(AutofillOverlayPort.List), + ); + listPortSpy = overlayBackground["overlayListPort"]; + + await overlayBackground["handlePortOnConnect"]( + createPortSpyMock(AutofillOverlayPort.Button), + ); + buttonPortSpy = overlayBackground["overlayButtonPort"]; + }); + + it("ignores updating the position if the overlay element type is not provided", () => { + sendExtensionRuntimeMessage({ command: "updateAutofillOverlayPosition" }); + + expect(listPortSpy.postMessage).not.toHaveBeenCalledWith({ + command: "updateIframePosition", + styles: expect.anything(), + }); + expect(buttonPortSpy.postMessage).not.toHaveBeenCalledWith({ + command: "updateIframePosition", + styles: expect.anything(), + }); + }); + + it("updates the overlay button's position", () => { + const focusedFieldData = createFocusedFieldDataMock(); + sendExtensionRuntimeMessage({ command: "updateFocusedFieldData", focusedFieldData }); + + sendExtensionRuntimeMessage({ + command: "updateAutofillOverlayPosition", + overlayElement: AutofillOverlayElement.Button, + }); + + expect(buttonPortSpy.postMessage).toHaveBeenCalledWith({ + command: "updateIframePosition", + styles: { height: "2px", left: "4px", top: "2px", width: "2px" }, + }); + }); + + it("modifies the overlay button's height for medium sized input elements", () => { + const focusedFieldData = createFocusedFieldDataMock({ + focusedFieldRects: { top: 1, left: 2, height: 35, width: 4 }, + }); + sendExtensionRuntimeMessage({ command: "updateFocusedFieldData", focusedFieldData }); + + sendExtensionRuntimeMessage({ + command: "updateAutofillOverlayPosition", + overlayElement: AutofillOverlayElement.Button, + }); + + expect(buttonPortSpy.postMessage).toHaveBeenCalledWith({ + command: "updateIframePosition", + styles: { height: "20px", left: "-22px", top: "8px", width: "20px" }, + }); + }); + + it("modifies the overlay button's height for large sized input elements", () => { + const focusedFieldData = createFocusedFieldDataMock({ + focusedFieldRects: { top: 1, left: 2, height: 50, width: 4 }, + }); + sendExtensionRuntimeMessage({ command: "updateFocusedFieldData", focusedFieldData }); + + sendExtensionRuntimeMessage({ + command: "updateAutofillOverlayPosition", + overlayElement: AutofillOverlayElement.Button, + }); + + expect(buttonPortSpy.postMessage).toHaveBeenCalledWith({ + command: "updateIframePosition", + styles: { height: "27px", left: "-32px", top: "13px", width: "27px" }, + }); + }); + + it("takes into account the right padding of the focused field in positioning the button if the right padding of the field is larger than the left padding", () => { + const focusedFieldData = createFocusedFieldDataMock({ + focusedFieldStyles: { paddingRight: "20px", paddingLeft: "6px" }, + }); + sendExtensionRuntimeMessage({ command: "updateFocusedFieldData", focusedFieldData }); + + sendExtensionRuntimeMessage({ + command: "updateAutofillOverlayPosition", + overlayElement: AutofillOverlayElement.Button, + }); + + expect(buttonPortSpy.postMessage).toHaveBeenCalledWith({ + command: "updateIframePosition", + styles: { height: "2px", left: "-18px", top: "2px", width: "2px" }, + }); + }); + + it("will post a message to the overlay list facilitating an update of the list's position", () => { + const focusedFieldData = createFocusedFieldDataMock(); + sendExtensionRuntimeMessage({ command: "updateFocusedFieldData", focusedFieldData }); + + overlayBackground["updateOverlayPosition"]({ + overlayElement: AutofillOverlayElement.List, + }); + sendExtensionRuntimeMessage({ + command: "updateAutofillOverlayPosition", + overlayElement: AutofillOverlayElement.List, + }); + + expect(listPortSpy.postMessage).toHaveBeenCalledWith({ + command: "updateIframePosition", + styles: { left: "2px", top: "4px", width: "4px" }, + }); + }); + }); + + describe("updateOverlayHidden", () => { + beforeEach(async () => { + await initOverlayElementPorts(); + }); + + it("returns early if the display value is not provided", () => { + const message = { + command: "updateAutofillOverlayHidden", + }; + + sendExtensionRuntimeMessage(message); + + expect(buttonPortSpy.postMessage).not.toHaveBeenCalledWith(message); + expect(listPortSpy.postMessage).not.toHaveBeenCalledWith(message); + }); + + it("posts a message to the overlay button and list with the display value", () => { + const message = { command: "updateAutofillOverlayHidden", display: "none" }; + + sendExtensionRuntimeMessage(message); + + expect(overlayBackground["overlayButtonPort"].postMessage).toHaveBeenCalledWith({ + command: "updateOverlayHidden", + styles: { + display: message.display, + }, + }); + expect(overlayBackground["overlayListPort"].postMessage).toHaveBeenCalledWith({ + command: "updateOverlayHidden", + styles: { + display: message.display, + }, + }); + }); + }); + + describe("collectPageDetailsResponse message handler", () => { + let sender: chrome.runtime.MessageSender; + const pageDetails1 = createAutofillPageDetailsMock({ + login: { username: "username1", password: "password1" }, + }); + const pageDetails2 = createAutofillPageDetailsMock({ + login: { username: "username2", password: "password2" }, + }); + + beforeEach(() => { + sender = mock({ tab: { id: 1 } }); + }); + + it("stores the page details provided by the message by the tab id of the sender", () => { + sendExtensionRuntimeMessage( + { command: "collectPageDetailsResponse", details: pageDetails1 }, + sender, + ); + + expect(overlayBackground["pageDetailsForTab"][sender.tab.id]).toStrictEqual( + new Map([ + [sender.frameId, { frameId: sender.frameId, tab: sender.tab, details: pageDetails1 }], + ]), + ); + }); + + it("updates the page details for a tab that already has a set of page details stored ", () => { + const secondFrameSender = mock({ + tab: { id: 1 }, + frameId: 3, + }); + overlayBackground["pageDetailsForTab"][sender.tab.id] = new Map([ + [sender.frameId, { frameId: sender.frameId, tab: sender.tab, details: pageDetails1 }], + ]); + + sendExtensionRuntimeMessage( + { command: "collectPageDetailsResponse", details: pageDetails2 }, + secondFrameSender, + ); + + expect(overlayBackground["pageDetailsForTab"][sender.tab.id]).toStrictEqual( + new Map([ + [sender.frameId, { frameId: sender.frameId, tab: sender.tab, details: pageDetails1 }], + [ + secondFrameSender.frameId, + { + frameId: secondFrameSender.frameId, + tab: secondFrameSender.tab, + details: pageDetails2, + }, + ], + ]), + ); + }); + }); + + describe("unlockCompleted message handler", () => { + let getAuthStatusSpy: jest.SpyInstance; + + beforeEach(() => { + overlayBackground["userAuthStatus"] = AuthenticationStatus.LoggedOut; + jest.spyOn(BrowserApi, "tabSendMessageData"); + getAuthStatusSpy = jest + .spyOn(overlayBackground as any, "getAuthStatus") + .mockImplementation(() => { + overlayBackground["userAuthStatus"] = AuthenticationStatus.Unlocked; + return Promise.resolve(AuthenticationStatus.Unlocked); + }); + }); + + it("updates the user's auth status but does not open the overlay", async () => { + const message = { + command: "unlockCompleted", + data: { + commandToRetry: { message: { command: "" } }, + }, + }; + + sendExtensionRuntimeMessage(message); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(BrowserApi.tabSendMessageData).not.toHaveBeenCalled(); + }); + + it("updates user's auth status and opens the overlay if a follow up command is provided", async () => { + const sender = mock({ tab: { id: 1 } }); + const message = { + command: "unlockCompleted", + data: { + commandToRetry: { message: { command: "openAutofillOverlay" } }, + }, + }; + jest.spyOn(BrowserApi, "getTabFromCurrentWindowId").mockResolvedValueOnce(sender.tab); + + sendExtensionRuntimeMessage(message); + await flushPromises(); + + expect(getAuthStatusSpy).toHaveBeenCalled(); + expect(BrowserApi.tabSendMessageData).toHaveBeenCalledWith( + sender.tab, + "openAutofillOverlay", + { + isFocusingFieldElement: true, + isOpeningFullOverlay: false, + authStatus: AuthenticationStatus.Unlocked, + }, + ); + }); + }); + + describe("addEditCipherSubmitted message handler", () => { + it("updates the overlay ciphers", () => { + const message = { + command: "addEditCipherSubmitted", + }; + jest.spyOn(overlayBackground as any, "updateOverlayCiphers").mockImplementation(); + + sendExtensionRuntimeMessage(message); + + expect(overlayBackground["updateOverlayCiphers"]).toHaveBeenCalled(); + }); + }); + + describe("deletedCipher message handler", () => { + it("updates the overlay ciphers", () => { + const message = { + command: "deletedCipher", + }; + jest.spyOn(overlayBackground as any, "updateOverlayCiphers").mockImplementation(); + + sendExtensionRuntimeMessage(message); + + expect(overlayBackground["updateOverlayCiphers"]).toHaveBeenCalled(); + }); + }); + }); + }); + + describe("handlePortOnConnect", () => { + beforeEach(() => { + jest.spyOn(overlayBackground as any, "updateOverlayPosition").mockImplementation(); + jest.spyOn(overlayBackground as any, "getAuthStatus").mockImplementation(); + jest.spyOn(overlayBackground as any, "getTranslations").mockImplementation(); + jest.spyOn(overlayBackground as any, "getOverlayCipherData").mockImplementation(); + }); + + it("skips setting up the overlay port if the port connection is not for an overlay element", async () => { + const port = createPortSpyMock("not-an-overlay-element"); + + await overlayBackground["handlePortOnConnect"](port); + + expect(port.onMessage.addListener).not.toHaveBeenCalled(); + expect(port.postMessage).not.toHaveBeenCalled(); + }); + + it("sets up the overlay list port if the port connection is for the overlay list", async () => { + await initOverlayElementPorts({ initList: true, initButton: false }); + await flushPromises(); + + expect(overlayBackground["overlayButtonPort"]).toBeUndefined(); + expect(listPortSpy.onMessage.addListener).toHaveBeenCalled(); + expect(listPortSpy.postMessage).toHaveBeenCalled(); + expect(overlayBackground["getAuthStatus"]).toHaveBeenCalled(); + expect(chrome.runtime.getURL).toHaveBeenCalledWith("overlay/list.css"); + expect(overlayBackground["getTranslations"]).toHaveBeenCalled(); + expect(overlayBackground["getOverlayCipherData"]).toHaveBeenCalled(); + expect(overlayBackground["updateOverlayPosition"]).toHaveBeenCalledWith({ + overlayElement: AutofillOverlayElement.List, + }); + }); + + it("sets up the overlay button port if the port connection is for the overlay button", async () => { + await initOverlayElementPorts({ initList: false, initButton: true }); + await flushPromises(); + + expect(overlayBackground["overlayListPort"]).toBeUndefined(); + expect(buttonPortSpy.onMessage.addListener).toHaveBeenCalled(); + expect(buttonPortSpy.postMessage).toHaveBeenCalled(); + expect(overlayBackground["getAuthStatus"]).toHaveBeenCalled(); + expect(chrome.runtime.getURL).toHaveBeenCalledWith("overlay/button.css"); + expect(overlayBackground["getTranslations"]).toHaveBeenCalled(); + expect(overlayBackground["updateOverlayPosition"]).toHaveBeenCalledWith({ + overlayElement: AutofillOverlayElement.Button, + }); + }); + + it("gets the system theme", async () => { + themeStateService.selectedTheme$ = of(ThemeType.System); + + await initOverlayElementPorts({ initList: true, initButton: false }); + await flushPromises(); + + expect(listPortSpy.postMessage).toHaveBeenCalledWith( + expect.objectContaining({ theme: ThemeType.System }), + ); + }); + }); + + describe("handleOverlayElementPortMessage", () => { + beforeEach(async () => { + await initOverlayElementPorts(); + overlayBackground["userAuthStatus"] = AuthenticationStatus.Unlocked; + }); + + it("ignores port messages that do not contain a handler", () => { + jest.spyOn(overlayBackground as any, "checkOverlayButtonFocused").mockImplementation(); + + sendPortMessage(buttonPortSpy, { command: "checkAutofillOverlayButtonFocused" }); + + expect(overlayBackground["checkOverlayButtonFocused"]).not.toHaveBeenCalled(); + }); + + describe("overlay button message handlers", () => { + it("unlocks the vault if the user auth status is not unlocked", () => { + overlayBackground["userAuthStatus"] = AuthenticationStatus.LoggedOut; + jest.spyOn(overlayBackground as any, "unlockVault").mockImplementation(); + + sendPortMessage(buttonPortSpy, { command: "overlayButtonClicked" }); + + expect(overlayBackground["unlockVault"]).toHaveBeenCalled(); + }); + + it("opens the autofill overlay if the auth status is unlocked", () => { + jest.spyOn(overlayBackground as any, "openOverlay").mockImplementation(); + + sendPortMessage(buttonPortSpy, { command: "overlayButtonClicked" }); + + expect(overlayBackground["openOverlay"]).toHaveBeenCalled(); + }); + + describe("closeAutofillOverlay", () => { + it("sends a `closeOverlay` message to the sender tab", () => { + jest.spyOn(BrowserApi, "tabSendMessageData"); + + sendPortMessage(buttonPortSpy, { command: "closeAutofillOverlay" }); + + expect(BrowserApi.tabSendMessageData).toHaveBeenCalledWith( + buttonPortSpy.sender.tab, + "closeAutofillOverlay", + { forceCloseOverlay: false }, + ); + }); + }); + + describe("forceCloseAutofillOverlay", () => { + it("sends a `closeOverlay` message to the sender tab with a `forceCloseOverlay` flag of `true` set", () => { + jest.spyOn(BrowserApi, "tabSendMessageData"); + + sendPortMessage(buttonPortSpy, { command: "forceCloseAutofillOverlay" }); + + expect(BrowserApi.tabSendMessageData).toHaveBeenCalledWith( + buttonPortSpy.sender.tab, + "closeAutofillOverlay", + { forceCloseOverlay: true }, + ); + }); + }); + + describe("overlayPageBlurred", () => { + it("checks if the overlay list is focused", () => { + jest.spyOn(overlayBackground as any, "checkOverlayListFocused"); + + sendPortMessage(buttonPortSpy, { command: "overlayPageBlurred" }); + + expect(overlayBackground["checkOverlayListFocused"]).toHaveBeenCalled(); + }); + }); + + describe("redirectOverlayFocusOut", () => { + beforeEach(() => { + jest.spyOn(BrowserApi, "tabSendMessageData"); + }); + + it("ignores the redirect message if the direction is not provided", () => { + sendPortMessage(buttonPortSpy, { command: "redirectOverlayFocusOut" }); + + expect(BrowserApi.tabSendMessageData).not.toHaveBeenCalled(); + }); + + it("sends the redirect message if the direction is provided", () => { + sendPortMessage(buttonPortSpy, { + command: "redirectOverlayFocusOut", + direction: RedirectFocusDirection.Next, + }); + + expect(BrowserApi.tabSendMessageData).toHaveBeenCalledWith( + buttonPortSpy.sender.tab, + "redirectOverlayFocusOut", + { direction: RedirectFocusDirection.Next }, + ); + }); + }); + }); + + describe("overlay list message handlers", () => { + describe("checkAutofillOverlayButtonFocused", () => { + it("checks on the focus state of the overlay button", () => { + jest.spyOn(overlayBackground as any, "checkOverlayButtonFocused").mockImplementation(); + + sendPortMessage(listPortSpy, { command: "checkAutofillOverlayButtonFocused" }); + + expect(overlayBackground["checkOverlayButtonFocused"]).toHaveBeenCalled(); + }); + }); + + describe("forceCloseAutofillOverlay", () => { + it("sends a `closeOverlay` message to the sender tab with a `forceCloseOverlay` flag of `true` set", () => { + jest.spyOn(BrowserApi, "tabSendMessageData"); + + sendPortMessage(listPortSpy, { command: "forceCloseAutofillOverlay" }); + + expect(BrowserApi.tabSendMessageData).toHaveBeenCalledWith( + listPortSpy.sender.tab, + "closeAutofillOverlay", + { forceCloseOverlay: true }, + ); + }); + }); + + describe("overlayPageBlurred", () => { + it("checks on the focus state of the overlay button", () => { + jest.spyOn(overlayBackground as any, "checkOverlayButtonFocused").mockImplementation(); + + sendPortMessage(listPortSpy, { command: "overlayPageBlurred" }); + + expect(overlayBackground["checkOverlayButtonFocused"]).toHaveBeenCalled(); + }); + }); + + describe("unlockVault", () => { + it("closes the autofill overlay and opens the unlock popout", async () => { + jest.spyOn(overlayBackground as any, "closeOverlay").mockImplementation(); + jest.spyOn(overlayBackground as any, "openUnlockPopout").mockImplementation(); + jest.spyOn(BrowserApi, "tabSendMessageData").mockImplementation(); + + sendPortMessage(listPortSpy, { command: "unlockVault" }); + await flushPromises(); + + expect(overlayBackground["closeOverlay"]).toHaveBeenCalledWith(listPortSpy); + expect(BrowserApi.tabSendMessageData).toHaveBeenCalledWith( + listPortSpy.sender.tab, + "addToLockedVaultPendingNotifications", + { + commandToRetry: { + message: { command: "openAutofillOverlay" }, + sender: listPortSpy.sender, + }, + target: "overlay.background", + }, + ); + expect(overlayBackground["openUnlockPopout"]).toHaveBeenCalledWith( + listPortSpy.sender.tab, + true, + ); + }); + }); + + describe("fillSelectedListItem", () => { + let getLoginCiphersSpy: jest.SpyInstance; + let isPasswordRepromptRequiredSpy: jest.SpyInstance; + let doAutoFillSpy: jest.SpyInstance; + let sender: chrome.runtime.MessageSender; + const pageDetails = createAutofillPageDetailsMock({ + login: { username: "username1", password: "password1" }, + }); + + beforeEach(() => { + getLoginCiphersSpy = jest.spyOn(overlayBackground["overlayLoginCiphers"], "get"); + isPasswordRepromptRequiredSpy = jest.spyOn( + overlayBackground["autofillService"], + "isPasswordRepromptRequired", + ); + doAutoFillSpy = jest.spyOn(overlayBackground["autofillService"], "doAutoFill"); + sender = mock({ tab: { id: 1 } }); + }); + + it("ignores the fill request if the overlay cipher id is not provided", async () => { + sendPortMessage(listPortSpy, { command: "fillSelectedListItem" }); + await flushPromises(); + + expect(getLoginCiphersSpy).not.toHaveBeenCalled(); + expect(isPasswordRepromptRequiredSpy).not.toHaveBeenCalled(); + expect(doAutoFillSpy).not.toHaveBeenCalled(); + }); + + it("ignores the fill request if the tab does not contain any identified page details", async () => { + sendPortMessage(listPortSpy, { + command: "fillSelectedListItem", + overlayCipherId: "overlay-cipher-1", + }); + await flushPromises(); + + expect(getLoginCiphersSpy).not.toHaveBeenCalled(); + expect(isPasswordRepromptRequiredSpy).not.toHaveBeenCalled(); + expect(doAutoFillSpy).not.toHaveBeenCalled(); + }); + + it("ignores the fill request if a master password reprompt is required", async () => { + const cipher = mock({ + reprompt: CipherRepromptType.Password, + type: CipherType.Login, + }); + overlayBackground["overlayLoginCiphers"] = new Map([["overlay-cipher-1", cipher]]); + overlayBackground["pageDetailsForTab"][sender.tab.id] = new Map([ + [sender.frameId, { frameId: sender.frameId, tab: sender.tab, details: pageDetails }], + ]); + getLoginCiphersSpy = jest.spyOn(overlayBackground["overlayLoginCiphers"], "get"); + isPasswordRepromptRequiredSpy.mockResolvedValue(true); + + sendPortMessage(listPortSpy, { + command: "fillSelectedListItem", + overlayCipherId: "overlay-cipher-1", + }); + await flushPromises(); + + expect(getLoginCiphersSpy).toHaveBeenCalled(); + expect(isPasswordRepromptRequiredSpy).toHaveBeenCalledWith( + cipher, + listPortSpy.sender.tab, + ); + expect(doAutoFillSpy).not.toHaveBeenCalled(); + }); + + it("auto-fills the selected cipher and move it to the top of the front of the ciphers map", async () => { + const cipher1 = mock({ id: "overlay-cipher-1" }); + const cipher2 = mock({ id: "overlay-cipher-2" }); + const cipher3 = mock({ id: "overlay-cipher-3" }); + overlayBackground["overlayLoginCiphers"] = new Map([ + ["overlay-cipher-1", cipher1], + ["overlay-cipher-2", cipher2], + ["overlay-cipher-3", cipher3], + ]); + const pageDetailsForTab = { + frameId: sender.frameId, + tab: sender.tab, + details: pageDetails, + }; + overlayBackground["pageDetailsForTab"][sender.tab.id] = new Map([ + [sender.frameId, pageDetailsForTab], + ]); + isPasswordRepromptRequiredSpy.mockResolvedValue(false); + + sendPortMessage(listPortSpy, { + command: "fillSelectedListItem", + overlayCipherId: "overlay-cipher-2", + }); + await flushPromises(); + + expect(isPasswordRepromptRequiredSpy).toHaveBeenCalledWith( + cipher2, + listPortSpy.sender.tab, + ); + expect(doAutoFillSpy).toHaveBeenCalledWith({ + tab: listPortSpy.sender.tab, + cipher: cipher2, + pageDetails: [pageDetailsForTab], + fillNewPassword: true, + allowTotpAutofill: true, + }); + expect(overlayBackground["overlayLoginCiphers"].entries()).toStrictEqual( + new Map([ + ["overlay-cipher-2", cipher2], + ["overlay-cipher-1", cipher1], + ["overlay-cipher-3", cipher3], + ]).entries(), + ); + }); + + it("copies the cipher's totp code to the clipboard after filling", async () => { + const cipher1 = mock({ id: "overlay-cipher-1" }); + overlayBackground["overlayLoginCiphers"] = new Map([["overlay-cipher-1", cipher1]]); + overlayBackground["pageDetailsForTab"][sender.tab.id] = new Map([ + [sender.frameId, { frameId: sender.frameId, tab: sender.tab, details: pageDetails }], + ]); + isPasswordRepromptRequiredSpy.mockResolvedValue(false); + const copyToClipboardSpy = jest + .spyOn(overlayBackground["platformUtilsService"], "copyToClipboard") + .mockImplementation(); + doAutoFillSpy.mockReturnValueOnce("totp-code"); + + sendPortMessage(listPortSpy, { + command: "fillSelectedListItem", + overlayCipherId: "overlay-cipher-2", + }); + await flushPromises(); + + expect(copyToClipboardSpy).toHaveBeenCalledWith("totp-code"); + }); + }); + + describe("getNewVaultItemDetails", () => { + it("will send an addNewVaultItemFromOverlay message", async () => { + jest.spyOn(BrowserApi, "tabSendMessage"); + + sendPortMessage(listPortSpy, { command: "addNewVaultItem" }); + await flushPromises(); + + expect(BrowserApi.tabSendMessage).toHaveBeenCalledWith(listPortSpy.sender.tab, { + command: "addNewVaultItemFromOverlay", + }); + }); + }); + + describe("viewSelectedCipher", () => { + let openViewVaultItemPopoutSpy: jest.SpyInstance; + + beforeEach(() => { + openViewVaultItemPopoutSpy = jest + .spyOn(overlayBackground as any, "openViewVaultItemPopout") + .mockImplementation(); + }); + + it("returns early if the passed cipher ID does not match one of the overlay login ciphers", async () => { + overlayBackground["overlayLoginCiphers"] = new Map([ + ["overlay-cipher-0", mock({ id: "overlay-cipher-0" })], + ]); + + sendPortMessage(listPortSpy, { + command: "viewSelectedCipher", + overlayCipherId: "overlay-cipher-1", + }); + await flushPromises(); + + expect(openViewVaultItemPopoutSpy).not.toHaveBeenCalled(); + }); + + it("will open the view vault item popout with the selected cipher", async () => { + const cipher = mock({ id: "overlay-cipher-1" }); + overlayBackground["overlayLoginCiphers"] = new Map([ + ["overlay-cipher-0", mock({ id: "overlay-cipher-0" })], + ["overlay-cipher-1", cipher], + ]); + + sendPortMessage(listPortSpy, { + command: "viewSelectedCipher", + overlayCipherId: "overlay-cipher-1", + }); + await flushPromises(); + + expect(overlayBackground["openViewVaultItemPopout"]).toHaveBeenCalledWith( + listPortSpy.sender.tab, + { + cipherId: cipher.id, + action: SHOW_AUTOFILL_BUTTON, + }, + ); + }); + }); + + describe("redirectOverlayFocusOut", () => { + it("redirects focus out of the overlay list", async () => { + const message = { + command: "redirectOverlayFocusOut", + direction: RedirectFocusDirection.Next, + }; + const redirectOverlayFocusOutSpy = jest.spyOn( + overlayBackground as any, + "redirectOverlayFocusOut", + ); + + sendPortMessage(listPortSpy, message); + await flushPromises(); + + expect(redirectOverlayFocusOutSpy).toHaveBeenCalledWith(message, listPortSpy); + }); + }); + }); + }); +}); diff --git a/apps/browser/src/autofill/background/overlay.background.ts b/apps/browser/src/autofill/background/overlay.background.ts new file mode 100644 index 0000000000..50fb80ef1b --- /dev/null +++ b/apps/browser/src/autofill/background/overlay.background.ts @@ -0,0 +1,748 @@ +import { firstValueFrom } from "rxjs"; + +import { AuthService } from "@bitwarden/common/auth/abstractions/auth.service"; +import { AuthenticationStatus } from "@bitwarden/common/auth/enums/authentication-status"; +import { SHOW_AUTOFILL_BUTTON } from "@bitwarden/common/autofill/constants"; +import { AutofillSettingsServiceAbstraction } from "@bitwarden/common/autofill/services/autofill-settings.service"; +import { DomainSettingsService } from "@bitwarden/common/autofill/services/domain-settings.service"; +import { InlineMenuVisibilitySetting } from "@bitwarden/common/autofill/types"; +import { EnvironmentService } from "@bitwarden/common/platform/abstractions/environment.service"; +import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service"; +import { PlatformUtilsService } from "@bitwarden/common/platform/abstractions/platform-utils.service"; +import { StateService } from "@bitwarden/common/platform/abstractions/state.service"; +import { Utils } from "@bitwarden/common/platform/misc/utils"; +import { ThemeStateService } from "@bitwarden/common/platform/theming/theme-state.service"; +import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service"; +import { CipherType } from "@bitwarden/common/vault/enums"; +import { buildCipherIcon } from "@bitwarden/common/vault/icon/build-cipher-icon"; +import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view"; +import { LoginUriView } from "@bitwarden/common/vault/models/view/login-uri.view"; +import { LoginView } from "@bitwarden/common/vault/models/view/login.view"; + +import { openUnlockPopout } from "../../auth/popup/utils/auth-popout-window"; +import { BrowserApi } from "../../platform/browser/browser-api"; +import { + openViewVaultItemPopout, + openAddEditVaultItemPopout, +} from "../../vault/popup/utils/vault-popout-window"; +import { AutofillService, PageDetail } from "../services/abstractions/autofill.service"; +import { AutofillOverlayElement, AutofillOverlayPort } from "../utils/autofill-overlay.enum"; + +import { LockedVaultPendingNotificationsData } from "./abstractions/notification.background"; +import { + FocusedFieldData, + OverlayBackgroundExtensionMessageHandlers, + OverlayButtonPortMessageHandlers, + OverlayCipherData, + OverlayListPortMessageHandlers, + OverlayBackground as OverlayBackgroundInterface, + OverlayBackgroundExtensionMessage, + OverlayAddNewItemMessage, + OverlayPortMessage, + WebsiteIconData, +} from "./abstractions/overlay.background"; + +class OverlayBackground implements OverlayBackgroundInterface { + private readonly openUnlockPopout = openUnlockPopout; + private readonly openViewVaultItemPopout = openViewVaultItemPopout; + private readonly openAddEditVaultItemPopout = openAddEditVaultItemPopout; + private overlayLoginCiphers: Map = new Map(); + private pageDetailsForTab: Record< + chrome.runtime.MessageSender["tab"]["id"], + Map + > = {}; + private userAuthStatus: AuthenticationStatus = AuthenticationStatus.LoggedOut; + private overlayButtonPort: chrome.runtime.Port; + private overlayListPort: chrome.runtime.Port; + private focusedFieldData: FocusedFieldData; + private overlayPageTranslations: Record; + private iconsServerUrl: string; + private readonly extensionMessageHandlers: OverlayBackgroundExtensionMessageHandlers = { + openAutofillOverlay: () => this.openOverlay(false), + autofillOverlayElementClosed: ({ message }) => this.overlayElementClosed(message), + autofillOverlayAddNewVaultItem: ({ message, sender }) => this.addNewVaultItem(message, sender), + getAutofillOverlayVisibility: () => this.getOverlayVisibility(), + checkAutofillOverlayFocused: () => this.checkOverlayFocused(), + focusAutofillOverlayList: () => this.focusOverlayList(), + updateAutofillOverlayPosition: ({ message }) => this.updateOverlayPosition(message), + updateAutofillOverlayHidden: ({ message }) => this.updateOverlayHidden(message), + updateFocusedFieldData: ({ message }) => this.setFocusedFieldData(message), + collectPageDetailsResponse: ({ message, sender }) => this.storePageDetails(message, sender), + unlockCompleted: ({ message }) => this.unlockCompleted(message), + addEditCipherSubmitted: () => this.updateOverlayCiphers(), + deletedCipher: () => this.updateOverlayCiphers(), + }; + private readonly overlayButtonPortMessageHandlers: OverlayButtonPortMessageHandlers = { + overlayButtonClicked: ({ port }) => this.handleOverlayButtonClicked(port), + closeAutofillOverlay: ({ port }) => this.closeOverlay(port), + forceCloseAutofillOverlay: ({ port }) => this.closeOverlay(port, true), + overlayPageBlurred: () => this.checkOverlayListFocused(), + redirectOverlayFocusOut: ({ message, port }) => this.redirectOverlayFocusOut(message, port), + }; + private readonly overlayListPortMessageHandlers: OverlayListPortMessageHandlers = { + checkAutofillOverlayButtonFocused: () => this.checkOverlayButtonFocused(), + forceCloseAutofillOverlay: ({ port }) => this.closeOverlay(port, true), + overlayPageBlurred: () => this.checkOverlayButtonFocused(), + unlockVault: ({ port }) => this.unlockVault(port), + fillSelectedListItem: ({ message, port }) => this.fillSelectedOverlayListItem(message, port), + addNewVaultItem: ({ port }) => this.getNewVaultItemDetails(port), + viewSelectedCipher: ({ message, port }) => this.viewSelectedCipher(message, port), + redirectOverlayFocusOut: ({ message, port }) => this.redirectOverlayFocusOut(message, port), + }; + + constructor( + private cipherService: CipherService, + private autofillService: AutofillService, + private authService: AuthService, + private environmentService: EnvironmentService, + private domainSettingsService: DomainSettingsService, + private stateService: StateService, + private autofillSettingsService: AutofillSettingsServiceAbstraction, + private i18nService: I18nService, + private platformUtilsService: PlatformUtilsService, + private themeStateService: ThemeStateService, + ) {} + + /** + * Removes cached page details for a tab + * based on the passed tabId. + * + * @param tabId - Used to reference the page details of a specific tab + */ + removePageDetails(tabId: number) { + if (!this.pageDetailsForTab[tabId]) { + return; + } + + this.pageDetailsForTab[tabId].clear(); + delete this.pageDetailsForTab[tabId]; + } + + /** + * Sets up the extension message listeners and gets the settings for the + * overlay's visibility and the user's authentication status. + */ + async init() { + this.setupExtensionMessageListeners(); + const env = await firstValueFrom(this.environmentService.environment$); + this.iconsServerUrl = env.getIconsUrl(); + await this.getOverlayVisibility(); + await this.getAuthStatus(); + } + + /** + * Updates the overlay list's ciphers and sends the updated list to the overlay list iframe. + * Queries all ciphers for the given url, and sorts them by last used. Will not update the + * list of ciphers if the extension is not unlocked. + */ + async updateOverlayCiphers() { + if (this.userAuthStatus !== AuthenticationStatus.Unlocked) { + return; + } + + const currentTab = await BrowserApi.getTabFromCurrentWindowId(); + if (!currentTab?.url) { + return; + } + + this.overlayLoginCiphers = new Map(); + const ciphersViews = (await this.cipherService.getAllDecryptedForUrl(currentTab.url)).sort( + (a, b) => this.cipherService.sortCiphersByLastUsedThenName(a, b), + ); + for (let cipherIndex = 0; cipherIndex < ciphersViews.length; cipherIndex++) { + this.overlayLoginCiphers.set(`overlay-cipher-${cipherIndex}`, ciphersViews[cipherIndex]); + } + + const ciphers = await this.getOverlayCipherData(); + this.overlayListPort?.postMessage({ command: "updateOverlayListCiphers", ciphers }); + await BrowserApi.tabSendMessageData(currentTab, "updateIsOverlayCiphersPopulated", { + isOverlayCiphersPopulated: Boolean(ciphers.length), + }); + } + + /** + * Strips out unnecessary data from the ciphers and returns an array of + * objects that contain the cipher data needed for the overlay list. + */ + private async getOverlayCipherData(): Promise { + const showFavicons = await firstValueFrom(this.domainSettingsService.showFavicons$); + const overlayCiphersArray = Array.from(this.overlayLoginCiphers); + const overlayCipherData = []; + let loginCipherIcon: WebsiteIconData; + + for (let cipherIndex = 0; cipherIndex < overlayCiphersArray.length; cipherIndex++) { + const [overlayCipherId, cipher] = overlayCiphersArray[cipherIndex]; + if (!loginCipherIcon && cipher.type === CipherType.Login) { + loginCipherIcon = buildCipherIcon(this.iconsServerUrl, cipher, showFavicons); + } + + overlayCipherData.push({ + id: overlayCipherId, + name: cipher.name, + type: cipher.type, + reprompt: cipher.reprompt, + favorite: cipher.favorite, + icon: + cipher.type === CipherType.Login + ? loginCipherIcon + : buildCipherIcon(this.iconsServerUrl, cipher, showFavicons), + login: cipher.type === CipherType.Login ? { username: cipher.login.username } : null, + card: cipher.type === CipherType.Card ? cipher.card.subTitle : null, + }); + } + + return overlayCipherData; + } + + /** + * Handles aggregation of page details for a tab. Stores the page details + * in association with the tabId of the tab that sent the message. + * + * @param message - Message received from the `collectPageDetailsResponse` command + * @param sender - The sender of the message + */ + private storePageDetails( + message: OverlayBackgroundExtensionMessage, + sender: chrome.runtime.MessageSender, + ) { + const pageDetails = { + frameId: sender.frameId, + tab: sender.tab, + details: message.details, + }; + + const pageDetailsMap = this.pageDetailsForTab[sender.tab.id]; + if (!pageDetailsMap) { + this.pageDetailsForTab[sender.tab.id] = new Map([[sender.frameId, pageDetails]]); + return; + } + + pageDetailsMap.set(sender.frameId, pageDetails); + } + + /** + * Triggers autofill for the selected cipher in the overlay list. Also places + * the selected cipher at the top of the list of ciphers. + * + * @param overlayCipherId - Cipher ID corresponding to the overlayLoginCiphers map. Does not correspond to the actual cipher's ID. + * @param sender - The sender of the port message + */ + private async fillSelectedOverlayListItem( + { overlayCipherId }: OverlayPortMessage, + { sender }: chrome.runtime.Port, + ) { + const pageDetails = this.pageDetailsForTab[sender.tab.id]; + if (!overlayCipherId || !pageDetails?.size) { + return; + } + + const cipher = this.overlayLoginCiphers.get(overlayCipherId); + + if (await this.autofillService.isPasswordRepromptRequired(cipher, sender.tab)) { + return; + } + const totpCode = await this.autofillService.doAutoFill({ + tab: sender.tab, + cipher: cipher, + pageDetails: Array.from(pageDetails.values()), + fillNewPassword: true, + allowTotpAutofill: true, + }); + + if (totpCode) { + this.platformUtilsService.copyToClipboard(totpCode); + } + + this.overlayLoginCiphers = new Map([[overlayCipherId, cipher], ...this.overlayLoginCiphers]); + } + + /** + * Checks if the overlay is focused. Will check the overlay list + * if it is open, otherwise it will check the overlay button. + */ + private checkOverlayFocused() { + if (this.overlayListPort) { + this.checkOverlayListFocused(); + + return; + } + + this.checkOverlayButtonFocused(); + } + + /** + * Posts a message to the overlay button iframe to check if it is focused. + */ + private checkOverlayButtonFocused() { + this.overlayButtonPort?.postMessage({ command: "checkAutofillOverlayButtonFocused" }); + } + + /** + * Posts a message to the overlay list iframe to check if it is focused. + */ + private checkOverlayListFocused() { + this.overlayListPort?.postMessage({ command: "checkAutofillOverlayListFocused" }); + } + + /** + * Sends a message to the sender tab to close the autofill overlay. + * + * @param sender - The sender of the port message + * @param forceCloseOverlay - Identifies whether the overlay should be force closed + */ + private closeOverlay({ sender }: chrome.runtime.Port, forceCloseOverlay = false) { + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + BrowserApi.tabSendMessageData(sender.tab, "closeAutofillOverlay", { forceCloseOverlay }); + } + + /** + * Handles cleanup when an overlay element is closed. Disconnects + * the list and button ports and sets them to null. + * + * @param overlayElement - The overlay element that was closed, either the list or button + */ + private overlayElementClosed({ overlayElement }: OverlayBackgroundExtensionMessage) { + if (overlayElement === AutofillOverlayElement.Button) { + this.overlayButtonPort?.disconnect(); + this.overlayButtonPort = null; + + return; + } + + this.overlayListPort?.disconnect(); + this.overlayListPort = null; + } + + /** + * Updates the position of either the overlay list or button. The position + * is based on the focused field's position and dimensions. + * + * @param overlayElement - The overlay element to update, either the list or button + */ + private updateOverlayPosition({ overlayElement }: { overlayElement?: string }) { + if (!overlayElement) { + return; + } + + if (overlayElement === AutofillOverlayElement.Button) { + this.overlayButtonPort?.postMessage({ + command: "updateIframePosition", + styles: this.getOverlayButtonPosition(), + }); + + return; + } + + this.overlayListPort?.postMessage({ + command: "updateIframePosition", + styles: this.getOverlayListPosition(), + }); + } + + /** + * Gets the position of the focused field and calculates the position + * of the overlay button based on the focused field's position and dimensions. + */ + private getOverlayButtonPosition() { + if (!this.focusedFieldData) { + return; + } + + const { top, left, width, height } = this.focusedFieldData.focusedFieldRects; + const { paddingRight, paddingLeft } = this.focusedFieldData.focusedFieldStyles; + let elementOffset = height * 0.37; + if (height >= 35) { + elementOffset = height >= 50 ? height * 0.47 : height * 0.42; + } + + const elementHeight = height - elementOffset; + const elementTopPosition = top + elementOffset / 2; + let elementLeftPosition = left + width - height + elementOffset / 2; + + const fieldPaddingRight = parseInt(paddingRight, 10); + const fieldPaddingLeft = parseInt(paddingLeft, 10); + if (fieldPaddingRight > fieldPaddingLeft) { + elementLeftPosition = left + width - height - (fieldPaddingRight - elementOffset + 2); + } + + return { + top: `${Math.round(elementTopPosition)}px`, + left: `${Math.round(elementLeftPosition)}px`, + height: `${Math.round(elementHeight)}px`, + width: `${Math.round(elementHeight)}px`, + }; + } + + /** + * Gets the position of the focused field and calculates the position + * of the overlay list based on the focused field's position and dimensions. + */ + private getOverlayListPosition() { + if (!this.focusedFieldData) { + return; + } + + const { top, left, width, height } = this.focusedFieldData.focusedFieldRects; + return { + width: `${Math.round(width)}px`, + top: `${Math.round(top + height)}px`, + left: `${Math.round(left)}px`, + }; + } + + /** + * Sets the focused field data to the data passed in the extension message. + * + * @param focusedFieldData - Contains the rects and styles of the focused field. + */ + private setFocusedFieldData({ focusedFieldData }: OverlayBackgroundExtensionMessage) { + this.focusedFieldData = focusedFieldData; + } + + /** + * Updates the overlay's visibility based on the display property passed in the extension message. + * + * @param display - The display property of the overlay, either "block" or "none" + */ + private updateOverlayHidden({ display }: OverlayBackgroundExtensionMessage) { + if (!display) { + return; + } + + const portMessage = { command: "updateOverlayHidden", styles: { display } }; + + this.overlayButtonPort?.postMessage(portMessage); + this.overlayListPort?.postMessage(portMessage); + } + + /** + * Sends a message to the currently active tab to open the autofill overlay. + * + * @param isFocusingFieldElement - Identifies whether the field element should be focused when the overlay is opened + * @param isOpeningFullOverlay - Identifies whether the full overlay should be forced open regardless of other states + */ + private async openOverlay(isFocusingFieldElement = false, isOpeningFullOverlay = false) { + const currentTab = await BrowserApi.getTabFromCurrentWindowId(); + + await BrowserApi.tabSendMessageData(currentTab, "openAutofillOverlay", { + isFocusingFieldElement, + isOpeningFullOverlay, + authStatus: await this.getAuthStatus(), + }); + } + + /** + * Gets the overlay's visibility setting from the settings service. + */ + private async getOverlayVisibility(): Promise { + return await firstValueFrom(this.autofillSettingsService.inlineMenuVisibility$); + } + + /** + * Gets the user's authentication status from the auth service. If the user's + * authentication status has changed, the overlay button's authentication status + * will be updated and the overlay list's ciphers will be updated. + */ + private async getAuthStatus() { + const formerAuthStatus = this.userAuthStatus; + this.userAuthStatus = await this.authService.getAuthStatus(); + + if ( + this.userAuthStatus !== formerAuthStatus && + this.userAuthStatus === AuthenticationStatus.Unlocked + ) { + this.updateOverlayButtonAuthStatus(); + await this.updateOverlayCiphers(); + } + + return this.userAuthStatus; + } + + /** + * Sends a message to the overlay button to update its authentication status. + */ + private updateOverlayButtonAuthStatus() { + this.overlayButtonPort?.postMessage({ + command: "updateOverlayButtonAuthStatus", + authStatus: this.userAuthStatus, + }); + } + + /** + * Handles the overlay button being clicked. If the user is not authenticated, + * the vault will be unlocked. If the user is authenticated, the overlay will + * be opened. + * + * @param port - The port of the overlay button + */ + private handleOverlayButtonClicked(port: chrome.runtime.Port) { + if (this.userAuthStatus !== AuthenticationStatus.Unlocked) { + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + this.unlockVault(port); + return; + } + + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + this.openOverlay(false, true); + } + + /** + * Facilitates opening the unlock popout window. + * + * @param port - The port of the overlay list + */ + private async unlockVault(port: chrome.runtime.Port) { + const { sender } = port; + + this.closeOverlay(port); + const retryMessage: LockedVaultPendingNotificationsData = { + commandToRetry: { message: { command: "openAutofillOverlay" }, sender }, + target: "overlay.background", + }; + await BrowserApi.tabSendMessageData( + sender.tab, + "addToLockedVaultPendingNotifications", + retryMessage, + ); + await this.openUnlockPopout(sender.tab, true); + } + + /** + * Triggers the opening of a vault item popout window associated + * with the passed cipher ID. + * @param overlayCipherId - Cipher ID corresponding to the overlayLoginCiphers map. Does not correspond to the actual cipher's ID. + * @param sender - The sender of the port message + */ + private async viewSelectedCipher( + { overlayCipherId }: OverlayPortMessage, + { sender }: chrome.runtime.Port, + ) { + const cipher = this.overlayLoginCiphers.get(overlayCipherId); + if (!cipher) { + return; + } + + await this.openViewVaultItemPopout(sender.tab, { + cipherId: cipher.id, + action: SHOW_AUTOFILL_BUTTON, + }); + } + + /** + * Facilitates redirecting focus to the overlay list. + */ + private focusOverlayList() { + this.overlayListPort?.postMessage({ command: "focusOverlayList" }); + } + + /** + * Updates the authentication status for the user and opens the overlay if + * a followup command is present in the message. + * + * @param message - Extension message received from the `unlockCompleted` command + */ + private async unlockCompleted(message: OverlayBackgroundExtensionMessage) { + await this.getAuthStatus(); + + if (message.data?.commandToRetry?.message?.command === "openAutofillOverlay") { + await this.openOverlay(true); + } + } + + /** + * Gets the translations for the overlay page. + */ + private getTranslations() { + if (!this.overlayPageTranslations) { + this.overlayPageTranslations = { + locale: BrowserApi.getUILanguage(), + opensInANewWindow: this.i18nService.translate("opensInANewWindow"), + buttonPageTitle: this.i18nService.translate("bitwardenOverlayButton"), + toggleBitwardenVaultOverlay: this.i18nService.translate("toggleBitwardenVaultOverlay"), + listPageTitle: this.i18nService.translate("bitwardenVault"), + unlockYourAccount: this.i18nService.translate("unlockYourAccountToViewMatchingLogins"), + unlockAccount: this.i18nService.translate("unlockAccount"), + fillCredentialsFor: this.i18nService.translate("fillCredentialsFor"), + partialUsername: this.i18nService.translate("partialUsername"), + view: this.i18nService.translate("view"), + noItemsToShow: this.i18nService.translate("noItemsToShow"), + newItem: this.i18nService.translate("newItem"), + addNewVaultItem: this.i18nService.translate("addNewVaultItem"), + }; + } + + return this.overlayPageTranslations; + } + + /** + * Facilitates redirecting focus out of one of the + * overlay elements to elements on the page. + * + * @param direction - The direction to redirect focus to (either "next", "previous" or "current) + * @param sender - The sender of the port message + */ + private redirectOverlayFocusOut( + { direction }: OverlayPortMessage, + { sender }: chrome.runtime.Port, + ) { + if (!direction) { + return; + } + + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + BrowserApi.tabSendMessageData(sender.tab, "redirectOverlayFocusOut", { direction }); + } + + /** + * Triggers adding a new vault item from the overlay. Gathers data + * input by the user before calling to open the add/edit window. + * + * @param sender - The sender of the port message + */ + private getNewVaultItemDetails({ sender }: chrome.runtime.Port) { + void BrowserApi.tabSendMessage(sender.tab, { command: "addNewVaultItemFromOverlay" }); + } + + /** + * Handles adding a new vault item from the overlay. Gathers data login + * data captured in the extension message. + * + * @param login - The login data captured from the extension message + * @param sender - The sender of the extension message + */ + private async addNewVaultItem( + { login }: OverlayAddNewItemMessage, + sender: chrome.runtime.MessageSender, + ) { + if (!login) { + return; + } + + const uriView = new LoginUriView(); + uriView.uri = login.uri; + + const loginView = new LoginView(); + loginView.uris = [uriView]; + loginView.username = login.username || ""; + loginView.password = login.password || ""; + + const cipherView = new CipherView(); + cipherView.name = (Utils.getHostname(login.uri) || login.hostname).replace(/^www\./, ""); + cipherView.folderId = null; + cipherView.type = CipherType.Login; + cipherView.login = loginView; + + await this.stateService.setAddEditCipherInfo({ + cipher: cipherView, + collectionIds: cipherView.collectionIds, + }); + + await this.openAddEditVaultItemPopout(sender.tab, { cipherId: cipherView.id }); + await BrowserApi.sendMessage("inlineAutofillMenuRefreshAddEditCipher"); + } + + /** + * Sets up the extension message listeners for the overlay. + */ + private setupExtensionMessageListeners() { + BrowserApi.messageListener("overlay.background", this.handleExtensionMessage); + BrowserApi.addListener(chrome.runtime.onConnect, this.handlePortOnConnect); + } + + /** + * Handles extension messages sent to the extension background. + * + * @param message - The message received from the extension + * @param sender - The sender of the message + * @param sendResponse - The response to send back to the sender + */ + private handleExtensionMessage = ( + message: OverlayBackgroundExtensionMessage, + sender: chrome.runtime.MessageSender, + sendResponse: (response?: any) => void, + ) => { + const handler: CallableFunction | undefined = this.extensionMessageHandlers[message?.command]; + if (!handler) { + return; + } + + const messageResponse = handler({ message, sender }); + if (!messageResponse) { + return; + } + + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + Promise.resolve(messageResponse).then((response) => sendResponse(response)); + return true; + }; + + /** + * Handles the connection of a port to the extension background. + * + * @param port - The port that connected to the extension background + */ + private handlePortOnConnect = async (port: chrome.runtime.Port) => { + const isOverlayListPort = port.name === AutofillOverlayPort.List; + const isOverlayButtonPort = port.name === AutofillOverlayPort.Button; + + if (!isOverlayListPort && !isOverlayButtonPort) { + return; + } + + if (isOverlayListPort) { + this.overlayListPort = port; + } else { + this.overlayButtonPort = port; + } + + port.onMessage.addListener(this.handleOverlayElementPortMessage); + port.postMessage({ + command: `initAutofillOverlay${isOverlayListPort ? "List" : "Button"}`, + authStatus: await this.getAuthStatus(), + styleSheetUrl: chrome.runtime.getURL(`overlay/${isOverlayListPort ? "list" : "button"}.css`), + theme: await firstValueFrom(this.themeStateService.selectedTheme$), + translations: this.getTranslations(), + ciphers: isOverlayListPort ? await this.getOverlayCipherData() : null, + }); + this.updateOverlayPosition({ + overlayElement: isOverlayListPort + ? AutofillOverlayElement.List + : AutofillOverlayElement.Button, + }); + }; + + /** + * Handles messages sent to the overlay list or button ports. + * + * @param message - The message received from the port + * @param port - The port that sent the message + */ + private handleOverlayElementPortMessage = ( + message: OverlayBackgroundExtensionMessage, + port: chrome.runtime.Port, + ) => { + const command = message?.command; + let handler: CallableFunction | undefined; + + if (port.name === AutofillOverlayPort.Button) { + handler = this.overlayButtonPortMessageHandlers[command]; + } + + if (port.name === AutofillOverlayPort.List) { + handler = this.overlayListPortMessageHandlers[command]; + } + + if (!handler) { + return; + } + + handler({ message, port }); + }; +} + +export default OverlayBackground; diff --git a/apps/browser/src/autofill/background/service_factories/autofill-service.factory.ts b/apps/browser/src/autofill/background/service_factories/autofill-service.factory.ts index a802fd8cf1..c948f7aa94 100644 --- a/apps/browser/src/autofill/background/service_factories/autofill-service.factory.ts +++ b/apps/browser/src/autofill/background/service_factories/autofill-service.factory.ts @@ -1,15 +1,12 @@ import { - TotpServiceInitOptions, - totpServiceFactory, -} from "../../../auth/background/service-factories/totp-service.factory"; + UserVerificationServiceInitOptions, + userVerificationServiceFactory, +} from "../../../auth/background/service-factories/user-verification-service.factory"; import { EventCollectionServiceInitOptions, eventCollectionServiceFactory, } from "../../../background/service-factories/event-collection-service.factory"; -import { - settingsServiceFactory, - SettingsServiceInitOptions, -} from "../../../background/service-factories/settings-service.factory"; +import { billingAccountProfileStateServiceFactory } from "../../../platform/background/service-factories/billing-account-profile-state-service.factory"; import { CachedServices, factory, @@ -19,30 +16,40 @@ import { logServiceFactory, LogServiceInitOptions, } from "../../../platform/background/service-factories/log-service.factory"; -import { - stateServiceFactory, - StateServiceInitOptions, -} from "../../../platform/background/service-factories/state-service.factory"; import { cipherServiceFactory, CipherServiceInitOptions, } from "../../../vault/background/service_factories/cipher-service.factory"; +import { + TotpServiceInitOptions, + totpServiceFactory, +} from "../../../vault/background/service_factories/totp-service.factory"; import { AutofillService as AbstractAutoFillService } from "../../services/abstractions/autofill.service"; import AutofillService from "../../services/autofill.service"; +import { + AutofillSettingsServiceInitOptions, + autofillSettingsServiceFactory, +} from "./autofill-settings-service.factory"; +import { + DomainSettingsServiceInitOptions, + domainSettingsServiceFactory, +} from "./domain-settings-service.factory"; + type AutoFillServiceOptions = FactoryOptions; export type AutoFillServiceInitOptions = AutoFillServiceOptions & CipherServiceInitOptions & - StateServiceInitOptions & + AutofillSettingsServiceInitOptions & TotpServiceInitOptions & EventCollectionServiceInitOptions & LogServiceInitOptions & - SettingsServiceInitOptions; + UserVerificationServiceInitOptions & + DomainSettingsServiceInitOptions; export function autofillServiceFactory( cache: { autofillService?: AbstractAutoFillService } & CachedServices, - opts: AutoFillServiceInitOptions + opts: AutoFillServiceInitOptions, ): Promise { return factory( cache, @@ -51,11 +58,13 @@ export function autofillServiceFactory( async () => new AutofillService( await cipherServiceFactory(cache, opts), - await stateServiceFactory(cache, opts), + await autofillSettingsServiceFactory(cache, opts), await totpServiceFactory(cache, opts), await eventCollectionServiceFactory(cache, opts), await logServiceFactory(cache, opts), - await settingsServiceFactory(cache, opts) - ) + await domainSettingsServiceFactory(cache, opts), + await userVerificationServiceFactory(cache, opts), + await billingAccountProfileStateServiceFactory(cache, opts), + ), ); } diff --git a/apps/browser/src/autofill/background/service_factories/autofill-settings-service.factory.ts b/apps/browser/src/autofill/background/service_factories/autofill-settings-service.factory.ts new file mode 100644 index 0000000000..ef9fdac968 --- /dev/null +++ b/apps/browser/src/autofill/background/service_factories/autofill-settings-service.factory.ts @@ -0,0 +1,35 @@ +import { AutofillSettingsService } from "@bitwarden/common/autofill/services/autofill-settings.service"; + +import { + policyServiceFactory, + PolicyServiceInitOptions, +} from "../../../admin-console/background/service-factories/policy-service.factory"; +import { + CachedServices, + factory, + FactoryOptions, +} from "../../../platform/background/service-factories/factory-options"; +import { + stateProviderFactory, + StateProviderInitOptions, +} from "../../../platform/background/service-factories/state-provider.factory"; + +export type AutofillSettingsServiceInitOptions = FactoryOptions & + StateProviderInitOptions & + PolicyServiceInitOptions; + +export function autofillSettingsServiceFactory( + cache: { autofillSettingsService?: AutofillSettingsService } & CachedServices, + opts: AutofillSettingsServiceInitOptions, +): Promise { + return factory( + cache, + "autofillSettingsService", + opts, + async () => + new AutofillSettingsService( + await stateProviderFactory(cache, opts), + await policyServiceFactory(cache, opts), + ), + ); +} diff --git a/apps/browser/src/autofill/background/service_factories/badge-settings-service.factory.ts b/apps/browser/src/autofill/background/service_factories/badge-settings-service.factory.ts new file mode 100644 index 0000000000..c51a9b31b0 --- /dev/null +++ b/apps/browser/src/autofill/background/service_factories/badge-settings-service.factory.ts @@ -0,0 +1,25 @@ +import { BadgeSettingsService } from "@bitwarden/common/autofill/services/badge-settings.service"; + +import { + CachedServices, + factory, + FactoryOptions, +} from "../../../platform/background/service-factories/factory-options"; +import { + stateProviderFactory, + StateProviderInitOptions, +} from "../../../platform/background/service-factories/state-provider.factory"; + +export type BadgeSettingsServiceInitOptions = FactoryOptions & StateProviderInitOptions; + +export function badgeSettingsServiceFactory( + cache: { badgeSettingsService?: BadgeSettingsService } & CachedServices, + opts: BadgeSettingsServiceInitOptions, +): Promise { + return factory( + cache, + "badgeSettingsService", + opts, + async () => new BadgeSettingsService(await stateProviderFactory(cache, opts)), + ); +} diff --git a/apps/browser/src/autofill/background/service_factories/domain-settings-service.factory.ts b/apps/browser/src/autofill/background/service_factories/domain-settings-service.factory.ts new file mode 100644 index 0000000000..1b4127c4cc --- /dev/null +++ b/apps/browser/src/autofill/background/service_factories/domain-settings-service.factory.ts @@ -0,0 +1,25 @@ +import { DefaultDomainSettingsService } from "@bitwarden/common/autofill/services/domain-settings.service"; + +import { + CachedServices, + factory, + FactoryOptions, +} from "../../../platform/background/service-factories/factory-options"; +import { + stateProviderFactory, + StateProviderInitOptions, +} from "../../../platform/background/service-factories/state-provider.factory"; + +export type DomainSettingsServiceInitOptions = FactoryOptions & StateProviderInitOptions; + +export function domainSettingsServiceFactory( + cache: { domainSettingsService?: DefaultDomainSettingsService } & CachedServices, + opts: DomainSettingsServiceInitOptions, +): Promise { + return factory( + cache, + "domainSettingsService", + opts, + async () => new DefaultDomainSettingsService(await stateProviderFactory(cache, opts)), + ); +} diff --git a/apps/browser/src/autofill/background/service_factories/user-notification-settings-service.factory.ts b/apps/browser/src/autofill/background/service_factories/user-notification-settings-service.factory.ts new file mode 100644 index 0000000000..5e19795e0e --- /dev/null +++ b/apps/browser/src/autofill/background/service_factories/user-notification-settings-service.factory.ts @@ -0,0 +1,25 @@ +import { UserNotificationSettingsService } from "@bitwarden/common/autofill/services/user-notification-settings.service"; + +import { + CachedServices, + factory, + FactoryOptions, +} from "../../../platform/background/service-factories/factory-options"; +import { + stateProviderFactory, + StateProviderInitOptions, +} from "../../../platform/background/service-factories/state-provider.factory"; + +export type UserNotificationSettingsServiceInitOptions = FactoryOptions & StateProviderInitOptions; + +export function userNotificationSettingsServiceFactory( + cache: { userNotificationSettingsService?: UserNotificationSettingsService } & CachedServices, + opts: UserNotificationSettingsServiceInitOptions, +): Promise { + return factory( + cache, + "userNotificationSettingsService", + opts, + async () => new UserNotificationSettingsService(await stateProviderFactory(cache, opts)), + ); +} diff --git a/apps/browser/src/autofill/background/tabs.background.spec.ts b/apps/browser/src/autofill/background/tabs.background.spec.ts new file mode 100644 index 0000000000..b95e303f17 --- /dev/null +++ b/apps/browser/src/autofill/background/tabs.background.spec.ts @@ -0,0 +1,240 @@ +import { mock } from "jest-mock-extended"; + +import MainBackground from "../../background/main.background"; +import { + flushPromises, + triggerTabOnActivatedEvent, + triggerTabOnRemovedEvent, + triggerTabOnReplacedEvent, + triggerTabOnUpdatedEvent, + triggerWindowOnFocusedChangedEvent, +} from "../spec/testing-utils"; + +import NotificationBackground from "./notification.background"; +import OverlayBackground from "./overlay.background"; +import TabsBackground from "./tabs.background"; + +describe("TabsBackground", () => { + let tabsBackground: TabsBackground; + const mainBackground = mock({ + messagingService: { + send: jest.fn(), + }, + }); + const notificationBackground = mock(); + const overlayBackground = mock(); + + beforeEach(() => { + tabsBackground = new TabsBackground(mainBackground, notificationBackground, overlayBackground); + }); + + afterEach(() => { + jest.clearAllMocks(); + }); + + describe("init", () => { + it("sets up a window on focusChanged listener", () => { + const handleWindowOnFocusChangedSpy = jest.spyOn( + tabsBackground as any, + "handleWindowOnFocusChanged", + ); + + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + tabsBackground.init(); + + expect(chrome.windows.onFocusChanged.addListener).toHaveBeenCalledWith( + handleWindowOnFocusChangedSpy, + ); + }); + }); + + describe("tab event listeners", () => { + beforeEach(() => { + tabsBackground["setupTabEventListeners"](); + }); + + describe("window onFocusChanged event", () => { + it("ignores focus change events that do not contain a windowId", async () => { + triggerWindowOnFocusedChangedEvent(undefined); + await flushPromises(); + + expect(mainBackground.messagingService.send).not.toHaveBeenCalled(); + }); + + it("sets the local focusedWindowId property", async () => { + triggerWindowOnFocusedChangedEvent(10); + await flushPromises(); + + expect(tabsBackground["focusedWindowId"]).toBe(10); + }); + + it("updates the current tab data", async () => { + triggerWindowOnFocusedChangedEvent(10); + await flushPromises(); + + expect(mainBackground.refreshBadge).toHaveBeenCalled(); + expect(mainBackground.refreshMenu).toHaveBeenCalled(); + expect(overlayBackground.updateOverlayCiphers).toHaveBeenCalled(); + }); + + it("sends a `windowChanged` message", async () => { + triggerWindowOnFocusedChangedEvent(10); + await flushPromises(); + + expect(mainBackground.messagingService.send).toHaveBeenCalledWith("windowChanged"); + }); + }); + + describe("handleTabOnActivated", () => { + it("updates the current tab data", async () => { + triggerTabOnActivatedEvent({ tabId: 10, windowId: 20 }); + await flushPromises(); + + expect(mainBackground.refreshBadge).toHaveBeenCalled(); + expect(mainBackground.refreshMenu).toHaveBeenCalled(); + expect(overlayBackground.updateOverlayCiphers).toHaveBeenCalled(); + }); + + it("sends a `tabChanged` message to the messaging service", async () => { + triggerTabOnActivatedEvent({ tabId: 10, windowId: 20 }); + await flushPromises(); + + expect(mainBackground.messagingService.send).toHaveBeenCalledWith("tabChanged"); + }); + }); + + describe("handleTabOnReplaced", () => { + beforeEach(() => { + mainBackground.onReplacedRan = false; + }); + + it("ignores the event if the `onReplacedRan` property of the main background class is set to `true`", () => { + mainBackground.onReplacedRan = true; + + triggerTabOnReplacedEvent(10, 20); + + expect(notificationBackground.checkNotificationQueue).not.toHaveBeenCalled(); + }); + + it("checks the notification queue", () => { + triggerTabOnReplacedEvent(10, 20); + + expect(notificationBackground.checkNotificationQueue).toHaveBeenCalled(); + }); + + it("updates the current tab data", async () => { + triggerTabOnReplacedEvent(10, 20); + await flushPromises(); + + expect(mainBackground.refreshBadge).toHaveBeenCalled(); + expect(mainBackground.refreshMenu).toHaveBeenCalled(); + expect(overlayBackground.updateOverlayCiphers).toHaveBeenCalled(); + }); + + it("sends a `tabChanged` message to the messaging service", async () => { + triggerTabOnReplacedEvent(10, 20); + await flushPromises(); + + expect(mainBackground.messagingService.send).toHaveBeenCalledWith("tabChanged"); + }); + }); + + describe("handleTabOnUpdated", () => { + const focusedWindowId = 10; + let tab: chrome.tabs.Tab; + + beforeEach(() => { + mainBackground.onUpdatedRan = false; + tabsBackground["focusedWindowId"] = focusedWindowId; + tab = mock({ + windowId: focusedWindowId, + active: true, + status: "loading", + }); + }); + + it("removes the cached page details from the overlay background if the tab status is `loading`", () => { + triggerTabOnUpdatedEvent(focusedWindowId, { status: "loading" }, tab); + + expect(overlayBackground.removePageDetails).toHaveBeenCalledWith(focusedWindowId); + }); + + it("removes the cached page details from the overlay background if the tab status is `unloaded`", () => { + triggerTabOnUpdatedEvent(focusedWindowId, { status: "unloaded" }, tab); + + expect(overlayBackground.removePageDetails).toHaveBeenCalledWith(focusedWindowId); + }); + + it("skips updating the current tab data the focusedWindowId is set to a value less than zero", async () => { + tab.windowId = -1; + triggerTabOnUpdatedEvent(focusedWindowId, { status: "loading" }, tab); + await flushPromises(); + + expect(mainBackground.refreshBadge).not.toHaveBeenCalled(); + expect(mainBackground.refreshMenu).not.toHaveBeenCalled(); + expect(overlayBackground.updateOverlayCiphers).not.toHaveBeenCalled(); + }); + + it("skips updating the current tab data if the updated tab is not for the focusedWindowId", async () => { + tab.windowId = 20; + triggerTabOnUpdatedEvent(focusedWindowId, { status: "loading" }, tab); + await flushPromises(); + + expect(mainBackground.refreshBadge).not.toHaveBeenCalled(); + expect(mainBackground.refreshMenu).not.toHaveBeenCalled(); + expect(overlayBackground.updateOverlayCiphers).not.toHaveBeenCalled(); + }); + + it("skips updating the current tab data if the updated tab is not active", async () => { + tab.active = false; + triggerTabOnUpdatedEvent(focusedWindowId, { status: "loading" }, tab); + await flushPromises(); + + expect(mainBackground.refreshBadge).not.toHaveBeenCalled(); + expect(mainBackground.refreshMenu).not.toHaveBeenCalled(); + expect(overlayBackground.updateOverlayCiphers).not.toHaveBeenCalled(); + }); + + it("skips updating the badge, context menu and notification bar if the `onUpdatedRan` property of the main background class is set to `true`", async () => { + mainBackground.onUpdatedRan = true; + triggerTabOnUpdatedEvent(focusedWindowId, { status: "loading" }, tab); + await flushPromises(); + + expect(mainBackground.refreshBadge).not.toHaveBeenCalled(); + expect(mainBackground.refreshMenu).not.toHaveBeenCalled(); + }); + + it("checks the notification queue", async () => { + triggerTabOnUpdatedEvent(focusedWindowId, { status: "loading" }, tab); + await flushPromises(); + + expect(notificationBackground.checkNotificationQueue).toHaveBeenCalled(); + }); + + it("updates the current tab data", async () => { + triggerTabOnUpdatedEvent(focusedWindowId, { status: "loading" }, tab); + await flushPromises(); + + expect(mainBackground.refreshBadge).toHaveBeenCalled(); + expect(mainBackground.refreshMenu).toHaveBeenCalled(); + expect(overlayBackground.updateOverlayCiphers).toHaveBeenCalled(); + }); + + it("sends a `tabChanged` message to the messaging service", async () => { + triggerTabOnUpdatedEvent(focusedWindowId, { status: "loading" }, tab); + await flushPromises(); + + expect(mainBackground.messagingService.send).toHaveBeenCalledWith("tabChanged"); + }); + }); + + describe("handleTabOnRemoved", () => { + it("removes the cached overlay page details", () => { + triggerTabOnRemovedEvent(10, { windowId: 20, isWindowClosing: false }); + + expect(overlayBackground.removePageDetails).toHaveBeenCalledWith(10); + }); + }); + }); +}); diff --git a/apps/browser/src/autofill/background/tabs.background.ts b/apps/browser/src/autofill/background/tabs.background.ts index 0655fd23b6..53c801ff7b 100644 --- a/apps/browser/src/autofill/background/tabs.background.ts +++ b/apps/browser/src/autofill/background/tabs.background.ts @@ -1,69 +1,135 @@ import MainBackground from "../../background/main.background"; import NotificationBackground from "./notification.background"; +import OverlayBackground from "./overlay.background"; export default class TabsBackground { constructor( private main: MainBackground, - private notificationBackground: NotificationBackground + private notificationBackground: NotificationBackground, + private overlayBackground: OverlayBackground, ) {} private focusedWindowId: number; + /** + * Initializes the window and tab listeners. + */ async init() { if (!chrome.tabs || !chrome.windows) { return; } - chrome.windows.onFocusChanged.addListener(async (windowId: number) => { - if (windowId === null || windowId < 0) { - return; - } - - this.focusedWindowId = windowId; - await this.main.refreshBadge(); - await this.main.refreshMenu(); - this.main.messagingService.send("windowChanged"); - }); - - chrome.tabs.onActivated.addListener(async (activeInfo: chrome.tabs.TabActiveInfo) => { - await this.main.refreshBadge(); - await this.main.refreshMenu(); - this.main.messagingService.send("tabChanged"); - }); - - chrome.tabs.onReplaced.addListener(async (addedTabId: number, removedTabId: number) => { - if (this.main.onReplacedRan) { - return; - } - this.main.onReplacedRan = true; - - await this.notificationBackground.checkNotificationQueue(); - await this.main.refreshBadge(); - await this.main.refreshMenu(); - this.main.messagingService.send("tabChanged"); - }); - - chrome.tabs.onUpdated.addListener( - async (tabId: number, changeInfo: chrome.tabs.TabChangeInfo, tab: chrome.tabs.Tab) => { - if (this.focusedWindowId > 0 && tab.windowId != this.focusedWindowId) { - return; - } - - if (!tab.active) { - return; - } - - if (this.main.onUpdatedRan) { - return; - } - this.main.onUpdatedRan = true; - - await this.notificationBackground.checkNotificationQueue(tab); - await this.main.refreshBadge(); - await this.main.refreshMenu(); - this.main.messagingService.send("tabChanged"); - } - ); + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + this.updateCurrentTabData(); + this.setupTabEventListeners(); } + + /** + * Sets up the tab and window event listeners. + */ + private setupTabEventListeners() { + chrome.windows.onFocusChanged.addListener(this.handleWindowOnFocusChanged); + chrome.tabs.onActivated.addListener(this.handleTabOnActivated); + chrome.tabs.onReplaced.addListener(this.handleTabOnReplaced); + chrome.tabs.onUpdated.addListener(this.handleTabOnUpdated); + chrome.tabs.onRemoved.addListener(this.handleTabOnRemoved); + } + + /** + * Handles the window onFocusChanged event. + * + * @param windowId - The ID of the window that was focused. + */ + private handleWindowOnFocusChanged = async (windowId: number) => { + if (windowId == null || windowId < 0) { + return; + } + + this.focusedWindowId = windowId; + await this.updateCurrentTabData(); + this.main.messagingService.send("windowChanged"); + }; + + /** + * Handles the tab onActivated event. + */ + private handleTabOnActivated = async () => { + await this.updateCurrentTabData(); + this.main.messagingService.send("tabChanged"); + }; + + /** + * Handles the tab onReplaced event. + */ + private handleTabOnReplaced = async () => { + if (this.main.onReplacedRan) { + return; + } + this.main.onReplacedRan = true; + + await this.notificationBackground.checkNotificationQueue(); + await this.updateCurrentTabData(); + this.main.messagingService.send("tabChanged"); + }; + + /** + * Handles the tab onUpdated event. + * + * @param tabId - The ID of the tab that was updated. + * @param changeInfo - The change information. + * @param tab - The updated tab. + */ + private handleTabOnUpdated = async ( + tabId: number, + changeInfo: chrome.tabs.TabChangeInfo, + tab: chrome.tabs.Tab, + ) => { + const removePageDetailsStatus = new Set(["loading", "unloaded"]); + if (removePageDetailsStatus.has(changeInfo.status)) { + this.overlayBackground.removePageDetails(tabId); + } + + if (this.focusedWindowId > 0 && tab.windowId !== this.focusedWindowId) { + return; + } + + if (!tab.active) { + return; + } + + await this.overlayBackground.updateOverlayCiphers(); + + if (this.main.onUpdatedRan) { + return; + } + this.main.onUpdatedRan = true; + + await this.notificationBackground.checkNotificationQueue(tab); + await this.main.refreshBadge(); + await this.main.refreshMenu(); + this.main.messagingService.send("tabChanged"); + }; + + /** + * Handles the tab onRemoved event. + * + * @param tabId - The ID of the tab that was removed. + */ + private handleTabOnRemoved = async (tabId: number) => { + this.overlayBackground.removePageDetails(tabId); + }; + + /** + * Updates the current tab data, refreshing the badge and context menu + * for the current tab. Also updates the overlay ciphers. + */ + private updateCurrentTabData = async () => { + await Promise.all([ + this.main.refreshBadge(), + this.main.refreshMenu(), + this.overlayBackground.updateOverlayCiphers(), + ]); + }; } diff --git a/apps/browser/src/autofill/background/web-request.background.ts b/apps/browser/src/autofill/background/web-request.background.ts new file mode 100644 index 0000000000..8cdfa0f027 --- /dev/null +++ b/apps/browser/src/autofill/background/web-request.background.ts @@ -0,0 +1,100 @@ +import { AuthService } from "@bitwarden/common/auth/abstractions/auth.service"; +import { AuthenticationStatus } from "@bitwarden/common/auth/enums/authentication-status"; +import { UriMatchStrategy } from "@bitwarden/common/models/domain/domain-service"; +import { PlatformUtilsService } from "@bitwarden/common/platform/abstractions/platform-utils.service"; +import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service"; + +import { BrowserApi } from "../../platform/browser/browser-api"; + +export default class WebRequestBackground { + private pendingAuthRequests: any[] = []; + private webRequest: any; + private isFirefox: boolean; + + constructor( + platformUtilsService: PlatformUtilsService, + private cipherService: CipherService, + private authService: AuthService, + ) { + if (BrowserApi.isManifestVersion(2)) { + this.webRequest = chrome.webRequest; + } + this.isFirefox = platformUtilsService.isFirefox(); + } + + async init() { + if (!this.webRequest || !this.webRequest.onAuthRequired) { + return; + } + + this.webRequest.onAuthRequired.addListener( + async (details: any, callback: any) => { + if (!details.url || this.pendingAuthRequests.indexOf(details.requestId) !== -1) { + if (callback) { + callback(); + } + return; + } + + this.pendingAuthRequests.push(details.requestId); + + if (this.isFirefox) { + // eslint-disable-next-line + return new Promise(async (resolve, reject) => { + await this.resolveAuthCredentials(details.url, resolve, reject); + }); + } else { + await this.resolveAuthCredentials(details.url, callback, callback); + } + }, + { urls: ["http://*/*", "https://*/*"] }, + [this.isFirefox ? "blocking" : "asyncBlocking"], + ); + + this.webRequest.onCompleted.addListener((details: any) => this.completeAuthRequest(details), { + urls: ["http://*/*"], + }); + this.webRequest.onErrorOccurred.addListener( + (details: any) => this.completeAuthRequest(details), + { + urls: ["http://*/*"], + }, + ); + } + + // eslint-disable-next-line + private async resolveAuthCredentials(domain: string, success: Function, error: Function) { + if ((await this.authService.getAuthStatus()) < AuthenticationStatus.Unlocked) { + error(); + return; + } + + try { + const ciphers = await this.cipherService.getAllDecryptedForUrl( + domain, + null, + UriMatchStrategy.Host, + ); + if (ciphers == null || ciphers.length !== 1) { + error(); + return; + } + + success({ + authCredentials: { + username: ciphers[0].login.username, + password: ciphers[0].login.password, + }, + }); + } catch { + error(); + } + } + + private completeAuthRequest(details: any) { + const i = this.pendingAuthRequests.indexOf(details.requestId); + if (i > -1) { + this.pendingAuthRequests.splice(i, 1); + } + } +} diff --git a/apps/browser/src/autofill/browser/abstractions/main-context-menu-handler.ts b/apps/browser/src/autofill/browser/abstractions/main-context-menu-handler.ts new file mode 100644 index 0000000000..7ded23116e --- /dev/null +++ b/apps/browser/src/autofill/browser/abstractions/main-context-menu-handler.ts @@ -0,0 +1,5 @@ +type InitContextMenuItems = Omit & { + checkPremiumAccess?: boolean; +}; + +export { InitContextMenuItems }; diff --git a/apps/browser/src/autofill/browser/cipher-context-menu-handler.spec.ts b/apps/browser/src/autofill/browser/cipher-context-menu-handler.spec.ts index 53d3d10076..4fed9eee5e 100644 --- a/apps/browser/src/autofill/browser/cipher-context-menu-handler.spec.ts +++ b/apps/browser/src/autofill/browser/cipher-context-menu-handler.spec.ts @@ -3,8 +3,8 @@ import { mock, MockProxy } from "jest-mock-extended"; import { AuthService } from "@bitwarden/common/auth/abstractions/auth.service"; import { AuthenticationStatus } from "@bitwarden/common/auth/enums/authentication-status"; import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service"; +import { CipherType } from "@bitwarden/common/vault/enums"; import { CipherRepromptType } from "@bitwarden/common/vault/enums/cipher-reprompt-type"; -import { CipherType } from "@bitwarden/common/vault/enums/cipher-type"; import { CipherContextMenuHandler } from "./cipher-context-menu-handler"; import { MainContextMenuHandler } from "./main-context-menu-handler"; @@ -18,6 +18,7 @@ describe("CipherContextMenuHandler", () => { beforeEach(() => { mainContextMenuHandler = mock(); + mainContextMenuHandler.initRunning = false; authService = mock(); cipherService = mock(); @@ -29,6 +30,14 @@ describe("CipherContextMenuHandler", () => { afterEach(() => jest.resetAllMocks()); describe("update", () => { + it("skips updating if the init process for the mainContextMenuHandler is running", async () => { + mainContextMenuHandler.initRunning = true; + + await sut.update("https://test.com"); + + expect(authService.getAuthStatus).not.toHaveBeenCalled(); + }); + it("locked, updates for no access", async () => { authService.getAuthStatus.mockResolvedValue(AuthenticationStatus.Locked); @@ -69,12 +78,12 @@ describe("CipherContextMenuHandler", () => { expect(mainContextMenuHandler.noLogins).toHaveBeenCalledTimes(1); }); - it("only adds valid ciphers", async () => { + it("only adds autofill ciphers including ciphers that require reprompt", async () => { authService.getAuthStatus.mockResolvedValue(AuthenticationStatus.Unlocked); mainContextMenuHandler.init.mockResolvedValue(true); - const realCipher = { + const loginCipher = { id: "5", type: CipherType.Login, reprompt: CipherRepromptType.None, @@ -82,27 +91,57 @@ describe("CipherContextMenuHandler", () => { login: { username: "Test Username" }, }; + const repromptLoginCipher = { + id: "6", + type: CipherType.Login, + reprompt: CipherRepromptType.Password, + name: "Test Reprompt Cipher", + login: { username: "Test Username" }, + }; + + const cardCipher = { + id: "7", + type: CipherType.Card, + name: "Test Card Cipher", + card: { username: "Test Username" }, + }; + cipherService.getAllDecryptedForUrl.mockResolvedValue([ - null, - undefined, - { type: CipherType.Card }, - { type: CipherType.Login, reprompt: CipherRepromptType.Password }, - realCipher, + null, // invalid cipher + undefined, // invalid cipher + { type: CipherType.SecureNote }, // invalid cipher + loginCipher, // valid cipher + repromptLoginCipher, + cardCipher, // valid cipher ] as any[]); await sut.update("https://test.com"); expect(cipherService.getAllDecryptedForUrl).toHaveBeenCalledTimes(1); - expect(cipherService.getAllDecryptedForUrl).toHaveBeenCalledWith("https://test.com"); + expect(cipherService.getAllDecryptedForUrl).toHaveBeenCalledWith("https://test.com", [ + CipherType.Card, + CipherType.Identity, + ]); - expect(mainContextMenuHandler.loadOptions).toHaveBeenCalledTimes(1); + expect(mainContextMenuHandler.loadOptions).toHaveBeenCalledTimes(3); expect(mainContextMenuHandler.loadOptions).toHaveBeenCalledWith( "Test Cipher (Test Username)", "5", - "https://test.com", - realCipher + loginCipher, + ); + + expect(mainContextMenuHandler.loadOptions).toHaveBeenCalledWith( + "Test Reprompt Cipher (Test Username)", + "6", + repromptLoginCipher, + ); + + expect(mainContextMenuHandler.loadOptions).toHaveBeenCalledWith( + "Test Card Cipher", + "7", + cardCipher, ); }); }); diff --git a/apps/browser/src/autofill/browser/cipher-context-menu-handler.ts b/apps/browser/src/autofill/browser/cipher-context-menu-handler.ts index d4f72e5663..d66d4361db 100644 --- a/apps/browser/src/autofill/browser/cipher-context-menu-handler.ts +++ b/apps/browser/src/autofill/browser/cipher-context-menu-handler.ts @@ -4,8 +4,7 @@ import { StateFactory } from "@bitwarden/common/platform/factories/state-factory import { Utils } from "@bitwarden/common/platform/misc/utils"; import { GlobalState } from "@bitwarden/common/platform/models/domain/global-state"; import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service"; -import { CipherRepromptType } from "@bitwarden/common/vault/enums/cipher-reprompt-type"; -import { CipherType } from "@bitwarden/common/vault/enums/cipher-type"; +import { CipherType } from "@bitwarden/common/vault/enums"; import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view"; import { @@ -19,6 +18,7 @@ import { cipherServiceFactory, CipherServiceInitOptions, } from "../../vault/background/service_factories/cipher-service.factory"; +import { AutofillCipherTypeId } from "../types"; import { MainContextMenuHandler } from "./main-context-menu-handler"; @@ -38,7 +38,7 @@ export class CipherContextMenuHandler { constructor( private mainContextMenuHandler: MainContextMenuHandler, private authService: AuthService, - private cipherService: CipherService + private cipherService: CipherService, ) {} static async create(cachedServices: CachedServices) { @@ -67,9 +67,6 @@ export class CipherContextMenuHandler { clipboardWriteCallback: NOT_IMPLEMENTED, win: self, }, - stateMigrationServiceOptions: { - stateFactory: stateFactory, - }, stateServiceOptions: { stateFactory: stateFactory, }, @@ -77,7 +74,7 @@ export class CipherContextMenuHandler { return new CipherContextMenuHandler( await MainContextMenuHandler.mv3Create(cachedServices), await authServiceFactory(cachedServices, serviceOptions), - await cipherServiceFactory(cachedServices, serviceOptions) + await cipherServiceFactory(cachedServices, serviceOptions), ); } @@ -89,7 +86,7 @@ export class CipherContextMenuHandler { static async tabsOnActivatedListener( activeInfo: chrome.tabs.TabActiveInfo, - serviceCache: CachedServices + serviceCache: CachedServices, ) { const cipherContextMenuHandler = await CipherContextMenuHandler.create(serviceCache); const tab = await BrowserApi.getTab(activeInfo.tabId); @@ -99,7 +96,7 @@ export class CipherContextMenuHandler { static async tabsOnReplacedListener( addedTabId: number, removedTabId: number, - serviceCache: CachedServices + serviceCache: CachedServices, ) { const cipherContextMenuHandler = await CipherContextMenuHandler.create(serviceCache); const tab = await BrowserApi.getTab(addedTabId); @@ -110,7 +107,7 @@ export class CipherContextMenuHandler { tabId: number, changeInfo: chrome.tabs.TabChangeInfo, tab: chrome.tabs.Tab, - serviceCache: CachedServices + serviceCache: CachedServices, ) { if (changeInfo.status !== "complete") { return; @@ -122,7 +119,7 @@ export class CipherContextMenuHandler { static async messageListener( message: { command: string }, sender: chrome.runtime.MessageSender, - cachedServices: CachedServices + cachedServices: CachedServices, ) { if (!CipherContextMenuHandler.shouldListen(message)) { return; @@ -149,6 +146,10 @@ export class CipherContextMenuHandler { } async update(url: string) { + if (this.mainContextMenuHandler.initRunning) { + return; + } + const authStatus = await this.authService.getAuthStatus(); await MainContextMenuHandler.removeAll(); if (authStatus !== AuthenticationStatus.Unlocked) { @@ -163,33 +164,67 @@ export class CipherContextMenuHandler { return; } - const ciphers = await this.cipherService.getAllDecryptedForUrl(url); + const ciphers = await this.cipherService.getAllDecryptedForUrl(url, [ + CipherType.Card, + CipherType.Identity, + ]); ciphers.sort((a, b) => this.cipherService.sortCiphersByLastUsedThenName(a, b)); - if (ciphers.length === 0) { - await this.mainContextMenuHandler.noLogins(url); - return; + const groupedCiphers: Record = ciphers.reduce( + (ciphersByType, cipher) => { + if (!cipher?.type) { + return ciphersByType; + } + + const existingCiphersOfType = ciphersByType[cipher.type as AutofillCipherTypeId] || []; + + return { + ...ciphersByType, + [cipher.type]: [...existingCiphersOfType, cipher], + }; + }, + { + [CipherType.Login]: [], + [CipherType.Card]: [], + [CipherType.Identity]: [], + }, + ); + + if (groupedCiphers[CipherType.Login].length === 0) { + await this.mainContextMenuHandler.noLogins(); + } + + if (groupedCiphers[CipherType.Identity].length === 0) { + await this.mainContextMenuHandler.noIdentities(); + } + + if (groupedCiphers[CipherType.Card].length === 0) { + await this.mainContextMenuHandler.noCards(); } for (const cipher of ciphers) { - await this.updateForCipher(url, cipher); + await this.updateForCipher(cipher); } } - private async updateForCipher(url: string, cipher: CipherView) { + private async updateForCipher(cipher: CipherView) { if ( cipher == null || - cipher.type !== CipherType.Login || - cipher.reprompt !== CipherRepromptType.None + !new Set([CipherType.Login, CipherType.Card, CipherType.Identity]).has(cipher.type) ) { return; } let title = cipher.name; - if (!Utils.isNullOrEmpty(title)) { + + if (cipher.type === CipherType.Login && !Utils.isNullOrEmpty(title) && cipher.login?.username) { title += ` (${cipher.login.username})`; } - await this.mainContextMenuHandler.loadOptions(title, cipher.id, url, cipher); + if (cipher.type === CipherType.Card && cipher.card?.subTitle) { + title += ` ${cipher.card.subTitle}`; + } + + await this.mainContextMenuHandler.loadOptions(title, cipher.id, cipher); } } diff --git a/apps/browser/src/autofill/browser/context-menu-clicked-handler.spec.ts b/apps/browser/src/autofill/browser/context-menu-clicked-handler.spec.ts index a9dbcbaacc..e54f37489b 100644 --- a/apps/browser/src/autofill/browser/context-menu-clicked-handler.spec.ts +++ b/apps/browser/src/autofill/browser/context-menu-clicked-handler.spec.ts @@ -1,11 +1,21 @@ import { mock, MockProxy } from "jest-mock-extended"; import { EventCollectionService } from "@bitwarden/common/abstractions/event/event-collection.service"; -import { TotpService } from "@bitwarden/common/abstractions/totp.service"; import { AuthService } from "@bitwarden/common/auth/abstractions/auth.service"; +import { UserVerificationService } from "@bitwarden/common/auth/abstractions/user-verification/user-verification.service.abstraction"; +import { + AUTOFILL_ID, + COPY_PASSWORD_ID, + COPY_USERNAME_ID, + COPY_VERIFICATION_CODE_ID, + GENERATE_PASSWORD_ID, + NOOP_COMMAND_SUFFIX, +} from "@bitwarden/common/autofill/constants"; +import { StateService } from "@bitwarden/common/platform/abstractions/state.service"; import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service"; +import { TotpService } from "@bitwarden/common/vault/abstractions/totp.service"; +import { CipherType } from "@bitwarden/common/vault/enums"; import { CipherRepromptType } from "@bitwarden/common/vault/enums/cipher-reprompt-type"; -import { CipherType } from "@bitwarden/common/vault/enums/cipher-type"; import { Cipher } from "@bitwarden/common/vault/models/domain/cipher"; import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view"; @@ -16,18 +26,11 @@ import { GeneratePasswordToClipboardAction, AutofillAction, } from "./context-menu-clicked-handler"; -import { - AUTOFILL_ID, - COPY_PASSWORD_ID, - COPY_USERNAME_ID, - COPY_VERIFICATIONCODE_ID, - GENERATE_PASSWORD_ID, -} from "./main-context-menu-handler"; describe("ContextMenuClickedHandler", () => { const createData = ( menuItemId: chrome.contextMenus.OnClickData["menuItemId"], - parentMenuItemId?: chrome.contextMenus.OnClickData["parentMenuItemId"] + parentMenuItemId?: chrome.contextMenus.OnClickData["parentMenuItemId"], ): chrome.contextMenus.OnClickData => { return { menuItemId: menuItemId, @@ -48,8 +51,9 @@ describe("ContextMenuClickedHandler", () => { new Cipher({ id: id ?? "1", type: CipherType.Login, - } as any) + } as any), ); + cipherView.login.username = username ?? "USERNAME"; cipherView.login.password = password ?? "PASSWORD"; cipherView.login.totp = totp ?? "TOTP"; @@ -61,8 +65,10 @@ describe("ContextMenuClickedHandler", () => { let autofill: AutofillAction; let authService: MockProxy; let cipherService: MockProxy; + let stateService: MockProxy; let totpService: MockProxy; let eventCollectionService: MockProxy; + let userVerificationService: MockProxy; let sut: ContextMenuClickedHandler; @@ -72,6 +78,7 @@ describe("ContextMenuClickedHandler", () => { autofill = jest.fn, [tab: chrome.tabs.Tab, cipher: CipherView]>(); authService = mock(); cipherService = mock(); + stateService = mock(); totpService = mock(); eventCollectionService = mock(); @@ -81,8 +88,10 @@ describe("ContextMenuClickedHandler", () => { autofill, authService, cipherService, + stateService, totpService, - eventCollectionService + eventCollectionService, + userVerificationService, ); }); @@ -103,7 +112,7 @@ describe("ContextMenuClickedHandler", () => { const cipher = createCipher(); cipherService.getAllDecrypted.mockResolvedValue([cipher]); - await sut.run(createData("T_1", AUTOFILL_ID), { id: 5 } as any); + await sut.run(createData(`${AUTOFILL_ID}_1`, AUTOFILL_ID), { id: 5 } as any); expect(autofill).toBeCalledTimes(1); @@ -115,11 +124,16 @@ describe("ContextMenuClickedHandler", () => { createCipher({ username: "TEST_USERNAME" }), ]); - await sut.run(createData("T_1", COPY_USERNAME_ID)); + await sut.run(createData(`${COPY_USERNAME_ID}_1`, COPY_USERNAME_ID), { + url: "https://test.com", + } as any); expect(copyToClipboard).toBeCalledTimes(1); - expect(copyToClipboard).toHaveBeenCalledWith({ text: "TEST_USERNAME", options: undefined }); + expect(copyToClipboard).toHaveBeenCalledWith({ + text: "TEST_USERNAME", + tab: { url: "https://test.com" }, + }); }); it("copies password to clipboard", async () => { @@ -127,11 +141,16 @@ describe("ContextMenuClickedHandler", () => { createCipher({ password: "TEST_PASSWORD" }), ]); - await sut.run(createData("T_1", COPY_PASSWORD_ID)); + await sut.run(createData(`${COPY_PASSWORD_ID}_1`, COPY_PASSWORD_ID), { + url: "https://test.com", + } as any); expect(copyToClipboard).toBeCalledTimes(1); - expect(copyToClipboard).toHaveBeenCalledWith({ text: "TEST_PASSWORD", options: undefined }); + expect(copyToClipboard).toHaveBeenCalledWith({ + text: "TEST_PASSWORD", + tab: { url: "https://test.com" }, + }); }); it("copies totp code to clipboard", async () => { @@ -145,11 +164,16 @@ describe("ContextMenuClickedHandler", () => { return Promise.resolve("654321"); }); - await sut.run(createData("T_1", COPY_VERIFICATIONCODE_ID)); + await sut.run(createData(`${COPY_VERIFICATION_CODE_ID}_1`, COPY_VERIFICATION_CODE_ID), { + url: "https://test.com", + } as any); expect(totpService.getCode).toHaveBeenCalledTimes(1); - expect(copyToClipboard).toHaveBeenCalledWith({ text: "123456" }); + expect(copyToClipboard).toHaveBeenCalledWith({ + text: "123456", + tab: { url: "https://test.com" }, + }); }); it("attempts to find a cipher when noop but unlocked", async () => { @@ -160,11 +184,13 @@ describe("ContextMenuClickedHandler", () => { } as any, ]); - await sut.run(createData("T_noop", COPY_USERNAME_ID), { url: "https://test.com" } as any); + await sut.run(createData(`${COPY_USERNAME_ID}_${NOOP_COMMAND_SUFFIX}`, COPY_USERNAME_ID), { + url: "https://test.com", + } as any); expect(cipherService.getAllDecryptedForUrl).toHaveBeenCalledTimes(1); - expect(cipherService.getAllDecryptedForUrl).toHaveBeenCalledWith("https://test.com"); + expect(cipherService.getAllDecryptedForUrl).toHaveBeenCalledWith("https://test.com", []); expect(copyToClipboard).toHaveBeenCalledTimes(1); @@ -182,11 +208,13 @@ describe("ContextMenuClickedHandler", () => { } as any, ]); - await sut.run(createData("T_noop", COPY_USERNAME_ID), { url: "https://test.com" } as any); + await sut.run(createData(`${COPY_USERNAME_ID}_${NOOP_COMMAND_SUFFIX}`, COPY_USERNAME_ID), { + url: "https://test.com", + } as any); expect(cipherService.getAllDecryptedForUrl).toHaveBeenCalledTimes(1); - expect(cipherService.getAllDecryptedForUrl).toHaveBeenCalledWith("https://test.com"); + expect(cipherService.getAllDecryptedForUrl).toHaveBeenCalledWith("https://test.com", []); }); }); }); diff --git a/apps/browser/src/autofill/browser/context-menu-clicked-handler.ts b/apps/browser/src/autofill/browser/context-menu-clicked-handler.ts index a5cf1c7065..596d6b7235 100644 --- a/apps/browser/src/autofill/browser/context-menu-clicked-handler.ts +++ b/apps/browser/src/autofill/browser/context-menu-clicked-handler.ts @@ -1,11 +1,28 @@ import { EventCollectionService } from "@bitwarden/common/abstractions/event/event-collection.service"; -import { TotpService } from "@bitwarden/common/abstractions/totp.service"; import { AuthService } from "@bitwarden/common/auth/abstractions/auth.service"; +import { UserVerificationService } from "@bitwarden/common/auth/abstractions/user-verification/user-verification.service.abstraction"; import { AuthenticationStatus } from "@bitwarden/common/auth/enums/authentication-status"; +import { + AUTOFILL_CARD_ID, + AUTOFILL_ID, + AUTOFILL_IDENTITY_ID, + COPY_IDENTIFIER_ID, + COPY_PASSWORD_ID, + COPY_USERNAME_ID, + COPY_VERIFICATION_CODE_ID, + CREATE_CARD_ID, + CREATE_IDENTITY_ID, + CREATE_LOGIN_ID, + GENERATE_PASSWORD_ID, + NOOP_COMMAND_SUFFIX, +} from "@bitwarden/common/autofill/constants"; import { EventType } from "@bitwarden/common/enums"; +import { StateService } from "@bitwarden/common/platform/abstractions/state.service"; import { StateFactory } from "@bitwarden/common/platform/factories/state-factory"; import { GlobalState } from "@bitwarden/common/platform/models/domain/global-state"; import { CipherService } from "@bitwarden/common/vault/abstractions/cipher.service"; +import { TotpService } from "@bitwarden/common/vault/abstractions/totp.service"; +import { CipherType } from "@bitwarden/common/vault/enums"; import { CipherRepromptType } from "@bitwarden/common/vault/enums/cipher-reprompt-type"; import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view"; @@ -13,8 +30,10 @@ import { authServiceFactory, AuthServiceInitOptions, } from "../../auth/background/service-factories/auth-service.factory"; -import { totpServiceFactory } from "../../auth/background/service-factories/totp-service.factory"; -import LockedVaultPendingNotificationsItem from "../../background/models/lockedVaultPendingNotificationsItem"; +import { KeyConnectorServiceInitOptions } from "../../auth/background/service-factories/key-connector-service.factory"; +import { userVerificationServiceFactory } from "../../auth/background/service-factories/user-verification-service.factory"; +import { openUnlockPopout } from "../../auth/popup/utils/auth-popout-window"; +import { autofillSettingsServiceFactory } from "../../autofill/background/service_factories/autofill-settings-service.factory"; import { eventCollectionServiceFactory } from "../../background/service-factories/event-collection-service.factory"; import { Account } from "../../models/account"; import { CachedServices } from "../../platform/background/service-factories/factory-options"; @@ -25,19 +44,16 @@ import { cipherServiceFactory, CipherServiceInitOptions, } from "../../vault/background/service_factories/cipher-service.factory"; +import { totpServiceFactory } from "../../vault/background/service_factories/totp-service.factory"; +import { + openAddEditVaultItemPopout, + openVaultItemPasswordRepromptPopout, +} from "../../vault/popup/utils/vault-popout-window"; +import { LockedVaultPendingNotificationsData } from "../background/abstractions/notification.background"; import { autofillServiceFactory } from "../background/service_factories/autofill-service.factory"; import { copyToClipboard, GeneratePasswordToClipboardCommand } from "../clipboard"; import { AutofillTabCommand } from "../commands/autofill-tab-command"; - -import { - AUTOFILL_ID, - COPY_IDENTIFIER_ID, - COPY_PASSWORD_ID, - COPY_USERNAME_ID, - COPY_VERIFICATIONCODE_ID, - GENERATE_PASSWORD_ID, - NOOP_COMMAND_SUFFIX, -} from "./main-context-menu-handler"; +import { AutofillCipherTypeId } from "../types"; export type CopyToClipboardOptions = { text: string; tab: chrome.tabs.Tab }; export type CopyToClipboardAction = (options: CopyToClipboardOptions) => void; @@ -55,13 +71,17 @@ export class ContextMenuClickedHandler { private autofillAction: AutofillAction, private authService: AuthService, private cipherService: CipherService, + private stateService: StateService, private totpService: TotpService, - private eventCollectionService: EventCollectionService + private eventCollectionService: EventCollectionService, + private userVerificationService: UserVerificationService, ) {} static async mv3Create(cachedServices: CachedServices) { const stateFactory = new StateFactory(GlobalState, Account); - const serviceOptions: AuthServiceInitOptions & CipherServiceInitOptions = { + const serviceOptions: AuthServiceInitOptions & + CipherServiceInitOptions & + KeyConnectorServiceInitOptions = { apiServiceOptions: { logoutCallback: NOT_IMPLEMENTED, }, @@ -85,21 +105,21 @@ export class ContextMenuClickedHandler { clipboardWriteCallback: NOT_IMPLEMENTED, win: self, }, - stateMigrationServiceOptions: { - stateFactory: stateFactory, - }, stateServiceOptions: { stateFactory: stateFactory, }, + autofillSettingsServiceOptions: { + stateFactory: autofillSettingsServiceFactory, + }, }; const generatePasswordToClipboardCommand = new GeneratePasswordToClipboardCommand( await passwordGenerationServiceFactory(cachedServices, serviceOptions), - await stateServiceFactory(cachedServices, serviceOptions) + await autofillSettingsServiceFactory(cachedServices, serviceOptions), ); const autofillCommand = new AutofillTabCommand( - await autofillServiceFactory(cachedServices, serviceOptions) + await autofillServiceFactory(cachedServices, serviceOptions), ); return new ContextMenuClickedHandler( @@ -108,24 +128,26 @@ export class ContextMenuClickedHandler { (tab, cipher) => autofillCommand.doAutofillTabWithCipherCommand(tab, cipher), await authServiceFactory(cachedServices, serviceOptions), await cipherServiceFactory(cachedServices, serviceOptions), + await stateServiceFactory(cachedServices, serviceOptions), await totpServiceFactory(cachedServices, serviceOptions), - await eventCollectionServiceFactory(cachedServices, serviceOptions) + await eventCollectionServiceFactory(cachedServices, serviceOptions), + await userVerificationServiceFactory(cachedServices, serviceOptions), ); } static async onClickedListener( info: chrome.contextMenus.OnClickData, tab?: chrome.tabs.Tab, - cachedServices: CachedServices = {} + cachedServices: CachedServices = {}, ) { const contextMenuClickedHandler = await ContextMenuClickedHandler.mv3Create(cachedServices); await contextMenuClickedHandler.run(info, tab); } static async messageListener( - message: { command: string; data: LockedVaultPendingNotificationsItem }, + message: { command: string; data: LockedVaultPendingNotificationsData }, sender: chrome.runtime.MessageSender, - cachedServices: CachedServices + cachedServices: CachedServices, ) { if ( message.command !== "unlockCompleted" || @@ -136,23 +158,21 @@ export class ContextMenuClickedHandler { const contextMenuClickedHandler = await ContextMenuClickedHandler.mv3Create(cachedServices); await contextMenuClickedHandler.run( - message.data.commandToRetry.msg.data, - message.data.commandToRetry.sender.tab + message.data.commandToRetry.message.contextMenuOnClickData, + message.data.commandToRetry.sender.tab, ); } - async run(info: chrome.contextMenus.OnClickData, tab?: chrome.tabs.Tab) { + async run(info: chrome.contextMenus.OnClickData, tab: chrome.tabs.Tab) { + if (!tab) { + return; + } + switch (info.menuItemId) { case GENERATE_PASSWORD_ID: - if (!tab) { - return; - } await this.generatePasswordToClipboard(tab); break; case COPY_IDENTIFIER_ID: - if (!tab) { - return; - } this.copyToClipboard({ text: await this.getIdentifier(tab, info), tab: tab }); break; default: @@ -160,11 +180,15 @@ export class ContextMenuClickedHandler { } } - async cipherAction(info: chrome.contextMenus.OnClickData, tab?: chrome.tabs.Tab) { + async cipherAction(info: chrome.contextMenus.OnClickData, tab: chrome.tabs.Tab) { + if (!tab) { + return; + } + if ((await this.authService.getAuthStatus()) < AuthenticationStatus.Unlocked) { - const retryMessage: LockedVaultPendingNotificationsItem = { + const retryMessage: LockedVaultPendingNotificationsData = { commandToRetry: { - msg: { command: NOOP_COMMAND_SUFFIX, data: info }, + message: { command: NOOP_COMMAND_SUFFIX, contextMenuOnClickData: info }, sender: { tab: tab }, }, target: "contextmenus.background", @@ -172,52 +196,141 @@ export class ContextMenuClickedHandler { await BrowserApi.tabSendMessageData( tab, "addToLockedVaultPendingNotifications", - retryMessage + retryMessage, ); - await BrowserApi.tabSendMessageData(tab, "promptForLogin"); + await openUnlockPopout(tab); return; } // NOTE: We don't actually use the first part of this ID, we further switch based on the parentMenuItemId // I would really love to not add it but that is a departure from how it currently works. - const id = (info.menuItemId as string).split("_")[1]; // We create all the ids, we can guarantee they are strings + const menuItemId = (info.menuItemId as string).split("_")[1]; // We create all the ids, we can guarantee they are strings let cipher: CipherView | undefined; - if (id === NOOP_COMMAND_SUFFIX) { + const isCreateCipherAction = [CREATE_LOGIN_ID, CREATE_IDENTITY_ID, CREATE_CARD_ID].includes( + menuItemId as string, + ); + + if (isCreateCipherAction) { + // pass; defer to logic below + } else if (menuItemId === NOOP_COMMAND_SUFFIX) { + const additionalCiphersToGet = + info.parentMenuItemId === AUTOFILL_IDENTITY_ID + ? [CipherType.Identity] + : info.parentMenuItemId === AUTOFILL_CARD_ID + ? [CipherType.Card] + : []; + // This NOOP item has come through which is generally only for no access state but since we got here // we are actually unlocked we will do our best to find a good match of an item to autofill this is useful // in scenarios like unlock on autofill - const ciphers = await this.cipherService.getAllDecryptedForUrl(tab.url); - cipher = ciphers.find((c) => c.reprompt === CipherRepromptType.None); + const ciphers = await this.cipherService.getAllDecryptedForUrl( + tab.url, + additionalCiphersToGet, + ); + + cipher = ciphers[0]; } else { const ciphers = await this.cipherService.getAllDecrypted(); - cipher = ciphers.find((c) => c.id === id); + cipher = ciphers.find(({ id }) => id === menuItemId); } - if (cipher == null) { + if (!cipher && !isCreateCipherAction) { return; } + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + this.stateService.setLastActive(new Date().getTime()); switch (info.parentMenuItemId) { case AUTOFILL_ID: - if (tab == null) { - return; + case AUTOFILL_IDENTITY_ID: + case AUTOFILL_CARD_ID: { + const cipherType = this.getCipherCreationType(menuItemId); + + if (cipherType) { + await openAddEditVaultItemPopout(tab, { cipherType }); + break; } - await this.autofillAction(tab, cipher); + + if (await this.isPasswordRepromptRequired(cipher)) { + await openVaultItemPasswordRepromptPopout(tab, { + cipherId: cipher.id, + // The action here is passed on to the single-use reprompt window and doesn't change based on cipher type + action: AUTOFILL_ID, + }); + } else { + await this.autofillAction(tab, cipher); + } + break; + } case COPY_USERNAME_ID: + if (menuItemId === CREATE_LOGIN_ID) { + await openAddEditVaultItemPopout(tab, { cipherType: CipherType.Login }); + break; + } + this.copyToClipboard({ text: cipher.login.username, tab: tab }); break; case COPY_PASSWORD_ID: - this.copyToClipboard({ text: cipher.login.password, tab: tab }); - this.eventCollectionService.collect(EventType.Cipher_ClientCopiedPassword, cipher.id); + if (menuItemId === CREATE_LOGIN_ID) { + await openAddEditVaultItemPopout(tab, { cipherType: CipherType.Login }); + break; + } + + if (await this.isPasswordRepromptRequired(cipher)) { + await openVaultItemPasswordRepromptPopout(tab, { + cipherId: cipher.id, + action: COPY_PASSWORD_ID, + }); + } else { + this.copyToClipboard({ text: cipher.login.password, tab: tab }); + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises + this.eventCollectionService.collect(EventType.Cipher_ClientCopiedPassword, cipher.id); + } + break; - case COPY_VERIFICATIONCODE_ID: - this.copyToClipboard({ text: await this.totpService.getCode(cipher.login.totp), tab: tab }); + case COPY_VERIFICATION_CODE_ID: + if (menuItemId === CREATE_LOGIN_ID) { + await openAddEditVaultItemPopout(tab, { cipherType: CipherType.Login }); + break; + } + + if (await this.isPasswordRepromptRequired(cipher)) { + await openVaultItemPasswordRepromptPopout(tab, { + cipherId: cipher.id, + action: COPY_VERIFICATION_CODE_ID, + }); + } else { + this.copyToClipboard({ + text: await this.totpService.getCode(cipher.login.totp), + tab: tab, + }); + } + break; } } + private async isPasswordRepromptRequired(cipher: CipherView): Promise { + return ( + cipher.reprompt === CipherRepromptType.Password && + (await this.userVerificationService.hasMasterPasswordAndMasterKeyHash()) + ); + } + + private getCipherCreationType(menuItemId?: string): AutofillCipherTypeId | null { + return menuItemId === CREATE_IDENTITY_ID + ? CipherType.Identity + : menuItemId === CREATE_CARD_ID + ? CipherType.Card + : menuItemId === CREATE_LOGIN_ID + ? CipherType.Login + : null; + } + private async getIdentifier(tab: chrome.tabs.Tab, info: chrome.contextMenus.OnClickData) { return new Promise((resolve, reject) => { BrowserApi.sendTabsMessage( @@ -231,7 +344,7 @@ export class ContextMenuClickedHandler { } resolve(identifier); - } + }, ); }); } diff --git a/apps/browser/src/autofill/browser/main-context-menu-handler.spec.ts b/apps/browser/src/autofill/browser/main-context-menu-handler.spec.ts index 6b599986b6..67637da2fd 100644 --- a/apps/browser/src/autofill/browser/main-context-menu-handler.spec.ts +++ b/apps/browser/src/autofill/browser/main-context-menu-handler.spec.ts @@ -1,8 +1,12 @@ import { mock, MockProxy } from "jest-mock-extended"; +import { of } from "rxjs"; +import { NOOP_COMMAND_SUFFIX } from "@bitwarden/common/autofill/constants"; +import { AutofillSettingsServiceAbstraction } from "@bitwarden/common/autofill/services/autofill-settings.service"; +import { BillingAccountProfileStateService } from "@bitwarden/common/billing/abstractions/account/billing-account-profile-state.service"; import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service"; import { LogService } from "@bitwarden/common/platform/abstractions/log.service"; -import { CipherType } from "@bitwarden/common/vault/enums/cipher-type"; +import { CipherType } from "@bitwarden/common/vault/enums"; import { Cipher } from "@bitwarden/common/vault/models/domain/cipher"; import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view"; @@ -12,8 +16,10 @@ import { MainContextMenuHandler } from "./main-context-menu-handler"; describe("context-menu", () => { let stateService: MockProxy; + let autofillSettingsService: MockProxy; let i18nService: MockProxy; let logService: MockProxy; + let billingAccountProfileStateService: MockProxy; let removeAllSpy: jest.SpyInstance void]>; let createSpy: jest.SpyInstance< @@ -25,8 +31,10 @@ describe("context-menu", () => { beforeEach(() => { stateService = mock(); + autofillSettingsService = mock(); i18nService = mock(); logService = mock(); + billingAccountProfileStateService = mock(); removeAllSpy = jest .spyOn(chrome.contextMenus, "removeAll") @@ -39,14 +47,22 @@ describe("context-menu", () => { return props.id; }); - sut = new MainContextMenuHandler(stateService, i18nService, logService); + i18nService.t.mockImplementation((key) => key); + sut = new MainContextMenuHandler( + stateService, + autofillSettingsService, + i18nService, + logService, + billingAccountProfileStateService, + ); + autofillSettingsService.enableContextMenu$ = of(true); }); afterEach(() => jest.resetAllMocks()); describe("init", () => { it("has menu disabled", async () => { - stateService.getDisableContextMenuItem.mockResolvedValue(true); + autofillSettingsService.enableContextMenu$ = of(false); const createdMenu = await sut.init(); expect(createdMenu).toBeFalsy(); @@ -54,23 +70,19 @@ describe("context-menu", () => { }); it("has menu enabled, but does not have premium", async () => { - stateService.getDisableContextMenuItem.mockResolvedValue(false); - - stateService.getCanAccessPremium.mockResolvedValue(false); + billingAccountProfileStateService.hasPremiumFromAnySource$ = of(false); const createdMenu = await sut.init(); expect(createdMenu).toBeTruthy(); - expect(createSpy).toHaveBeenCalledTimes(7); + expect(createSpy).toHaveBeenCalledTimes(10); }); it("has menu enabled and has premium", async () => { - stateService.getDisableContextMenuItem.mockResolvedValue(false); - - stateService.getCanAccessPremium.mockResolvedValue(true); + billingAccountProfileStateService.hasPremiumFromAnySource$ = of(true); const createdMenu = await sut.init(); expect(createdMenu).toBeTruthy(); - expect(createSpy).toHaveBeenCalledTimes(8); + expect(createSpy).toHaveBeenCalledTimes(11); }); }); @@ -88,7 +100,7 @@ describe("context-menu", () => { id: id ?? "1", type: CipherType.Login, viewPassword: viewPassword ?? true, - } as any) + } as any), ); cipherView.login.username = username ?? "USERNAME"; cipherView.login.password = password ?? "PASSWORD"; @@ -97,7 +109,7 @@ describe("context-menu", () => { }; it("is not a login cipher", async () => { - await sut.loadOptions("TEST_TITLE", "1", "", { + await sut.loadOptions("TEST_TITLE", "1", { ...createCipher(), type: CipherType.SecureNote, } as any); @@ -109,32 +121,102 @@ describe("context-menu", () => { await sut.loadOptions( "TEST_TITLE", "1", - "", createCipher({ username: "", totp: "", viewPassword: false, - }) + }), ); expect(createSpy).toHaveBeenCalledTimes(1); }); it("create entry for each cipher piece", async () => { - stateService.getCanAccessPremium.mockResolvedValue(true); + billingAccountProfileStateService.hasPremiumFromAnySource$ = of(true); - await sut.loadOptions("TEST_TITLE", "1", "", createCipher()); + await sut.loadOptions("TEST_TITLE", "1", createCipher()); // One for autofill, copy username, copy password, and copy totp code expect(createSpy).toHaveBeenCalledTimes(4); }); - it("creates noop item for no cipher", async () => { - stateService.getCanAccessPremium.mockResolvedValue(true); + it("creates a login/unlock item for each context menu action option when user is not authenticated", async () => { + billingAccountProfileStateService.hasPremiumFromAnySource$ = of(true); - await sut.loadOptions("TEST_TITLE", "NOOP", ""); + await sut.loadOptions("TEST_TITLE", "NOOP"); - expect(createSpy).toHaveBeenCalledTimes(4); + expect(createSpy).toHaveBeenCalledTimes(6); + }); + }); + + describe("creating noAccess context menu items", () => { + let loadOptionsSpy: jest.SpyInstance; + beforeEach(() => { + loadOptionsSpy = jest.spyOn(sut, "loadOptions").mockResolvedValue(); + }); + + it("Loads context menu items that ask the user to unlock their vault if they are authed", async () => { + stateService.getIsAuthenticated.mockResolvedValue(true); + + await sut.noAccess(); + + expect(loadOptionsSpy).toHaveBeenCalledWith("unlockVaultMenu", NOOP_COMMAND_SUFFIX); + }); + + it("Loads context menu items that ask the user to login to their vault if they are not authed", async () => { + stateService.getIsAuthenticated.mockResolvedValue(false); + + await sut.noAccess(); + + expect(loadOptionsSpy).toHaveBeenCalledWith("loginToVaultMenu", NOOP_COMMAND_SUFFIX); + }); + }); + + describe("creating noCards context menu items", () => { + it("Loads a noCards context menu item and an addCardMenu context item", async () => { + const noCardsContextMenuItems = sut["noCardsContextMenuItems"]; + + await sut.noCards(); + + expect(createSpy).toHaveBeenCalledTimes(3); + expect(createSpy).toHaveBeenCalledWith(noCardsContextMenuItems[0], expect.any(Function)); + expect(createSpy).toHaveBeenCalledWith(noCardsContextMenuItems[1], expect.any(Function)); + expect(createSpy).toHaveBeenCalledWith(noCardsContextMenuItems[2], expect.any(Function)); + }); + }); + + describe("creating noIdentities context menu items", () => { + it("Loads a noIdentities context menu item and an addIdentityMenu context item", async () => { + const noIdentitiesContextMenuItems = sut["noIdentitiesContextMenuItems"]; + + await sut.noIdentities(); + + expect(createSpy).toHaveBeenCalledTimes(3); + expect(createSpy).toHaveBeenCalledWith(noIdentitiesContextMenuItems[0], expect.any(Function)); + expect(createSpy).toHaveBeenCalledWith(noIdentitiesContextMenuItems[1], expect.any(Function)); + expect(createSpy).toHaveBeenCalledWith(noIdentitiesContextMenuItems[2], expect.any(Function)); + }); + }); + + describe("creating noLogins context menu items", () => { + it("Loads a noLogins context menu item and an addLoginMenu context item", async () => { + const noLoginsContextMenuItems = sut["noLoginsContextMenuItems"]; + + await sut.noLogins(); + + expect(createSpy).toHaveBeenCalledTimes(5); + expect(createSpy).toHaveBeenCalledWith(noLoginsContextMenuItems[0], expect.any(Function)); + expect(createSpy).toHaveBeenCalledWith(noLoginsContextMenuItems[1], expect.any(Function)); + expect(createSpy).toHaveBeenCalledWith( + { + enabled: false, + id: "autofill_NOTICE", + parentId: "autofill", + title: "noMatchingLogins", + type: "normal", + }, + expect.any(Function), + ); }); }); }); diff --git a/apps/browser/src/autofill/browser/main-context-menu-handler.ts b/apps/browser/src/autofill/browser/main-context-menu-handler.ts index 9b16aa266d..9422756e07 100644 --- a/apps/browser/src/autofill/browser/main-context-menu-handler.ts +++ b/apps/browser/src/autofill/browser/main-context-menu-handler.ts @@ -1,12 +1,34 @@ +import { firstValueFrom } from "rxjs"; + +import { + AUTOFILL_CARD_ID, + AUTOFILL_ID, + AUTOFILL_IDENTITY_ID, + COPY_IDENTIFIER_ID, + COPY_PASSWORD_ID, + COPY_USERNAME_ID, + COPY_VERIFICATION_CODE_ID, + CREATE_CARD_ID, + CREATE_IDENTITY_ID, + CREATE_LOGIN_ID, + GENERATE_PASSWORD_ID, + NOOP_COMMAND_SUFFIX, + ROOT_ID, + SEPARATOR_ID, +} from "@bitwarden/common/autofill/constants"; +import { AutofillSettingsServiceAbstraction } from "@bitwarden/common/autofill/services/autofill-settings.service"; +import { BillingAccountProfileStateService } from "@bitwarden/common/billing/abstractions/account/billing-account-profile-state.service"; import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service"; import { LogService } from "@bitwarden/common/platform/abstractions/log.service"; import { StateFactory } from "@bitwarden/common/platform/factories/state-factory"; import { Utils } from "@bitwarden/common/platform/misc/utils"; import { GlobalState } from "@bitwarden/common/platform/models/domain/global-state"; -import { CipherType } from "@bitwarden/common/vault/enums/cipher-type"; +import { CipherType } from "@bitwarden/common/vault/enums"; import { CipherView } from "@bitwarden/common/vault/models/view/cipher.view"; +import { autofillSettingsServiceFactory } from "../../autofill/background/service_factories/autofill-settings-service.factory"; import { Account } from "../../models/account"; +import { billingAccountProfileStateServiceFactory } from "../../platform/background/service-factories/billing-account-profile-state-service.factory"; import { CachedServices } from "../../platform/background/service-factories/factory-options"; import { i18nServiceFactory, @@ -22,46 +44,129 @@ import { } from "../../platform/background/service-factories/state-service.factory"; import { BrowserStateService } from "../../platform/services/abstractions/browser-state.service"; -export const ROOT_ID = "root"; - -export const AUTOFILL_ID = "autofill"; -export const COPY_USERNAME_ID = "copy-username"; -export const COPY_PASSWORD_ID = "copy-password"; -export const COPY_VERIFICATIONCODE_ID = "copy-totp"; -export const COPY_IDENTIFIER_ID = "copy-identifier"; - -const SEPARATOR_ID = "separator"; -export const GENERATE_PASSWORD_ID = "generate-password"; - -export const NOOP_COMMAND_SUFFIX = "noop"; +import { InitContextMenuItems } from "./abstractions/main-context-menu-handler"; export class MainContextMenuHandler { - // - private initRunning = false; - - create: (options: chrome.contextMenus.CreateProperties) => Promise; + initRunning = false; + private initContextMenuItems: InitContextMenuItems[] = [ + { + id: ROOT_ID, + title: "Bitwarden", + }, + { + id: AUTOFILL_ID, + parentId: ROOT_ID, + title: this.i18nService.t("autoFillLogin"), + }, + { + id: COPY_USERNAME_ID, + parentId: ROOT_ID, + title: this.i18nService.t("copyUsername"), + }, + { + id: COPY_PASSWORD_ID, + parentId: ROOT_ID, + title: this.i18nService.t("copyPassword"), + }, + { + id: COPY_VERIFICATION_CODE_ID, + parentId: ROOT_ID, + title: this.i18nService.t("copyVerificationCode"), + checkPremiumAccess: true, + }, + { + id: SEPARATOR_ID + 1, + type: "separator", + parentId: ROOT_ID, + }, + { + id: AUTOFILL_IDENTITY_ID, + parentId: ROOT_ID, + title: this.i18nService.t("autoFillIdentity"), + }, + { + id: AUTOFILL_CARD_ID, + parentId: ROOT_ID, + title: this.i18nService.t("autoFillCard"), + }, + { + id: SEPARATOR_ID + 2, + type: "separator", + parentId: ROOT_ID, + }, + { + id: GENERATE_PASSWORD_ID, + parentId: ROOT_ID, + title: this.i18nService.t("generatePasswordCopied"), + }, + { + id: COPY_IDENTIFIER_ID, + parentId: ROOT_ID, + title: this.i18nService.t("copyElementIdentifier"), + }, + ]; + private noCardsContextMenuItems: chrome.contextMenus.CreateProperties[] = [ + { + id: `${AUTOFILL_CARD_ID}_NOTICE`, + enabled: false, + parentId: AUTOFILL_CARD_ID, + title: this.i18nService.t("noCards"), + type: "normal", + }, + { + id: `${AUTOFILL_CARD_ID}_${SEPARATOR_ID}`, + parentId: AUTOFILL_CARD_ID, + type: "separator", + }, + { + id: `${AUTOFILL_CARD_ID}_${CREATE_CARD_ID}`, + parentId: AUTOFILL_CARD_ID, + title: this.i18nService.t("addCardMenu"), + type: "normal", + }, + ]; + private noIdentitiesContextMenuItems: chrome.contextMenus.CreateProperties[] = [ + { + id: `${AUTOFILL_IDENTITY_ID}_NOTICE`, + enabled: false, + parentId: AUTOFILL_IDENTITY_ID, + title: this.i18nService.t("noIdentities"), + type: "normal", + }, + { + id: `${AUTOFILL_IDENTITY_ID}_${SEPARATOR_ID}`, + parentId: AUTOFILL_IDENTITY_ID, + type: "separator", + }, + { + id: `${AUTOFILL_IDENTITY_ID}_${CREATE_IDENTITY_ID}`, + parentId: AUTOFILL_IDENTITY_ID, + title: this.i18nService.t("addIdentityMenu"), + type: "normal", + }, + ]; + private noLoginsContextMenuItems: chrome.contextMenus.CreateProperties[] = [ + { + id: `${AUTOFILL_ID}_NOTICE`, + enabled: false, + parentId: AUTOFILL_ID, + title: this.i18nService.t("noMatchingLogins"), + type: "normal", + }, + { + id: `${AUTOFILL_ID}_${SEPARATOR_ID}1`, + parentId: AUTOFILL_ID, + type: "separator", + }, + ]; constructor( private stateService: BrowserStateService, + private autofillSettingsService: AutofillSettingsServiceAbstraction, private i18nService: I18nService, - private logService: LogService - ) { - if (chrome.contextMenus) { - this.create = (options) => { - return new Promise((resolve, reject) => { - chrome.contextMenus.create(options, () => { - if (chrome.runtime.lastError) { - reject(chrome.runtime.lastError); - return; - } - resolve(); - }); - }); - }; - } else { - this.create = (_options) => Promise.resolve(); - } - } + private logService: LogService, + private billingAccountProfileStateService: BillingAccountProfileStateService, + ) {} static async mv3Create(cachedServices: CachedServices) { const stateFactory = new StateFactory(GlobalState, Account); @@ -79,18 +184,22 @@ export class MainContextMenuHandler { logServiceOptions: { isDev: false, }, - stateMigrationServiceOptions: { - stateFactory: stateFactory, - }, stateServiceOptions: { stateFactory: stateFactory, }, + platformUtilsServiceOptions: { + clipboardWriteCallback: () => Promise.resolve(), + biometricCallback: () => Promise.resolve(false), + win: self, + }, }; return new MainContextMenuHandler( await stateServiceFactory(cachedServices, serviceOptions), + await autofillSettingsServiceFactory(cachedServices, serviceOptions), await i18nServiceFactory(cachedServices, serviceOptions), - await logServiceFactory(cachedServices, serviceOptions) + await logServiceFactory(cachedServices, serviceOptions), + await billingAccountProfileStateServiceFactory(cachedServices, serviceOptions), ); } @@ -99,8 +208,8 @@ export class MainContextMenuHandler { * @returns a boolean showing whether or not items were created */ async init(): Promise { - const menuDisabled = await this.stateService.getDisableContextMenuItem(); - if (menuDisabled) { + const menuEnabled = await firstValueFrom(this.autofillSettingsService.enableContextMenu$); + if (!menuEnabled) { await MainContextMenuHandler.removeAll(); return false; } @@ -111,58 +220,17 @@ export class MainContextMenuHandler { this.initRunning = true; try { - const create = async (options: Omit) => { - await this.create({ ...options, contexts: ["all"] }); - }; + for (const options of this.initContextMenuItems) { + if ( + options.checkPremiumAccess && + !(await firstValueFrom(this.billingAccountProfileStateService.hasPremiumFromAnySource$)) + ) { + continue; + } - await create({ - id: ROOT_ID, - title: "Bitwarden", - }); - - await create({ - id: AUTOFILL_ID, - parentId: ROOT_ID, - title: this.i18nService.t("autoFill"), - }); - - await create({ - id: COPY_USERNAME_ID, - parentId: ROOT_ID, - title: this.i18nService.t("copyUsername"), - }); - - await create({ - id: COPY_PASSWORD_ID, - parentId: ROOT_ID, - title: this.i18nService.t("copyPassword"), - }); - - if (await this.stateService.getCanAccessPremium()) { - await create({ - id: COPY_VERIFICATIONCODE_ID, - parentId: ROOT_ID, - title: this.i18nService.t("copyVerificationCode"), - }); + delete options.checkPremiumAccess; + await MainContextMenuHandler.create({ ...options, contexts: ["all"] }); } - - await create({ - id: SEPARATOR_ID, - type: "separator", - parentId: ROOT_ID, - }); - - await create({ - id: GENERATE_PASSWORD_ID, - parentId: ROOT_ID, - title: this.i18nService.t("generatePasswordCopied"), - }); - - await create({ - id: COPY_IDENTIFIER_ID, - parentId: ROOT_ID, - title: this.i18nService.t("copyElementIdentifier"), - }); } catch (error) { this.logService.warning(error.message); } finally { @@ -171,6 +239,26 @@ export class MainContextMenuHandler { return true; } + /** + * Creates a context menu item + * + * @param options - the options for the context menu item + */ + private static create = async (options: chrome.contextMenus.CreateProperties) => { + if (!chrome.contextMenus) { + return; + } + + return new Promise((resolve, reject) => { + chrome.contextMenus.create(options, () => { + if (chrome.runtime.lastError) { + return reject(chrome.runtime.lastError); + } + resolve(); + }); + }); + }; + static async removeAll() { return new Promise((resolve, reject) => { chrome.contextMenus.removeAll(() => { @@ -197,39 +285,53 @@ export class MainContextMenuHandler { }); } - async loadOptions(title: string, id: string, url: string, cipher?: CipherView | undefined) { - if (cipher != null && cipher.type !== CipherType.Login) { - return; - } - + async loadOptions(title: string, optionId: string, cipher?: CipherView) { try { const sanitizedTitle = MainContextMenuHandler.sanitizeContextMenuTitle(title); - const createChildItem = async (parent: string) => { - const menuItemId = `${parent}_${id}`; - return await this.create({ + const createChildItem = async (parentId: string) => { + const menuItemId = `${parentId}_${optionId}`; + + return await MainContextMenuHandler.create({ type: "normal", id: menuItemId, - parentId: parent, + parentId, title: sanitizedTitle, contexts: ["all"], }); }; - if (cipher == null || !Utils.isNullOrEmpty(cipher.login.password)) { + if ( + !cipher || + (cipher.type === CipherType.Login && !Utils.isNullOrEmpty(cipher.login?.password)) + ) { await createChildItem(AUTOFILL_ID); + if (cipher?.viewPassword ?? true) { await createChildItem(COPY_PASSWORD_ID); } } - if (cipher == null || !Utils.isNullOrEmpty(cipher.login.username)) { + if ( + !cipher || + (cipher.type === CipherType.Login && !Utils.isNullOrEmpty(cipher.login?.username)) + ) { await createChildItem(COPY_USERNAME_ID); } - const canAccessPremium = await this.stateService.getCanAccessPremium(); - if (canAccessPremium && (cipher == null || !Utils.isNullOrEmpty(cipher.login.totp))) { - await createChildItem(COPY_VERIFICATIONCODE_ID); + const canAccessPremium = await firstValueFrom( + this.billingAccountProfileStateService.hasPremiumFromAnySource$, + ); + if (canAccessPremium && (!cipher || !Utils.isNullOrEmpty(cipher.login?.totp))) { + await createChildItem(COPY_VERIFICATION_CODE_ID); + } + + if ((!cipher || cipher.type === CipherType.Card) && optionId !== CREATE_LOGIN_ID) { + await createChildItem(AUTOFILL_CARD_ID); + } + + if ((!cipher || cipher.type === CipherType.Identity) && optionId !== CREATE_LOGIN_ID) { + await createChildItem(AUTOFILL_IDENTITY_ID); } } catch (error) { this.logService.warning(error.message); @@ -243,15 +345,42 @@ export class MainContextMenuHandler { async noAccess() { if (await this.init()) { const authed = await this.stateService.getIsAuthenticated(); - await this.loadOptions( + this.loadOptions( this.i18nService.t(authed ? "unlockVaultMenu" : "loginToVaultMenu"), NOOP_COMMAND_SUFFIX, - "" - ); + ).catch((error) => this.logService.warning(error.message)); } } - async noLogins(url: string) { - await this.loadOptions(this.i18nService.t("noMatchingLogins"), NOOP_COMMAND_SUFFIX, url); + async noCards() { + try { + for (const option of this.noCardsContextMenuItems) { + await MainContextMenuHandler.create(option); + } + } catch (error) { + this.logService.warning(error.message); + } + } + + async noIdentities() { + try { + for (const option of this.noIdentitiesContextMenuItems) { + await MainContextMenuHandler.create(option); + } + } catch (error) { + this.logService.warning(error.message); + } + } + + async noLogins() { + try { + for (const option of this.noLoginsContextMenuItems) { + await MainContextMenuHandler.create(option); + } + + await this.loadOptions(this.i18nService.t("addLoginMenu"), CREATE_LOGIN_ID); + } catch (error) { + this.logService.warning(error.message); + } } } diff --git a/apps/browser/src/autofill/clipboard/generate-password-to-clipboard-command.spec.ts b/apps/browser/src/autofill/clipboard/generate-password-to-clipboard-command.spec.ts index 3001087f74..e3639ef81f 100644 --- a/apps/browser/src/autofill/clipboard/generate-password-to-clipboard-command.spec.ts +++ b/apps/browser/src/autofill/clipboard/generate-password-to-clipboard-command.spec.ts @@ -1,10 +1,10 @@ import { mock, MockProxy } from "jest-mock-extended"; +import { AutofillSettingsService } from "@bitwarden/common/autofill/services/autofill-settings.service"; import { PasswordGenerationServiceAbstraction } from "@bitwarden/common/tools/generator/password"; import { setAlarmTime } from "../../platform/alarms/alarm-state"; import { BrowserApi } from "../../platform/browser/browser-api"; -import { BrowserStateService } from "../../platform/services/abstractions/browser-state.service"; import { clearClipboardAlarmName } from "./clear-clipboard"; import { GeneratePasswordToClipboardCommand } from "./generate-password-to-clipboard-command"; @@ -19,13 +19,12 @@ const setAlarmTimeMock = setAlarmTime as jest.Mock; describe("GeneratePasswordToClipboardCommand", () => { let passwordGenerationService: MockProxy; - let stateService: MockProxy; + let autofillSettingsService: MockProxy; let sut: GeneratePasswordToClipboardCommand; beforeEach(() => { passwordGenerationService = mock(); - stateService = mock(); passwordGenerationService.getOptions.mockResolvedValue([{ length: 8 }, {} as any]); @@ -33,7 +32,10 @@ describe("GeneratePasswordToClipboardCommand", () => { jest.spyOn(BrowserApi, "sendTabsMessage").mockReturnValue(); - sut = new GeneratePasswordToClipboardCommand(passwordGenerationService, stateService); + sut = new GeneratePasswordToClipboardCommand( + passwordGenerationService, + autofillSettingsService, + ); }); afterEach(() => { @@ -42,7 +44,7 @@ describe("GeneratePasswordToClipboardCommand", () => { describe("generatePasswordToClipboard", () => { it("has clear clipboard value", async () => { - stateService.getClearClipboard.mockResolvedValue(5 * 60); // 5 minutes + jest.spyOn(sut as any, "getClearClipboard").mockImplementation(() => 5 * 60); // 5 minutes await sut.generatePasswordToClipboard({ id: 1 } as any); @@ -59,7 +61,7 @@ describe("GeneratePasswordToClipboardCommand", () => { }); it("does not have clear clipboard value", async () => { - stateService.getClearClipboard.mockResolvedValue(null); + jest.spyOn(sut as any, "getClearClipboard").mockImplementation(() => null); await sut.generatePasswordToClipboard({ id: 1 } as any); diff --git a/apps/browser/src/autofill/clipboard/generate-password-to-clipboard-command.ts b/apps/browser/src/autofill/clipboard/generate-password-to-clipboard-command.ts index 6211016665..c46718ebad 100644 --- a/apps/browser/src/autofill/clipboard/generate-password-to-clipboard-command.ts +++ b/apps/browser/src/autofill/clipboard/generate-password-to-clipboard-command.ts @@ -1,7 +1,9 @@ +import { firstValueFrom } from "rxjs"; + +import { AutofillSettingsServiceAbstraction } from "@bitwarden/common/autofill/services/autofill-settings.service"; import { PasswordGenerationServiceAbstraction } from "@bitwarden/common/tools/generator/password"; import { setAlarmTime } from "../../platform/alarms/alarm-state"; -import { BrowserStateService } from "../../platform/services/abstractions/browser-state.service"; import { clearClipboardAlarmName } from "./clear-clipboard"; import { copyToClipboard } from "./copy-to-clipboard-command"; @@ -9,16 +11,22 @@ import { copyToClipboard } from "./copy-to-clipboard-command"; export class GeneratePasswordToClipboardCommand { constructor( private passwordGenerationService: PasswordGenerationServiceAbstraction, - private stateService: BrowserStateService + private autofillSettingsService: AutofillSettingsServiceAbstraction, ) {} + async getClearClipboard() { + return await firstValueFrom(this.autofillSettingsService.clearClipboardDelay$); + } + async generatePasswordToClipboard(tab: chrome.tabs.Tab) { const [options] = await this.passwordGenerationService.getOptions(); const password = await this.passwordGenerationService.generatePassword(options); + // FIXME: Verify that this floating promise is intentional. If it is, add an explanatory comment and ensure there is proper error handling. + // eslint-disable-next-line @typescript-eslint/no-floating-promises copyToClipboard(tab, password); - const clearClipboard = await this.stateService.getClearClipboard(); + const clearClipboard = await this.getClearClipboard(); if (clearClipboard != null) { await setAlarmTime(clearClipboardAlarmName, clearClipboard * 1000); diff --git a/apps/browser/src/autofill/commands/autofill-tab-command.ts b/apps/browser/src/autofill/commands/autofill-tab-command.ts index b51edd929e..16ce40ff3d 100644 --- a/apps/browser/src/autofill/commands/autofill-tab-command.ts +++ b/apps/browser/src/autofill/commands/autofill-tab-command.ts @@ -21,7 +21,7 @@ export class AutofillTabCommand { }, ], tab, - true + true, ); } @@ -64,7 +64,7 @@ export class AutofillTabCommand { } resolve(response); - } + }, ); }); } diff --git a/apps/browser/src/autofill/content/abstractions/autofill-init.ts b/apps/browser/src/autofill/content/abstractions/autofill-init.ts new file mode 100644 index 0000000000..91866ffa0b --- /dev/null +++ b/apps/browser/src/autofill/content/abstractions/autofill-init.ts @@ -0,0 +1,46 @@ +import { AuthenticationStatus } from "@bitwarden/common/auth/enums/authentication-status"; + +import AutofillScript from "../../models/autofill-script"; + +type AutofillExtensionMessage = { + command: string; + tab?: chrome.tabs.Tab; + sender?: string; + fillScript?: AutofillScript; + url?: string; + pageDetailsUrl?: string; + ciphers?: any; + data?: { + authStatus?: AuthenticationStatus; + isFocusingFieldElement?: boolean; + isOverlayCiphersPopulated?: boolean; + direction?: "previous" | "next"; + isOpeningFullOverlay?: boolean; + forceCloseOverlay?: boolean; + autofillOverlayVisibility?: number; + }; +}; + +type AutofillExtensionMessageParam = { message: AutofillExtensionMessage }; + +type AutofillExtensionMessageHandlers = { + [key: string]: CallableFunction; + collectPageDetails: ({ message }: AutofillExtensionMessageParam) => void; + collectPageDetailsImmediately: ({ message }: AutofillExtensionMessageParam) => void; + fillForm: ({ message }: AutofillExtensionMessageParam) => void; + openAutofillOverlay: ({ message }: AutofillExtensionMessageParam) => void; + closeAutofillOverlay: ({ message }: AutofillExtensionMessageParam) => void; + addNewVaultItemFromOverlay: () => void; + redirectOverlayFocusOut: ({ message }: AutofillExtensionMessageParam) => void; + updateIsOverlayCiphersPopulated: ({ message }: AutofillExtensionMessageParam) => void; + bgUnlockPopoutOpened: () => void; + bgVaultItemRepromptPopoutOpened: () => void; + updateAutofillOverlayVisibility: ({ message }: AutofillExtensionMessageParam) => void; +}; + +interface AutofillInit { + init(): void; + destroy(): void; +} + +export { AutofillExtensionMessage, AutofillExtensionMessageHandlers, AutofillInit }; diff --git a/apps/browser/src/autofill/content/abstractions/content-message-handler.ts b/apps/browser/src/autofill/content/abstractions/content-message-handler.ts new file mode 100644 index 0000000000..8231bd688c --- /dev/null +++ b/apps/browser/src/autofill/content/abstractions/content-message-handler.ts @@ -0,0 +1,26 @@ +type ContentMessageWindowData = { + command: string; + lastpass?: boolean; + code?: string; + state?: string; + data?: string; + remember?: boolean; +}; +type ContentMessageWindowEventParams = { + data: ContentMessageWindowData; + referrer: string; +}; + +type ContentMessageWindowEventHandlers = { + [key: string]: ({ data, referrer }: ContentMessageWindowEventParams) => void; + authResult: ({ data, referrer }: ContentMessageWindowEventParams) => void; + webAuthnResult: ({ data, referrer }: ContentMessageWindowEventParams) => void; + duoResult: ({ data, referrer }: ContentMessageWindowEventParams) => void; + checkIfBWExtensionInstalled: () => void; +}; + +export { + ContentMessageWindowData, + ContentMessageWindowEventParams, + ContentMessageWindowEventHandlers, +}; diff --git a/apps/browser/src/autofill/content/autofill-init.spec.ts b/apps/browser/src/autofill/content/autofill-init.spec.ts new file mode 100644 index 0000000000..b299ddccbf --- /dev/null +++ b/apps/browser/src/autofill/content/autofill-init.spec.ts @@ -0,0 +1,579 @@ +import { mock } from "jest-mock-extended"; + +import { AuthenticationStatus } from "@bitwarden/common/auth/enums/authentication-status"; +import { AutofillOverlayVisibility } from "@bitwarden/common/autofill/constants"; + +import AutofillPageDetails from "../models/autofill-page-details"; +import AutofillScript from "../models/autofill-script"; +import AutofillOverlayContentService from "../services/autofill-overlay-content.service"; +import { flushPromises, sendExtensionRuntimeMessage } from "../spec/testing-utils"; +import { RedirectFocusDirection } from "../utils/autofill-overlay.enum"; + +import { AutofillExtensionMessage } from "./abstractions/autofill-init"; +import AutofillInit from "./autofill-init"; + +describe("AutofillInit", () => { + let autofillInit: AutofillInit; + const autofillOverlayContentService = mock
+ 
-
-
- 
-
-
- 
-
-
- 
-
-
- 
-
+ 
+ 
+ 
+ 
+ 
+
-
-
+
The Bitwarden browser extension is written using the Web Extension API and Angular.
diff --git a/apps/browser/config/base.json b/apps/browser/config/base.json
index 81b11cd38b..8a3ccc14d3 100644
--- a/apps/browser/config/base.json
+++ b/apps/browser/config/base.json
@@ -1,6 +1,8 @@
{
"dev_flags": {},
"flags": {
- "showPasswordless": true
+ "showPasswordless": true,
+ "enableCipherKeyEncryption": false,
+ "accountSwitching": false
}
}
diff --git a/apps/browser/config/development.json b/apps/browser/config/development.json
index 972812a9c5..1b628c173c 100644
--- a/apps/browser/config/development.json
+++ b/apps/browser/config/development.json
@@ -6,6 +6,8 @@
}
},
"flags": {
- "showPasswordless": true
+ "showPasswordless": true,
+ "enableCipherKeyEncryption": false,
+ "accountSwitching": true
}
}
diff --git a/apps/browser/config/production.json b/apps/browser/config/production.json
index b04d1531a2..027003f6c7 100644
--- a/apps/browser/config/production.json
+++ b/apps/browser/config/production.json
@@ -1,3 +1,6 @@
{
- "flags": {}
+ "flags": {
+ "enableCipherKeyEncryption": false,
+ "accountSwitching": true
+ }
}
diff --git a/apps/browser/gulpfile.js b/apps/browser/gulpfile.js
index 2f672ffcdd..6a0980fc27 100644
--- a/apps/browser/gulpfile.js
+++ b/apps/browser/gulpfile.js
@@ -1,13 +1,11 @@
const child = require("child_process");
const fs = require("fs");
-const del = require("del");
+const { rimraf } = require("rimraf");
const gulp = require("gulp");
-const filter = require("gulp-filter");
const gulpif = require("gulp-if");
const jeditor = require("gulp-json-editor");
const replace = require("gulp-replace");
-const zip = require("gulp-zip");
const manifest = require("./src/manifest.json");
@@ -47,7 +45,10 @@ function distFileName(browserName, ext) {
return `dist-${browserName}${buildString()}.${ext}`;
}
-function dist(browserName, manifest) {
+async function dist(browserName, manifest) {
+ const { default: zip } = await import("gulp-zip");
+ const { default: filter } = await import("gulp-filter");
+
return gulp
.src(paths.build + "**/*")
.pipe(filter(["**"].concat(filters.fonts).concat(filters.safari)))
@@ -60,6 +61,10 @@ function dist(browserName, manifest) {
function distFirefox() {
return dist("firefox", (manifest) => {
delete manifest.storage;
+ delete manifest.sandbox;
+ manifest.optional_permissions = manifest.optional_permissions.filter(
+ (permission) => permission !== "privacy",
+ );
return manifest;
});
}
@@ -123,13 +128,13 @@ function distSafariApp(cb, subBuildPath) {
"--sign",
subBuildPath === "mas"
? "3rd Party Mac Developer Application: Bitwarden Inc"
- : "E661AB6249AEB60B0F47ABBD7326B2877D2575B0",
+ : "E7C9978F6FBCE0553429185C405E61F5380BE8EB",
"--entitlements",
entitlementsPath,
];
}
- return del([buildPath + "**/*"])
+ return rimraf([buildPath + "**/*"], { glob: true })
.then(() => safariCopyAssets(paths.safari + "**/*", buildPath))
.then(() => safariCopyBuild(paths.build + "**/*", buildPath + "safari/app"))
.then(() => {
@@ -143,7 +148,9 @@ function distSafariApp(cb, subBuildPath) {
stdOutProc(proc);
return new Promise((resolve) => proc.on("close", resolve));
})
- .then(() => {
+ .then(async () => {
+ const { default: filter } = await import("gulp-filter");
+
const libs = fs
.readdirSync(builtAppexFrameworkPath)
.filter((p) => p.endsWith(".dylib"))
@@ -167,7 +174,7 @@ function distSafariApp(cb, subBuildPath) {
},
() => {
return cb;
- }
+ },
);
}
@@ -178,7 +185,7 @@ function safariCopyAssets(source, dest) {
.on("error", reject)
.pipe(gulpif("safari/Info.plist", replace("0.0.1", manifest.version)))
.pipe(
- gulpif("safari/Info.plist", replace("0.0.2", process.env.BUILD_NUMBER || manifest.version))
+ gulpif("safari/Info.plist", replace("0.0.2", process.env.BUILD_NUMBER || manifest.version)),
)
.pipe(gulpif("desktop.xcodeproj/project.pbxproj", replace("../../../build", "../safari/app")))
.pipe(gulp.dest(dest))
@@ -186,7 +193,9 @@ function safariCopyAssets(source, dest) {
});
}
-function safariCopyBuild(source, dest) {
+async function safariCopyBuild(source, dest) {
+ const { default: filter } = await import("gulp-filter");
+
return new Promise((resolve, reject) => {
gulp
.src(source)
@@ -202,8 +211,8 @@ function safariCopyBuild(source, dest) {
delete manifest.optional_permissions;
manifest.permissions.push("nativeMessaging");
return manifest;
- })
- )
+ }),
+ ),
)
.pipe(gulp.dest(dest))
.on("end", resolve);
@@ -215,7 +224,10 @@ function stdOutProc(proc) {
proc.stderr.on("data", (data) => console.error(data.toString()));
}
-function ciCoverage(cb) {
+async function ciCoverage(cb) {
+ const { default: zip } = await import("gulp-zip");
+ const { default: filter } = await import("gulp-filter");
+
return gulp
.src(paths.coverage + "**/*")
.pipe(filter(["**", "!coverage/coverage*.zip"]))
diff --git a/apps/browser/jest.config.js b/apps/browser/jest.config.js
index cde02cd995..73f5ada287 100644
--- a/apps/browser/jest.config.js
+++ b/apps/browser/jest.config.js
@@ -9,7 +9,10 @@ module.exports = {
...sharedConfig,
preset: "jest-preset-angular",
setupFilesAfterEnv: ["