[PM-5562] Implement Domain Settings state provider (#8226)

* create domain settings state provider * replace callsites for defaultUriMatch and neverDomains with DomainSettingsService equivalents * replace callsites for equivalentDomains with DomainSettingsService equivalents and clean up unused AccountSettingsSettings * add migrations for domain settings state * do not use enum for URI match strategy constants and types * add getUrlEquivalentDomains test * PR suggestions/cleanup * refactor getUrlEquivalentDomains to return an observable Co-authored-by: Justin Baur <19896123+justindbaur@users.noreply.github.com> Co-authored-by: ✨ Audrey ✨ <ajensen@bitwarden.com> * update tests * add UriMatchStrategy docs notes * service class renames * use service abstraction at callsites previously using service class directly --------- Co-authored-by: Justin Baur <19896123+justindbaur@users.noreply.github.com> Co-authored-by: ✨ Audrey ✨ <ajensen@bitwarden.com>
2025-12-18 09:13:33 +00:00 · 2024-03-12 15:07:14 -04:00
parent a0e0637bb6
commit 0a595ea95e
58 changed files with 945 additions and 455 deletions
--- a/libs/common/src/vault/abstractions/cipher.service.ts
+++ b/libs/common/src/vault/abstractions/cipher.service.ts
@@ -1,5 +1,5 @@
+import { UriMatchStrategySetting } from "../../models/domain/domain-service";
 import { SymmetricCryptoKey } from "../../platform/models/domain/symmetric-crypto-key";
-import { UriMatchType } from "../enums";
 import { CipherType } from "../enums/cipher-type";
 import { CipherData } from "../models/data/cipher.data";
 import { Cipher } from "../models/domain/cipher";
@@ -24,7 +24,7 @@ export abstract class CipherService {
  getAllDecryptedForUrl: (
    url: string,
    includeOtherTypes?: CipherType[],
-    defaultMatch?: UriMatchType,
+    defaultMatch?: UriMatchStrategySetting,
  ) => Promise<CipherView[]>;
  getAllFromApiForOrganization: (organizationId: string) => Promise<CipherView[]>;
  /**
--- a/libs/common/src/vault/enums/index.ts
+++ b/libs/common/src/vault/enums/index.ts
@@ -3,4 +3,3 @@ export * from "./cipher-type";
 export * from "./field-type.enum";
 export * from "./linked-id-type.enum";
 export * from "./secure-note-type.enum";
-export * from "./uri-match-type.enum";
--- a/libs/common/src/vault/enums/uri-match-type.enum.ts
+++ b/libs/common/src/vault/enums/uri-match-type.enum.ts
@@ -1,8 +0,0 @@
-export enum UriMatchType {
-  Domain = 0,
-  Host = 1,
-  StartsWith = 2,
-  Exact = 3,
-  RegularExpression = 4,
-  Never = 5,
-}
--- a/libs/common/src/vault/models/api/login-uri.api.ts
+++ b/libs/common/src/vault/models/api/login-uri.api.ts
@@ -1,10 +1,10 @@
+import { UriMatchStrategySetting } from "../../../models/domain/domain-service";
 import { BaseResponse } from "../../../models/response/base.response";
-import { UriMatchType } from "../../enums";

 export class LoginUriApi extends BaseResponse {
  uri: string;
  uriChecksum: string;
-  match: UriMatchType = null;
+  match: UriMatchStrategySetting = null;

  constructor(data: any = null) {
    super(data);
--- a/libs/common/src/vault/models/data/login-uri.data.ts
+++ b/libs/common/src/vault/models/data/login-uri.data.ts
@@ -1,10 +1,10 @@
-import { UriMatchType } from "../../enums";
+import { UriMatchStrategySetting } from "../../../models/domain/domain-service";
 import { LoginUriApi } from "../api/login-uri.api";

 export class LoginUriData {
  uri: string;
  uriChecksum: string;
-  match: UriMatchType = null;
+  match: UriMatchStrategySetting = null;

  constructor(data?: LoginUriApi) {
    if (data == null) {
--- a/libs/common/src/vault/models/domain/cipher.spec.ts
+++ b/libs/common/src/vault/models/domain/cipher.spec.ts
@@ -2,13 +2,14 @@ import { mock } from "jest-mock-extended";
 import { Jsonify } from "type-fest";

 import { makeStaticByteArray, mockEnc, mockFromJson } from "../../../../spec/utils";
+import { UriMatchStrategy } from "../../../models/domain/domain-service";
 import { CryptoService } from "../../../platform/abstractions/crypto.service";
 import { EncryptService } from "../../../platform/abstractions/encrypt.service";
 import { EncString } from "../../../platform/models/domain/enc-string";
 import { ContainerService } from "../../../platform/services/container.service";
 import { InitializerKey } from "../../../platform/services/cryptography/initializer-key";
 import { CipherService } from "../../abstractions/cipher.service";
-import { FieldType, SecureNoteType, UriMatchType } from "../../enums";
+import { FieldType, SecureNoteType } from "../../enums";
 import { CipherRepromptType } from "../../enums/cipher-reprompt-type";
 import { CipherType } from "../../enums/cipher-type";
 import { CipherData } from "../../models/data/cipher.data";
@@ -76,7 +77,11 @@ describe("Cipher DTO", () => {
        key: "EncryptedString",
        login: {
          uris: [
-            { uri: "EncryptedString", uriChecksum: "EncryptedString", match: UriMatchType.Domain },
+            {
+              uri: "EncryptedString",
+              uriChecksum: "EncryptedString",
+              match: UriMatchStrategy.Domain,
+            },
          ],
          username: "EncryptedString",
          password: "EncryptedString",
--- a/libs/common/src/vault/models/domain/login-uri.spec.ts
+++ b/libs/common/src/vault/models/domain/login-uri.spec.ts
@@ -2,9 +2,9 @@ import { MockProxy, mock } from "jest-mock-extended";
 import { Jsonify } from "type-fest";

 import { mockEnc, mockFromJson } from "../../../../spec";
+import { UriMatchStrategy } from "../../../models/domain/domain-service";
 import { EncryptService } from "../../../platform/abstractions/encrypt.service";
 import { EncString } from "../../../platform/models/domain/enc-string";
-import { UriMatchType } from "../../enums";
 import { LoginUriData } from "../data/login-uri.data";

 import { LoginUri } from "./login-uri";
@@ -16,7 +16,7 @@ describe("LoginUri", () => {
    data = {
      uri: "encUri",
      uriChecksum: "encUriChecksum",
-      match: UriMatchType.Domain,
+      match: UriMatchStrategy.Domain,
    };
  });

@@ -48,7 +48,7 @@ describe("LoginUri", () => {

  it("Decrypt", async () => {
    const loginUri = new LoginUri();
-    loginUri.match = UriMatchType.Exact;
+    loginUri.match = UriMatchStrategy.Exact;
    loginUri.uri = mockEnc("uri");

    const view = await loginUri.decrypt(null);
@@ -103,13 +103,13 @@ describe("LoginUri", () => {
      const actual = LoginUri.fromJSON({
        uri: "myUri",
        uriChecksum: "myUriChecksum",
-        match: UriMatchType.Domain,
+        match: UriMatchStrategy.Domain,
      } as Jsonify<LoginUri>);

      expect(actual).toEqual({
        uri: "myUri_fromJSON",
        uriChecksum: "myUriChecksum_fromJSON",
-        match: UriMatchType.Domain,
+        match: UriMatchStrategy.Domain,
      });
      expect(actual).toBeInstanceOf(LoginUri);
    });
--- a/libs/common/src/vault/models/domain/login-uri.ts
+++ b/libs/common/src/vault/models/domain/login-uri.ts
@@ -1,17 +1,17 @@
 import { Jsonify } from "type-fest";

+import { UriMatchStrategySetting } from "../../../models/domain/domain-service";
 import { Utils } from "../../../platform/misc/utils";
 import Domain from "../../../platform/models/domain/domain-base";
 import { EncString } from "../../../platform/models/domain/enc-string";
 import { SymmetricCryptoKey } from "../../../platform/models/domain/symmetric-crypto-key";
-import { UriMatchType } from "../../enums";
 import { LoginUriData } from "../data/login-uri.data";
 import { LoginUriView } from "../view/login-uri.view";

 export class LoginUri extends Domain {
  uri: EncString;
  uriChecksum: EncString | undefined;
-  match: UriMatchType;
+  match: UriMatchStrategySetting;

  constructor(obj?: LoginUriData) {
    super();
--- a/libs/common/src/vault/models/domain/login.spec.ts
+++ b/libs/common/src/vault/models/domain/login.spec.ts
@@ -1,8 +1,8 @@
 import { MockProxy, mock } from "jest-mock-extended";

 import { mockEnc, mockFromJson } from "../../../../spec";
+import { UriMatchStrategy, UriMatchStrategySetting } from "../../../models/domain/domain-service";
 import { EncryptedString, EncString } from "../../../platform/models/domain/enc-string";
-import { UriMatchType } from "../../enums";
 import { LoginData } from "../../models/data/login.data";
 import { Login } from "../../models/domain/login";
 import { LoginUri } from "../../models/domain/login-uri";
@@ -30,7 +30,7 @@ describe("Login DTO", () => {
  it("Convert from full LoginData", () => {
    const fido2CredentialData = initializeFido2Credential(new Fido2CredentialData());
    const data: LoginData = {
-      uris: [{ uri: "uri", uriChecksum: "checksum", match: UriMatchType.Domain }],
+      uris: [{ uri: "uri", uriChecksum: "checksum", match: UriMatchStrategy.Domain }],
      username: "username",
      password: "password",
      passwordRevisionDate: "2022-01-31T12:00:00.000Z",
@@ -82,7 +82,7 @@ describe("Login DTO", () => {
      totp: "encrypted totp",
      uris: [
        {
-          match: null as UriMatchType,
+          match: null as UriMatchStrategySetting,
          _uri: "decrypted uri",
          _domain: null as string,
          _hostname: null as string,
@@ -123,7 +123,7 @@ describe("Login DTO", () => {

  it("Converts from LoginData and back", () => {
    const data: LoginData = {
-      uris: [{ uri: "uri", uriChecksum: "checksum", match: UriMatchType.Domain }],
+      uris: [{ uri: "uri", uriChecksum: "checksum", match: UriMatchStrategy.Domain }],
      username: "username",
      password: "password",
      passwordRevisionDate: "2022-01-31T12:00:00.000Z",
--- a/libs/common/src/vault/models/view/login-uri-view.spec.ts
+++ b/libs/common/src/vault/models/view/login-uri-view.spec.ts
@@ -1,26 +1,26 @@
+import { UriMatchStrategy, UriMatchStrategySetting } from "../../../models/domain/domain-service";
 import { Utils } from "../../../platform/misc/utils";
-import { UriMatchType } from "../../enums";

 import { LoginUriView } from "./login-uri.view";

 const testData = [
  {
-    match: UriMatchType.Host,
+    match: UriMatchStrategy.Host,
    uri: "http://example.com/login",
    expected: "http://example.com/login",
  },
  {
-    match: UriMatchType.Host,
+    match: UriMatchStrategy.Host,
    uri: "bitwarden.com",
    expected: "http://bitwarden.com",
  },
  {
-    match: UriMatchType.Host,
+    match: UriMatchStrategy.Host,
    uri: "bitwarden.de",
    expected: "http://bitwarden.de",
  },
  {
-    match: UriMatchType.Host,
+    match: UriMatchStrategy.Host,
    uri: "bitwarden.br",
    expected: "http://bitwarden.br",
  },
@@ -41,7 +41,7 @@ const exampleUris = {
 describe("LoginUriView", () => {
  it("isWebsite() given an invalid domain should return false", async () => {
    const uri = new LoginUriView();
-    Object.assign(uri, { match: UriMatchType.Host, uri: "bit!:_&ward.com" });
+    Object.assign(uri, { match: UriMatchStrategy.Host, uri: "bit!:_&ward.com" });
    expect(uri.isWebsite).toBe(false);
  });

@@ -67,32 +67,32 @@ describe("LoginUriView", () => {

  it(`canLaunch should return false when MatchDetection is set to Regex`, async () => {
    const uri = new LoginUriView();
-    Object.assign(uri, { match: UriMatchType.RegularExpression, uri: "bitwarden.com" });
+    Object.assign(uri, { match: UriMatchStrategy.RegularExpression, uri: "bitwarden.com" });
    expect(uri.canLaunch).toBe(false);
  });

  it(`canLaunch() should return false when the given protocol does not match CanLaunchWhiteList`, async () => {
    const uri = new LoginUriView();
-    Object.assign(uri, { match: UriMatchType.Host, uri: "someprotocol://bitwarden.com" });
+    Object.assign(uri, { match: UriMatchStrategy.Host, uri: "someprotocol://bitwarden.com" });
    expect(uri.canLaunch).toBe(false);
  });

  describe("uri matching", () => {
    describe("using domain matching", () => {
      it("matches the same domain", () => {
-        const uri = uriFactory(UriMatchType.Domain, exampleUris.standard);
+        const uri = uriFactory(UriMatchStrategy.Domain, exampleUris.standard);
        const actual = uri.matchesUri(exampleUris.subdomain, exampleUris.noEquivalentDomains());
        expect(actual).toBe(true);
      });

      it("matches equivalent domains", () => {
-        const uri = uriFactory(UriMatchType.Domain, exampleUris.standard);
+        const uri = uriFactory(UriMatchStrategy.Domain, exampleUris.standard);
        const actual = uri.matchesUri(exampleUris.differentDomain, exampleUris.equivalentDomains());
        expect(actual).toBe(true);
      });

      it("does not match a different domain", () => {
-        const uri = uriFactory(UriMatchType.Domain, exampleUris.standard);
+        const uri = uriFactory(UriMatchStrategy.Domain, exampleUris.standard);
        const actual = uri.matchesUri(
          exampleUris.differentDomain,
          exampleUris.noEquivalentDomains(),
@@ -103,7 +103,7 @@ describe("LoginUriView", () => {
      // Actual integration test with the real blacklist, not ideal
      it("does not match domains that are blacklisted", () => {
        const googleEquivalentDomains = new Set(["google.com", "script.google.com"]);
-        const uri = uriFactory(UriMatchType.Domain, "google.com");
+        const uri = uriFactory(UriMatchStrategy.Domain, "google.com");

        const actual = uri.matchesUri("script.google.com", googleEquivalentDomains);

@@ -113,13 +113,13 @@ describe("LoginUriView", () => {

    describe("using host matching", () => {
      it("matches the same host", () => {
-        const uri = uriFactory(UriMatchType.Host, Utils.getHost(exampleUris.standard));
+        const uri = uriFactory(UriMatchStrategy.Host, Utils.getHost(exampleUris.standard));
        const actual = uri.matchesUri(exampleUris.standard, exampleUris.noEquivalentDomains());
        expect(actual).toBe(true);
      });

      it("does not match a different host", () => {
-        const uri = uriFactory(UriMatchType.Host, Utils.getHost(exampleUris.differentDomain));
+        const uri = uriFactory(UriMatchStrategy.Host, Utils.getHost(exampleUris.differentDomain));
        const actual = uri.matchesUri(exampleUris.standard, exampleUris.noEquivalentDomains());
        expect(actual).toBe(false);
      });
@@ -127,13 +127,13 @@ describe("LoginUriView", () => {

    describe("using exact matching", () => {
      it("matches if both uris are the same", () => {
-        const uri = uriFactory(UriMatchType.Exact, exampleUris.standard);
+        const uri = uriFactory(UriMatchStrategy.Exact, exampleUris.standard);
        const actual = uri.matchesUri(exampleUris.standard, exampleUris.noEquivalentDomains());
        expect(actual).toBe(true);
      });

      it("does not match if the uris are different", () => {
-        const uri = uriFactory(UriMatchType.Exact, exampleUris.standard);
+        const uri = uriFactory(UriMatchStrategy.Exact, exampleUris.standard);
        const actual = uri.matchesUri(
          exampleUris.standard + "#",
          exampleUris.noEquivalentDomains(),
@@ -144,7 +144,7 @@ describe("LoginUriView", () => {

    describe("using startsWith matching", () => {
      it("matches if the target URI starts with the saved URI", () => {
-        const uri = uriFactory(UriMatchType.StartsWith, exampleUris.standard);
+        const uri = uriFactory(UriMatchStrategy.StartsWith, exampleUris.standard);
        const actual = uri.matchesUri(
          exampleUris.standard + "#bookmark",
          exampleUris.noEquivalentDomains(),
@@ -153,7 +153,7 @@ describe("LoginUriView", () => {
      });

      it("does not match if the start of the uri is not the same", () => {
-        const uri = uriFactory(UriMatchType.StartsWith, exampleUris.standard);
+        const uri = uriFactory(UriMatchStrategy.StartsWith, exampleUris.standard);
        const actual = uri.matchesUri(
          exampleUris.standard.slice(1),
          exampleUris.noEquivalentDomains(),
@@ -164,13 +164,13 @@ describe("LoginUriView", () => {

    describe("using regular expression matching", () => {
      it("matches if the regular expression matches", () => {
-        const uri = uriFactory(UriMatchType.RegularExpression, exampleUris.standard);
+        const uri = uriFactory(UriMatchStrategy.RegularExpression, exampleUris.standard);
        const actual = uri.matchesUri(exampleUris.standardRegex, exampleUris.noEquivalentDomains());
        expect(actual).toBe(false);
      });

      it("does not match if the regular expression does not match", () => {
-        const uri = uriFactory(UriMatchType.RegularExpression, exampleUris.standardNotMatching);
+        const uri = uriFactory(UriMatchStrategy.RegularExpression, exampleUris.standardNotMatching);
        const actual = uri.matchesUri(exampleUris.standardRegex, exampleUris.noEquivalentDomains());
        expect(actual).toBe(false);
      });
@@ -178,7 +178,7 @@ describe("LoginUriView", () => {

    describe("using never matching", () => {
      it("does not match even if uris are identical", () => {
-        const uri = uriFactory(UriMatchType.Never, exampleUris.standard);
+        const uri = uriFactory(UriMatchStrategy.Never, exampleUris.standard);
        const actual = uri.matchesUri(exampleUris.standard, exampleUris.noEquivalentDomains());
        expect(actual).toBe(false);
      });
@@ -186,7 +186,7 @@ describe("LoginUriView", () => {
  });
 });

-function uriFactory(match: UriMatchType, uri: string) {
+function uriFactory(match: UriMatchStrategySetting, uri: string) {
  const loginUri = new LoginUriView();
  loginUri.match = match;
  loginUri.uri = uri;
--- a/libs/common/src/vault/models/view/login-uri.view.ts
+++ b/libs/common/src/vault/models/view/login-uri.view.ts
@@ -1,13 +1,13 @@
 import { Jsonify } from "type-fest";

+import { UriMatchStrategy, UriMatchStrategySetting } from "../../../models/domain/domain-service";
 import { View } from "../../../models/view/view";
 import { SafeUrls } from "../../../platform/misc/safe-urls";
 import { Utils } from "../../../platform/misc/utils";
-import { UriMatchType } from "../../enums";
 import { LoginUri } from "../domain/login-uri";

 export class LoginUriView implements View {
-  match: UriMatchType = null;
+  match: UriMatchStrategySetting = null;

  private _uri: string = null;
  private _domain: string = null;
@@ -44,7 +44,7 @@ export class LoginUriView implements View {
  }

  get hostname(): string {
-    if (this.match === UriMatchType.RegularExpression) {
+    if (this.match === UriMatchStrategy.RegularExpression) {
      return null;
    }
    if (this._hostname == null && this.uri != null) {
@@ -58,7 +58,7 @@ export class LoginUriView implements View {
  }

  get host(): string {
-    if (this.match === UriMatchType.RegularExpression) {
+    if (this.match === UriMatchStrategy.RegularExpression) {
      return null;
    }
    if (this._host == null && this.uri != null) {
@@ -92,7 +92,7 @@ export class LoginUriView implements View {
    if (this._canLaunch != null) {
      return this._canLaunch;
    }
-    if (this.uri != null && this.match !== UriMatchType.RegularExpression) {
+    if (this.uri != null && this.match !== UriMatchStrategy.RegularExpression) {
      this._canLaunch = SafeUrls.canLaunch(this.launchUri);
    } else {
      this._canLaunch = false;
@@ -113,30 +113,30 @@ export class LoginUriView implements View {
  matchesUri(
    targetUri: string,
    equivalentDomains: Set<string>,
-    defaultUriMatch: UriMatchType = null,
+    defaultUriMatch: UriMatchStrategySetting = null,
  ): boolean {
    if (!this.uri || !targetUri) {
      return false;
    }

    let matchType = this.match ?? defaultUriMatch;
-    matchType ??= UriMatchType.Domain;
+    matchType ??= UriMatchStrategy.Domain;

    const targetDomain = Utils.getDomain(targetUri);
    const matchDomains = equivalentDomains.add(targetDomain);

    switch (matchType) {
-      case UriMatchType.Domain:
+      case UriMatchStrategy.Domain:
        return this.matchesDomain(targetUri, matchDomains);
-      case UriMatchType.Host: {
+      case UriMatchStrategy.Host: {
        const urlHost = Utils.getHost(targetUri);
        return urlHost != null && urlHost === Utils.getHost(this.uri);
      }
-      case UriMatchType.Exact:
+      case UriMatchStrategy.Exact:
        return targetUri === this.uri;
-      case UriMatchType.StartsWith:
+      case UriMatchStrategy.StartsWith:
        return targetUri.startsWith(this.uri);
-      case UriMatchType.RegularExpression:
+      case UriMatchStrategy.RegularExpression:
        try {
          const regex = new RegExp(this.uri, "i");
          return regex.test(targetUri);
@@ -144,7 +144,7 @@ export class LoginUriView implements View {
          // Invalid regex
          return false;
        }
-      case UriMatchType.Never:
+      case UriMatchStrategy.Never:
        return false;
      default:
        break;
--- a/libs/common/src/vault/models/view/login.view.ts
+++ b/libs/common/src/vault/models/view/login.view.ts
@@ -1,6 +1,7 @@
+import { UriMatchStrategySetting } from "../../../models/domain/domain-service";
 import { Utils } from "../../../platform/misc/utils";
 import { DeepJsonify } from "../../../types/deep-jsonify";
-import { LoginLinkedId as LinkedId, UriMatchType } from "../../enums";
+import { LoginLinkedId as LinkedId } from "../../enums";
 import { linkedFieldOption } from "../../linked-field-option.decorator";
 import { Login } from "../domain/login";

@@ -71,7 +72,7 @@ export class LoginView extends ItemView {
  matchesUri(
    targetUri: string,
    equivalentDomains: Set<string>,
-    defaultUriMatch: UriMatchType = null,
+    defaultUriMatch: UriMatchStrategySetting = null,
  ): boolean {
    if (this.uris == null) {
      return false;
--- a/libs/common/src/vault/services/cipher.service.spec.ts
+++ b/libs/common/src/vault/services/cipher.service.spec.ts
@@ -4,8 +4,9 @@ import { of } from "rxjs";
 import { makeStaticByteArray } from "../../../spec/utils";
 import { ApiService } from "../../abstractions/api.service";
 import { SearchService } from "../../abstractions/search.service";
-import { SettingsService } from "../../abstractions/settings.service";
 import { AutofillSettingsService } from "../../autofill/services/autofill-settings.service";
+import { DomainSettingsService } from "../../autofill/services/domain-settings.service";
+import { UriMatchStrategy } from "../../models/domain/domain-service";
 import { ConfigServiceAbstraction } from "../../platform/abstractions/config/config.service.abstraction";
 import { CryptoService } from "../../platform/abstractions/crypto.service";
 import { EncryptService } from "../../platform/abstractions/encrypt.service";
@@ -17,7 +18,7 @@ import { SymmetricCryptoKey } from "../../platform/models/domain/symmetric-crypt
 import { ContainerService } from "../../platform/services/container.service";
 import { CipherKey, OrgKey } from "../../types/key";
 import { CipherFileUploadService } from "../abstractions/file-upload/cipher-file-upload.service";
-import { UriMatchType, FieldType } from "../enums";
+import { FieldType } from "../enums";
 import { CipherRepromptType } from "../enums/cipher-reprompt-type";
 import { CipherType } from "../enums/cipher-type";
 import { CipherData } from "../models/data/cipher.data";
@@ -53,7 +54,9 @@ const cipherData: CipherData = {
  key: "EncKey",
  reprompt: CipherRepromptType.None,
  login: {
-    uris: [{ uri: "EncryptedString", uriChecksum: "EncryptedString", match: UriMatchType.Domain }],
+    uris: [
+      { uri: "EncryptedString", uriChecksum: "EncryptedString", match: UriMatchStrategy.Domain },
+    ],
    username: "EncryptedString",
    password: "EncryptedString",
    passwordRevisionDate: "2022-01-31T12:00:00.000Z",
@@ -99,7 +102,7 @@ describe("Cipher Service", () => {
  const cryptoService = mock<CryptoService>();
  const stateService = mock<StateService>();
  const autofillSettingsService = mock<AutofillSettingsService>();
-  const settingsService = mock<SettingsService>();
+  const domainSettingsService = mock<DomainSettingsService>();
  const apiService = mock<ApiService>();
  const cipherFileUploadService = mock<CipherFileUploadService>();
  const i18nService = mock<I18nService>();
@@ -118,7 +121,7 @@ describe("Cipher Service", () => {

    cipherService = new CipherService(
      cryptoService,
-      settingsService,
+      domainSettingsService,
      apiService,
      i18nService,
      searchService,
@@ -277,7 +280,7 @@ describe("Cipher Service", () => {
      it("should add a uri hash to login uris", async () => {
        encryptService.hash.mockImplementation((value) => Promise.resolve(`${value} hash`));
        cipherView.login.uris = [
-          { uri: "uri", match: UriMatchType.RegularExpression } as LoginUriView,
+          { uri: "uri", match: UriMatchStrategy.RegularExpression } as LoginUriView,
        ];

        const domain = await cipherService.encrypt(cipherView);
@@ -286,7 +289,7 @@ describe("Cipher Service", () => {
          {
            uri: new EncString("uri has been encrypted"),
            uriChecksum: new EncString("uri hash has been encrypted"),
-            match: UriMatchType.RegularExpression,
+            match: UriMatchStrategy.RegularExpression,
          },
        ]);
      });
--- a/libs/common/src/vault/services/cipher.service.ts
+++ b/libs/common/src/vault/services/cipher.service.ts
@@ -3,8 +3,9 @@ import { SemVer } from "semver";

 import { ApiService } from "../../abstractions/api.service";
 import { SearchService } from "../../abstractions/search.service";
-import { SettingsService } from "../../abstractions/settings.service";
 import { AutofillSettingsServiceAbstraction } from "../../autofill/services/autofill-settings.service";
+import { DomainSettingsService } from "../../autofill/services/domain-settings.service";
+import { UriMatchStrategySetting } from "../../models/domain/domain-service";
 import { ErrorResponse } from "../../models/response/error.response";
 import { ListResponse } from "../../models/response/list.response";
 import { View } from "../../models/view/view";
@@ -23,7 +24,7 @@ import { SymmetricCryptoKey } from "../../platform/models/domain/symmetric-crypt
 import { UserKey, OrgKey } from "../../types/key";
 import { CipherService as CipherServiceAbstraction } from "../abstractions/cipher.service";
 import { CipherFileUploadService } from "../abstractions/file-upload/cipher-file-upload.service";
-import { FieldType, UriMatchType } from "../enums";
+import { FieldType } from "../enums";
 import { CipherType } from "../enums/cipher-type";
 import { CipherData } from "../models/data/cipher.data";
 import { Attachment } from "../models/domain/attachment";
@@ -61,7 +62,7 @@ export class CipherService implements CipherServiceAbstraction {

  constructor(
    private cryptoService: CryptoService,
-    private settingsService: SettingsService,
+    private domainSettingsService: DomainSettingsService,
    private apiService: ApiService,
    private i18nService: I18nService,
    private searchService: SearchService,
@@ -355,15 +356,17 @@ export class CipherService implements CipherServiceAbstraction {
  async getAllDecryptedForUrl(
    url: string,
    includeOtherTypes?: CipherType[],
-    defaultMatch: UriMatchType = null,
+    defaultMatch: UriMatchStrategySetting = null,
  ): Promise<CipherView[]> {
    if (url == null && includeOtherTypes == null) {
      return Promise.resolve([]);
    }

-    const equivalentDomains = this.settingsService.getEquivalentDomains(url);
+    const equivalentDomains = await firstValueFrom(
+      this.domainSettingsService.getUrlEquivalentDomains(url),
+    );
    const ciphers = await this.getAllDecrypted();
-    defaultMatch ??= await this.stateService.getDefaultUriMatch();
+    defaultMatch ??= await firstValueFrom(this.domainSettingsService.defaultUriMatchStrategy$);

    return ciphers.filter((cipher) => {
      const cipherIsLogin = cipher.type === CipherType.Login && cipher.login !== null;
@@ -503,12 +506,12 @@ export class CipherService implements CipherServiceAbstraction {
      return;
    }

-    let domains = await this.stateService.getNeverDomains();
+    let domains = await firstValueFrom(this.domainSettingsService.neverDomains$);
    if (!domains) {
      domains = {};
    }
    domains[domain] = null;
-    await this.stateService.setNeverDomains(domains);
+    await this.domainSettingsService.setNeverDomains(domains);
  }

  async createWithServer(cipher: Cipher, orgAdmin?: boolean): Promise<any> {
--- a/libs/common/src/vault/services/fido2/fido2-client.service.spec.ts
+++ b/libs/common/src/vault/services/fido2/fido2-client.service.spec.ts
@@ -3,6 +3,7 @@ import { of } from "rxjs";

 import { AuthService } from "../../../auth/abstractions/auth.service";
 import { AuthenticationStatus } from "../../../auth/enums/authentication-status";
+import { DomainSettingsService } from "../../../autofill/services/domain-settings.service";
 import { ConfigServiceAbstraction } from "../../../platform/abstractions/config/config.service.abstraction";
 import { StateService } from "../../../platform/abstractions/state.service";
 import { Utils } from "../../../platform/misc/utils";
@@ -34,6 +35,7 @@ describe("FidoAuthenticatorService", () => {
  let authService!: MockProxy<AuthService>;
  let stateService!: MockProxy<StateService>;
  let vaultSettingsService: MockProxy<VaultSettingsService>;
+  let domainSettingsService: MockProxy<DomainSettingsService>;
  let client!: Fido2ClientService;
  let tab!: chrome.tabs.Tab;

@@ -43,6 +45,7 @@ describe("FidoAuthenticatorService", () => {
    authService = mock<AuthService>();
    stateService = mock<StateService>();
    vaultSettingsService = mock<VaultSettingsService>();
+    domainSettingsService = mock<DomainSettingsService>();

    client = new Fido2ClientService(
      authenticator,
@@ -50,9 +53,11 @@ describe("FidoAuthenticatorService", () => {
      authService,
      stateService,
      vaultSettingsService,
+      domainSettingsService,
    );
    configService.serverConfig$ = of({ environment: { vault: VaultUrl } } as any);
    vaultSettingsService.enablePasskeys$ = of(true);
+    domainSettingsService.neverDomains$ = of({});
    authService.getAuthStatus.mockResolvedValue(AuthenticationStatus.Unlocked);
    tab = { id: 123, windowId: 456 } as chrome.tabs.Tab;
  });
@@ -130,7 +135,7 @@ describe("FidoAuthenticatorService", () => {
          origin: "https://bitwarden.com",
          rp: { id: "bitwarden.com", name: "Bitwarden" },
        });
-        stateService.getNeverDomains.mockResolvedValue({ "bitwarden.com": null });
+        domainSettingsService.neverDomains$ = of({ "bitwarden.com": null });

        const result = async () => await client.createCredential(params, tab);

@@ -376,7 +381,8 @@ describe("FidoAuthenticatorService", () => {
        const params = createParams({
          origin: "https://bitwarden.com",
        });
-        stateService.getNeverDomains.mockResolvedValue({ "bitwarden.com": null });
+
+        domainSettingsService.neverDomains$ = of({ "bitwarden.com": null });

        const result = async () => await client.assertCredential(params, tab);

--- a/libs/common/src/vault/services/fido2/fido2-client.service.ts
+++ b/libs/common/src/vault/services/fido2/fido2-client.service.ts
@@ -3,6 +3,7 @@ import { parse } from "tldts";

 import { AuthService } from "../../../auth/abstractions/auth.service";
 import { AuthenticationStatus } from "../../../auth/enums/authentication-status";
+import { DomainSettingsService } from "../../../autofill/services/domain-settings.service";
 import { ConfigServiceAbstraction } from "../../../platform/abstractions/config/config.service.abstraction";
 import { LogService } from "../../../platform/abstractions/log.service";
 import { StateService } from "../../../platform/abstractions/state.service";
@@ -44,6 +45,7 @@ export class Fido2ClientService implements Fido2ClientServiceAbstraction {
    private authService: AuthService,
    private stateService: StateService,
    private vaultSettingsService: VaultSettingsService,
+    private domainSettingsService: DomainSettingsService,
    private logService?: LogService,
  ) {}

@@ -52,7 +54,8 @@ export class Fido2ClientService implements Fido2ClientServiceAbstraction {
    const isUserLoggedIn =
      (await this.authService.getAuthStatus()) !== AuthenticationStatus.LoggedOut;

-    const neverDomains = await this.stateService.getNeverDomains();
+    const neverDomains = await firstValueFrom(this.domainSettingsService.neverDomains$);
+
    const isExcludedDomain = neverDomains != null && hostname in neverDomains;

    const serverConfig = await firstValueFrom(this.configService.serverConfig$);
--- a/libs/common/src/vault/services/sync/sync.service.ts
+++ b/libs/common/src/vault/services/sync/sync.service.ts
@@ -1,5 +1,4 @@
 import { ApiService } from "../../../abstractions/api.service";
-import { SettingsService } from "../../../abstractions/settings.service";
 import { InternalOrganizationServiceAbstraction } from "../../../admin-console/abstractions/organization/organization.service.abstraction";
 import { InternalPolicyService } from "../../../admin-console/abstractions/policy/policy.service.abstraction";
 import { ProviderService } from "../../../admin-console/abstractions/provider.service";
@@ -10,6 +9,7 @@ import { ProviderData } from "../../../admin-console/models/data/provider.data";
 import { PolicyResponse } from "../../../admin-console/models/response/policy.response";
 import { KeyConnectorService } from "../../../auth/abstractions/key-connector.service";
 import { ForceSetPasswordReason } from "../../../auth/models/domain/force-set-password-reason";
+import { DomainSettingsService } from "../../../autofill/services/domain-settings.service";
 import { DomainsResponse } from "../../../models/response/domains.response";
 import {
  SyncCipherNotification,
@@ -44,7 +44,7 @@ export class SyncService implements SyncServiceAbstraction {

  constructor(
    private apiService: ApiService,
-    private settingsService: SettingsService,
+    private domainSettingsService: DomainSettingsService,
    private folderService: InternalFolderService,
    private cipherService: CipherService,
    private cryptoService: CryptoService,
@@ -457,7 +457,7 @@ export class SyncService implements SyncServiceAbstraction {
      });
    }

-    return this.settingsService.setEquivalentDomains(eqDomains);
+    return this.domainSettingsService.setEquivalentDomains(eqDomains);
  }

  private async syncPolicies(response: PolicyResponse[]) {