Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.
TypeScript analyticsanalytics-dashboardclickhouseelixirgoogle-analyticsmarketingopen-source-analyticsphoenixplausible-analyticspostgresqlprivacyprivacy-friendlyself-hostedsimple-analyticsstatisticstailwindcssweb-analyticswebsite-analyticswebsite-statswebsite-tracking
Implement SSO login against fake SAML endpoints (#5434)
Adrian Gruntkowskibca78169bb02
diff --git a/config/.env.dev b/config/.env.devindex cb957fe126..87cfab1031 100644--- a/config/.env.dev+++ b/config/.env.dev@@ -14,6 +14,7 @@ ADMIN_USER_IDS=1SHOW_CITIES=truePADDLE_VENDOR_AUTH_CODE=895e20d4efaec0575bb857f44b183217b332d9592e76e69b8aPADDLE_VENDOR_ID=3942+SSO_ENABLED=trueGOOGLE_CLIENT_ID=875387135161-l8tp53dpt7fdhdg9m1pc3vl42si95rh0.apps.googleusercontent.comGOOGLE_CLIENT_SECRET=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diff --git a/config/.env.load b/config/.env.loadindex cb957fe126..87cfab1031 100644--- a/config/.env.load+++ b/config/.env.load@@ -14,6 +14,7 @@ ADMIN_USER_IDS=1SHOW_CITIES=truePADDLE_VENDOR_AUTH_CODE=895e20d4efaec0575bb857f44b183217b332d9592e76e69b8aPADDLE_VENDOR_ID=3942+SSO_ENABLED=trueGOOGLE_CLIENT_ID=875387135161-l8tp53dpt7fdhdg9m1pc3vl42si95rh0.apps.googleusercontent.comGOOGLE_CLIENT_SECRET=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diff --git a/config/.env.test b/config/.env.testindex 42a1e85526..a4b073b64b 100644--- a/config/.env.test+++ b/config/.env.test@@ -19,6 +19,7 @@ HELP_SCOUT_APP_ID=fake_app_idHELP_SCOUT_APP_SECRET=fake_app_secretHELP_SCOUT_SIGNATURE_KEY=fake_signature_keyHELP_SCOUT_VAULT_KEY=ym9ZQg0KPNGCH3C2eD5y6KpL0tFzUqAhwxQO6uEv/ZM=+SSO_ENABLED=trueS3_DISABLED=falseS3_ACCESS_KEY_ID=minioadmindiff --git a/config/runtime.exs b/config/runtime.exsindex 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_enabledconfig :plausible, :selfhost,enable_email_verification: enable_email_verification,diff --git a/extra/lib/plausible/auth/sso.ex b/extra/lib/plausible/auth/sso.exindex 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 doalias Plausible.Repoalias 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) dochangeset = SSO.Integration.init_changeset(team)@@ -34,16 +50,16 @@ defmodule Plausible.Auth.SSO doend@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) docase 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 dodefp find_by_identity(id) doif 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 doendend- defp provision_sso_user(user, identity) do+ defp provision_sso_user(user, identity, integration) dochangeset =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}endend@@ -137,7 +153,7 @@ defmodule Plausible.Auth.SSO dowith :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}endend@@ -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 ->+ errorendenddiff --git a/extra/lib/plausible_web/controllers/sso_controller.ex b/extra/lib/plausible_web/controllers/sso_controller.exnew file mode 100644index 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+enddiff --git a/extra/lib/plausible_web/plugs/gate_sso.ex b/extra/lib/plausible_web/plugs/gate_sso.exnew file mode 100644index 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+enddiff --git a/extra/lib/plausible_web/plugs/secure_sso.ex b/extra/lib/plausible_web/plugs/secure_sso.exnew file mode 100644index 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+enddiff --git a/extra/lib/plausible_web/templates/sso/login_form.html.heex b/extra/lib/plausible_web/templates/sso/login_form.html.heexnew file mode 100644index 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.heexnew file mode 100644index 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.exnew file mode 100644index 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+enddiff --git a/lib/plausible.ex b/lib/plausible.exindex 39b39aa66a..4e62aaf276 100644--- a/lib/plausible.ex+++ b/lib/plausible.ex@@ -12,6 +12,11 @@ defmodule Plausible doendend+ @spec sso_enabled?() :: boolean()+ def sso_enabled?() do+ Application.fetch_env!(:plausible, :sso_enabled)+ end+defmacro on_ee(clauses) dodo_on_ee(clauses)enddiff --git a/lib/plausible/auth/user_session.ex b/lib/plausible/auth/user_session.exindex 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)enddiff --git a/lib/plausible/teams/invitations.ex b/lib/plausible/teams/invitations.exindex 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) doconflict_query =from(tm in Teams.Membership,update: [diff --git a/lib/plausible_web.ex b/lib/plausible_web.exindex 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 \\ []) doquote douse Plausible@@ -66,6 +68,25 @@ defmodule PlausibleWeb doendend+ 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 doquote douse Phoenix.Routerdiff --git a/lib/plausible_web/router.ex b/lib/plausible_web/router.exindex e7f564ffe6..de188d4da3 100644--- a/lib/plausible_web/router.ex+++ b/lib/plausible_web/router.ex@@ -162,6 +162,36 @@ defmodule PlausibleWeb.Router doendend+ # 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 dopipeline :plugins_api_auth doplug(PlausibleWeb.Plugs.AuthorizePluginsAPI)diff --git a/lib/plausible_web/templates/auth/login_form.html.heex b/lib/plausible_web/templates/auth/login_form.html.heexindex 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.exindex 4c594932e7..bc718d87fa 100644--- a/lib/plausible_web/user_auth.ex+++ b/lib/plausible_web/user_auth.ex@@ -38,7 +38,7 @@ defmodule PlausibleWeb.UserAuth doon_ee dodef log_in_user(conn, %Auth.SSO.Identity{} = identity, redirect_path) docase 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 doconn|> 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.exsindex 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+ } doidentity = 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.idassert user.idassert user.email == identity.emailassert user.type == :sso@@ -188,6 +193,7 @@ defmodule Plausible.Auth.SSOTest doassert user.sso_integration_id == integration.idassert user.email_verifiedassert user.last_sso_login+ assert_team_membership(user, team, :viewer)endtest "provisions SSO user from existing user", %{@@ -204,8 +210,9 @@ defmodule Plausible.Auth.SSOTest doidentity = 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.idassert sso_user.id == user.idassert sso_user.email == identity.emailassert sso_user.type == :sso@@ -220,10 +227,11 @@ defmodule Plausible.Auth.SSOTest douser = 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.idassert sso_user.id == user.idassert sso_user.email == identity.emailassert sso_user.type == :sso@@ -281,6 +289,19 @@ defmodule Plausible.Auth.SSOTest doassert matched_team.id == team.idassert matched_user.id == user.idend++ 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)+ endenddefp new_identity(name, email, id \\ Ecto.UUID.generate()) dodiff --git a/test/plausible_web/controllers/sso_controller_sync_test.exs b/test/plausible_web/controllers/sso_controller_sync_test.exsnew file mode 100644index 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+enddiff --git a/test/plausible_web/controllers/sso_controller_test.exs b/test/plausible_web/controllers/sso_controller_test.exsnew file mode 100644index 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+enddiff --git a/test/plausible_web/user_auth_test.exs b/test/plausible_web/user_auth_test.exsindex 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 doassert redirected_to(conn, 302) == Routes.site_path(conn, :index)assert conn.private[:plug_session_info] == :renewassert conn.resp_cookies["logged_in"].max_age > 0+ assert get_session(conn, :current_team_id) == team.identifierassert get_session(conn, :user_token) == session.tokenend+ 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] == :renewrefute 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} doteam = new_site().teamintegration = 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