[PM-1426] Refactor uri matching (#5003)

* Move URI matching logic into uriView

* Fix url parsing: always assign default protocol, otherwise no protocol with port is parsed incorrectly

* Codescene: refactor domain matching logic

libs/common/src/vault/models/view/login-uri-view.spec.ts

@@ -1,4 +1,5 @@
 import { UriMatchType } from "../../../enums";
+import { Utils } from "../../../misc/utils";
 
 import { LoginUriView } from "./login-uri.view";
 
@@ -25,6 +26,18 @@ const testData = [
   },
 ];
 
+const exampleUris = {
+  standard: "https://www.exampleapp.com.au:4000/userauth/login.html",
+  standardRegex: "https://www.exampleapp.com.au:[0-9]*/[A-Za-z]+/login.html",
+  standardNotMatching: "https://www.exampleapp.com.au:4000/userauth123/login.html",
+  subdomain: "https://www.auth.exampleapp.com.au",
+  differentDomain: "https://www.exampleapp.co.uk/subpage",
+  differentHost: "https://www.exampleapp.com.au/userauth/login.html",
+  equivalentDomains: () =>
+    new Set(["exampleapp.com.au", "exampleapp.com", "exampleapp.co.uk", "example.com"]),
+  noEquivalentDomains: () => new Set<string>(),
+};
+
 describe("LoginUriView", () => {
   it("isWebsite() given an invalid domain should return false", async () => {
     const uri = new LoginUriView();
@@ -63,4 +76,119 @@ describe("LoginUriView", () => {
     Object.assign(uri, { match: UriMatchType.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 actual = uri.matchesUri(exampleUris.subdomain, exampleUris.noEquivalentDomains());
+        expect(actual).toBe(true);
+      });
+
+      it("matches equivalent domains", () => {
+        const uri = uriFactory(UriMatchType.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 actual = uri.matchesUri(
+          exampleUris.differentDomain,
+          exampleUris.noEquivalentDomains()
+        );
+        expect(actual).toBe(false);
+      });
+
+      // 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 actual = uri.matchesUri("script.google.com", googleEquivalentDomains);
+
+        expect(actual).toBe(false);
+      });
+    });
+
+    describe("using host matching", () => {
+      it("matches the same host", () => {
+        const uri = uriFactory(UriMatchType.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 actual = uri.matchesUri(exampleUris.standard, exampleUris.noEquivalentDomains());
+        expect(actual).toBe(false);
+      });
+    });
+
+    describe("using exact matching", () => {
+      it("matches if both uris are the same", () => {
+        const uri = uriFactory(UriMatchType.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 actual = uri.matchesUri(
+          exampleUris.standard + "#",
+          exampleUris.noEquivalentDomains()
+        );
+        expect(actual).toBe(false);
+      });
+    });
+
+    describe("using startsWith matching", () => {
+      it("matches if the target URI starts with the saved URI", () => {
+        const uri = uriFactory(UriMatchType.StartsWith, exampleUris.standard);
+        const actual = uri.matchesUri(
+          exampleUris.standard + "#bookmark",
+          exampleUris.noEquivalentDomains()
+        );
+        expect(actual).toBe(true);
+      });
+
+      it("does not match if the start of the uri is not the same", () => {
+        const uri = uriFactory(UriMatchType.StartsWith, exampleUris.standard);
+        const actual = uri.matchesUri(
+          exampleUris.standard.slice(1),
+          exampleUris.noEquivalentDomains()
+        );
+        expect(actual).toBe(false);
+      });
+    });
+
+    describe("using regular expression matching", () => {
+      it("matches if the regular expression matches", () => {
+        const uri = uriFactory(UriMatchType.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 actual = uri.matchesUri(exampleUris.standardRegex, exampleUris.noEquivalentDomains());
+        expect(actual).toBe(false);
+      });
+    });
+
+    describe("using never matching", () => {
+      it("does not match even if uris are identical", () => {
+        const uri = uriFactory(UriMatchType.Never, exampleUris.standard);
+        const actual = uri.matchesUri(exampleUris.standard, exampleUris.noEquivalentDomains());
+        expect(actual).toBe(false);
+      });
+    });
+  });
 });
+
+function uriFactory(match: UriMatchType, uri: string) {
+  const loginUri = new LoginUriView();
+  loginUri.match = match;
+  loginUri.uri = uri;
+  return loginUri;
+}

libs/common/src/vault/models/view/login-uri.view.ts

@@ -129,4 +129,60 @@ export class LoginUriView implements View {
   static fromJSON(obj: Partial<Jsonify<LoginUriView>>): LoginUriView {
     return Object.assign(new LoginUriView(), obj);
   }
+
+  matchesUri(
+    targetUri: string,
+    equivalentDomains: Set<string>,
+    defaultUriMatch: UriMatchType = null
+  ): boolean {
+    if (!this.uri || !targetUri) {
+      return false;
+    }
+
+    let matchType = this.match ?? defaultUriMatch;
+    matchType ??= UriMatchType.Domain;
+
+    const targetDomain = Utils.getDomain(targetUri);
+    const matchDomains = equivalentDomains.add(targetDomain);
+
+    switch (matchType) {
+      case UriMatchType.Domain:
+        return this.matchesDomain(targetUri, matchDomains);
+      case UriMatchType.Host: {
+        const urlHost = Utils.getHost(targetUri);
+        return urlHost != null && urlHost === Utils.getHost(this.uri);
+      }
+      case UriMatchType.Exact:
+        return targetUri === this.uri;
+      case UriMatchType.StartsWith:
+        return targetUri.startsWith(this.uri);
+      case UriMatchType.RegularExpression:
+        try {
+          const regex = new RegExp(this.uri, "i");
+          return regex.test(targetUri);
+        } catch (e) {
+          // Invalid regex
+          return false;
+        }
+      case UriMatchType.Never:
+        return false;
+      default:
+        break;
+    }
+
+    return false;
+  }
+
+  private matchesDomain(targetUri: string, matchDomains: Set<string>) {
+    if (targetUri == null || this.domain == null || !matchDomains.has(this.domain)) {
+      return false;
+    }
+
+    if (Utils.DomainMatchBlacklist.has(this.domain)) {
+      const domainUrlHost = Utils.getHost(targetUri);
+      return !Utils.DomainMatchBlacklist.get(this.domain).has(domainUrlHost);
+    }
+
+    return true;
+  }
 }

libs/common/src/vault/models/view/login.view.ts

@@ -1,6 +1,6 @@
 import { Jsonify } from "type-fest";
 
-import { LoginLinkedId as LinkedId } from "../../../enums";
+import { LoginLinkedId as LinkedId, UriMatchType } from "../../../enums";
 import { linkedFieldOption } from "../../../misc/linkedFieldOption.decorator";
 import { Utils } from "../../../misc/utils";
 import { Login } from "../domain/login";
@@ -63,6 +63,18 @@ export class LoginView extends ItemView {
     return this.uris != null && this.uris.length > 0;
   }
 
+  matchesUri(
+    targetUri: string,
+    equivalentDomains: Set<string>,
+    defaultUriMatch: UriMatchType = null
+  ): boolean {
+    if (this.uris == null) {
+      return false;
+    }
+
+    return this.uris.some((uri) => uri.matchesUri(targetUri, equivalentDomains, defaultUriMatch));
+  }
+
   static fromJSON(obj: Partial<Jsonify<LoginView>>): LoginView {
     const passwordRevisionDate =
       obj.passwordRevisionDate == null ? null : new Date(obj.passwordRevisionDate);