[Pm-13097] Rename cryptoservice to keyservice and move it to km ownership (#11358)

* Rename cryptoservice to keyservice

* Rename cryptoservice to keyservice

* Move key service to key management ownership

* Remove accidentally added file

* Fix cli build

* Fix browser build

* Run prettier

* Fix builds

* Fix cli build

* Fix tests

* Fix incorrect renames

* Rename webauthn-login-crypto-service

* Fix build errors due to merge conflicts

* Fix linting

libs/tools/generator/components/src/generator.module.ts

@@ -7,7 +7,6 @@ import { safeProvider } from "@bitwarden/angular/platform/utils/safe-provider";
 import { SafeInjectionToken } from "@bitwarden/angular/services/injection-tokens";
 import { ApiService } from "@bitwarden/common/abstractions/api.service";
 import { PolicyService } from "@bitwarden/common/admin-console/abstractions/policy/policy.service.abstraction";
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
 import { EncryptService } from "@bitwarden/common/platform/abstractions/encrypt.service";
 import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
 import { StateProvider } from "@bitwarden/common/platform/state";
@@ -30,6 +29,7 @@ import {
   CredentialGeneratorService,
   Randomizer,
 } from "@bitwarden/generator-core";
+import { KeyService } from "@bitwarden/key-management";
 
 import { CatchallSettingsComponent } from "./catchall-settings.component";
 import { CredentialGeneratorComponent } from "./credential-generator.component";
@@ -66,7 +66,7 @@ const RANDOMIZER = new SafeInjectionToken<Randomizer>("Randomizer");
     safeProvider({
       provide: RANDOMIZER,
       useFactory: createRandomizer,
-      deps: [CryptoService],
+      deps: [KeyService],
     }),
     safeProvider({
       provide: CredentialGeneratorService,
@@ -78,7 +78,7 @@ const RANDOMIZER = new SafeInjectionToken<Randomizer>("Randomizer");
         ApiService,
         I18nService,
         EncryptService,
-        CryptoService,
+        KeyService,
       ],
     }),
   ],

libs/tools/generator/core/src/engine/index.ts

@@ -1,4 +1,4 @@
-export { CryptoServiceRandomizer } from "./crypto-service-randomizer";
+export { KeyServiceRandomizer } from "./key-service-randomizer";
 export { ForwarderConfiguration, AccountRequest } from "./forwarder-configuration";
 export { ForwarderContext } from "./forwarder-context";
 export * from "./settings";

libs/tools/generator/core/src/engine/key-service-randomizer.spec.ts

@@ -1,11 +1,11 @@
 import { mock } from "jest-mock-extended";
 
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
+import { KeyService } from "@bitwarden/key-management";
 
-import { CryptoServiceRandomizer } from "./crypto-service-randomizer";
+import { KeyServiceRandomizer } from "./key-service-randomizer";
 
