Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

Implement `SSO.Domains.lookup` and `SSO.Domains.add` (#5419)

Adrian Gruntkowski0b7bccd6a5c1
diff --git a/extra/lib/plausible/auth/sso/domain.ex b/extra/lib/plausible/auth/sso/domain.ex
index 7097b49f94..a3dcda00ce 100644
--- a/extra/lib/plausible/auth/sso/domain.ex
+++ b/extra/lib/plausible/auth/sso/domain.ex
@@ -15,12 +15,18 @@ defmodule Plausible.Auth.SSO.Domain do
import Ecto.Changeset
+ alias Plausible.Auth.SSO
+
+ @validation_methods [:dns_txt, :url, :meta_tag]
+
@type t() :: %__MODULE__{}
+ @type validation_method() :: unquote(Enum.reduce(@validation_methods, &{:|, [], [&1, &2]}))
+
schema "sso_domains" do
field :identifier, Ecto.UUID
field :domain, :string
- field :validated_via, Ecto.Enum, values: [:dns_txt, :url, :meta_tag]
+ field :validated_via, Ecto.Enum, values: @validation_methods
field :last_validated_at, :naive_datetime
field :status, Ecto.Enum, values: [:pending, :validated], default: :pending
@@ -29,9 +35,84 @@ defmodule Plausible.Auth.SSO.Domain do
timestamps()
end
- def create_changeset(name) do
+ @spec create_changeset(SSO.Integration.t(), String.t() | nil) :: Ecto.Changeset.t()
+ def create_changeset(integration, domain) do
%__MODULE__{}
- |> cast(%{name: name}, [:name])
- |> validate_required(:name)
+ |> cast(%{domain: domain}, [:domain])
+ |> validate_required(:domain)
+ |> normalize_domain(:domain)
+ |> validate_domain(:domain)
+ |> unique_constraint(:domain, message: "is already in use")
+ |> put_change(:identifier, Ecto.UUID.generate())
+ |> put_assoc(:sso_integration, integration)
+ end
+
+ @spec valid_changeset(t(), validation_method(), NaiveDateTime.t()) ::
+ Ecto.Changeset.t()
+ def valid_changeset(sso_domain, method, now) do
+ sso_domain
+ |> change()
+ |> put_change(:validated_via, method)
+ |> put_change(:last_validated_at, now)
+ |> put_change(:status, :validated)
+ end
+
+ @spec invalid_changeset(t(), NaiveDateTime.t()) :: Ecto.Changeset.t()
+ def invalid_changeset(sso_domain, now) do
+ sso_domain
+ |> change()
+ |> put_change(:validated_via, nil)
+ |> put_change(:last_validated_at, now)
+ |> put_change(:status, :pending)
+ end
+
+ @spec valid_domain?(String.t()) :: boolean()
+ def valid_domain?(domain) do
+ # This is not a surefire way to ensure the domain is correct,
+ # but it should give a bit more confidence that it's at least
+ # resolvable.
+ case URI.new("https://" <> domain) do
+ {:ok, %{host: host, port: port, path: nil, query: nil, fragment: nil, userinfo: nil}}
+ when is_binary(host) and port in [80, 443] ->
+ true
+
+ _ ->
+ false
+ end
+ end
+
+ defp normalize_domain(changeset, field) do
+ if domain = get_change(changeset, field) do
+ # We try to clear the usual copy-paste prefixes.
+ normalized =
+ domain
+ |> String.trim()
+ |> String.downcase()
+ |> String.split("://", parts: 2)
+ |> List.last()
+ |> String.trim("/")
+
+ case URI.new("https://" <> normalized) do
+ {:ok, %{host: host}} when is_binary(host) and host != "" ->
+ put_change(changeset, field, host)
+
+ _ ->
+ put_change(changeset, field, normalized)
+ end
+ else
+ changeset
+ end
+ end
+
+ defp validate_domain(changeset, field) do
+ if domain = get_change(changeset, field) do
+ if valid_domain?(domain) do
+ changeset
+ else
+ add_error(changeset, field, "invalid domain", validation: :domain)
+ end
+ else
+ changeset
+ end
end
end
diff --git a/extra/lib/plausible/auth/sso/domains.ex b/extra/lib/plausible/auth/sso/domains.ex
new file mode 100644
index 0000000000..4212ae8925
--- /dev/null
+++ b/extra/lib/plausible/auth/sso/domains.ex
@@ -0,0 +1,72 @@
+defmodule Plausible.Auth.SSO.Domains do
+ @moduledoc """
+ API for SSO domains.
+ """
+
+ import Ecto.Query
+
+ alias Plausible.Auth.SSO
+ alias Plausible.Repo
+
+ @spec add(SSO.Integration.t(), String.t()) ::
+ {:ok, SSO.Domain.t()} | {:error, Ecto.Changeset.t()}
+ def add(integration, domain) do
+ changeset = SSO.Domain.create_changeset(integration, domain)
+
+ Repo.insert(changeset)
+ end
+
+ @spec verify(SSO.Domain.t(), Keyword.t()) :: SSO.Domain.t()
+ def verify(sso_domain, opts \\ []) do
+ skip_checks? = Keyword.get(opts, :skip_checks?, false)
+ now = Keyword.get(opts, :now, NaiveDateTime.utc_now(:second))
+
+ if skip_checks? do
+ mark_valid(sso_domain, :dns_txt, now)
+ else
+ mark_invalid(sso_domain, now)
+ end
+ end
+
+ @spec lookup(String.t()) :: {:ok, SSO.Domain.t()} | {:error, :not_found}
+ def lookup(domain_or_email) when is_binary(domain_or_email) do
+ search = normalize_lookup(domain_or_email)
+
+ result =
+ from(
+ d in SSO.Domain,
+ inner_join: i in assoc(d, :sso_integration),
+ inner_join: t in assoc(i, :team),
+ where: d.domain == ^search,
+ where: d.status == :validated,
+ preload: [sso_integration: {i, team: t}]
+ )
+ |> Repo.one()
+
+ if result do
+ {:ok, result}
+ else
+ {:error, :not_found}
+ end
+ end
+
+ defp normalize_lookup(domain_or_email) do
+ domain_or_email
+ |> String.split("@", parts: 2)
+ |> List.last()
+ |> String.trim()
+ |> String.downcase()
+ end
+
+ defp mark_valid(sso_domain, method, now) do
+ sso_domain
+ |> SSO.Domain.valid_changeset(method, now)
+ |> Repo.update!()
+ end
+
+ defp mark_invalid(sso_domain, now) do
+ sso_domain
+ |> SSO.Domain.invalid_changeset(now)
+ |> Repo.update!()
+ end
+end
diff --git a/test/plausible/auth/sso/domains_test.exs b/test/plausible/auth/sso/domains_test.exs
new file mode 100644
index 0000000000..a766f282ba
--- /dev/null
+++ b/test/plausible/auth/sso/domains_test.exs
@@ -0,0 +1,182 @@
+defmodule Plausible.Auth.SSO.DomainsTest do
+ use Plausible.DataCase, async: true
+ use Plausible
+
+ on_ee do
+ use Plausible.Teams.Test
+
+ alias Plausible.Auth.SSO
+ alias Plausible.Teams
+
+ setup do
+ team = new_site().team
+
+ integration = SSO.initiate_saml_integration(team)
+
+ {:ok, team: team, integration: integration}
+ end
+
+ describe "add/2" do
+ test "adds a new domain", %{integration: integration} do
+ domain = generate_domain()
+
+ assert {:ok, sso_domain} = SSO.Domains.add(integration, domain)
+
+ assert sso_domain.domain == domain
+ assert is_binary(sso_domain.identifier)
+ refute sso_domain.validated_via
+ refute sso_domain.last_validated_at
+ assert sso_domain.status == :pending
+ end
+
+ test "normalizes domain before adding", %{integration: integration} do
+ domain = generate_domain()
+
+ inputs = [
+ " " <> String.upcase(domain) <> " ",
+ "https://" <> domain,
+ "http://" <> domain,
+ "http://" <> domain <> "/",
+ "//" <> domain,
+ "//" <> domain <> ":1234",
+ "https://" <> domain <> ":443",
+ "ftp://" <> domain,
+ domain <> "/path",
+ "https://" <> domain <> "?query=string",
+ "https://" <> domain <> "#fragment",
+ "https://user:info@" <> domain
+ ]
+
+ for input <- inputs do
+ assert {:ok, sso_domain} = SSO.Domains.add(integration, input)
+ assert sso_domain.domain == domain
+ Repo.delete!(sso_domain)
+ end
+ end
+
+ test "rejects empty domain", %{integration: integration} do
+ assert {:error, changeset} = SSO.Domains.add(integration, " ")
+
+ assert %{domain: [:required]} =
+ Ecto.Changeset.traverse_errors(changeset, fn {_msg, opts} ->
+ opts[:validation]
+ end)
+ end
+
+ test "rejects invalid domain", %{integration: integration} do
+ assert {:error, _changeset} = SSO.Domains.add(integration, "invalid domain")
+ assert {:error, _changeset} = SSO.Domains.add(integration, "invalid domain.com")
+ end
+
+ test "rejects already added domain", %{integration: integration} do
+ domain = generate_domain()
+ {:ok, _} = SSO.Domains.add(integration, domain)
+
+ assert {:error, changeset} = SSO.Domains.add(integration, domain)
+
+ assert %{domain: [:unique]} =
+ Ecto.Changeset.traverse_errors(changeset, fn {_msg, opts} ->
+ opts[:constraint]
+ end)
+ end
+
+ test "rejects domain which is already added in another team", %{integration: integration} do
+ domain = generate_domain()
+ {:ok, _} = SSO.Domains.add(integration, domain)
+
+ other_team = new_site().team
+ other_integration = SSO.initiate_saml_integration(other_team)
+
+ assert {:error, changeset} = SSO.Domains.add(other_integration, domain)
+
+ assert %{domain: [:unique]} =
+ Ecto.Changeset.traverse_errors(changeset, fn {_msg, opts} ->
+ opts[:constraint]
+ end)
+ end
+ end
+
+ describe "verify/2" do
+ test "marks domain as validated when skip_checks? option passed", %{
+ integration: integration
+ } do
+ domain = generate_domain()
+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)
+
+ valid_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)
+
+ assert valid_domain.id == sso_domain.id
+ assert valid_domain.validated_via == :dns_txt
+ assert valid_domain.status == :validated
+ assert valid_domain.last_validated_at
+ end
+
+ test "does not mark domain as validated when no skip flag passed", %{
+ integration: integration
+ } do
+ domain = generate_domain()
+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)
+
+ invalid_domain = SSO.Domains.verify(sso_domain)
+
+ assert invalid_domain.id == sso_domain.id
+ refute invalid_domain.validated_via
+ assert invalid_domain.status == :pending
+ assert invalid_domain.last_validated_at
+ end
+ end
+
+ describe "lookup/1" do
+ test "looks up domain by email", %{integration: integration} do
+ domain = generate_domain()
+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)
+ sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)
+
+ email = "mary.jane@" <> domain
+
+ assert {:ok, found_sso_domain} = SSO.Domains.lookup(email)
+
+ assert found_sso_domain.id == sso_domain.id
+ assert %SSO.Integration{} = found_sso_domain.sso_integration
+ assert %Teams.Team{} = found_sso_domain.sso_integration.team
+ end
+
+ test "looks up domain by plain domain", %{integration: integration} do
+ domain = generate_domain()
+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)
+ sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)
+
+ assert {:ok, found_sso_domain} = SSO.Domains.lookup(domain)
+ assert found_sso_domain.id == sso_domain.id
+ end
+
+ test "normalizes input removing whitespace and capitalizations", %{integration: integration} do
+ domain = generate_domain()
+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)
+ sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)
+
+ email = " maRy.jAnE@" <> String.upcase(domain) <> " "
+
+ assert {:ok, found_sso_domain} = SSO.Domains.lookup(email)
+ assert found_sso_domain.id == sso_domain.id
+ end
+
+ test "returns error if matching domain is not validated", %{integration: integration} do
+ domain = generate_domain()
+ {:ok, _sso_domain} = SSO.Domains.add(integration, domain)
+
+ assert {:error, :not_found} = SSO.Domains.lookup(domain)
+ end
+
+ test "returns error if domain not found" do
+ domain = generate_domain()
+
+ assert {:error, :not_found} = SSO.Domains.lookup(domain)
+ end
+ end
+
+ defp generate_domain() do
+ "example-#{Enum.random(1..10_000)}.com"
+ end
+ end
+end