Skip to content

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

Implement SSO login against fake SAML endpoints (#5434)

Adrian Gruntkowskibca78169bb02
diff --git a/config/.env.dev b/config/.env.dev
index cb957fe126..87cfab1031 100644
--- a/config/.env.dev
+++ b/config/.env.dev
@@ -14,6 +14,7 @@ ADMIN_USER_IDS=1
SHOW_CITIES=true
PADDLE_VENDOR_AUTH_CODE=895e20d4efaec0575bb857f44b183217b332d9592e76e69b8a
PADDLE_VENDOR_ID=3942
+SSO_ENABLED=true
GOOGLE_CLIENT_ID=875387135161-l8tp53dpt7fdhdg9m1pc3vl42si95rh0.apps.googleusercontent.com
GOOGLE_CLIENT_SECRET=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
diff --git a/config/.env.load b/config/.env.load
index cb957fe126..87cfab1031 100644
--- a/config/.env.load
+++ b/config/.env.load
@@ -14,6 +14,7 @@ ADMIN_USER_IDS=1
SHOW_CITIES=true
PADDLE_VENDOR_AUTH_CODE=895e20d4efaec0575bb857f44b183217b332d9592e76e69b8a
PADDLE_VENDOR_ID=3942
+SSO_ENABLED=true
GOOGLE_CLIENT_ID=875387135161-l8tp53dpt7fdhdg9m1pc3vl42si95rh0.apps.googleusercontent.com
GOOGLE_CLIENT_SECRET=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
diff --git a/config/.env.test b/config/.env.test
index 42a1e85526..a4b073b64b 100644
--- a/config/.env.test
+++ b/config/.env.test
@@ -19,6 +19,7 @@ HELP_SCOUT_APP_ID=fake_app_id
HELP_SCOUT_APP_SECRET=fake_app_secret
HELP_SCOUT_SIGNATURE_KEY=fake_signature_key
HELP_SCOUT_VAULT_KEY=ym9ZQg0KPNGCH3C2eD5y6KpL0tFzUqAhwxQO6uEv/ZM=
+SSO_ENABLED=true
S3_DISABLED=false
S3_ACCESS_KEY_ID=minioadmin
diff --git a/config/runtime.exs b/config/runtime.exs
index ea8d8f3d0a..4054cf00e9 100644
--- a/config/runtime.exs
+++ b/config/runtime.exs
@@ -304,6 +304,8 @@ secure_cookie =
license_key = get_var_from_path_or_env(config_dir, "LICENSE_KEY", "")
+sso_enabled = get_bool_from_path_or_env(config_dir, "SSO_ENABLED", false)
+
config :plausible,
environment: env,
mailer_email: mailer_email,
@@ -313,7 +315,8 @@ config :plausible,
log_failed_login_attempts: log_failed_login_attempts,
license_key: license_key,
data_dir: data_dir,
- session_transfer_dir: session_transfer_dir
+ session_transfer_dir: session_transfer_dir,
+ sso_enabled: sso_enabled
config :plausible, :selfhost,
enable_email_verification: enable_email_verification,
diff --git a/extra/lib/plausible/auth/sso.ex b/extra/lib/plausible/auth/sso.ex
index ea48a6ab5c..1e4e88ab56 100644
--- a/extra/lib/plausible/auth/sso.ex
+++ b/extra/lib/plausible/auth/sso.ex
@@ -11,6 +11,22 @@ defmodule Plausible.Auth.SSO do
alias Plausible.Repo
alias Plausible.Teams
+ @spec get_integration(String.t()) :: {:ok, SSO.Integration.t()} | {:error, :not_found}
+ def get_integration(identifier) when is_binary(identifier) do
+ query =
+ from(i in SSO.Integration,
+ inner_join: t in assoc(i, :team),
+ where: i.identifier == ^identifier,
+ preload: [team: t]
+ )
+
+ if integration = Repo.one(query) do
+ {:ok, integration}
+ else
+ {:error, :not_found}
+ end
+ end
+
@spec initiate_saml_integration(Teams.Team.t()) :: SSO.Integration.t()
def initiate_saml_integration(team) do
changeset = SSO.Integration.init_changeset(team)
@@ -34,16 +50,16 @@ defmodule Plausible.Auth.SSO do
end
@spec provision_user(SSO.Identity.t()) ::
- {:ok, :standard | :sso | :integration, Auth.User.t()}
- | {:error, :integration_not_found}
+ {:ok, :standard | :sso | :integration, Teams.Team.t(), Auth.User.t()}
+ | {:error, :integration_not_found | :over_limit}
| {: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, :sso, user, integration} ->
+ provision_sso_user(user, identity, integration)
{:ok, :integration, integration} ->
provision_identity(identity, integration)
@@ -71,7 +87,7 @@ defmodule Plausible.Auth.SSO do
defp find_by_identity(id) do
if user = Repo.get_by(Auth.User, sso_identity_id: id) do
- user = Repo.preload(user, :sso_integration)
+ user = Repo.preload(user, sso_integration: :team)
{:ok, user.type, user, user.sso_integration}
else
@@ -110,7 +126,7 @@ defmodule Plausible.Auth.SSO do
end
end
- defp provision_sso_user(user, identity) do
+ defp provision_sso_user(user, identity, integration) do
changeset =
user
|> change()
@@ -120,7 +136,7 @@ defmodule Plausible.Auth.SSO do
|> put_change(:last_sso_login, NaiveDateTime.utc_now(:second))
with {:ok, user} <- Repo.update(changeset) do
- {:ok, :sso, user}
+ {:ok, :sso, integration.team, user}
end
end
@@ -137,7 +153,7 @@ defmodule Plausible.Auth.SSO do
with :ok <- ensure_team_member(integration.team, user),
:ok <- ensure_one_membership(user, integration.team),
{:ok, user} <- Repo.update(changeset) do
- {:ok, :standard, user}
+ {:ok, :standard, integration.team, user}
end
end
@@ -162,13 +178,37 @@ defmodule Plausible.Auth.SSO do
|> put_change(:last_sso_login, NaiveDateTime.utc_now(:second))
|> put_assoc(:sso_integration, integration)
- case Repo.insert(changeset) do
- {:ok, user} ->
- {:ok, :identity, user}
+ team = integration.team
+ role = integration.team.policy.sso_default_role
+ now = NaiveDateTime.utc_now(:second)
- {:error, %{errors: [email: {_, attrs}]}} ->
- true = {:constraint, :unique} in attrs
- {:error, :integration_not_found}
+ result =
+ Repo.transaction(fn ->
+ with {:ok, user} <- Repo.insert(changeset),
+ :ok <- Teams.Invitations.check_team_member_limit(team, role, user.email),
+ {:ok, team_membership} <-
+ Teams.Invitations.create_team_membership(team, role, user, now) do
+ if team_membership.role != :guest do
+ {:identity, team, user}
+ else
+ Repo.rollback(:integration_not_found)
+ end
+ else
+ {:error, %{errors: [email: {_, attrs}]}} ->
+ true = {:constraint, :unique} in attrs
+ Repo.rollback(:integration_not_found)
+
+ {:error, {:over_limit, _}} ->
+ Repo.rollback(:over_limit)
+ end
+ end)
+
+ case result do
+ {:ok, {type, team, user}} ->
+ {:ok, type, team, user}
+
+ {:error, _} = error ->
+ error
end
end
diff --git a/extra/lib/plausible_web/controllers/sso_controller.ex b/extra/lib/plausible_web/controllers/sso_controller.ex
new file mode 100644
index 0000000000..74c00b316c
--- /dev/null
+++ b/extra/lib/plausible_web/controllers/sso_controller.ex
@@ -0,0 +1,93 @@
+defmodule PlausibleWeb.SSOController do
+ use PlausibleWeb, :controller
+
+ require Logger
+
+ alias Plausible.Auth
+ alias Plausible.Auth.SSO
+ alias Plausible.Repo
+
+ alias PlausibleWeb.Router.Helpers, as: Routes
+
+ def login_form(conn, params) do
+ render(conn, "login_form.html", error: params["error"])
+ end
+
+ def login(conn, %{"email" => email} = params) do
+ case SSO.Domains.lookup(email) do
+ {:ok, %{sso_integration: integration}} ->
+ redirect(conn,
+ to:
+ Routes.sso_path(
+ conn,
+ :saml_signin,
+ integration.identifier,
+ email: email,
+ return_to: params["return_to"]
+ )
+ )
+
+ {:error, :not_found} ->
+ render(conn, "login_form.html", error: "Wrong email.")
+ end
+ end
+
+ def saml_signin(conn, %{
+ "integration_id" => integration_id,
+ "email" => email,
+ "return_to" => return_to
+ }) do
+ conn
+ |> put_layout(false)
+ |> render("saml_signin.html",
+ integration_id: integration_id,
+ email: email,
+ return_to: return_to,
+ nonce: conn.private[:sso_nonce]
+ )
+ end
+
+ def saml_consume(conn, %{
+ "integration_id" => integration_id,
+ "email" => email,
+ "return_to" => return_to
+ }) do
+ case SSO.get_integration(integration_id) do
+ {:ok, integration} ->
+ session_timeout_minutes = integration.team.policy.sso_session_timeout_minutes
+
+ expires_at =
+ NaiveDateTime.add(NaiveDateTime.utc_now(:second), session_timeout_minutes, :minute)
+
+ identity =
+ if user = Repo.get_by(Auth.User, email: email) do
+ %SSO.Identity{
+ id: user.sso_identity_id || Ecto.UUID.generate(),
+ name: user.name,
+ email: email,
+ expires_at: expires_at
+ }
+ else
+ %SSO.Identity{
+ id: Ecto.UUID.generate(),
+ name: "Some SSO Person",
+ email: email,
+ expires_at: expires_at
+ }
+ end
+
+ PlausibleWeb.UserAuth.log_in_user(conn, identity, return_to)
+
+ {:error, :not_found} ->
+ redirect(conn,
+ to: Routes.sso_path(conn, :login_form, error: "Wrong email.", return_to: return_to)
+ )
+ end
+ end
+
+ def csp_report(conn, _params) do
+ {:ok, body, conn} = Plug.Conn.read_body(conn)
+ Logger.error(body)
+ conn |> send_resp(200, "OK")
+ end
+end
diff --git a/extra/lib/plausible_web/plugs/gate_sso.ex b/extra/lib/plausible_web/plugs/gate_sso.ex
new file mode 100644
index 0000000000..941858a390
--- /dev/null
+++ b/extra/lib/plausible_web/plugs/gate_sso.ex
@@ -0,0 +1,22 @@
+defmodule PlausibleWeb.Plugs.GateSSO do
+ @moduledoc """
+ Plug for gating access to SSO routes with `SSO_ENABLED` env var.
+ """
+
+ @behaviour Plug
+ import Plug.Conn
+
+ @impl true
+ def init(opts), do: opts
+
+ @impl true
+ def call(conn, _) do
+ if Plausible.sso_enabled?() do
+ conn
+ else
+ conn
+ |> Phoenix.Controller.redirect(to: "/")
+ |> halt()
+ end
+ end
+end
diff --git a/extra/lib/plausible_web/plugs/secure_sso.ex b/extra/lib/plausible_web/plugs/secure_sso.ex
new file mode 100644
index 0000000000..39d30b20dd
--- /dev/null
+++ b/extra/lib/plausible_web/plugs/secure_sso.ex
@@ -0,0 +1,39 @@
+defmodule PlausibleWeb.Plugs.SecureSSO do
+ @moduledoc """
+ Plug for securing SSO routes by setting proper policies in headers.
+ """
+
+ alias PlausibleWeb.Router.Helpers, as: Routes
+
+ @csp """
+ default-src 'none';
+ script-src 'self' 'nonce-<%= nonce %>' 'report-sample';
+ img-src 'self' 'report-sample';
+ report-uri <%= report_path %>;
+ report-to csp-report-endpoint
+ """
+ |> String.replace("\n", " ")
+
+ @behaviour Plug
+ import Plug.Conn
+
+ @impl true
+ def init(opts), do: opts
+
+ @impl true
+ def call(conn, _) do
+ nonce = :crypto.strong_rand_bytes(18) |> Base.encode64()
+ csp_report_path = Routes.sso_path(conn, :csp_report)
+
+ conn
+ |> put_private(:sso_nonce, nonce)
+ |> Phoenix.Controller.put_secure_browser_headers(%{
+ "cache-control" => "no-cache, no-store, must-revalidate",
+ "pragma" => "no-cache",
+ "reporting-endpoints" => "csp-report-endpoint=\"#{csp_report_path}\"",
+ "content-security-policy" =>
+ EEx.eval_string(@csp, nonce: nonce, report_path: csp_report_path),
+ "x-xss-protection" => "1; mode=block"
+ })
+ end
+end
diff --git a/extra/lib/plausible_web/templates/sso/login_form.html.heex b/extra/lib/plausible_web/templates/sso/login_form.html.heex
new file mode 100644
index 0000000000..8e8aaeea08
--- /dev/null
+++ b/extra/lib/plausible_web/templates/sso/login_form.html.heex
@@ -0,0 +1,44 @@
+<.focus_box>
+ <:title>
+ {Phoenix.Flash.get(@flash, :login_title) || "Enter your Single Sign-on email"}
+ </:title>
+ <:subtitle>
+ <%= if Phoenix.Flash.get(@flash, :login_instructions) do %>
+ <p class="text-gray-500 mt-1 mb-2">
+ {Phoenix.Flash.get(@flash, :login_instructions)}
+ </p>
+ <% end %>
+ </:subtitle>
+ <.form :let={f} for={@conn} action={Routes.sso_path(@conn, :login)}>
+ <div class="my-4 mt-8">
+ <.input
+ type="email"
+ autocomplete="username"
+ placeholder="[email protected]"
+ field={f[:email]}
+ />
+ </div>
+
+ <%= if @conn.assigns[:error] do %>
+ <div class="text-red-500 mt-4">{@conn.assigns[:error]}</div>
+ <% end %>
+
+ <.input type="hidden" field={f[:return_to]} />
+
+ <.button class="w-full" type="submit">Sign In</.button>
+ </.form>
+
+ <:footer>
+ <.focus_list>
+ <:item>
+ Have a standard account?
+ <.styled_link href={
+ Routes.auth_path(@conn, :login_form, return_to: @conn.params["return_to"])
+ }>
+ Log in here
+ </.styled_link>
+ instead.
+ </:item>
+ </.focus_list>
+ </:footer>
+</.focus_box>
diff --git a/extra/lib/plausible_web/templates/sso/saml_signin.html.heex b/extra/lib/plausible_web/templates/sso/saml_signin.html.heex
new file mode 100644
index 0000000000..e30be282b4
--- /dev/null
+++ b/extra/lib/plausible_web/templates/sso/saml_signin.html.heex
@@ -0,0 +1,36 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+ <head>
+ <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+ </head>
+ <body>
+ <script nonce={@nonce}>
+ document.addEventListener("DOMContentLoaded", function () {
+ document.getElementById("sso-req-form").submit();
+ });
+ </script>
+ <div>
+ <h1>
+ Processing Single Sign-on request...
+ </h1>
+ <noscript>
+ <p>
+ Since your browser does not support JavaScript, you must press
+ the button below to proceed.
+ </p>
+ </noscript>
+ <.form
+ :let={f}
+ id="sso-req-form"
+ for={@conn}
+ action={Routes.sso_path(@conn, :saml_consume, @integration_id)}
+ >
+ <.input type="hidden" field={f[:email]} />
+ <.input type="hidden" field={f[:return_to]} />
+
+ <.button class="w-full" type="submit">sign in</.button>
+ </.form>
+ </div>
+ </body>
+</html>
diff --git a/extra/lib/plausible_web/views/sso_view.ex b/extra/lib/plausible_web/views/sso_view.ex
new file mode 100644
index 0000000000..cb14fa1931
--- /dev/null
+++ b/extra/lib/plausible_web/views/sso_view.ex
@@ -0,0 +1,3 @@
+defmodule PlausibleWeb.SSOView do
+ use PlausibleWeb, :extra_view
+end
diff --git a/lib/plausible.ex b/lib/plausible.ex
index 39b39aa66a..4e62aaf276 100644
--- a/lib/plausible.ex
+++ b/lib/plausible.ex
@@ -12,6 +12,11 @@ defmodule Plausible do
end
end
+ @spec sso_enabled?() :: boolean()
+ def sso_enabled?() do
+ Application.fetch_env!(:plausible, :sso_enabled)
+ end
+
defmacro on_ee(clauses) do
do_on_ee(clauses)
end
diff --git a/lib/plausible/auth/user_session.ex b/lib/plausible/auth/user_session.ex
index 8e351c6e39..8bf6b40f59 100644
--- a/lib/plausible/auth/user_session.ex
+++ b/lib/plausible/auth/user_session.ex
@@ -35,6 +35,7 @@ defmodule Plausible.Auth.UserSession do
|> cast(%{device: device}, [:device])
|> generate_token()
|> put_assoc(:user, user)
+ |> put_change(:timeout_at, NaiveDateTime.shift(now, @timeout))
|> touch_session(now)
end
diff --git a/lib/plausible/teams/invitations.ex b/lib/plausible/teams/invitations.ex
index 92826fa9f8..07a21f840f 100644
--- a/lib/plausible/teams/invitations.ex
+++ b/lib/plausible/teams/invitations.ex
@@ -717,7 +717,7 @@ defmodule Plausible.Teams.Invitations do
@team_role_type Plausible.Teams.Membership.__schema__(:type, :role)
- defp create_team_membership(team, role, user, now) do
+ def create_team_membership(team, role, user, now) do
conflict_query =
from(tm in Teams.Membership,
update: [
diff --git a/lib/plausible_web.ex b/lib/plausible_web.ex
index a4da51cc9e..dd610782ae 100644
--- a/lib/plausible_web.ex
+++ b/lib/plausible_web.ex
@@ -1,4 +1,6 @@
defmodule PlausibleWeb do
+ use Plausible
+
def live_view(opts \\ []) do
quote do
use Plausible
@@ -66,6 +68,25 @@ defmodule PlausibleWeb do
end
end
+ on_ee do
+ def extra_view do
+ quote do
+ use Phoenix.View,
+ root: "extra/lib/plausible_web/templates",
+ namespace: PlausibleWeb
+
+ # Import convenience functions from controllers
+ import Phoenix.Controller, only: [view_module: 1]
+
+ use Phoenix.Component
+
+ import PlausibleWeb.Components.Generic
+ import PlausibleWeb.Live.Components.Form
+ alias PlausibleWeb.Router.Helpers, as: Routes
+ end
+ end
+ end
+
def router do
quote do
use Phoenix.Router
diff --git a/lib/plausible_web/router.ex b/lib/plausible_web/router.ex
index e7f564ffe6..de188d4da3 100644
--- a/lib/plausible_web/router.ex
+++ b/lib/plausible_web/router.ex
@@ -162,6 +162,36 @@ defmodule PlausibleWeb.Router do
end
end
+ # SSO routes
+ on_ee do
+ pipeline :sso_saml do
+ plug :accepts, ["html"]
+
+ plug PlausibleWeb.Plugs.SecureSSO
+
+ plug PlausibleWeb.Plugs.NoRobots
+
+ plug :fetch_session
+ plug :fetch_live_flash
+ plug :protect_from_forgery, with: :clear_session
+ end
+
+ scope "/sso", PlausibleWeb do
+ pipe_through [PlausibleWeb.Plugs.GateSSO, :browser, :csrf]
+
+ get "/login", SSOController, :login_form
+ post "/login", SSOController, :login
+ end
+
+ scope "/sso/saml", PlausibleWeb do
+ pipe_through [PlausibleWeb.Plugs.GateSSO, :sso_saml]
+
+ get "/signin/:integration_id", SSOController, :saml_signin
+ post "/consume/:integration_id", SSOController, :saml_consume
+ post "/csp-report", SSOController, :csp_report
+ end
+ end
+
scope path: "/api/plugins", as: :plugins_api do
pipeline :plugins_api_auth do
plug(PlausibleWeb.Plugs.AuthorizePluginsAPI)
diff --git a/lib/plausible_web/templates/auth/login_form.html.heex b/lib/plausible_web/templates/auth/login_form.html.heex
index a9960e5f0a..e064dfdcff 100644
--- a/lib/plausible_web/templates/auth/login_form.html.heex
+++ b/lib/plausible_web/templates/auth/login_form.html.heex
@@ -49,6 +49,17 @@
</.styled_link>
instead.
</:item>
+ <:item :if={ee?() and Plausible.sso_enabled?()}>
+ <%= on_ee do %>
+ Have a Single Sign-on account?
+ <.styled_link href={
+ Routes.sso_path(@conn, :login_form, return_to: @conn.params["return_to"])
+ }>
+ Sign in here
+ </.styled_link>
+ instead.
+ <% end %>
+ </:item>
<:item>
Forgot password?
<.styled_link href="/password/request-reset">
diff --git a/lib/plausible_web/user_auth.ex b/lib/plausible_web/user_auth.ex
index 4c594932e7..bc718d87fa 100644
--- a/lib/plausible_web/user_auth.ex
+++ b/lib/plausible_web/user_auth.ex
@@ -38,7 +38,7 @@ defmodule PlausibleWeb.UserAuth do
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} ->
+ {:ok, provisioning_from, team, user} ->
if provisioning_from == :standard do
:ok = revoke_all_user_sessions(user)
end
@@ -48,13 +48,26 @@ defmodule PlausibleWeb.UserAuth do
conn
|> set_user_token(token)
+ |> Plug.Conn.put_session("current_team_id", team.identifier)
|> set_logged_in_cookie()
|> Phoenix.Controller.redirect(to: redirect_to)
{:error, :integration_not_found} ->
conn
|> log_out_user()
- |> Phoenix.Controller.redirect(to: "/")
+ |> Phoenix.Controller.redirect(
+ to:
+ Routes.sso_path(conn, :login_form, error: "Wrong email.", return_to: redirect_path)
+ )
+
+ {:error, :over_limit} ->
+ error = "Team can't accept more members. Please contact the owner."
+
+ conn
+ |> log_out_user()
+ |> Phoenix.Controller.redirect(
+ to: Routes.sso_path(conn, :login_form, error: error, return_to: redirect_path)
+ )
{:error, :multiple_memberships, team, user} ->
redirect_path = Routes.site_path(conn, :index, __team: team.identifier)
diff --git a/test/plausible/auth/sso_test.exs b/test/plausible/auth/sso_test.exs
index 5d7912a0bc..db98639459 100644
--- a/test/plausible/auth/sso_test.exs
+++ b/test/plausible/auth/sso_test.exs
@@ -175,11 +175,16 @@ defmodule Plausible.Auth.SSOTest do
{: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
+ test "provisions a new SSO user form identity", %{
+ integration: integration,
+ domain: domain,
+ team: team
+ } do
identity = new_identity("Jane Sculley", "jane@" <> domain)
- assert {:ok, :identity, user} = SSO.provision_user(identity)
+ assert {:ok, :identity, matched_team, user} = SSO.provision_user(identity)
+ assert matched_team.id == team.id
assert user.id
assert user.email == identity.email
assert user.type == :sso
@@ -188,6 +193,7 @@ defmodule Plausible.Auth.SSOTest do
assert user.sso_integration_id == integration.id
assert user.email_verified
assert user.last_sso_login
+ assert_team_membership(user, team, :viewer)
end
test "provisions SSO user from existing user", %{
@@ -204,8 +210,9 @@ defmodule Plausible.Auth.SSOTest do
identity = new_identity(user.name, user.email)
- assert {:ok, :standard, sso_user} = SSO.provision_user(identity)
+ assert {:ok, :standard, matched_team, sso_user} = SSO.provision_user(identity)
+ assert matched_team.id == team.id
assert sso_user.id == user.id
assert sso_user.email == identity.email
assert sso_user.type == :sso
@@ -220,10 +227,11 @@ defmodule Plausible.Auth.SSOTest 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)
+ {:ok, :standard, _team, user} = SSO.provision_user(identity)
- assert {:ok, :sso, sso_user} = SSO.provision_user(identity)
+ assert {:ok, :sso, matched_team, sso_user} = SSO.provision_user(identity)
+ assert matched_team.id == team.id
assert sso_user.id == user.id
assert sso_user.email == identity.email
assert sso_user.type == :sso
@@ -281,6 +289,19 @@ defmodule Plausible.Auth.SSOTest do
assert matched_team.id == team.id
assert matched_user.id == user.id
end
+
+ test "does not provision new SSO user from identity when team is over members limit", %{
+ domain: domain,
+ team: team
+ } do
+ add_member(team, role: :viewer)
+ add_member(team, role: :viewer)
+ add_member(team, role: :viewer)
+
+ identity = new_identity("Jane Sculley", "jane@" <> domain)
+
+ assert {:error, :over_limit} = SSO.provision_user(identity)
+ end
end
defp new_identity(name, email, id \\ Ecto.UUID.generate()) do
diff --git a/test/plausible_web/controllers/sso_controller_sync_test.exs b/test/plausible_web/controllers/sso_controller_sync_test.exs
new file mode 100644
index 0000000000..eb37966129
--- /dev/null
+++ b/test/plausible_web/controllers/sso_controller_sync_test.exs
@@ -0,0 +1,61 @@
+defmodule PlausibleWeb.SSOControllerSyncTest do
+ use PlausibleWeb.ConnCase
+
+ @moduletag :ee_only
+
+ on_ee do
+ setup do
+ patch_env(:sso_enabled, false)
+ end
+
+ test "standard login form does not show link to SSO login", %{conn: conn} do
+ conn = get(conn, Routes.auth_path(conn, :login_form))
+
+ assert html = html_response(conn, 200)
+
+ refute html =~ Routes.sso_path(conn, :login_form)
+ refute html =~ "Single Sign-on"
+ end
+
+ test "login_form/2 is guarded by the env var", %{conn: conn} do
+ conn = get(conn, Routes.sso_path(conn, :login_form))
+
+ assert redirected_to(conn, 302) == "/"
+ end
+
+ test "login/2 is guarded by the env var", %{conn: conn} do
+ conn = post(conn, Routes.sso_path(conn, :login), %{"email" => "[email protected]"})
+
+ assert redirected_to(conn, 302) == "/"
+ end
+
+ test "saml_signin/2 is guarded by the env var", %{conn: conn} do
+ conn =
+ get(
+ conn,
+ Routes.sso_path(conn, :saml_signin, Ecto.UUID.generate(),
+ email: "[email protected]",
+ return_to: "/sites"
+ )
+ )
+
+ assert redirected_to(conn, 302) == "/"
+ end
+
+ test "saml_consume/2 is guarded by the env var", %{conn: conn} do
+ conn =
+ post(conn, Routes.sso_path(conn, :saml_consume, Ecto.UUID.generate()), %{
+ "email" => "[email protected]",
+ "return_to" => "/sites"
+ })
+
+ assert redirected_to(conn, 302) == "/"
+ end
+
+ test "csp_report/2 is guarded by the env var", %{conn: conn} do
+ conn = post(conn, Routes.sso_path(conn, :csp_report), %{})
+
+ assert redirected_to(conn, 302) == "/"
+ end
+ end
+end
diff --git a/test/plausible_web/controllers/sso_controller_test.exs b/test/plausible_web/controllers/sso_controller_test.exs
new file mode 100644
index 0000000000..eb04000a4d
--- /dev/null
+++ b/test/plausible_web/controllers/sso_controller_test.exs
@@ -0,0 +1,185 @@
+defmodule PlausibleWeb.SSOControllerTest do
+ use PlausibleWeb.ConnCase, async: true
+ use Plausible
+
+ @moduletag :ee_only
+
+ on_ee do
+ import Plausible.Teams.Test
+ import Plausible.Test.Support.HTML
+
+ alias Plausible.Auth.SSO
+ alias Plausible.Repo
+
+ 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
+
+ describe "login_form/2" do
+ test "renders login view", %{conn: conn} do
+ conn = get(conn, Routes.sso_path(conn, :login_form))
+
+ assert html = html_response(conn, 200)
+
+ assert html =~ "Enter your Single Sign-on email"
+ assert element_exists?(html, "input[name=email]")
+ assert text_of_attr(html, "input[name=return_to]", "value") == ""
+ end
+
+ test "passes return_to parameter to form", %{conn: conn} do
+ conn = get(conn, Routes.sso_path(conn, :login_form, return_to: "/sites"))
+
+ assert html = html_response(conn, 200)
+
+ assert text_of_attr(html, "input[name=return_to]", "value") == "/sites"
+ end
+ end
+
+ describe "login/2" do
+ test "redirects to SAML signin on matching integration", %{
+ conn: conn,
+ domain: domain,
+ integration: integration
+ } do
+ email = "paul@" <> domain
+
+ conn = post(conn, Routes.sso_path(conn, :login), %{"email" => email})
+
+ assert redirected_to(conn, 302) ==
+ Routes.sso_path(conn, :saml_signin, integration.identifier,
+ email: email,
+ return_to: ""
+ )
+ end
+
+ test "passes redirect path if provided", %{
+ conn: conn,
+ domain: domain,
+ integration: integration
+ } do
+ email = "paul@" <> domain
+
+ conn =
+ post(conn, Routes.sso_path(conn, :login), %{"email" => email, "return_to" => "/sites"})
+
+ assert redirected_to(conn, 302) ==
+ Routes.sso_path(conn, :saml_signin, integration.identifier,
+ email: email,
+ return_to: "/sites"
+ )
+ end
+
+ test "renders login form with error on no matching integration", %{conn: conn} do
+ conn =
+ post(conn, Routes.sso_path(conn, :login), %{
+ "email" => "[email protected]",
+ "return_to" => "/sites"
+ })
+
+ assert html = html_response(conn, 200)
+
+ assert html =~ "Wrong email."
+ assert element_exists?(html, "input[name=email]")
+ assert text_of_attr(html, "input[name=return_to]", "value") == "/sites"
+ end
+ end
+
+ describe "saml_signin/2 (fake SAML)" do
+ test "renders autosubmitted form", %{conn: conn, domain: domain, integration: integration} do
+ email = "paul@" <> domain
+
+ conn =
+ get(
+ conn,
+ Routes.sso_path(conn, :saml_signin, integration.identifier,
+ email: email,
+ return_to: "/sites"
+ )
+ )
+
+ assert html = html_response(conn, 200)
+
+ assert html =~ "Processing Single Sign-on request..."
+
+ assert text_of_attr(html, "form#sso-req-form", "action") ==
+ Routes.sso_path(conn, :saml_consume, integration.identifier)
+
+ assert text_of_attr(html, "input[name=email]", "value") == email
+ assert text_of_attr(html, "input[name=return_to]", "value") == "/sites"
+ end
+ end
+
+ describe "saml_consume/2 (fake SAML)" do
+ test "provisions identity for new user", %{
+ conn: conn,
+ domain: domain,
+ integration: integration
+ } do
+ email = "dana@" <> domain
+
+ conn =
+ post(conn, Routes.sso_path(conn, :saml_consume, integration.identifier), %{
+ "email" => email,
+ "return_to" => "/sites"
+ })
+
+ assert redirected_to(conn, 302) == "/sites"
+
+ assert %{sessions: [sso_session]} =
+ user = Repo.get_by(Plausible.Auth.User, email: email) |> Repo.preload(:sessions)
+
+ assert user.type == :sso
+ assert user.email == email
+ assert user.name == "Some SSO Person"
+ assert get_session(conn, :user_token) == sso_session.token
+ end
+
+ test "provisions identity for existing user", %{
+ conn: conn,
+ team: team,
+ domain: domain,
+ integration: integration
+ } do
+ email = "dana@" <> domain
+
+ existing_user = new_user(name: "Dana Woodworth", email: email)
+
+ add_member(team, user: existing_user, role: :admin)
+
+ conn =
+ post(conn, Routes.sso_path(conn, :saml_consume, integration.identifier), %{
+ "email" => email,
+ "return_to" => "/sites"
+ })
+
+ assert redirected_to(conn, 302) == "/sites"
+
+ assert %{sessions: [sso_session]} =
+ user = Repo.get_by(Plausible.Auth.User, email: email) |> Repo.preload(:sessions)
+
+ assert user.type == :sso
+ assert user.email == email
+ assert user.name == "Dana Woodworth"
+ assert get_session(conn, :user_token) == sso_session.token
+ end
+
+ test "redirects to login when no matching integration found", %{conn: conn} do
+ conn =
+ post(conn, Routes.sso_path(conn, :saml_consume, Ecto.UUID.generate()), %{
+ "email" => "[email protected]",
+ "return_to" => "/sites"
+ })
+
+ assert redirected_to(conn, 302) ==
+ Routes.sso_path(conn, :login_form, error: "Wrong email.", return_to: "/sites")
+ end
+ end
+ end
+end
diff --git a/test/plausible_web/user_auth_test.exs b/test/plausible_web/user_auth_test.exs
index 358b8601f2..5458c799cb 100644
--- a/test/plausible_web/user_auth_test.exs
+++ b/test/plausible_web/user_auth_test.exs
@@ -72,9 +72,69 @@ defmodule PlausibleWeb.UserAuthTest do
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, :current_team_id) == team.identifier
assert get_session(conn, :user_token) == session.token
end
+ test "logs in existing SSO owner using standard login correctly", %{
+ conn: conn,
+ user: user
+ } do
+ team = new_site(owner: user).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!()
+ {: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)
+ {:ok, :standard, _, user} = SSO.provision_user(identity)
+
+ assert user.type == :sso
+
+ conn =
+ conn
+ |> init_session()
+ |> UserAuth.log_in_user(user)
+
+ assert %{sessions: [session]} = user |> Repo.reload!() |> Repo.preload(:sessions)
+ assert session.user_id == user.id
+ assert session.token == get_session(conn, :user_token)
+
+ assert redirected_to(conn, 302) == Routes.site_path(conn, :index)
+ end
+
+ test "invalidates any existing sessions of user logging in when converting", %{
+ 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 |> init_session() |> UserAuth.log_in_user(user)
+
+ assert [standard_session] = Repo.preload(user, :sessions).sessions
+
+ conn =
+ conn
+ |> init_session()
+ |> UserAuth.log_in_user(identity)
+
+ assert [sso_session] = Repo.preload(user, :sessions).sessions
+
+ assert standard_session.id != sso_session.id
+ assert standard_session.token != sso_session.token
+ assert get_session(conn, :user_token) == sso_session.token
+ end
+
test "tries to log out and redirects if SSO identity is not matched", %{
conn: conn,
user: user
@@ -87,18 +147,55 @@ defmodule PlausibleWeb.UserAuthTest do
|> UserAuth.log_in_user(identity)
assert %{sessions: []} = user |> Repo.reload!() |> Repo.preload(:sessions)
- assert redirected_to(conn, 302) == "/"
+
+ assert redirected_to(conn, 302) ==
+ Routes.sso_path(conn, :login_form, error: "Wrong email.", return_to: "")
+
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", %{
+ test "tries to log out and redirects if SSO identity exceeds team members limit", %{
conn: conn,
user: user
} do
team = new_site().team
integration = SSO.initiate_saml_integration(team)
domain = "example-#{Enum.random(1..10_000)}.com"
+ add_member(team, role: :viewer)
+ add_member(team, role: :viewer)
+ add_member(team, role: :viewer)
+
+ {:ok, sso_domain} = SSO.Domains.add(integration, domain)
+ _sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)
+
+ identity = new_identity("Jane Doe", "jane@" <> domain)
+
+ conn =
+ conn
+ |> init_session()
+ |> UserAuth.log_in_user(identity)
+
+ assert %{sessions: []} = user |> Repo.reload!() |> Repo.preload(:sessions)
+
+ assert redirected_to(conn, 302) ==
+ Routes.sso_path(conn, :login_form,
+ error: "Team can't accept more members. Please contact the owner.",
+ return_to: ""
+ )
+
+ assert conn.private[:plug_session_info] == :renew
+ refute get_session(conn, :user_token)
+ end
+
+ test "passes through for user matching SSO identity on multiple teams, 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