-describe("CryptoServiceRandomizer", () => {
-  const cryptoService = mock<CryptoService>();
+describe("KeyServiceRandomizer", () => {
+  const keyService = mock<KeyService>();
 
   afterEach(() => {
     jest.resetAllMocks();
@@ -13,7 +13,7 @@ describe("CryptoServiceRandomizer", () => {
 
   describe("pick", () => {
     it.each([[null], [undefined], [[]]])("throws when the list is %p", async (list) => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
+      const randomizer = new KeyServiceRandomizer(keyService);
 
       await expect(() => randomizer.pick(list)).rejects.toBeInstanceOf(Error);
 
@@ -21,8 +21,8 @@ describe("CryptoServiceRandomizer", () => {
     });
 
     it("picks an item from the list", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
-      cryptoService.randomNumber.mockResolvedValue(1);
+      const randomizer = new KeyServiceRandomizer(keyService);
+      keyService.randomNumber.mockResolvedValue(1);
 
       const result = await randomizer.pick([0, 1]);
 
@@ -32,7 +32,7 @@ describe("CryptoServiceRandomizer", () => {
 
   describe("pickWord", () => {
     it.each([[null], [undefined], [[]]])("throws when the list is %p", async (list) => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
+      const randomizer = new KeyServiceRandomizer(keyService);
 
       await expect(() => randomizer.pickWord(list)).rejects.toBeInstanceOf(Error);
 
@@ -40,8 +40,8 @@ describe("CryptoServiceRandomizer", () => {
     });
 
     it("picks a word from the list", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
-      cryptoService.randomNumber.mockResolvedValue(1);
+      const randomizer = new KeyServiceRandomizer(keyService);
+      keyService.randomNumber.mockResolvedValue(1);
 
       const result = await randomizer.pickWord(["foo", "bar"]);
 
@@ -49,8 +49,8 @@ describe("CryptoServiceRandomizer", () => {
     });
 
     it("capitalizes the word when options.titleCase is true", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
-      cryptoService.randomNumber.mockResolvedValue(1);
+      const randomizer = new KeyServiceRandomizer(keyService);
+      keyService.randomNumber.mockResolvedValue(1);
 
       const result = await randomizer.pickWord(["foo", "bar"], { titleCase: true });
 
@@ -58,9 +58,9 @@ describe("CryptoServiceRandomizer", () => {
     });
 
     it("appends a random number when options.number is true", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
-      cryptoService.randomNumber.mockResolvedValueOnce(1);
-      cryptoService.randomNumber.mockResolvedValueOnce(2);
+      const randomizer = new KeyServiceRandomizer(keyService);
+      keyService.randomNumber.mockResolvedValueOnce(1);
+      keyService.randomNumber.mockResolvedValueOnce(2);
 
       const result = await randomizer.pickWord(["foo", "bar"], { number: true });
 
@@ -70,7 +70,7 @@ describe("CryptoServiceRandomizer", () => {
 
   describe("shuffle", () => {
     it.each([[null], [undefined], [[]]])("throws when the list is %p", async (list) => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
+      const randomizer = new KeyServiceRandomizer(keyService);
 
       await expect(() => randomizer.shuffle(list)).rejects.toBeInstanceOf(Error);
 
@@ -78,18 +78,18 @@ describe("CryptoServiceRandomizer", () => {
     });
 
     it("returns a copy of the list without shuffling it when theres only one entry", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
+      const randomizer = new KeyServiceRandomizer(keyService);
 
       const result = await randomizer.shuffle(["foo"]);
 
       expect(result).toEqual(["foo"]);
       expect(result).not.toBe(["foo"]);
-      expect(cryptoService.randomNumber).not.toHaveBeenCalled();
+      expect(keyService.randomNumber).not.toHaveBeenCalled();
     });
 
     it("shuffles the tail of the list", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
-      cryptoService.randomNumber.mockResolvedValueOnce(0);
+      const randomizer = new KeyServiceRandomizer(keyService);
+      keyService.randomNumber.mockResolvedValueOnce(0);
 
       const result = await randomizer.shuffle(["bar", "foo"]);
 
@@ -97,9 +97,9 @@ describe("CryptoServiceRandomizer", () => {
     });
 
     it("shuffles the list", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
-      cryptoService.randomNumber.mockResolvedValueOnce(0);
-      cryptoService.randomNumber.mockResolvedValueOnce(1);
+      const randomizer = new KeyServiceRandomizer(keyService);
+      keyService.randomNumber.mockResolvedValueOnce(0);
+      keyService.randomNumber.mockResolvedValueOnce(1);
 
       const result = await randomizer.shuffle(["baz", "bar", "foo"]);
 
@@ -107,8 +107,8 @@ describe("CryptoServiceRandomizer", () => {
     });
 
     it("returns the input list when options.copy is false", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
-      cryptoService.randomNumber.mockResolvedValueOnce(0);
+      const randomizer = new KeyServiceRandomizer(keyService);
+      keyService.randomNumber.mockResolvedValueOnce(0);
 
       const expectedResult = ["foo"];
       const result = await randomizer.shuffle(expectedResult, { copy: false });
@@ -119,7 +119,7 @@ describe("CryptoServiceRandomizer", () => {
 
   describe("chars", () => {
     it("returns an empty string when the length is 0", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
+      const randomizer = new KeyServiceRandomizer(keyService);
 
       const result = await randomizer.chars(0);
 
@@ -127,8 +127,8 @@ describe("CryptoServiceRandomizer", () => {
     });
 
     it("returns an arbitrary lowercase ascii character", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
-      cryptoService.randomNumber.mockResolvedValueOnce(0);
+      const randomizer = new KeyServiceRandomizer(keyService);
+      keyService.randomNumber.mockResolvedValueOnce(0);
 
       const result = await randomizer.chars(1);
 
@@ -136,38 +136,38 @@ describe("CryptoServiceRandomizer", () => {
     });
 
     it("returns a number of ascii characters based on the length", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
-      cryptoService.randomNumber.mockResolvedValue(0);
+      const randomizer = new KeyServiceRandomizer(keyService);
+      keyService.randomNumber.mockResolvedValue(0);
 
       const result = await randomizer.chars(2);
 
       expect(result).toEqual("aa");
-      expect(cryptoService.randomNumber).toHaveBeenCalledTimes(2);
+      expect(keyService.randomNumber).toHaveBeenCalledTimes(2);
     });
 
     it("returns a new random character each time its called", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
-      cryptoService.randomNumber.mockResolvedValueOnce(0);
-      cryptoService.randomNumber.mockResolvedValueOnce(1);
+      const randomizer = new KeyServiceRandomizer(keyService);
+      keyService.randomNumber.mockResolvedValueOnce(0);
+      keyService.randomNumber.mockResolvedValueOnce(1);
 
       const resultA = await randomizer.chars(1);
       const resultB = await randomizer.chars(1);
 
       expect(resultA).toEqual("a");
       expect(resultB).toEqual("b");
-      expect(cryptoService.randomNumber).toHaveBeenCalledTimes(2);
+      expect(keyService.randomNumber).toHaveBeenCalledTimes(2);
     });
   });
 
   describe("uniform", () => {
     it("forwards requests to the crypto service", async () => {
-      const randomizer = new CryptoServiceRandomizer(cryptoService);
-      cryptoService.randomNumber.mockResolvedValue(5);
+      const randomizer = new KeyServiceRandomizer(keyService);
+      keyService.randomNumber.mockResolvedValue(5);
 
       const result = await randomizer.uniform(0, 5);
 
       expect(result).toBe(5);
-      expect(cryptoService.randomNumber).toHaveBeenCalledWith(0, 5);
+      expect(keyService.randomNumber).toHaveBeenCalledWith(0, 5);
     });
   });
 });

libs/tools/generator/core/src/engine/key-service-randomizer.ts

@@ -1,14 +1,14 @@
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
+import { KeyService } from "@bitwarden/key-management";
 
 import { Randomizer } from "../abstractions";
 import { WordOptions } from "../types";
 
-/** A randomizer backed by a CryptoService. */
-export class CryptoServiceRandomizer implements Randomizer {
+/** A randomizer backed by a KeyService. */
+export class KeyServiceRandomizer implements Randomizer {
   /** instantiates the type.
-   * @param crypto generates random numbers
+   * @param keyService generates random numbers
    */
-  constructor(private crypto: CryptoService) {}
+  constructor(private keyService: KeyService) {}
 
   async pick<Entry>(list: Array<Entry>): Promise<Entry> {
     const length = list?.length ?? 0;
@@ -28,7 +28,7 @@ export class CryptoServiceRandomizer implements Randomizer {
     }
 
     if (options?.number ?? false) {
-      const num = await this.crypto.randomNumber(1, 9);
+      const num = await this.keyService.randomNumber(1, 9);
       word = word + num.toString();
     }
 
@@ -63,6 +63,6 @@ export class CryptoServiceRandomizer implements Randomizer {
   }
 
   async uniform(min: number, max: number) {
-    return this.crypto.randomNumber(min, max);
+    return this.keyService.randomNumber(min, max);
   }
 }

libs/tools/generator/core/src/factories.ts

@@ -1,11 +1,11 @@
 // contains logic that constructs generator services dynamically given
 // a generator id.
 
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
+import { KeyService } from "@bitwarden/key-management";
 
 import { Randomizer } from "./abstractions";
-import { CryptoServiceRandomizer } from "./engine/crypto-service-randomizer";
+import { KeyServiceRandomizer } from "./engine/key-service-randomizer";
 
-export function createRandomizer(cryptoService: CryptoService): Randomizer {
-  return new CryptoServiceRandomizer(cryptoService);
+export function createRandomizer(keyService: KeyService): Randomizer {
+  return new KeyServiceRandomizer(keyService);
 }

libs/tools/generator/core/src/services/credential-generator.service.spec.ts

@@ -5,13 +5,13 @@ import { ApiService } from "@bitwarden/common/abstractions/api.service";
 import { PolicyService } from "@bitwarden/common/admin-console/abstractions/policy/policy.service.abstraction";
 import { PolicyType } from "@bitwarden/common/admin-console/enums";
 import { Policy } from "@bitwarden/common/admin-console/models/domain/policy";
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
 import { EncryptService } from "@bitwarden/common/platform/abstractions/encrypt.service";
 import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
 import { GENERATOR_DISK, UserKeyDefinition } from "@bitwarden/common/platform/state";
 import { StateConstraints } from "@bitwarden/common/tools/types";
 import { OrganizationId, PolicyId, UserId } from "@bitwarden/common/types/guid";
 import { UserKey } from "@bitwarden/common/types/key";
+import { KeyService } from "@bitwarden/key-management";
 
 import {
   FakeStateProvider,
@@ -175,7 +175,7 @@ const apiService = mock<ApiService>();
 
 const encryptService = mock<EncryptService>();
 
-const cryptoService = mock<CryptoService>();
+const keyService = mock<KeyService>();
 
 describe("CredentialGeneratorService", () => {
   beforeEach(async () => {
@@ -184,7 +184,7 @@ describe("CredentialGeneratorService", () => {
     i18nService.t.mockImplementation((key) => key);
     apiService.fetch.mockImplementation(() => Promise.resolve(mock<Response>()));
     const keyAvailable = new BehaviorSubject({} as UserKey);
-    cryptoService.userKey$.mockReturnValue(keyAvailable);
+    keyService.userKey$.mockReturnValue(keyAvailable);
     jest.clearAllMocks();
   });
 
@@ -199,7 +199,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const generated = new ObservableTracker(generator.generate$(SomeConfiguration));
 
@@ -220,7 +220,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const generated = new ObservableTracker(generator.generate$(SomeConfiguration));
 
@@ -245,7 +245,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const generated = new ObservableTracker(generator.generate$(SomeConfiguration));
 
@@ -273,7 +273,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const website$ = new BehaviorSubject("some website");
       const generated = new ObservableTracker(generator.generate$(SomeConfiguration, { website$ }));
@@ -294,7 +294,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const website$ = new BehaviorSubject("some website");
       let error = null;
@@ -319,7 +319,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const website$ = new BehaviorSubject("some website");
       let completed = false;
@@ -345,7 +345,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId$ = new BehaviorSubject(AnotherUser).asObservable();
       const generated = new ObservableTracker(generator.generate$(SomeConfiguration, { userId$ }));
@@ -365,7 +365,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.pipe(filter((u) => !!u));
@@ -389,7 +389,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId$ = new BehaviorSubject(SomeUser);
       let error = null;
@@ -414,7 +414,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId$ = new BehaviorSubject(SomeUser);
       let completed = false;
@@ -440,7 +440,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const on$ = new Subject<void>();
       const results: any[] = [];
@@ -482,7 +482,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const on$ = new Subject<void>();
       let error: any = null;
@@ -508,7 +508,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const on$ = new Subject<void>();
       let complete = false;
@@ -539,7 +539,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       const result = generator.algorithms("password");
@@ -560,7 +560,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       const result = generator.algorithms("username");
@@ -580,7 +580,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       const result = generator.algorithms("email");
@@ -601,7 +601,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       const result = generator.algorithms(["username", "email"]);
@@ -626,7 +626,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       const result = await firstValueFrom(generator.algorithms$("password"));
@@ -643,7 +643,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       const result = await firstValueFrom(generator.algorithms$("username"));
@@ -659,7 +659,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       const result = await firstValueFrom(generator.algorithms$("email"));
@@ -676,7 +676,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       const result = await firstValueFrom(generator.algorithms$(["username", "email"]));
@@ -698,7 +698,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       const result = await firstValueFrom(generator.algorithms$(["password"]));
@@ -723,7 +723,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const results: any = [];
       const sub = generator.algorithms$("password").subscribe((r) => results.push(r));
@@ -760,7 +760,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId$ = new BehaviorSubject(AnotherUser).asObservable();
 
@@ -781,7 +781,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.asObservable();
@@ -811,7 +811,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.asObservable();
@@ -837,7 +837,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.asObservable();
@@ -863,7 +863,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.asObservable();
@@ -895,7 +895,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       const result = await firstValueFrom(generator.settings$(SomeConfiguration));
@@ -913,7 +913,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       const result = await firstValueFrom(generator.settings$(SomeConfiguration));
@@ -933,7 +933,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       const result = await firstValueFrom(generator.settings$(SomeConfiguration));
@@ -958,7 +958,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const results: any = [];
       const sub = generator.settings$(SomeConfiguration).subscribe((r) => results.push(r));
@@ -983,7 +983,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId$ = new BehaviorSubject(AnotherUser).asObservable();
 
@@ -1004,7 +1004,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.asObservable();
@@ -1031,7 +1031,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.asObservable();
@@ -1057,7 +1057,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.asObservable();
@@ -1083,7 +1083,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.asObservable();
@@ -1115,7 +1115,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const subject = await generator.settings(SomeConfiguration, { singleUserId$ });
 
@@ -1136,7 +1136,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
 
       let completed = false;
@@ -1162,7 +1162,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId$ = new BehaviorSubject(SomeUser).asObservable();
 
@@ -1179,7 +1179,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId$ = new BehaviorSubject(SomeUser).asObservable();
       const policy$ = new BehaviorSubject([somePolicy]);
@@ -1198,7 +1198,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.asObservable();
@@ -1227,7 +1227,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.asObservable();
@@ -1257,7 +1257,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.asObservable();
@@ -1283,7 +1283,7 @@ describe("CredentialGeneratorService", () => {
         apiService,
         i18nService,
         encryptService,
-        cryptoService,
+        keyService,
       );
       const userId = new BehaviorSubject(SomeUser);
       const userId$ = userId.asObservable();

libs/tools/generator/core/src/services/credential-generator.service.ts

@@ -23,7 +23,6 @@ import { Simplify } from "type-fest";
 import { ApiService } from "@bitwarden/common/abstractions/api.service";
 import { PolicyService } from "@bitwarden/common/admin-console/abstractions/policy/policy.service.abstraction";
 import { PolicyType } from "@bitwarden/common/admin-console/enums";
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
 import { EncryptService } from "@bitwarden/common/platform/abstractions/encrypt.service";
 import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
 import { StateProvider } from "@bitwarden/common/platform/state";
@@ -41,6 +40,7 @@ import { UserEncryptor } from "@bitwarden/common/tools/state/user-encryptor.abst
 import { UserKeyEncryptor } from "@bitwarden/common/tools/state/user-key-encryptor";
 import { UserStateSubject } from "@bitwarden/common/tools/state/user-state-subject";
 import { UserId } from "@bitwarden/common/types/guid";
+import { KeyService } from "@bitwarden/key-management";
 
 import { Randomizer } from "../abstractions";
 import {
@@ -97,7 +97,7 @@ export class CredentialGeneratorService {
     private readonly apiService: ApiService,
     private readonly i18nService: I18nService,
     private readonly encryptService: EncryptService,
-    private readonly cryptoService: CryptoService,
+    private readonly keyService: KeyService,
   ) {}
 
   private getDependencyProvider(): GeneratorDependencyProvider {
@@ -272,7 +272,7 @@ export class CredentialGeneratorService {
 
   private encryptor$(userId: UserId) {
     const packer = new PaddedDataPacker(OPTIONS_FRAME_SIZE);
-    const encryptor$ = this.cryptoService.userKey$(userId).pipe(
+    const encryptor$ = this.keyService.userKey$(userId).pipe(
       // complete when the account locks
       takeWhile((key) => !!key),
       map((key) => {

libs/tools/generator/core/src/strategies/forwarder-generator-strategy.spec.ts

@@ -5,13 +5,13 @@ import { PolicyType } from "@bitwarden/common/admin-console/enums";
 // FIXME: use index.ts imports once policy abstractions and models
 // implement ADR-0002
 import { Policy } from "@bitwarden/common/admin-console/models/domain/policy";
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
 import { EncryptService } from "@bitwarden/common/platform/abstractions/encrypt.service";
 import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
 import { RestClient } from "@bitwarden/common/tools/integration/rpc";
 import { BufferedState } from "@bitwarden/common/tools/state/buffered-state";
 import { UserId } from "@bitwarden/common/types/guid";
 import { UserKey } from "@bitwarden/common/types/key";
+import { KeyService } from "@bitwarden/key-management";
 
 import { FakeStateProvider, mockAccountServiceWith } from "../../../../../common/spec";
 import { AddyIo, Fastmail, FirefoxRelay } from "../integration";
@@ -30,7 +30,7 @@ const SomePolicy = mock<Policy>({
 
 describe("ForwarderGeneratorStrategy", () => {
   const encryptService = mock<EncryptService>();
-  const keyService = mock<CryptoService>();
+  const keyService = mock<KeyService>();
   const stateProvider = new FakeStateProvider(mockAccountServiceWith(SomeUser));
   const restClient = mock<RestClient>();
   const i18nService = mock<I18nService>();

libs/tools/generator/core/src/strategies/forwarder-generator-strategy.ts

@@ -2,7 +2,6 @@ import { filter, map } from "rxjs";
 import { Jsonify } from "type-fest";
 
 import { PolicyType } from "@bitwarden/common/admin-console/enums";
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
 import { EncryptService } from "@bitwarden/common/platform/abstractions/encrypt.service";
 import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
 import { SingleUserState, StateProvider } from "@bitwarden/common/platform/state";
@@ -17,6 +16,7 @@ import { SecretKeyDefinition } from "@bitwarden/common/tools/state/secret-key-de
 import { SecretState } from "@bitwarden/common/tools/state/secret-state";
 import { UserKeyEncryptor } from "@bitwarden/common/tools/state/user-key-encryptor";
 import { UserId } from "@bitwarden/common/types/guid";
+import { KeyService } from "@bitwarden/key-management";
 
 import { GeneratorStrategy } from "../abstractions";
 import { ForwarderConfiguration, AccountRequest, ForwarderContext } from "../engine";
@@ -45,7 +45,7 @@ export class ForwarderGeneratorStrategy<
     private client: RestClient,
     private i18nService: I18nService,
     private readonly encryptService: EncryptService,
-    private readonly keyService: CryptoService,
+    private readonly keyService: KeyService,
     private stateProvider: StateProvider,
   ) {
     super();

libs/tools/generator/extensions/history/src/legacy-password-history-decryptor.ts

@@ -1,7 +1,7 @@
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
 import { EncryptService } from "@bitwarden/common/platform/abstractions/encrypt.service";
 import { EncString } from "@bitwarden/common/platform/models/domain/enc-string";
 import { UserId } from "@bitwarden/common/types/guid";
+import { KeyService } from "@bitwarden/key-management";
 
 import { GeneratedPasswordHistory } from "./generated-password-history";
 
@@ -9,13 +9,13 @@ import { GeneratedPasswordHistory } from "./generated-password-history";
 export class LegacyPasswordHistoryDecryptor {
   constructor(
     private userId: UserId,
-    private cryptoService: CryptoService,
+    private keyService: KeyService,
     private encryptService: EncryptService,
   ) {}
 
   /** Decrypts a password history. */
   async decrypt(history: GeneratedPasswordHistory[]): Promise<GeneratedPasswordHistory[]> {
-    const key = await this.cryptoService.getUserKey(this.userId);
+    const key = await this.keyService.getUserKey(this.userId);
 
     const promises = (history ?? []).map(async (item) => {
       const encrypted = new EncString(item.password);

libs/tools/generator/extensions/history/src/local-generator-history.service.spec.ts

@@ -1,13 +1,13 @@
 import { mock } from "jest-mock-extended";
 import { firstValueFrom, of } from "rxjs";
 
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
 import { EncryptService } from "@bitwarden/common/platform/abstractions/encrypt.service";
 import { EncString } from "@bitwarden/common/platform/models/domain/enc-string";
 import { SymmetricCryptoKey } from "@bitwarden/common/platform/models/domain/symmetric-crypto-key";
 import { CsprngArray } from "@bitwarden/common/types/csprng";
 import { UserId } from "@bitwarden/common/types/guid";
 import { UserKey } from "@bitwarden/common/types/key";
+import { KeyService } from "@bitwarden/key-management";
 
 import { FakeStateProvider, awaitAsync, mockAccountServiceWith } from "../../../../../common/spec";
 
@@ -18,7 +18,7 @@ const AnotherUser = "AnotherUser" as UserId;
 
 describe("LocalGeneratorHistoryService", () => {
   const encryptService = mock<EncryptService>();
-  const keyService = mock<CryptoService>();
+  const keyService = mock<KeyService>();
   const userKey = new SymmetricCryptoKey(new Uint8Array(64) as CsprngArray) as UserKey;
 
   beforeEach(() => {

libs/tools/generator/extensions/history/src/local-generator-history.service.ts

@@ -1,6 +1,5 @@
 import { filter, map } from "rxjs";
 
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
 import { EncryptService } from "@bitwarden/common/platform/abstractions/encrypt.service";
 import { SingleUserState, StateProvider } from "@bitwarden/common/platform/state";
 import { BufferedState } from "@bitwarden/common/tools/state/buffered-state";
@@ -9,6 +8,7 @@ import { SecretState } from "@bitwarden/common/tools/state/secret-state";
 import { UserKeyEncryptor } from "@bitwarden/common/tools/state/user-key-encryptor";
 import { UserId } from "@bitwarden/common/types/guid";
 import { CredentialAlgorithm } from "@bitwarden/generator-core";
+import { KeyService } from "@bitwarden/key-management";
 
 import { GeneratedCredential } from "./generated-credential";
 import { GeneratorHistoryService } from "./generator-history.abstraction";
@@ -24,7 +24,7 @@ const OPTIONS_FRAME_SIZE = 2048;
 export class LocalGeneratorHistoryService extends GeneratorHistoryService {
   constructor(
     private readonly encryptService: EncryptService,
-    private readonly keyService: CryptoService,
+    private readonly keyService: KeyService,
     private readonly stateProvider: StateProvider,
     private readonly options: HistoryServiceOptions = { maxTotal: 200 },
   ) {

libs/tools/generator/extensions/legacy/src/create-legacy-password-generation-service.ts

@@ -1,28 +1,28 @@
 import { PolicyService } from "@bitwarden/common/admin-console/abstractions/policy/policy.service.abstraction";
 import { AccountService } from "@bitwarden/common/auth/abstractions/account.service";
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
 import { EncryptService } from "@bitwarden/common/platform/abstractions/encrypt.service";
 import { StateProvider } from "@bitwarden/common/platform/state";
 import { engine, services, strategies } from "@bitwarden/generator-core";
 import { LocalGeneratorHistoryService } from "@bitwarden/generator-history";
 import { DefaultGeneratorNavigationService } from "@bitwarden/generator-navigation";
+import { KeyService } from "@bitwarden/key-management";
 
 import { LegacyPasswordGenerationService } from "./legacy-password-generation.service";
 import { PasswordGenerationServiceAbstraction } from "./password-generation.service.abstraction";
 
 const { PassphraseGeneratorStrategy, PasswordGeneratorStrategy } = strategies;
-const { CryptoServiceRandomizer, PasswordRandomizer } = engine;
+const { KeyServiceRandomizer, PasswordRandomizer } = engine;
 
 const DefaultGeneratorService = services.DefaultGeneratorService;
 
 export function legacyPasswordGenerationServiceFactory(
   encryptService: EncryptService,
-  cryptoService: CryptoService,
+  keyService: KeyService,
   policyService: PolicyService,
   accountService: AccountService,
   stateProvider: StateProvider,
 ): PasswordGenerationServiceAbstraction {
-  const randomizer = new CryptoServiceRandomizer(cryptoService);
+  const randomizer = new KeyServiceRandomizer(keyService);
   const passwordRandomizer = new PasswordRandomizer(randomizer);
 
   const passwords = new DefaultGeneratorService(
@@ -37,7 +37,7 @@ export function legacyPasswordGenerationServiceFactory(
 
   const navigation = new DefaultGeneratorNavigationService(stateProvider, policyService);
 
-  const history = new LocalGeneratorHistoryService(encryptService, cryptoService, stateProvider);
+  const history = new LocalGeneratorHistoryService(encryptService, keyService, stateProvider);
 
   return new LegacyPasswordGenerationService(
     accountService,

libs/tools/generator/extensions/legacy/src/create-legacy-username-generation-service.ts

@@ -1,18 +1,18 @@
 import { ApiService } from "@bitwarden/common/abstractions/api.service";
 import { PolicyService } from "@bitwarden/common/admin-console/abstractions/policy/policy.service.abstraction";
 import { AccountService } from "@bitwarden/common/auth/abstractions/account.service";
-import { CryptoService } from "@bitwarden/common/platform/abstractions/crypto.service";
 import { EncryptService } from "@bitwarden/common/platform/abstractions/encrypt.service";
 import { I18nService } from "@bitwarden/common/platform/abstractions/i18n.service";
 import { StateProvider } from "@bitwarden/common/platform/state";
 import { RestClient } from "@bitwarden/common/tools/integration/rpc";
 import { engine, services, strategies, Integrations } from "@bitwarden/generator-core";
 import { DefaultGeneratorNavigationService } from "@bitwarden/generator-navigation";
+import { KeyService } from "@bitwarden/key-management";
 
 import { LegacyUsernameGenerationService } from "./legacy-username-generation.service";
 import { UsernameGenerationServiceAbstraction } from "./username-generation.service.abstraction";
 
-const { CryptoServiceRandomizer, UsernameRandomizer, EmailRandomizer, EmailCalculator } = engine;
+const { KeyServiceRandomizer, UsernameRandomizer, EmailRandomizer, EmailCalculator } = engine;
 const DefaultGeneratorService = services.DefaultGeneratorService;
 const {
   CatchallGeneratorStrategy,
@@ -24,13 +24,13 @@ const {
 export function legacyUsernameGenerationServiceFactory(
   apiService: ApiService,
   i18nService: I18nService,
-  cryptoService: CryptoService,
+  keyService: KeyService,
   encryptService: EncryptService,
   policyService: PolicyService,
   accountService: AccountService,
   stateProvider: StateProvider,
 ): UsernameGenerationServiceAbstraction {
-  const randomizer = new CryptoServiceRandomizer(cryptoService);
+  const randomizer = new KeyServiceRandomizer(keyService);
   const restClient = new RestClient(apiService, i18nService);
   const usernameRandomizer = new UsernameRandomizer(randomizer);
   const emailRandomizer = new EmailRandomizer(randomizer);
@@ -57,7 +57,7 @@ export function legacyUsernameGenerationServiceFactory(
       restClient,
       i18nService,
       encryptService,
-      cryptoService,
+      keyService,
       stateProvider,
     ),
     policyService,
@@ -69,7 +69,7 @@ export function legacyUsernameGenerationServiceFactory(
       restClient,
       i18nService,
       encryptService,
-      cryptoService,
+      keyService,
       stateProvider,
     ),
     policyService,
@@ -81,7 +81,7 @@ export function legacyUsernameGenerationServiceFactory(
       restClient,
       i18nService,
       encryptService,
-      cryptoService,
+      keyService,
       stateProvider,
     ),
     policyService,
@@ -93,7 +93,7 @@ export function legacyUsernameGenerationServiceFactory(
       restClient,
       i18nService,
       encryptService,
-      cryptoService,
+      keyService,
       stateProvider,
     ),
     policyService,
@@ -105,7 +105,7 @@ export function legacyUsernameGenerationServiceFactory(
       restClient,
       i18nService,
       encryptService,
-      cryptoService,
+      keyService,
       stateProvider,
     ),
     policyService,
@@ -117,7 +117,7 @@ export function legacyUsernameGenerationServiceFactory(
       restClient,
       i18nService,
       encryptService,
-      cryptoService,
+      keyService,
       stateProvider,
     ),
     policyService,