Skip to content

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

Implement `SSO.provision_user/1` and extend `UserAuth.log_in_user/3` (#5424)

Adrian Gruntkowski4ffdfe3f6917
diff --git a/extra/lib/plausible/auth/sso.ex b/extra/lib/plausible/auth/sso.ex
index 4b76ab1c96..ea48a6ab5c 100644
--- a/extra/lib/plausible/auth/sso.ex
+++ b/extra/lib/plausible/auth/sso.ex
@@ -3,6 +3,10 @@ defmodule Plausible.Auth.SSO do
API for SSO.
"""
+ import Ecto.Changeset
+ import Ecto.Query
+
+ alias Plausible.Auth
alias Plausible.Auth.SSO
alias Plausible.Repo
alias Plausible.Teams
@@ -12,7 +16,7 @@ defmodule Plausible.Auth.SSO do
changeset = SSO.Integration.init_changeset(team)
Repo.insert!(changeset,
- on_conflict: [set: [updated_at: NaiveDateTime.utc_now()]],
+ on_conflict: [set: [updated_at: NaiveDateTime.utc_now(:second)]],
conflict_target: :team_id,
returning: true
)
@@ -28,4 +32,163 @@ defmodule Plausible.Auth.SSO do
{:error, changeset} -> {:error, changeset.changes.config}
end
end
+
+ @spec provision_user(SSO.Identity.t()) ::
+ {:ok, :standard | :sso | :integration, Auth.User.t()}
+ | {:error, :integration_not_found}
+ | {:error, :multiple_memberships, Teams.Team.t(), Auth.User.t()}
+ def provision_user(identity) do
+ case find_user(identity) do
+ {:ok, :standard, user, integration} ->
+ provision_standard_user(user, identity, integration)
+
+ {:ok, :sso, user, _integration} ->
+ provision_sso_user(user, identity)
+
+ {:ok, :integration, integration} ->
+ provision_identity(identity, integration)
+
+ {:error, :not_found} ->
+ {:error, :integration_not_found}
+ end
+ end
+
+ defp find_user(identity) do
+ case find_user_with_fallback(identity) do
+ {:ok, type, user, integration} ->
+ {:ok, type, Repo.preload(user, :sso_integration), integration}
+
+ error ->
+ error
+ end
+ end
+
+ defp find_user_with_fallback(identity) do
+ with {:error, :not_found} <- find_by_identity(identity.id) do
+ find_by_email(identity.email)
+ end
+ end
+
+ defp find_by_identity(id) do
+ if user = Repo.get_by(Auth.User, sso_identity_id: id) do
+ user = Repo.preload(user, :sso_integration)
+
+ {:ok, user.type, user, user.sso_integration}
+ else
+ {:error, :not_found}
+ end
+ end
+
+ defp find_by_email(email) do
+ with {:ok, sso_domain} <- SSO.Domains.lookup(email) do
+ case find_by_email(sso_domain.sso_integration.team, email) do
+ {:ok, user} ->
+ {:ok, user.type, user, sso_domain.sso_integration}
+
+ {:error, :not_found} ->
+ {:ok, :integration, sso_domain.sso_integration}
+ end
+ end
+ end
+
+ defp find_by_email(team, email) do
+ result =
+ Repo.one(
+ from(
+ u in Auth.User,
+ inner_join: tm in assoc(u, :team_memberships),
+ where: u.email == ^email,
+ where: tm.team_id == ^team.id,
+ where: tm.role != :guest
+ )
+ )
+
+ if result do
+ {:ok, result}
+ else
+ {:error, :not_found}
+ end
+ end
+
+ defp provision_sso_user(user, identity) do
+ changeset =
+ user
+ |> change()
+ |> put_change(:email, identity.email)
+ |> put_change(:name, identity.name)
+ |> put_change(:sso_identity_id, identity.id)
+ |> put_change(:last_sso_login, NaiveDateTime.utc_now(:second))
+
+ with {:ok, user} <- Repo.update(changeset) do
+ {:ok, :sso, user}
+ end
+ end
+
+ defp provision_standard_user(user, identity, integration) do
+ changeset =
+ user
+ |> change()
+ |> put_change(:type, :sso)
+ |> put_change(:name, identity.name)
+ |> put_change(:sso_identity_id, identity.id)
+ |> put_change(:last_sso_login, NaiveDateTime.utc_now(:second))
+ |> put_assoc(:sso_integration, integration)
+
+ with :ok <- ensure_team_member(integration.team, user),
+ :ok <- ensure_one_membership(user, integration.team),
+ {:ok, user} <- Repo.update(changeset) do
+ {:ok, :standard, user}
+ end
+ end
+
+ defp provision_identity(identity, integration) do
+ random_password =
+ 64
+ |> :crypto.strong_rand_bytes()
+ |> Base.encode64(padding: false)
+
+ params = %{
+ email: identity.email,
+ name: identity.name,
+ password: random_password,
+ password_confirmation: random_password
+ }
+
+ changeset =
+ Auth.User.new(params)
+ |> put_change(:email_verified, true)
+ |> put_change(:type, :sso)
+ |> put_change(:sso_identity_id, identity.id)
+ |> put_change(:last_sso_login, NaiveDateTime.utc_now(:second))
+ |> put_assoc(:sso_integration, integration)
+
+ case Repo.insert(changeset) do
+ {:ok, user} ->
+ {:ok, :identity, user}
+
+ {:error, %{errors: [email: {_, attrs}]}} ->
+ true = {:constraint, :unique} in attrs
+ {:error, :integration_not_found}
+ end
+ end
+
+ defp ensure_team_member(team, user) do
+ case Teams.Memberships.team_role(team, user) do
+ {:ok, role} when role != :guest ->
+ :ok
+
+ _ ->
+ {:error, :integration_not_found}
+ end
+ end
+
+ defp ensure_one_membership(user, team) do
+ query = Teams.Users.teams_query(user)
+
+ if Repo.aggregate(query, :count) > 1 do
+ {:error, :multiple_memberships, team, user}
+ else
+ :ok
+ end
+ end
end
diff --git a/extra/lib/plausible/auth/sso/identity.ex b/extra/lib/plausible/auth/sso/identity.ex
new file mode 100644
index 0000000000..62c302d8c6
--- /dev/null
+++ b/extra/lib/plausible/auth/sso/identity.ex
@@ -0,0 +1,10 @@
+defmodule Plausible.Auth.SSO.Identity do
+ @moduledoc """
+ SSO Identity struct.
+ """
+
+ @type t() :: %__MODULE__{}
+
+ @enforce_keys [:id, :name, :email, :expires_at]
+ defstruct [:id, :name, :email, :expires_at]
+end
diff --git a/lib/plausible_web/user_auth.ex b/lib/plausible_web/user_auth.ex
index 758b4e234f..bdc1b8ee32 100644
--- a/lib/plausible_web/user_auth.ex
+++ b/lib/plausible_web/user_auth.ex
@@ -3,6 +3,8 @@ defmodule PlausibleWeb.UserAuth do
Functions for user session management.
"""
+ use Plausible
+
import Ecto.Query
alias Plausible.Auth
@@ -13,8 +15,17 @@ defmodule PlausibleWeb.UserAuth do
require Logger
- @spec log_in_user(Plug.Conn.t(), Auth.User.t(), String.t() | nil) :: Plug.Conn.t()
- def log_in_user(conn, user, redirect_path \\ nil) do
+ on_ee do
+ @type login_subject() :: Auth.User.t() | Auth.SSO.Identity.t()
+ else
+ @type login_subject() :: Auth.User.t()
+ end
+
+ @spec log_in_user(Plug.Conn.t(), login_subject(), String.t() | nil) ::
+ Plug.Conn.t()
+ def log_in_user(conn, subject, redirect_path \\ nil)
+
+ def log_in_user(conn, %Auth.User{} = user, redirect_path) do
redirect_to =
if String.starts_with?(redirect_path || "", "/") do
redirect_path
@@ -28,6 +39,29 @@ defmodule PlausibleWeb.UserAuth do
|> Phoenix.Controller.redirect(to: redirect_to)
end
+ on_ee do
+ def log_in_user(conn, %Auth.SSO.Identity{} = identity, redirect_path) do
+ case Auth.SSO.provision_user(identity) do
+ {:ok, provisioning_from, user} ->
+ if provisioning_from == :standard do
+ :ok = revoke_all_user_sessions(user)
+ end
+
+ log_in_user(conn, user, redirect_path)
+
+ {:error, :integration_not_found} ->
+ conn
+ |> log_out_user()
+ |> Phoenix.Controller.redirect(to: "/")
+
+ {:error, :multiple_memberships, team, user} ->
+ redirect_path = Routes.site_path(conn, :index, __team: team.identifier)
+
+ log_in_user(conn, user, redirect_path)
+ end
+ end
+ end
+
@spec log_out_user(Plug.Conn.t()) :: Plug.Conn.t()
def log_out_user(conn) do
case get_user_token(conn) do
diff --git a/test/plausible/auth/sso_test.exs b/test/plausible/auth/sso_test.exs
index c0f087942b..5d7912a0bc 100644
--- a/test/plausible/auth/sso_test.exs
+++ b/test/plausible/auth/sso_test.exs
@@ -162,5 +162,134 @@ defmodule Plausible.Auth.SSOTest do
end)
end
end
+
+ describe "provision_user/1" do
+ setup do
+ team = new_site().team
+ integration = SSO.initiate_saml_integration(team)
+ domain = "example-#{Enum.random(1..10_000)}.com"
+
+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)
+ sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)
+
+ {:ok, team: team, integration: integration, domain: domain, sso_domain: sso_domain}
+ end
+
+ test "provisions a new SSO user form identity", %{integration: integration, domain: domain} do
+ identity = new_identity("Jane Sculley", "jane@" <> domain)
+
+ assert {:ok, :identity, user} = SSO.provision_user(identity)
+
+ assert user.id
+ assert user.email == identity.email
+ assert user.type == :sso
+ assert user.name == identity.name
+ assert user.sso_identity_id == identity.id
+ assert user.sso_integration_id == integration.id
+ assert user.email_verified
+ assert user.last_sso_login
+ end
+
+ test "provisions SSO user from existing user", %{
+ integration: integration,
+ team: team,
+ domain: domain
+ } do
+ user = new_user(email: "jane@" <> domain, name: "Jane Sculley")
+ add_member(team, user: user, role: :editor)
+
+ # guest membership on a site on another team should not affect provisioning
+ another_team_site = new_site()
+ add_guest(another_team_site, user: user, role: :editor)
+
+ identity = new_identity(user.name, user.email)
+
+ assert {:ok, :standard, sso_user} = SSO.provision_user(identity)
+
+ assert sso_user.id == user.id
+ assert sso_user.email == identity.email
+ assert sso_user.type == :sso
+ assert sso_user.name == identity.name
+ assert sso_user.sso_identity_id == identity.id
+ assert sso_user.sso_integration_id == integration.id
+ assert sso_user.email_verified
+ assert sso_user.last_sso_login
+ end
+
+ test "provisions existing SSO user", %{integration: integration, team: team, domain: domain} do
+ user = new_user(email: "jane@" <> domain, name: "Jane Sculley")
+ add_member(team, user: user, role: :editor)
+ identity = new_identity(user.name, user.email)
+ {:ok, :standard, user} = SSO.provision_user(identity)
+
+ assert {:ok, :sso, sso_user} = SSO.provision_user(identity)
+
+ assert sso_user.id == user.id
+ assert sso_user.email == identity.email
+ assert sso_user.type == :sso
+ assert sso_user.name == identity.name
+ assert sso_user.sso_identity_id == identity.id
+ assert sso_user.sso_integration_id == integration.id
+ assert sso_user.last_sso_login
+ end
+
+ test "does not provision user without matching setup integration", %{team: team} do
+ # rogue e-mail
+ identity = new_identity("Rodney Williams", "[email protected]")
+
+ assert {:error, :integration_not_found} = SSO.provision_user(identity)
+
+ # member without setup domain
+ user = new_user(email: "[email protected]", name: "Jane Sculley")
+ add_member(team, user: user, role: :editor)
+ identity = new_identity(user.name, user.email)
+
+ assert {:error, :integration_not_found} = SSO.provision_user(identity)
+ end
+
+ test "does not provision non-member even if e-mail matches domain", %{domain: domain} do
+ user = new_user(email: "jane@" <> domain, name: "Jane Sculley")
+ another_team = new_site().team
+ add_member(another_team, user: user, role: :editor)
+ identity = new_identity(user.name, user.email)
+
+ assert {:error, :integration_not_found} = SSO.provision_user(identity)
+ end
+
+ test "does not provision guest member", %{team: team, domain: domain} do
+ user = new_user(email: "jane@" <> domain, name: "Jane Sculley")
+ site = new_site(team: team)
+ add_guest(site, user: user, role: :editor)
+ identity = new_identity(user.name, user.email)
+
+ assert {:error, :integration_not_found} = SSO.provision_user(identity)
+ end
+
+ test "does not provision when user is member of more than one team", %{
+ domain: domain,
+ team: team
+ } do
+ user = new_user(email: "jane@" <> domain, name: "Jane Sculley")
+ add_member(team, user: user, role: :editor)
+ another_team = new_site().team
+ add_member(another_team, user: user, role: :viewer)
+ identity = new_identity(user.name, user.email)
+
+ assert {:error, :multiple_memberships, matched_team, matched_user} =
+ SSO.provision_user(identity)
+
+ assert matched_team.id == team.id
+ assert matched_user.id == user.id
+ end
+ end
+
+ defp new_identity(name, email, id \\ Ecto.UUID.generate()) do
+ %SSO.Identity{
+ id: id,
+ name: name,
+ email: email,
+ expires_at: NaiveDateTime.add(NaiveDateTime.utc_now(:second), 6, :hour)
+ }
+ end
end
end
diff --git a/test/plausible_web/user_auth_test.exs b/test/plausible_web/user_auth_test.exs
index ddbf3cf600..a4c5c67607 100644
--- a/test/plausible_web/user_auth_test.exs
+++ b/test/plausible_web/user_auth_test.exs
@@ -1,5 +1,7 @@
defmodule PlausibleWeb.UserAuthTest do
use PlausibleWeb.ConnCase, async: true
+ use Plausible
+ use Plausible.Teams.Test
import Ecto.Query, only: [from: 2]
import Phoenix.ChannelTest
@@ -40,6 +42,88 @@ defmodule PlausibleWeb.UserAuthTest do
assert redirected_to(conn, 302) == "/next"
end
+
+ on_ee do
+ alias Plausible.Auth.SSO
+
+ test "sets up user session from SSO identity", %{conn: conn, user: user} do
+ team = new_site().team
+ integration = SSO.initiate_saml_integration(team)
+ domain = "example-#{Enum.random(1..10_000)}.com"
+ user = user |> Ecto.Changeset.change(email: "jane@" <> domain) |> Repo.update!()
+ add_member(team, user: user, role: :editor)
+
+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)
+ _sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)
+
+ identity = new_identity(user.name, user.email)
+
+ conn =
+ conn
+ |> init_session()
+ |> UserAuth.log_in_user(identity)
+
+ assert %{sessions: [session]} = user |> Repo.reload!() |> Repo.preload(:sessions)
+ assert session.user_id == user.id
+
+ assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
+ assert conn.private[:plug_session_info] == :renew
+ assert conn.resp_cookies["logged_in"].max_age > 0
+ assert get_session(conn, :user_token) == session.token
+ end
+
+ test "tries to log out and redirects if SSO identity is not matched", %{
+ conn: conn,
+ user: user
+ } do
+ identity = new_identity("Willy Wonka", "[email protected]")
+
+ conn =
+ conn
+ |> init_session()
+ |> UserAuth.log_in_user(identity)
+
+ assert %{sessions: []} = user |> Repo.reload!() |> Repo.preload(:sessions)
+ assert redirected_to(conn, 302) == "/"
+ assert conn.private[:plug_session_info] == :renew
+ refute get_session(conn, :user_token)
+ end
+
+ test "passes through for user matching SSO identity, redirecting to team", %{
+ conn: conn,
+ user: user
+ } do
+ team = new_site().team
+ integration = SSO.initiate_saml_integration(team)
+ domain = "example-#{Enum.random(1..10_000)}.com"
+ user = user |> Ecto.Changeset.change(email: "jane@" <> domain) |> Repo.update!()
+ add_member(team, user: user, role: :editor)
+ another_team = new_site().team
+ add_member(another_team, user: user, role: :viewer)
+
+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)
+ _sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)
+
+ identity = new_identity(user.name, user.email)
+
+ conn =
+ conn
+ |> init_session()
+ |> UserAuth.log_in_user(identity)
+
+ assert redirected_to(conn, 302) == Routes.site_path(conn, :index, __team: team.identifier)
+ assert get_session(conn, :user_token)
+ end
+
+ defp new_identity(name, email, id \\ Ecto.UUID.generate()) do
+ %SSO.Identity{
+ id: id,
+ name: name,
+ email: email,
+ expires_at: NaiveDateTime.add(NaiveDateTime.utc_now(:second), 6, :hour)
+ }
+ end
+ end
end
describe "log_out_user/1" do