From a6e178f1e60e8de42bd205e27dd4295a6ab79a6a Mon Sep 17 00:00:00 2001 From: Tom <144813356+ttalty@users.noreply.github.com> Date: Tue, 2 Apr 2024 12:39:06 -0400 Subject: [PATCH] [PM-5574] sends state provider (#8373) * Adding the key definitions and tests and initial send state service * Adding the abstraction and implementing * Planning comments * Everything but fixing the send tests * Moving send tests over to the state provider * jslib needed name refactor * removing get/set encrypted sends from web vault state service * browser send state service factory * Fixing conflicts * Removing send service from services module and fixing send service observable * Commenting the migrator to be clear on why only encrypted * No need for service factories in browser * browser send service is no longer needed * Key def test cases to use toStrictEqual * Running prettier * Creating send test data to avoid code duplication * Adding state provider and account service to send in cli * Fixing the send service test cases * Fixing state definition keys * Moving to observables and implementing encryption service * Fixing key def tests * The cli was using the deprecated get method * The observables init doesn't need to happen in constructor * Missed commented out code * If enc key is null get user key * Service factory fix --- .../browser/src/background/main.background.ts | 7 +- .../service-factories/send-service.factory.ts | 17 +- .../send-state-provider.factory.ts | 28 ++ apps/cli/src/bw.ts | 7 +- .../send/commands/remove-password.command.ts | 2 +- apps/web/src/app/core/state/state.service.ts | 14 - .../src/services/jslib-services.module.ts | 10 +- libs/angular/src/tools/send/send.component.ts | 14 +- .../platform/abstractions/state.service.ts | 18 -- .../src/platform/models/domain/account.ts | 3 - .../src/platform/services/state.service.ts | 41 --- .../src/platform/state/state-definitions.ts | 4 + libs/common/src/state-migrations/migrate.ts | 7 +- .../54-move-encrypted-sends.spec.ts | 236 +++++++++++++++ .../migrations/54-move-encrypted-sends.ts | 67 +++++ .../send/services/key-definitions.spec.ts | 21 ++ .../tools/send/services/key-definitions.ts | 13 + .../send-state.provider.abstraction.ts | 17 ++ .../send/services/send-state.provider.spec.ts | 48 ++++ .../send/services/send-state.provider.ts | 47 +++ .../send/services/send.service.abstraction.ts | 5 - .../tools/send/services/send.service.spec.ts | 270 +++++++----------- .../src/tools/send/services/send.service.ts | 117 +++----- .../services/test-data/send-tests.data.ts | 79 +++++ .../src/vault/services/sync/sync.service.ts | 2 +- 25 files changed, 767 insertions(+), 327 deletions(-) create mode 100644 apps/browser/src/background/service-factories/send-state-provider.factory.ts create mode 100644 libs/common/src/state-migrations/migrations/54-move-encrypted-sends.spec.ts create mode 100644 libs/common/src/state-migrations/migrations/54-move-encrypted-sends.ts create mode 100644 libs/common/src/tools/send/services/key-definitions.spec.ts create mode 100644 libs/common/src/tools/send/services/key-definitions.ts create mode 100644 libs/common/src/tools/send/services/send-state.provider.abstraction.ts create mode 100644 libs/common/src/tools/send/services/send-state.provider.spec.ts create mode 100644 libs/common/src/tools/send/services/send-state.provider.ts create mode 100644 libs/common/src/tools/send/services/test-data/send-tests.data.ts diff --git a/apps/browser/src/background/main.background.ts b/apps/browser/src/background/main.background.ts index 102dad80a7..ea43aecff9 100644 --- a/apps/browser/src/background/main.background.ts +++ b/apps/browser/src/background/main.background.ts @@ -146,6 +146,7 @@ import { } from "@bitwarden/common/tools/password-strength"; import { SendApiService } from "@bitwarden/common/tools/send/services/send-api.service"; import { SendApiService as SendApiServiceAbstraction } from "@bitwarden/common/tools/send/services/send-api.service.abstraction"; +import { SendStateProvider } from "@bitwarden/common/tools/send/services/send-state.provider"; import { SendService } from "@bitwarden/common/tools/send/services/send.service"; import { InternalSendService as InternalSendServiceAbstraction } from "@bitwarden/common/tools/send/services/send.service.abstraction"; import { UserId } from "@bitwarden/common/types/guid"; @@ -276,6 +277,7 @@ export default class MainBackground { eventUploadService: EventUploadServiceAbstraction; policyService: InternalPolicyServiceAbstraction; sendService: InternalSendServiceAbstraction; + sendStateProvider: SendStateProvider; fileUploadService: FileUploadServiceAbstraction; cipherFileUploadService: CipherFileUploadServiceAbstraction; organizationService: InternalOrganizationServiceAbstraction; @@ -707,11 +709,14 @@ export default class MainBackground { logoutCallback, ); this.containerService = new ContainerService(this.cryptoService, this.encryptService); + + this.sendStateProvider = new SendStateProvider(this.stateProvider); this.sendService = new SendService( this.cryptoService, this.i18nService, this.keyGenerationService, - this.stateService, + this.sendStateProvider, + this.encryptService, ); this.sendApiService = new SendApiService( this.apiService, diff --git a/apps/browser/src/background/service-factories/send-service.factory.ts b/apps/browser/src/background/service-factories/send-service.factory.ts index 7c64bc076a..942861b926 100644 --- a/apps/browser/src/background/service-factories/send-service.factory.ts +++ b/apps/browser/src/background/service-factories/send-service.factory.ts @@ -5,6 +5,10 @@ import { CryptoServiceInitOptions, cryptoServiceFactory, } from "../../platform/background/service-factories/crypto-service.factory"; +import { + EncryptServiceInitOptions, + encryptServiceFactory, +} from "../../platform/background/service-factories/encrypt-service.factory"; import { FactoryOptions, CachedServices, @@ -18,10 +22,11 @@ import { KeyGenerationServiceInitOptions, keyGenerationServiceFactory, } from "../../platform/background/service-factories/key-generation-service.factory"; + import { - stateServiceFactory, - StateServiceInitOptions, -} from "../../platform/background/service-factories/state-service.factory"; + SendStateProviderInitOptions, + sendStateProviderFactory, +} from "./send-state-provider.factory"; type SendServiceFactoryOptions = FactoryOptions; @@ -29,7 +34,8 @@ export type SendServiceInitOptions = SendServiceFactoryOptions & CryptoServiceInitOptions & I18nServiceInitOptions & KeyGenerationServiceInitOptions & - StateServiceInitOptions; + SendStateProviderInitOptions & + EncryptServiceInitOptions; export function sendServiceFactory( cache: { sendService?: InternalSendService } & CachedServices, @@ -44,7 +50,8 @@ export function sendServiceFactory( await cryptoServiceFactory(cache, opts), await i18nServiceFactory(cache, opts), await keyGenerationServiceFactory(cache, opts), - await stateServiceFactory(cache, opts), + await sendStateProviderFactory(cache, opts), + await encryptServiceFactory(cache, opts), ), ); } diff --git a/apps/browser/src/background/service-factories/send-state-provider.factory.ts b/apps/browser/src/background/service-factories/send-state-provider.factory.ts new file mode 100644 index 0000000000..01319756e4 --- /dev/null +++ b/apps/browser/src/background/service-factories/send-state-provider.factory.ts @@ -0,0 +1,28 @@ +import { SendStateProvider } from "@bitwarden/common/tools/send/services/send-state.provider"; + +import { + CachedServices, + FactoryOptions, + factory, +} from "../../platform/background/service-factories/factory-options"; +import { + StateProviderInitOptions, + stateProviderFactory, +} from "../../platform/background/service-factories/state-provider.factory"; + +type SendStateProviderFactoryOptions = FactoryOptions; + +export type SendStateProviderInitOptions = SendStateProviderFactoryOptions & + StateProviderInitOptions; + +export function sendStateProviderFactory( + cache: { sendStateProvider?: SendStateProvider } & CachedServices, + opts: SendStateProviderInitOptions, +): Promise { + return factory( + cache, + "sendStateProvider", + opts, + async () => new SendStateProvider(await stateProviderFactory(cache, opts)), + ); +} diff --git a/apps/cli/src/bw.ts b/apps/cli/src/bw.ts index 804b05e8e3..3815fc773b 100644 --- a/apps/cli/src/bw.ts +++ b/apps/cli/src/bw.ts @@ -106,6 +106,7 @@ import { PasswordStrengthServiceAbstraction, } from "@bitwarden/common/tools/password-strength"; import { SendApiService } from "@bitwarden/common/tools/send/services/send-api.service"; +import { SendStateProvider } from "@bitwarden/common/tools/send/services/send-state.provider"; import { SendService } from "@bitwarden/common/tools/send/services/send.service"; import { UserId } from "@bitwarden/common/types/guid"; import { InternalFolderService } from "@bitwarden/common/vault/abstractions/folder/folder.service.abstraction"; @@ -194,6 +195,7 @@ export class Main { sendProgram: SendProgram; logService: ConsoleLogService; sendService: SendService; + sendStateProvider: SendStateProvider; fileUploadService: FileUploadService; cipherFileUploadService: CipherFileUploadService; keyConnectorService: KeyConnectorService; @@ -388,11 +390,14 @@ export class Main { this.fileUploadService = new FileUploadService(this.logService); + this.sendStateProvider = new SendStateProvider(this.stateProvider); + this.sendService = new SendService( this.cryptoService, this.i18nService, this.keyGenerationService, - this.stateService, + this.sendStateProvider, + this.encryptService, ); this.cipherFileUploadService = new CipherFileUploadService( diff --git a/apps/cli/src/tools/send/commands/remove-password.command.ts b/apps/cli/src/tools/send/commands/remove-password.command.ts index 1c7289bf08..2613004a8c 100644 --- a/apps/cli/src/tools/send/commands/remove-password.command.ts +++ b/apps/cli/src/tools/send/commands/remove-password.command.ts @@ -18,7 +18,7 @@ export class SendRemovePasswordCommand { try { await this.sendApiService.removePassword(id); - const updatedSend = await this.sendService.get(id); + const updatedSend = await firstValueFrom(this.sendService.get$(id)); const decSend = await updatedSend.decrypt(); const env = await firstValueFrom(this.environmentService.environment$); const webVaultUrl = env.getWebVaultUrl(); diff --git a/apps/web/src/app/core/state/state.service.ts b/apps/web/src/app/core/state/state.service.ts index a80384d179..54e456d34c 100644 --- a/apps/web/src/app/core/state/state.service.ts +++ b/apps/web/src/app/core/state/state.service.ts @@ -18,7 +18,6 @@ import { StateFactory } from "@bitwarden/common/platform/factories/state-factory import { StorageOptions } from "@bitwarden/common/platform/models/domain/storage-options"; import { MigrationRunner } from "@bitwarden/common/platform/services/migration-runner"; import { StateService as BaseStateService } from "@bitwarden/common/platform/services/state.service"; -import { SendData } from "@bitwarden/common/tools/send/models/data/send.data"; import { CipherData } from "@bitwarden/common/vault/models/data/cipher.data"; import { Account } from "./account"; @@ -71,19 +70,6 @@ export class StateService extends BaseStateService { return await super.setEncryptedCiphers(value, options); } - async getEncryptedSends(options?: StorageOptions): Promise<{ [id: string]: SendData }> { - options = this.reconcileOptions(options, await this.defaultInMemoryOptions()); - return await super.getEncryptedSends(options); - } - - async setEncryptedSends( - value: { [id: string]: SendData }, - options?: StorageOptions, - ): Promise { - options = this.reconcileOptions(options, await this.defaultInMemoryOptions()); - return await super.setEncryptedSends(value, options); - } - override async getLastSync(options?: StorageOptions): Promise { options = this.reconcileOptions(options, await this.defaultInMemoryOptions()); return await super.getLastSync(options); diff --git a/libs/angular/src/services/jslib-services.module.ts b/libs/angular/src/services/jslib-services.module.ts index 6378eed755..73f2bb4a32 100644 --- a/libs/angular/src/services/jslib-services.module.ts +++ b/libs/angular/src/services/jslib-services.module.ts @@ -191,6 +191,8 @@ import { } from "@bitwarden/common/tools/password-strength"; import { SendApiService } from "@bitwarden/common/tools/send/services/send-api.service"; import { SendApiService as SendApiServiceAbstraction } from "@bitwarden/common/tools/send/services/send-api.service.abstraction"; +import { SendStateProvider as SendStateProvider } from "@bitwarden/common/tools/send/services/send-state.provider"; +import { SendStateProvider as SendStateProviderAbstraction } from "@bitwarden/common/tools/send/services/send-state.provider.abstraction"; import { SendService } from "@bitwarden/common/tools/send/services/send.service"; import { InternalSendService, @@ -567,9 +569,15 @@ const safeProviders: SafeProvider[] = [ CryptoServiceAbstraction, I18nServiceAbstraction, KeyGenerationServiceAbstraction, - StateServiceAbstraction, + SendStateProviderAbstraction, + EncryptService, ], }), + safeProvider({ + provide: SendStateProviderAbstraction, + useClass: SendStateProvider, + deps: [StateProvider], + }), safeProvider({ provide: SendApiServiceAbstraction, useClass: SendApiService, diff --git a/libs/angular/src/tools/send/send.component.ts b/libs/angular/src/tools/send/send.component.ts index b3b871a177..90d9b39e8c 100644 --- a/libs/angular/src/tools/send/send.component.ts +++ b/libs/angular/src/tools/send/send.component.ts @@ -1,5 +1,5 @@ import { Directive, NgZone, OnDestroy, OnInit } from "@angular/core"; -import { Subject, firstValueFrom, takeUntil } from "rxjs"; +import { Subject, firstValueFrom, mergeMap, takeUntil } from "rxjs"; import { SearchService } from "@bitwarden/common/abstractions/search.service"; import { PolicyService } from "@bitwarden/common/admin-console/abstractions/policy/policy.service.abstraction"; @@ -77,9 +77,15 @@ export class SendComponent implements OnInit, OnDestroy { async load(filter: (send: SendView) => boolean = null) { this.loading = true; - this.sendService.sendViews$.pipe(takeUntil(this.destroy$)).subscribe((sends) => { - this.sends = sends; - }); + this.sendService.sendViews$ + .pipe( + mergeMap(async (sends) => { + this.sends = sends; + await this.search(null); + }), + takeUntil(this.destroy$), + ) + .subscribe(); if (this.onSuccessfulLoad != null) { await this.onSuccessfulLoad(); } else { diff --git a/libs/common/src/platform/abstractions/state.service.ts b/libs/common/src/platform/abstractions/state.service.ts index 9bc6d698a7..4c876316cd 100644 --- a/libs/common/src/platform/abstractions/state.service.ts +++ b/libs/common/src/platform/abstractions/state.service.ts @@ -7,8 +7,6 @@ import { BiometricKey } from "../../auth/types/biometric-key"; import { GeneratorOptions } from "../../tools/generator/generator-options"; import { GeneratedPasswordHistory, PasswordGeneratorOptions } from "../../tools/generator/password"; import { UsernameGeneratorOptions } from "../../tools/generator/username"; -import { SendData } from "../../tools/send/models/data/send.data"; -import { SendView } from "../../tools/send/models/view/send.view"; import { UserId } from "../../types/guid"; import { MasterKey } from "../../types/key"; import { CipherData } from "../../vault/models/data/cipher.data"; @@ -151,14 +149,6 @@ export abstract class StateService { * @deprecated For migration purposes only, use setDecryptedUserKeyPin instead */ setDecryptedPinProtected: (value: EncString, options?: StorageOptions) => Promise; - /** - * @deprecated Do not call this directly, use SendService - */ - getDecryptedSends: (options?: StorageOptions) => Promise; - /** - * @deprecated Do not call this directly, use SendService - */ - setDecryptedSends: (value: SendView[], options?: StorageOptions) => Promise; getDuckDuckGoSharedKey: (options?: StorageOptions) => Promise; setDuckDuckGoSharedKey: (value: string, options?: StorageOptions) => Promise; getAdminAuthRequest: (options?: StorageOptions) => Promise; @@ -197,14 +187,6 @@ export abstract class StateService { * @deprecated For migration purposes only, use setEncryptedUserKeyPin instead */ setEncryptedPinProtected: (value: string, options?: StorageOptions) => Promise; - /** - * @deprecated Do not call this directly, use SendService - */ - getEncryptedSends: (options?: StorageOptions) => Promise<{ [id: string]: SendData }>; - /** - * @deprecated Do not call this directly, use SendService - */ - setEncryptedSends: (value: { [id: string]: SendData }, options?: StorageOptions) => Promise; getEverBeenUnlocked: (options?: StorageOptions) => Promise; setEverBeenUnlocked: (value: boolean, options?: StorageOptions) => Promise; getForceSetPasswordReason: (options?: StorageOptions) => Promise; diff --git a/libs/common/src/platform/models/domain/account.ts b/libs/common/src/platform/models/domain/account.ts index 798a60600a..4ed36fd389 100644 --- a/libs/common/src/platform/models/domain/account.ts +++ b/libs/common/src/platform/models/domain/account.ts @@ -9,8 +9,6 @@ import { PasswordGeneratorOptions, } from "../../../tools/generator/password"; import { UsernameGeneratorOptions } from "../../../tools/generator/username/username-generation-options"; -import { SendData } from "../../../tools/send/models/data/send.data"; -import { SendView } from "../../../tools/send/models/view/send.view"; import { DeepJsonify } from "../../../types/deep-jsonify"; import { MasterKey } from "../../../types/key"; import { CipherData } from "../../../vault/models/data/cipher.data"; @@ -71,7 +69,6 @@ export class AccountData { CipherView >(); localData?: any; - sends?: DataEncryptionPair = new DataEncryptionPair(); passwordGenerationHistory?: EncryptionPair< GeneratedPasswordHistory[], GeneratedPasswordHistory[] diff --git a/libs/common/src/platform/services/state.service.ts b/libs/common/src/platform/services/state.service.ts index 57a2085ccf..fb62af250b 100644 --- a/libs/common/src/platform/services/state.service.ts +++ b/libs/common/src/platform/services/state.service.ts @@ -11,8 +11,6 @@ import { BiometricKey } from "../../auth/types/biometric-key"; import { GeneratorOptions } from "../../tools/generator/generator-options"; import { GeneratedPasswordHistory, PasswordGeneratorOptions } from "../../tools/generator/password"; import { UsernameGeneratorOptions } from "../../tools/generator/username"; -import { SendData } from "../../tools/send/models/data/send.data"; -import { SendView } from "../../tools/send/models/view/send.view"; import { UserId } from "../../types/guid"; import { MasterKey } from "../../types/key"; import { CipherData } from "../../vault/models/data/cipher.data"; @@ -614,24 +612,6 @@ export class StateService< ); } - @withPrototypeForArrayMembers(SendView) - async getDecryptedSends(options?: StorageOptions): Promise { - return ( - await this.getAccount(this.reconcileOptions(options, await this.defaultInMemoryOptions())) - )?.data?.sends?.decrypted; - } - - async setDecryptedSends(value: SendView[], options?: StorageOptions): Promise { - const account = await this.getAccount( - this.reconcileOptions(options, await this.defaultInMemoryOptions()), - ); - account.data.sends.decrypted = value; - await this.saveAccount( - account, - this.reconcileOptions(options, await this.defaultInMemoryOptions()), - ); - } - async getDuckDuckGoSharedKey(options?: StorageOptions): Promise { options = this.reconcileOptions(options, await this.defaultSecureStorageOptions()); if (options?.userId == null) { @@ -825,27 +805,6 @@ export class StateService< ); } - @withPrototypeForObjectValues(SendData) - async getEncryptedSends(options?: StorageOptions): Promise<{ [id: string]: SendData }> { - return ( - await this.getAccount(this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions())) - )?.data?.sends.encrypted; - } - - async setEncryptedSends( - value: { [id: string]: SendData }, - options?: StorageOptions, - ): Promise { - const account = await this.getAccount( - this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()), - ); - account.data.sends.encrypted = value; - await this.saveAccount( - account, - this.reconcileOptions(options, await this.defaultOnDiskMemoryOptions()), - ); - } - async getEverBeenUnlocked(options?: StorageOptions): Promise { return ( (await this.getAccount(this.reconcileOptions(options, await this.defaultInMemoryOptions()))) diff --git a/libs/common/src/platform/state/state-definitions.ts b/libs/common/src/platform/state/state-definitions.ts index 9fca0e9445..d50a3e6ac7 100644 --- a/libs/common/src/platform/state/state-definitions.ts +++ b/libs/common/src/platform/state/state-definitions.ts @@ -102,6 +102,10 @@ export const SM_ONBOARDING_DISK = new StateDefinition("smOnboarding", "disk", { export const GENERATOR_DISK = new StateDefinition("generator", "disk"); export const GENERATOR_MEMORY = new StateDefinition("generator", "memory"); export const EVENT_COLLECTION_DISK = new StateDefinition("eventCollection", "disk"); +export const SEND_DISK = new StateDefinition("encryptedSend", "disk", { + web: "memory", +}); +export const SEND_MEMORY = new StateDefinition("decryptedSend", "memory"); // Vault diff --git a/libs/common/src/state-migrations/migrate.ts b/libs/common/src/state-migrations/migrate.ts index 4e1a0529fc..faccddb0af 100644 --- a/libs/common/src/state-migrations/migrate.ts +++ b/libs/common/src/state-migrations/migrate.ts @@ -50,6 +50,7 @@ import { KeyConnectorMigrator } from "./migrations/50-move-key-connector-to-stat import { RememberedEmailMigrator } from "./migrations/51-move-remembered-email-to-state-providers"; import { DeleteInstalledVersion } from "./migrations/52-delete-installed-version"; import { DeviceTrustCryptoServiceStateProviderMigrator } from "./migrations/53-migrate-device-trust-crypto-svc-to-state-providers"; +import { SendMigrator } from "./migrations/54-move-encrypted-sends"; import { RemoveLegacyEtmKeyMigrator } from "./migrations/6-remove-legacy-etm-key"; import { MoveBiometricAutoPromptToAccount } from "./migrations/7-move-biometric-auto-prompt-to-account"; import { MoveStateVersionMigrator } from "./migrations/8-move-state-version"; @@ -57,7 +58,8 @@ import { MoveBrowserSettingsToGlobal } from "./migrations/9-move-browser-setting import { MinVersionMigrator } from "./migrations/min-version"; export const MIN_VERSION = 3; -export const CURRENT_VERSION = 53; +export const CURRENT_VERSION = 54; + export type MinVersion = typeof MIN_VERSION; export function createMigrationBuilder() { @@ -112,7 +114,8 @@ export function createMigrationBuilder() { .with(KeyConnectorMigrator, 49, 50) .with(RememberedEmailMigrator, 50, 51) .with(DeleteInstalledVersion, 51, 52) - .with(DeviceTrustCryptoServiceStateProviderMigrator, 52, CURRENT_VERSION); + .with(DeviceTrustCryptoServiceStateProviderMigrator, 52, 53) + .with(SendMigrator, 53, 54); } export async function currentVersion( diff --git a/libs/common/src/state-migrations/migrations/54-move-encrypted-sends.spec.ts b/libs/common/src/state-migrations/migrations/54-move-encrypted-sends.spec.ts new file mode 100644 index 0000000000..9e73a1258a --- /dev/null +++ b/libs/common/src/state-migrations/migrations/54-move-encrypted-sends.spec.ts @@ -0,0 +1,236 @@ +import { MockProxy, any } from "jest-mock-extended"; + +import { MigrationHelper } from "../migration-helper"; +import { mockMigrationHelper } from "../migration-helper.spec"; + +import { SendMigrator } from "./54-move-encrypted-sends"; + +function exampleJSON() { + return { + global: { + otherStuff: "otherStuff1", + }, + authenticatedAccounts: ["user-1", "user-2"], + "user-1": { + data: { + sends: { + encrypted: { + "2ebadc23-e101-471b-bf2d-b125015337a0": { + id: "2ebadc23-e101-471b-bf2d-b125015337a0", + accessId: "I9y6LgHhG0e_LbElAVM3oA", + deletionDate: "2024-03-07T20:35:03Z", + disabled: false, + hideEmail: false, + key: "2.sR07sf4f18Rw6YQH9R/fPw==|DlLIYdTlFBktHVEJixqrOZmW/dTDGmZ+9iVftYkRh4s=|2mXH2fKgtItEMi8rcP1ykkVwRbxztw5MGboBwRl/kKM=", + name: "2.A0wIvDbyzuh6AjgFtv2gqQ==|D0FymzfCdYJQcAk5MARfjg==|2g52y7e/33A7Bafaaoy3Yvae7vxbIxoABZdZeoZuyg4=", + text: { + hidden: false, + text: "2.MkcPiJUnNfpcyETsoH3b8g==|/oHZ5g6pmcerXAJidP9sXg==|JDhd1Blsxm/ubp2AAggHZr6gZhyW4UYwZkF5rxlO6X0=", + }, + type: 0, + }, + "3b31c20d-b783-4912-9170-b12501555398": { + id: "3b31c20d-b783-4912-9170-b12501555398", + accessId: "DcIxO4O3EkmRcLElAVVTmA", + deletionDate: "2024-03-07T20:42:43Z", + disabled: false, + hideEmail: false, + key: "2.366XwLCi7RJnXuAvpsEVNw==|XfLoSsdOIYsHfcSMmv+7VJY97bKfS3fjpbq3ez+KCdk=|iTJxf4Pc3ub6hTFXGeU8NpUV3KxnuxzaHuNoFo/I6Vs=", + name: "2.uJ2FoouFJr/SR9gv3jYY/Q==|ksVre4/YqwY/XOtPyIfIJw==|/LVT842LJgyAchl7NffogXkrmCFwOEHX9NFd0zgLqKo=", + text: { + hidden: false, + text: "2.zBeOzMKtjnP5YI5lJWQTWA==|vxrGt4GKtydhrqaW35b/jw==|36Jtg172awn9YsgfzNs4pJ/OpA59NBnUkLNt6lg7Zw8=", + }, + type: 0, + }, + }, + }, + otherStuff: "otherStuff2", + }, + otherStuff: "otherStuff3", + }, + "user-2": { + data: { + otherStuff: "otherStuff4", + }, + otherStuff: "otherStuff5", + }, + }; +} + +function rollbackJSON() { + return { + "user_user-1_send_sends": { + "2ebadc23-e101-471b-bf2d-b125015337a0": { + id: "2ebadc23-e101-471b-bf2d-b125015337a0", + accessId: "I9y6LgHhG0e_LbElAVM3oA", + deletionDate: "2024-03-07T20:35:03Z", + disabled: false, + hideEmail: false, + key: "2.sR07sf4f18Rw6YQH9R/fPw==|DlLIYdTlFBktHVEJixqrOZmW/dTDGmZ+9iVftYkRh4s=|2mXH2fKgtItEMi8rcP1ykkVwRbxztw5MGboBwRl/kKM=", + name: "2.A0wIvDbyzuh6AjgFtv2gqQ==|D0FymzfCdYJQcAk5MARfjg==|2g52y7e/33A7Bafaaoy3Yvae7vxbIxoABZdZeoZuyg4=", + text: { + hidden: false, + text: "2.MkcPiJUnNfpcyETsoH3b8g==|/oHZ5g6pmcerXAJidP9sXg==|JDhd1Blsxm/ubp2AAggHZr6gZhyW4UYwZkF5rxlO6X0=", + }, + type: 0, + }, + "3b31c20d-b783-4912-9170-b12501555398": { + id: "3b31c20d-b783-4912-9170-b12501555398", + accessId: "DcIxO4O3EkmRcLElAVVTmA", + deletionDate: "2024-03-07T20:42:43Z", + disabled: false, + hideEmail: false, + key: "2.366XwLCi7RJnXuAvpsEVNw==|XfLoSsdOIYsHfcSMmv+7VJY97bKfS3fjpbq3ez+KCdk=|iTJxf4Pc3ub6hTFXGeU8NpUV3KxnuxzaHuNoFo/I6Vs=", + name: "2.uJ2FoouFJr/SR9gv3jYY/Q==|ksVre4/YqwY/XOtPyIfIJw==|/LVT842LJgyAchl7NffogXkrmCFwOEHX9NFd0zgLqKo=", + text: { + hidden: false, + text: "2.zBeOzMKtjnP5YI5lJWQTWA==|vxrGt4GKtydhrqaW35b/jw==|36Jtg172awn9YsgfzNs4pJ/OpA59NBnUkLNt6lg7Zw8=", + }, + type: 0, + }, + }, + "user_user-2_send_data": null as any, + global: { + otherStuff: "otherStuff1", + }, + authenticatedAccounts: ["user-1", "user-2"], + "user-1": { + data: { + otherStuff: "otherStuff2", + }, + otherStuff: "otherStuff3", + }, + "user-2": { + data: { + otherStuff: "otherStuff4", + }, + otherStuff: "otherStuff5", + }, + }; +} + +describe("SendMigrator", () => { + let helper: MockProxy; + let sut: SendMigrator; + const keyDefinitionLike = { + stateDefinition: { + name: "send", + }, + key: "sends", + }; + + describe("migrate", () => { + beforeEach(() => { + helper = mockMigrationHelper(exampleJSON(), 53); + sut = new SendMigrator(53, 54); + }); + + it("should remove encrypted sends from all accounts", async () => { + await sut.migrate(helper); + expect(helper.set).toHaveBeenCalledWith("user-1", { + data: { + otherStuff: "otherStuff2", + }, + otherStuff: "otherStuff3", + }); + }); + + it("should set encrypted sends for each account", async () => { + await sut.migrate(helper); + + expect(helper.setToUser).toHaveBeenCalledWith("user-1", keyDefinitionLike, { + "2ebadc23-e101-471b-bf2d-b125015337a0": { + id: "2ebadc23-e101-471b-bf2d-b125015337a0", + accessId: "I9y6LgHhG0e_LbElAVM3oA", + deletionDate: "2024-03-07T20:35:03Z", + disabled: false, + hideEmail: false, + key: "2.sR07sf4f18Rw6YQH9R/fPw==|DlLIYdTlFBktHVEJixqrOZmW/dTDGmZ+9iVftYkRh4s=|2mXH2fKgtItEMi8rcP1ykkVwRbxztw5MGboBwRl/kKM=", + name: "2.A0wIvDbyzuh6AjgFtv2gqQ==|D0FymzfCdYJQcAk5MARfjg==|2g52y7e/33A7Bafaaoy3Yvae7vxbIxoABZdZeoZuyg4=", + text: { + hidden: false, + text: "2.MkcPiJUnNfpcyETsoH3b8g==|/oHZ5g6pmcerXAJidP9sXg==|JDhd1Blsxm/ubp2AAggHZr6gZhyW4UYwZkF5rxlO6X0=", + }, + type: 0, + }, + "3b31c20d-b783-4912-9170-b12501555398": { + id: "3b31c20d-b783-4912-9170-b12501555398", + accessId: "DcIxO4O3EkmRcLElAVVTmA", + deletionDate: "2024-03-07T20:42:43Z", + disabled: false, + hideEmail: false, + key: "2.366XwLCi7RJnXuAvpsEVNw==|XfLoSsdOIYsHfcSMmv+7VJY97bKfS3fjpbq3ez+KCdk=|iTJxf4Pc3ub6hTFXGeU8NpUV3KxnuxzaHuNoFo/I6Vs=", + name: "2.uJ2FoouFJr/SR9gv3jYY/Q==|ksVre4/YqwY/XOtPyIfIJw==|/LVT842LJgyAchl7NffogXkrmCFwOEHX9NFd0zgLqKo=", + text: { + hidden: false, + text: "2.zBeOzMKtjnP5YI5lJWQTWA==|vxrGt4GKtydhrqaW35b/jw==|36Jtg172awn9YsgfzNs4pJ/OpA59NBnUkLNt6lg7Zw8=", + }, + type: 0, + }, + }); + }); + }); + + describe("rollback", () => { + beforeEach(() => { + helper = mockMigrationHelper(rollbackJSON(), 54); + sut = new SendMigrator(53, 54); + }); + + it.each(["user-1", "user-2"])("should null out new values", async (userId) => { + await sut.rollback(helper); + expect(helper.setToUser).toHaveBeenCalledWith(userId, keyDefinitionLike, null); + }); + + it("should add encrypted send values back to accounts", async () => { + await sut.rollback(helper); + + expect(helper.set).toHaveBeenCalled(); + expect(helper.set).toHaveBeenCalledWith("user-1", { + data: { + sends: { + encrypted: { + "2ebadc23-e101-471b-bf2d-b125015337a0": { + id: "2ebadc23-e101-471b-bf2d-b125015337a0", + accessId: "I9y6LgHhG0e_LbElAVM3oA", + deletionDate: "2024-03-07T20:35:03Z", + disabled: false, + hideEmail: false, + key: "2.sR07sf4f18Rw6YQH9R/fPw==|DlLIYdTlFBktHVEJixqrOZmW/dTDGmZ+9iVftYkRh4s=|2mXH2fKgtItEMi8rcP1ykkVwRbxztw5MGboBwRl/kKM=", + name: "2.A0wIvDbyzuh6AjgFtv2gqQ==|D0FymzfCdYJQcAk5MARfjg==|2g52y7e/33A7Bafaaoy3Yvae7vxbIxoABZdZeoZuyg4=", + text: { + hidden: false, + text: "2.MkcPiJUnNfpcyETsoH3b8g==|/oHZ5g6pmcerXAJidP9sXg==|JDhd1Blsxm/ubp2AAggHZr6gZhyW4UYwZkF5rxlO6X0=", + }, + type: 0, + }, + "3b31c20d-b783-4912-9170-b12501555398": { + id: "3b31c20d-b783-4912-9170-b12501555398", + accessId: "DcIxO4O3EkmRcLElAVVTmA", + deletionDate: "2024-03-07T20:42:43Z", + disabled: false, + hideEmail: false, + key: "2.366XwLCi7RJnXuAvpsEVNw==|XfLoSsdOIYsHfcSMmv+7VJY97bKfS3fjpbq3ez+KCdk=|iTJxf4Pc3ub6hTFXGeU8NpUV3KxnuxzaHuNoFo/I6Vs=", + name: "2.uJ2FoouFJr/SR9gv3jYY/Q==|ksVre4/YqwY/XOtPyIfIJw==|/LVT842LJgyAchl7NffogXkrmCFwOEHX9NFd0zgLqKo=", + text: { + hidden: false, + text: "2.zBeOzMKtjnP5YI5lJWQTWA==|vxrGt4GKtydhrqaW35b/jw==|36Jtg172awn9YsgfzNs4pJ/OpA59NBnUkLNt6lg7Zw8=", + }, + type: 0, + }, + }, + }, + otherStuff: "otherStuff2", + }, + otherStuff: "otherStuff3", + }); + }); + + it("should not try to restore values to missing accounts", async () => { + await sut.rollback(helper); + + expect(helper.set).not.toHaveBeenCalledWith("user-3", any()); + }); + }); +}); diff --git a/libs/common/src/state-migrations/migrations/54-move-encrypted-sends.ts b/libs/common/src/state-migrations/migrations/54-move-encrypted-sends.ts new file mode 100644 index 0000000000..7f60d18ffe --- /dev/null +++ b/libs/common/src/state-migrations/migrations/54-move-encrypted-sends.ts @@ -0,0 +1,67 @@ +import { KeyDefinitionLike, MigrationHelper } from "../migration-helper"; +import { Migrator } from "../migrator"; + +export enum SendType { + Text = 0, + File = 1, +} + +type SendData = { + id: string; + accessId: string; +}; + +type ExpectedSendState = { + data?: { + sends?: { + encrypted?: Record; + }; + }; +}; + +const ENCRYPTED_SENDS: KeyDefinitionLike = { + stateDefinition: { + name: "send", + }, + key: "sends", +}; + +/** + * Only encrypted sends are stored on disk. Only the encrypted items need to be + * migrated from the previous sends state data. + */ +export class SendMigrator extends Migrator<53, 54> { + async migrate(helper: MigrationHelper): Promise { + const accounts = await helper.getAccounts(); + + async function migrateAccount(userId: string, account: ExpectedSendState): Promise { + const value = account?.data?.sends?.encrypted; + if (value != null) { + await helper.setToUser(userId, ENCRYPTED_SENDS, value); + delete account.data.sends; + await helper.set(userId, account); + } + } + + await Promise.all([...accounts.map(({ userId, account }) => migrateAccount(userId, account))]); + } + + async rollback(helper: MigrationHelper): Promise { + const accounts = await helper.getAccounts(); + + async function rollbackAccount(userId: string, account: ExpectedSendState): Promise { + const value = await helper.getFromUser(userId, ENCRYPTED_SENDS); + if (account) { + account.data = Object.assign(account.data ?? {}, { + sends: { + encrypted: value, + }, + }); + + await helper.set(userId, account); + } + await helper.setToUser(userId, ENCRYPTED_SENDS, null); + } + await Promise.all([...accounts.map(({ userId, account }) => rollbackAccount(userId, account))]); + } +} diff --git a/libs/common/src/tools/send/services/key-definitions.spec.ts b/libs/common/src/tools/send/services/key-definitions.spec.ts new file mode 100644 index 0000000000..9916237349 --- /dev/null +++ b/libs/common/src/tools/send/services/key-definitions.spec.ts @@ -0,0 +1,21 @@ +import { SEND_USER_ENCRYPTED, SEND_USER_DECRYPTED } from "./key-definitions"; +import { testSendData, testSendViewData } from "./test-data/send-tests.data"; + +describe("Key definitions", () => { + describe("SEND_USER_ENCRYPTED", () => { + it("should pass through deserialization", () => { + const result = SEND_USER_ENCRYPTED.deserializer( + JSON.parse(JSON.stringify(testSendData("1", "Test Send Data"))), + ); + expect(result).toEqual(testSendData("1", "Test Send Data")); + }); + }); + + describe("SEND_USER_DECRYPTED", () => { + it("should pass through deserialization", () => { + const sendViews = [testSendViewData("1", "Test Send View")]; + const result = SEND_USER_DECRYPTED.deserializer(JSON.parse(JSON.stringify(sendViews))); + expect(result).toEqual(sendViews); + }); + }); +}); diff --git a/libs/common/src/tools/send/services/key-definitions.ts b/libs/common/src/tools/send/services/key-definitions.ts new file mode 100644 index 0000000000..b117c52268 --- /dev/null +++ b/libs/common/src/tools/send/services/key-definitions.ts @@ -0,0 +1,13 @@ +import { KeyDefinition, SEND_DISK, SEND_MEMORY } from "../../../platform/state"; +import { SendData } from "../models/data/send.data"; +import { SendView } from "../models/view/send.view"; + +/** Encrypted send state stored on disk */ +export const SEND_USER_ENCRYPTED = KeyDefinition.record(SEND_DISK, "sendUserEncrypted", { + deserializer: (obj: SendData) => obj, +}); + +/** Decrypted send state stored in memory */ +export const SEND_USER_DECRYPTED = new KeyDefinition(SEND_MEMORY, "sendUserDecrypted", { + deserializer: (obj) => obj, +}); diff --git a/libs/common/src/tools/send/services/send-state.provider.abstraction.ts b/libs/common/src/tools/send/services/send-state.provider.abstraction.ts new file mode 100644 index 0000000000..7a35506b56 --- /dev/null +++ b/libs/common/src/tools/send/services/send-state.provider.abstraction.ts @@ -0,0 +1,17 @@ +import { Observable } from "rxjs"; + +import { SendData } from "../models/data/send.data"; +import { SendView } from "../models/view/send.view"; + +export abstract class SendStateProvider { + encryptedState$: Observable>; + decryptedState$: Observable; + + getEncryptedSends: () => Promise<{ [id: string]: SendData }>; + + setEncryptedSends: (value: { [id: string]: SendData }) => Promise; + + getDecryptedSends: () => Promise; + + setDecryptedSends: (value: SendView[]) => Promise; +} diff --git a/libs/common/src/tools/send/services/send-state.provider.spec.ts b/libs/common/src/tools/send/services/send-state.provider.spec.ts new file mode 100644 index 0000000000..069e0d8069 --- /dev/null +++ b/libs/common/src/tools/send/services/send-state.provider.spec.ts @@ -0,0 +1,48 @@ +import { + FakeAccountService, + FakeStateProvider, + awaitAsync, + mockAccountServiceWith, +} from "../../../../spec"; +import { Utils } from "../../../platform/misc/utils"; +import { UserId } from "../../../types/guid"; + +import { SendStateProvider } from "./send-state.provider"; +import { testSendData, testSendViewData } from "./test-data/send-tests.data"; + +describe("Send State Provider", () => { + let stateProvider: FakeStateProvider; + let accountService: FakeAccountService; + let sendStateProvider: SendStateProvider; + + const mockUserId = Utils.newGuid() as UserId; + + beforeEach(() => { + accountService = mockAccountServiceWith(mockUserId); + stateProvider = new FakeStateProvider(accountService); + + sendStateProvider = new SendStateProvider(stateProvider); + }); + + describe("Encrypted Sends", () => { + it("should return SendData", async () => { + const sendData = { "1": testSendData("1", "Test Send Data") }; + await sendStateProvider.setEncryptedSends(sendData); + await awaitAsync(); + + const actual = await sendStateProvider.getEncryptedSends(); + expect(actual).toStrictEqual(sendData); + }); + }); + + describe("Decrypted Sends", () => { + it("should return SendView", async () => { + const state = [testSendViewData("1", "Test")]; + await sendStateProvider.setDecryptedSends(state); + await awaitAsync(); + + const actual = await sendStateProvider.getDecryptedSends(); + expect(actual).toStrictEqual(state); + }); + }); +}); diff --git a/libs/common/src/tools/send/services/send-state.provider.ts b/libs/common/src/tools/send/services/send-state.provider.ts new file mode 100644 index 0000000000..1e9397b7a9 --- /dev/null +++ b/libs/common/src/tools/send/services/send-state.provider.ts @@ -0,0 +1,47 @@ +import { Observable, firstValueFrom } from "rxjs"; + +import { ActiveUserState, StateProvider } from "../../../platform/state"; +import { SendData } from "../models/data/send.data"; +import { SendView } from "../models/view/send.view"; + +import { SEND_USER_DECRYPTED, SEND_USER_ENCRYPTED } from "./key-definitions"; +import { SendStateProvider as SendStateProviderAbstraction } from "./send-state.provider.abstraction"; + +/** State provider for sends */ +export class SendStateProvider implements SendStateProviderAbstraction { + /** Observable for the encrypted sends for an active user */ + encryptedState$: Observable>; + /** Observable with the decrypted sends for an active user */ + decryptedState$: Observable; + + private activeUserEncryptedState: ActiveUserState>; + private activeUserDecryptedState: ActiveUserState; + + constructor(protected stateProvider: StateProvider) { + this.activeUserEncryptedState = this.stateProvider.getActive(SEND_USER_ENCRYPTED); + this.encryptedState$ = this.activeUserEncryptedState.state$; + + this.activeUserDecryptedState = this.stateProvider.getActive(SEND_USER_DECRYPTED); + this.decryptedState$ = this.activeUserDecryptedState.state$; + } + + /** Gets the encrypted sends from state for an active user */ + async getEncryptedSends(): Promise<{ [id: string]: SendData }> { + return await firstValueFrom(this.encryptedState$); + } + + /** Sets the encrypted send state for an active user */ + async setEncryptedSends(value: { [id: string]: SendData }): Promise { + await this.activeUserEncryptedState.update(() => value); + } + + /** Gets the decrypted sends from state for the active user */ + async getDecryptedSends(): Promise { + return await firstValueFrom(this.decryptedState$); + } + + /** Sets the decrypted send state for an active user */ + async setDecryptedSends(value: SendView[]): Promise { + await this.activeUserDecryptedState.update(() => value); + } +} diff --git a/libs/common/src/tools/send/services/send.service.abstraction.ts b/libs/common/src/tools/send/services/send.service.abstraction.ts index 45f623537d..e9f9387169 100644 --- a/libs/common/src/tools/send/services/send.service.abstraction.ts +++ b/libs/common/src/tools/send/services/send.service.abstraction.ts @@ -18,10 +18,6 @@ export abstract class SendService { password: string, key?: SymmetricCryptoKey, ) => Promise<[Send, EncArrayBuffer]>; - /** - * @deprecated Do not call this, use the get$ method - */ - get: (id: string) => Send; /** * Provides a send for a determined id * updates after a change occurs to the send that matches the id @@ -53,6 +49,5 @@ export abstract class SendService { export abstract class InternalSendService extends SendService { upsert: (send: SendData | SendData[]) => Promise; replace: (sends: { [id: string]: SendData }) => Promise; - clear: (userId: string) => Promise; delete: (id: string | string[]) => Promise; } diff --git a/libs/common/src/tools/send/services/send.service.spec.ts b/libs/common/src/tools/send/services/send.service.spec.ts index 568bd70d52..fc793dba67 100644 --- a/libs/common/src/tools/send/services/send.service.spec.ts +++ b/libs/common/src/tools/send/services/send.service.spec.ts @@ -1,14 +1,23 @@ -import { any, mock, MockProxy } from "jest-mock-extended"; -import { BehaviorSubject, firstValueFrom } from "rxjs"; +import { mock } from "jest-mock-extended"; +import { firstValueFrom } from "rxjs"; +import { + FakeAccountService, + FakeActiveUserState, + FakeStateProvider, + awaitAsync, + mockAccountServiceWith, +} from "../../../../spec"; +import { AuthenticationStatus } from "../../../auth/enums/authentication-status"; import { CryptoService } from "../../../platform/abstractions/crypto.service"; import { EncryptService } from "../../../platform/abstractions/encrypt.service"; import { I18nService } from "../../../platform/abstractions/i18n.service"; import { KeyGenerationService } from "../../../platform/abstractions/key-generation.service"; -import { StateService } from "../../../platform/abstractions/state.service"; +import { Utils } from "../../../platform/misc/utils"; import { EncString } from "../../../platform/models/domain/enc-string"; import { SymmetricCryptoKey } from "../../../platform/models/domain/symmetric-crypto-key"; import { ContainerService } from "../../../platform/services/container.service"; +import { UserId } from "../../../types/guid"; import { UserKey } from "../../../types/key"; import { SendType } from "../enums/send-type"; import { SendFileApi } from "../models/api/send-file.api"; @@ -16,10 +25,17 @@ import { SendTextApi } from "../models/api/send-text.api"; import { SendFileData } from "../models/data/send-file.data"; import { SendTextData } from "../models/data/send-text.data"; import { SendData } from "../models/data/send.data"; -import { Send } from "../models/domain/send"; import { SendView } from "../models/view/send.view"; +import { SEND_USER_DECRYPTED, SEND_USER_ENCRYPTED } from "./key-definitions"; +import { SendStateProvider } from "./send-state.provider"; import { SendService } from "./send.service"; +import { + createSendData, + testSend, + testSendData, + testSendViewData, +} from "./test-data/send-tests.data"; describe("SendService", () => { const cryptoService = mock(); @@ -27,56 +43,53 @@ describe("SendService", () => { const keyGenerationService = mock(); const encryptService = mock(); + let sendStateProvider: SendStateProvider; let sendService: SendService; - let stateService: MockProxy; - let activeAccount: BehaviorSubject; - let activeAccountUnlocked: BehaviorSubject; + let stateProvider: FakeStateProvider; + let encryptedState: FakeActiveUserState>; + let decryptedState: FakeActiveUserState; + + const mockUserId = Utils.newGuid() as UserId; + let accountService: FakeAccountService; beforeEach(() => { - activeAccount = new BehaviorSubject("123"); - activeAccountUnlocked = new BehaviorSubject(true); + accountService = mockAccountServiceWith(mockUserId); + stateProvider = new FakeStateProvider(accountService); + sendStateProvider = new SendStateProvider(stateProvider); - stateService = mock(); - stateService.activeAccount$ = activeAccount; - stateService.activeAccountUnlocked$ = activeAccountUnlocked; (window as any).bitwardenContainerService = new ContainerService(cryptoService, encryptService); - stateService.getEncryptedSends.calledWith(any()).mockResolvedValue({ - "1": sendData("1", "Test Send"), + accountService.activeAccountSubject.next({ + id: mockUserId, + email: "email", + name: "name", + status: AuthenticationStatus.Unlocked, }); - stateService.getDecryptedSends - .calledWith(any()) - .mockResolvedValue([sendView("1", "Test Send")]); - - sendService = new SendService(cryptoService, i18nService, keyGenerationService, stateService); - }); - - afterEach(() => { - activeAccount.complete(); - activeAccountUnlocked.complete(); - }); - - describe("get", () => { - it("exists", async () => { - const result = sendService.get("1"); - - expect(result).toEqual(send("1", "Test Send")); + // Initial encrypted state + encryptedState = stateProvider.activeUser.getFake(SEND_USER_ENCRYPTED); + encryptedState.nextState({ + "1": testSendData("1", "Test Send"), }); + // Initial decrypted state + decryptedState = stateProvider.activeUser.getFake(SEND_USER_DECRYPTED); + decryptedState.nextState([testSendViewData("1", "Test Send")]); - it("does not exist", async () => { - const result = sendService.get("2"); - - expect(result).toBe(undefined); - }); + sendService = new SendService( + cryptoService, + i18nService, + keyGenerationService, + sendStateProvider, + encryptService, + ); }); describe("get$", () => { it("exists", async () => { const result = await firstValueFrom(sendService.get$("1")); - expect(result).toEqual(send("1", "Test Send")); + expect(result).toEqual(testSend("1", "Test Send")); }); it("does not exist", async () => { @@ -88,14 +101,14 @@ describe("SendService", () => { it("updated observable", async () => { const singleSendObservable = sendService.get$("1"); const result = await firstValueFrom(singleSendObservable); - expect(result).toEqual(send("1", "Test Send")); + expect(result).toEqual(testSend("1", "Test Send")); await sendService.replace({ - "1": sendData("1", "Test Send Updated"), + "1": testSendData("1", "Test Send Updated"), }); const result2 = await firstValueFrom(singleSendObservable); - expect(result2).toEqual(send("1", "Test Send Updated")); + expect(result2).toEqual(testSend("1", "Test Send Updated")); }); it("reports a change when name changes on a new send", async () => { @@ -103,13 +116,13 @@ describe("SendService", () => { sendService.get$("1").subscribe(() => { changed = true; }); - const sendDataObject = sendData("1", "Test Send 2"); + const sendDataObject = testSendData("1", "Test Send 2"); //it is immediately called when subscribed, we need to reset the value changed = false; await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); expect(changed).toEqual(true); @@ -120,7 +133,7 @@ describe("SendService", () => { await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); let changed = false; @@ -134,7 +147,7 @@ describe("SendService", () => { await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); expect(changed).toEqual(true); @@ -145,7 +158,7 @@ describe("SendService", () => { await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); let changed = false; @@ -159,7 +172,7 @@ describe("SendService", () => { sendDataObject.text.text = "new text"; await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); expect(changed).toEqual(true); @@ -170,7 +183,7 @@ describe("SendService", () => { await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); let changed = false; @@ -184,7 +197,7 @@ describe("SendService", () => { sendDataObject.text = null; await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); expect(changed).toEqual(true); @@ -197,7 +210,7 @@ describe("SendService", () => { }) as SendData; await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); sendDataObject.file = new SendFileData(new SendFileApi({ FileName: "updated name of file" })); @@ -211,7 +224,7 @@ describe("SendService", () => { await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); expect(changed).toEqual(false); @@ -222,7 +235,7 @@ describe("SendService", () => { await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); let changed = false; @@ -236,7 +249,7 @@ describe("SendService", () => { sendDataObject.key = "newKey"; await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); expect(changed).toEqual(true); @@ -247,7 +260,7 @@ describe("SendService", () => { await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); let changed = false; @@ -261,7 +274,7 @@ describe("SendService", () => { sendDataObject.revisionDate = "2025-04-05"; await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); expect(changed).toEqual(true); @@ -272,7 +285,7 @@ describe("SendService", () => { await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); let changed = false; @@ -286,7 +299,7 @@ describe("SendService", () => { sendDataObject.name = null; await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); expect(changed).toEqual(true); @@ -299,7 +312,7 @@ describe("SendService", () => { await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); let changed = false; @@ -312,7 +325,7 @@ describe("SendService", () => { await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); expect(changed).toEqual(false); @@ -320,7 +333,7 @@ describe("SendService", () => { sendDataObject.text.text = "Asdf"; await sendService.replace({ "1": sendDataObject, - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); expect(changed).toEqual(true); @@ -332,14 +345,14 @@ describe("SendService", () => { changed = true; }); - const sendDataObject = sendData("1", "Test Send"); + const sendDataObject = testSendData("1", "Test Send"); //it is immediately called when subscribed, we need to reset the value changed = false; await sendService.replace({ "1": sendDataObject, - "2": sendData("3", "Test Send 3"), + "2": testSendData("3", "Test Send 3"), }); expect(changed).toEqual(false); @@ -354,7 +367,7 @@ describe("SendService", () => { changed = false; await sendService.replace({ - "2": sendData("2", "Test Send 2"), + "2": testSendData("2", "Test Send 2"), }); expect(changed).toEqual(true); @@ -366,14 +379,14 @@ describe("SendService", () => { const send1 = sends[0]; expect(sends).toHaveLength(1); - expect(send1).toEqual(send("1", "Test Send")); + expect(send1).toEqual(testSend("1", "Test Send")); }); describe("getFromState", () => { it("exists", async () => { const result = await sendService.getFromState("1"); - expect(result).toEqual(send("1", "Test Send")); + expect(result).toEqual(testSend("1", "Test Send")); }); it("does not exist", async () => { const result = await sendService.getFromState("2"); @@ -383,17 +396,17 @@ describe("SendService", () => { }); it("getAllDecryptedFromState", async () => { - await sendService.getAllDecryptedFromState(); + const sends = await sendService.getAllDecryptedFromState(); - expect(stateService.getDecryptedSends).toHaveBeenCalledTimes(1); + expect(sends[0]).toMatchObject(testSendViewData("1", "Test Send")); }); describe("getRotatedKeys", () => { let encryptedKey: EncString; beforeEach(() => { - cryptoService.decryptToBytes.mockResolvedValue(new Uint8Array(32)); + encryptService.decryptToBytes.mockResolvedValue(new Uint8Array(32)); encryptedKey = new EncString("Re-encrypted Send Key"); - cryptoService.encrypt.mockResolvedValue(encryptedKey); + encryptService.encrypt.mockResolvedValue(encryptedKey); }); it("returns re-encrypted user sends", async () => { @@ -408,6 +421,8 @@ describe("SendService", () => { // eslint-disable-next-line @typescript-eslint/no-floating-promises sendService.replace(null); + await awaitAsync(); + const newUserKey = new SymmetricCryptoKey(new Uint8Array(32)) as UserKey; const result = await sendService.getRotatedKeys(newUserKey); @@ -424,114 +439,51 @@ describe("SendService", () => { // InternalSendService it("upsert", async () => { - await sendService.upsert(sendData("2", "Test 2")); + await sendService.upsert(testSendData("2", "Test 2")); expect(await firstValueFrom(sendService.sends$)).toEqual([ - send("1", "Test Send"), - send("2", "Test 2"), + testSend("1", "Test Send"), + testSend("2", "Test 2"), ]); }); it("replace", async () => { - await sendService.replace({ "2": sendData("2", "test 2") }); + await sendService.replace({ "2": testSendData("2", "test 2") }); - expect(await firstValueFrom(sendService.sends$)).toEqual([send("2", "test 2")]); + expect(await firstValueFrom(sendService.sends$)).toEqual([testSend("2", "test 2")]); }); it("clear", async () => { await sendService.clear(); - + await awaitAsync(); expect(await firstValueFrom(sendService.sends$)).toEqual([]); }); + describe("Delete", () => { + it("Sends count should decrease after delete", async () => { + const sendsBeforeDelete = await firstValueFrom(sendService.sends$); + await sendService.delete(sendsBeforeDelete[0].id); - describe("delete", () => { - it("exists", async () => { - await sendService.delete("1"); - - expect(stateService.getEncryptedSends).toHaveBeenCalledTimes(2); - expect(stateService.setEncryptedSends).toHaveBeenCalledTimes(1); + const sendsAfterDelete = await firstValueFrom(sendService.sends$); + expect(sendsAfterDelete.length).toBeLessThan(sendsBeforeDelete.length); }); - it("does not exist", 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 - sendService.delete("1"); + it("Intended send should be delete", async () => { + const sendsBeforeDelete = await firstValueFrom(sendService.sends$); + await sendService.delete(sendsBeforeDelete[0].id); + const sendsAfterDelete = await firstValueFrom(sendService.sends$); + expect(sendsAfterDelete[0]).not.toBe(sendsBeforeDelete[0]); + }); - expect(stateService.getEncryptedSends).toHaveBeenCalledTimes(2); + it("Deleting on an empty sends array should not throw", async () => { + sendStateProvider.getEncryptedSends = jest.fn().mockResolvedValue(null); + await expect(sendService.delete("2")).resolves.not.toThrow(); + }); + + it("Delete multiple sends", async () => { + await sendService.upsert(testSendData("2", "send data 2")); + await sendService.delete(["1", "2"]); + const sendsAfterDelete = await firstValueFrom(sendService.sends$); + expect(sendsAfterDelete.length).toBe(0); }); }); - - // Send object helper functions - - function sendData(id: string, name: string) { - const data = new SendData({} as any); - data.id = id; - data.name = name; - data.disabled = false; - data.accessCount = 2; - data.accessId = "1"; - data.revisionDate = null; - data.expirationDate = null; - data.deletionDate = null; - data.notes = "Notes!!"; - data.key = null; - return data; - } - - const defaultSendData: Partial = { - id: "1", - name: "Test Send", - accessId: "123", - type: SendType.Text, - notes: "notes!", - file: null, - text: new SendTextData(new SendTextApi({ Text: "send text" })), - key: "key", - maxAccessCount: 12, - accessCount: 2, - revisionDate: "2024-09-04", - expirationDate: "2024-09-04", - deletionDate: "2024-09-04", - password: "password", - disabled: false, - hideEmail: false, - }; - - function createSendData(value: Partial = {}) { - const testSend: any = {}; - for (const prop in defaultSendData) { - testSend[prop] = value[prop as keyof SendData] ?? defaultSendData[prop as keyof SendData]; - } - return testSend; - } - - function sendView(id: string, name: string) { - const data = new SendView({} as any); - data.id = id; - data.name = name; - data.disabled = false; - data.accessCount = 2; - data.accessId = "1"; - data.revisionDate = null; - data.expirationDate = null; - data.deletionDate = null; - data.notes = "Notes!!"; - data.key = null; - return data; - } - - function send(id: string, name: string) { - const data = new Send({} as any); - data.id = id; - data.name = new EncString(name); - data.disabled = false; - data.accessCount = 2; - data.accessId = "1"; - data.revisionDate = null; - data.expirationDate = null; - data.deletionDate = null; - data.notes = new EncString("Notes!!"); - data.key = null; - return data; - } }); diff --git a/libs/common/src/tools/send/services/send.service.ts b/libs/common/src/tools/send/services/send.service.ts index 528f90c1dc..33b1f28be0 100644 --- a/libs/common/src/tools/send/services/send.service.ts +++ b/libs/common/src/tools/send/services/send.service.ts @@ -1,9 +1,9 @@ -import { BehaviorSubject, Observable, concatMap, distinctUntilChanged, map } from "rxjs"; +import { Observable, concatMap, distinctUntilChanged, firstValueFrom, map } from "rxjs"; import { CryptoService } from "../../../platform/abstractions/crypto.service"; +import { EncryptService } from "../../../platform/abstractions/encrypt.service"; import { I18nService } from "../../../platform/abstractions/i18n.service"; import { KeyGenerationService } from "../../../platform/abstractions/key-generation.service"; -import { StateService } from "../../../platform/abstractions/state.service"; import { KdfType } from "../../../platform/enums"; import { Utils } from "../../../platform/misc/utils"; import { EncArrayBuffer } from "../../../platform/models/domain/enc-array-buffer"; @@ -19,48 +19,29 @@ import { SendWithIdRequest } from "../models/request/send-with-id.request"; import { SendView } from "../models/view/send.view"; import { SEND_KDF_ITERATIONS } from "../send-kdf"; +import { SendStateProvider } from "./send-state.provider.abstraction"; import { InternalSendService as InternalSendServiceAbstraction } from "./send.service.abstraction"; export class SendService implements InternalSendServiceAbstraction { readonly sendKeySalt = "bitwarden-send"; readonly sendKeyPurpose = "send"; - protected _sends: BehaviorSubject = new BehaviorSubject([]); - protected _sendViews: BehaviorSubject = new BehaviorSubject([]); - - sends$ = this._sends.asObservable(); - sendViews$ = this._sendViews.asObservable(); + sends$ = this.stateProvider.encryptedState$.pipe( + map((record) => Object.values(record || {}).map((data) => new Send(data))), + ); + sendViews$ = this.stateProvider.encryptedState$.pipe( + concatMap((record) => + this.decryptSends(Object.values(record || {}).map((data) => new Send(data))), + ), + ); constructor( private cryptoService: CryptoService, private i18nService: I18nService, private keyGenerationService: KeyGenerationService, - private stateService: StateService, - ) { - this.stateService.activeAccountUnlocked$ - .pipe( - concatMap(async (unlocked) => { - if (Utils.global.bitwardenContainerService == null) { - return; - } - - if (!unlocked) { - this._sends.next([]); - this._sendViews.next([]); - return; - } - - const data = await this.stateService.getEncryptedSends(); - - await this.updateObservables(data); - }), - ) - .subscribe(); - } - - async clearCache(): Promise { - await this._sendViews.next([]); - } + private stateProvider: SendStateProvider, + private encryptService: EncryptService, + ) {} async encrypt( model: SendView, @@ -93,12 +74,15 @@ export class SendService implements InternalSendServiceAbstraction { ); send.password = passwordKey.keyB64; } - send.key = await this.cryptoService.encrypt(model.key, key); - send.name = await this.cryptoService.encrypt(model.name, model.cryptoKey); - send.notes = await this.cryptoService.encrypt(model.notes, model.cryptoKey); + if (key == null) { + key = await this.cryptoService.getUserKey(); + } + send.key = await this.encryptService.encrypt(model.key, key); + send.name = await this.encryptService.encrypt(model.name, model.cryptoKey); + send.notes = await this.encryptService.encrypt(model.notes, model.cryptoKey); if (send.type === SendType.Text) { send.text = new SendText(); - send.text.text = await this.cryptoService.encrypt(model.text.text, model.cryptoKey); + send.text.text = await this.encryptService.encrypt(model.text.text, model.cryptoKey); send.text.hidden = model.text.hidden; } else if (send.type === SendType.File) { send.file = new SendFile(); @@ -120,11 +104,6 @@ export class SendService implements InternalSendServiceAbstraction { return [send, fileData]; } - get(id: string): Send { - const sends = this._sends.getValue(); - return sends.find((send) => send.id === id); - } - get$(id: string): Observable { return this.sends$.pipe( distinctUntilChanged((oldSends, newSends) => { @@ -188,7 +167,7 @@ export class SendService implements InternalSendServiceAbstraction { } async getFromState(id: string): Promise { - const sends = await this.stateService.getEncryptedSends(); + const sends = await this.stateProvider.getEncryptedSends(); // eslint-disable-next-line if (sends == null || !sends.hasOwnProperty(id)) { return null; @@ -198,7 +177,7 @@ export class SendService implements InternalSendServiceAbstraction { } async getAll(): Promise { - const sends = await this.stateService.getEncryptedSends(); + const sends = await this.stateProvider.getEncryptedSends(); const response: Send[] = []; for (const id in sends) { // eslint-disable-next-line @@ -210,7 +189,7 @@ export class SendService implements InternalSendServiceAbstraction { } async getAllDecryptedFromState(): Promise { - let decSends = await this.stateService.getDecryptedSends(); + let decSends = await this.stateProvider.getDecryptedSends(); if (decSends != null) { return decSends; } @@ -230,12 +209,12 @@ export class SendService implements InternalSendServiceAbstraction { await Promise.all(promises); decSends.sort(Utils.getSortFunction(this.i18nService, "name")); - await this.stateService.setDecryptedSends(decSends); + await this.stateProvider.setDecryptedSends(decSends); return decSends; } async upsert(send: SendData | SendData[]): Promise { - let sends = await this.stateService.getEncryptedSends(); + let sends = await this.stateProvider.getEncryptedSends(); if (sends == null) { sends = {}; } @@ -252,16 +231,12 @@ export class SendService implements InternalSendServiceAbstraction { } async clear(userId?: string): Promise { - if (userId == null || userId == (await this.stateService.getUserId())) { - this._sends.next([]); - this._sendViews.next([]); - } - await this.stateService.setDecryptedSends(null, { userId: userId }); - await this.stateService.setEncryptedSends(null, { userId: userId }); + await this.stateProvider.setDecryptedSends(null); + await this.stateProvider.setEncryptedSends(null); } async delete(id: string | string[]): Promise { - const sends = await this.stateService.getEncryptedSends(); + const sends = await this.stateProvider.getEncryptedSends(); if (sends == null) { return; } @@ -281,8 +256,7 @@ export class SendService implements InternalSendServiceAbstraction { } async replace(sends: { [id: string]: SendData }): Promise { - await this.updateObservables(sends); - await this.stateService.setEncryptedSends(sends); + await this.stateProvider.setEncryptedSends(sends); } async getRotatedKeys(newUserKey: UserKey): Promise { @@ -290,14 +264,21 @@ export class SendService implements InternalSendServiceAbstraction { throw new Error("New user key is required for rotation."); } + const req = await firstValueFrom( + this.sends$.pipe(concatMap(async (sends) => this.toRotatedKeyRequestMap(sends, newUserKey))), + ); + // separate return for easier debugging + return req; + } + + private async toRotatedKeyRequestMap(sends: Send[], newUserKey: UserKey) { const requests = await Promise.all( - this._sends.value.map(async (send) => { - const sendKey = await this.cryptoService.decryptToBytes(send.key); - send.key = await this.cryptoService.encrypt(sendKey, newUserKey); + sends.map(async (send) => { + const sendKey = await this.encryptService.decryptToBytes(send.key, newUserKey); + send.key = await this.encryptService.encrypt(sendKey, newUserKey); return new SendWithIdRequest(send); }), ); - // separate return for easier debugging return requests; } @@ -329,18 +310,12 @@ export class SendService implements InternalSendServiceAbstraction { data: ArrayBuffer, key: SymmetricCryptoKey, ): Promise<[EncString, EncArrayBuffer]> { - const encFileName = await this.cryptoService.encrypt(fileName, key); - const encFileData = await this.cryptoService.encryptToBytes(new Uint8Array(data), key); - return [encFileName, encFileData]; - } - - private async updateObservables(sendsMap: { [id: string]: SendData }) { - const sends = Object.values(sendsMap || {}).map((f) => new Send(f)); - this._sends.next(sends); - - if (await this.cryptoService.hasUserKey()) { - this._sendViews.next(await this.decryptSends(sends)); + if (key == null) { + key = await this.cryptoService.getUserKey(); } + const encFileName = await this.encryptService.encrypt(fileName, key); + const encFileData = await this.encryptService.encryptToBytes(new Uint8Array(data), key); + return [encFileName, encFileData]; } private async decryptSends(sends: Send[]) { diff --git a/libs/common/src/tools/send/services/test-data/send-tests.data.ts b/libs/common/src/tools/send/services/test-data/send-tests.data.ts new file mode 100644 index 0000000000..a57a39782e --- /dev/null +++ b/libs/common/src/tools/send/services/test-data/send-tests.data.ts @@ -0,0 +1,79 @@ +import { EncString } from "../../../../platform/models/domain/enc-string"; +import { SendType } from "../../enums/send-type"; +import { SendTextApi } from "../../models/api/send-text.api"; +import { SendTextData } from "../../models/data/send-text.data"; +import { SendData } from "../../models/data/send.data"; +import { Send } from "../../models/domain/send"; +import { SendView } from "../../models/view/send.view"; + +export function testSendViewData(id: string, name: string) { + const data = new SendView({} as any); + data.id = id; + data.name = name; + data.disabled = false; + data.accessCount = 2; + data.accessId = "1"; + data.revisionDate = null; + data.expirationDate = null; + data.deletionDate = null; + data.notes = "Notes!!"; + data.key = null; + return data; +} + +export function createSendData(value: Partial = {}) { + const defaultSendData: Partial = { + id: "1", + name: "Test Send", + accessId: "123", + type: SendType.Text, + notes: "notes!", + file: null, + text: new SendTextData(new SendTextApi({ Text: "send text" })), + key: "key", + maxAccessCount: 12, + accessCount: 2, + revisionDate: "2024-09-04", + expirationDate: "2024-09-04", + deletionDate: "2024-09-04", + password: "password", + disabled: false, + hideEmail: false, + }; + + const testSend: any = {}; + for (const prop in defaultSendData) { + testSend[prop] = value[prop as keyof SendData] ?? defaultSendData[prop as keyof SendData]; + } + return testSend; +} + +export function testSendData(id: string, name: string) { + const data = new SendData({} as any); + data.id = id; + data.name = name; + data.disabled = false; + data.accessCount = 2; + data.accessId = "1"; + data.revisionDate = null; + data.expirationDate = null; + data.deletionDate = null; + data.notes = "Notes!!"; + data.key = null; + return data; +} + +export function testSend(id: string, name: string) { + const data = new Send({} as any); + data.id = id; + data.name = new EncString(name); + data.disabled = false; + data.accessCount = 2; + data.accessId = "1"; + data.revisionDate = null; + data.expirationDate = null; + data.deletionDate = null; + data.notes = new EncString("Notes!!"); + data.key = null; + return data; +} diff --git a/libs/common/src/vault/services/sync/sync.service.ts b/libs/common/src/vault/services/sync/sync.service.ts index 3e8bd92a7a..d4601d9621 100644 --- a/libs/common/src/vault/services/sync/sync.service.ts +++ b/libs/common/src/vault/services/sync/sync.service.ts @@ -244,7 +244,7 @@ export class SyncService implements SyncServiceAbstraction { this.syncStarted(); if (await this.stateService.getIsAuthenticated()) { try { - const localSend = this.sendService.get(notification.id); + const localSend = await firstValueFrom(this.sendService.get$(notification.id)); if ( (!isEdit && localSend == null) || (isEdit && localSend != null && localSend.revisionDate < notification.revisionDate)