Skip to content

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

Refactor `AuthorizeSiteAccess` (#4583)

Adrian Gruntkowski6769ebdc2451
diff --git a/lib/plausible_web/controllers/google_analytics_controller.ex b/lib/plausible_web/controllers/google_analytics_controller.ex
index 9c48da7088..56734527da 100644
--- a/lib/plausible_web/controllers/google_analytics_controller.ex
+++ b/lib/plausible_web/controllers/google_analytics_controller.ex
@@ -8,7 +8,7 @@ defmodule PlausibleWeb.GoogleAnalyticsController do
plug(PlausibleWeb.RequireAccountPlug)
- plug(PlausibleWeb.AuthorizeSiteAccess, [:owner, :admin, :super_admin])
+ plug(PlausibleWeb.Plugs.AuthorizeSiteAccess, [:owner, :admin, :super_admin])
def property_form(
conn,
diff --git a/lib/plausible_web/controllers/invitation_controller.ex b/lib/plausible_web/controllers/invitation_controller.ex
index 65dd104c8e..3b97b9a62e 100644
--- a/lib/plausible_web/controllers/invitation_controller.ex
+++ b/lib/plausible_web/controllers/invitation_controller.ex
@@ -3,7 +3,8 @@ defmodule PlausibleWeb.InvitationController do
plug PlausibleWeb.RequireAccountPlug
- plug PlausibleWeb.AuthorizeSiteAccess, [:owner, :admin] when action in [:remove_invitation]
+ plug PlausibleWeb.Plugs.AuthorizeSiteAccess,
+ [:owner, :admin] when action in [:remove_invitation]
def accept_invitation(conn, %{"invitation_id" => invitation_id}) do
case Plausible.Site.Memberships.accept_invitation(invitation_id, conn.assigns.current_user) do
diff --git a/lib/plausible_web/controllers/site/membership_controller.ex b/lib/plausible_web/controllers/site/membership_controller.ex
index b348f1803a..f06cfdae54 100644
--- a/lib/plausible_web/controllers/site/membership_controller.ex
+++ b/lib/plausible_web/controllers/site/membership_controller.ex
@@ -18,9 +18,9 @@ defmodule PlausibleWeb.Site.MembershipController do
@only_owner_is_allowed_to [:transfer_ownership_form, :transfer_ownership]
plug PlausibleWeb.RequireAccountPlug
- plug PlausibleWeb.AuthorizeSiteAccess, [:owner] when action in @only_owner_is_allowed_to
+ plug PlausibleWeb.Plugs.AuthorizeSiteAccess, [:owner] when action in @only_owner_is_allowed_to
- plug PlausibleWeb.AuthorizeSiteAccess,
+ plug PlausibleWeb.Plugs.AuthorizeSiteAccess,
[:owner, :admin] when action not in @only_owner_is_allowed_to
def invite_member_form(conn, _params) do
diff --git a/lib/plausible_web/controllers/site_controller.ex b/lib/plausible_web/controllers/site_controller.ex
index ded55a20cb..58f6b1a35b 100644
--- a/lib/plausible_web/controllers/site_controller.ex
+++ b/lib/plausible_web/controllers/site_controller.ex
@@ -9,7 +9,7 @@ defmodule PlausibleWeb.SiteController do
plug(PlausibleWeb.RequireAccountPlug)
plug(
- PlausibleWeb.AuthorizeSiteAccess,
+ PlausibleWeb.Plugs.AuthorizeSiteAccess,
[:owner, :admin, :super_admin] when action not in [:new, :create_site]
)
diff --git a/lib/plausible_web/controllers/stats_controller.ex b/lib/plausible_web/controllers/stats_controller.ex
index dd1d52e450..e68c6bad39 100644
--- a/lib/plausible_web/controllers/stats_controller.ex
+++ b/lib/plausible_web/controllers/stats_controller.ex
@@ -48,7 +48,7 @@ defmodule PlausibleWeb.StatsController do
alias Plausible.Stats.{Filters, Query}
alias PlausibleWeb.Api
- plug(PlausibleWeb.AuthorizeSiteAccess when action in [:stats, :csv_export])
+ plug(PlausibleWeb.Plugs.AuthorizeSiteAccess when action in [:stats, :csv_export])
def stats(%{assigns: %{site: site}} = conn, _params) do
site = Plausible.Repo.preload(site, :owner)
diff --git a/lib/plausible_web/plugs/authorize_site_access.ex b/lib/plausible_web/plugs/authorize_site_access.ex
index dc2572916e..2f5f7da8df 100644
--- a/lib/plausible_web/plugs/authorize_site_access.ex
+++ b/lib/plausible_web/plugs/authorize_site_access.ex
@@ -1,46 +1,44 @@
-defmodule PlausibleWeb.AuthorizeSiteAccess do
+defmodule PlausibleWeb.Plugs.AuthorizeSiteAccess do
+ @moduledoc """
+ Plug restricting access to site and shared link, when present.
+ """
+
+ use Plausible.Repo
+
import Plug.Conn
import Phoenix.Controller, only: [get_format: 1]
- use Plausible.Repo
- def init([]), do: [:public, :viewer, :admin, :super_admin, :owner]
- def init(allowed_roles), do: allowed_roles
+ @all_roles [:public, :viewer, :admin, :super_admin, :owner]
- def call(conn, allowed_roles) do
- site =
- Repo.get_by(Plausible.Site,
- domain:
- conn.path_params["domain"] || conn.path_params["website"] || conn.params["site_id"]
- )
+ def init([]), do: @all_roles
- shared_link_auth = conn.params["auth"]
+ def init(allowed_roles) do
+ unknown_roles = allowed_roles -- @all_roles
- shared_link_record =
- shared_link_auth && Repo.get_by(Plausible.Site.SharedLink, slug: shared_link_auth)
+ if unknown_roles != [] do
+ raise ArgumentError, "Unknown allowed roles configured: #{inspect(unknown_roles)}"
+ end
- if !site do
- fail(conn)
- else
- user_id =
- case PlausibleWeb.UserAuth.get_user_session(conn) do
- {:ok, user_session} -> user_session.user_id
- _ -> nil
- end
+ allowed_roles
+ end
- membership_role = user_id && Plausible.Sites.role(user_id, site)
+ def call(conn, allowed_roles) do
+ current_user = conn.assigns[:current_user]
+ with {:ok, %{site: site, role: membership_role}} <- get_site_with_role(conn, current_user),
+ {:ok, shared_link} <- maybe_get_shared_link(conn, site) do
role =
cond do
- user_id && membership_role ->
+ membership_role ->
membership_role
- Plausible.Auth.is_super_admin?(user_id) ->
+ Plausible.Auth.is_super_admin?(current_user) ->
:super_admin
site.public ->
:public
- shared_link_record && shared_link_record.site_id == site.id ->
+ shared_link ->
:public
true ->
@@ -48,8 +46,10 @@ defmodule PlausibleWeb.AuthorizeSiteAccess do
end
if role in allowed_roles do
- Sentry.Context.set_user_context(%{id: user_id})
- Plausible.OpenTelemetry.add_user_attributes(user_id)
+ if current_user do
+ Sentry.Context.set_user_context(%{id: current_user.id})
+ Plausible.OpenTelemetry.add_user_attributes(current_user.id)
+ end
Sentry.Context.set_extra_context(%{site_id: site.id, domain: site.domain})
Plausible.OpenTelemetry.add_site_attributes(site)
@@ -58,21 +58,67 @@ defmodule PlausibleWeb.AuthorizeSiteAccess do
merge_assigns(conn, site: site, current_user_role: role)
else
- fail(conn)
+ error_not_found(conn)
+ end
+ end
+ end
+
+ defp get_site_with_role(conn, current_user) do
+ domain = conn.path_params["domain"] || conn.path_params["website"]
+
+ site_query =
+ from(
+ s in Plausible.Site,
+ where: s.domain == ^domain,
+ select: %{site: s}
+ )
+
+ full_query =
+ if current_user do
+ from(s in site_query,
+ left_join: sm in Plausible.Site.Membership,
+ on: sm.site_id == s.id and sm.user_id == ^current_user.id,
+ select_merge: %{role: sm.role}
+ )
+ else
+ from(s in site_query,
+ select_merge: %{role: nil}
+ )
end
+
+ case Repo.one(full_query) do
+ %{site: _site} = result -> {:ok, result}
+ _ -> error_not_found(conn)
+ end
+ end
+
+ defp maybe_get_shared_link(conn, site) do
+ slug = conn.path_params["slug"] || conn.params["auth"]
+
+ if is_binary(slug) do
+ if shared_link = Repo.get_by(Plausible.Site.SharedLink, slug: slug, site_id: site.id) do
+ {:ok, shared_link}
+ else
+ error_not_found(conn)
+ end
+ else
+ {:ok, nil}
end
end
- defp fail(conn) do
+ defp error_not_found(conn) do
case get_format(conn) do
"json" ->
- PlausibleWeb.Api.Helpers.not_found(
- conn,
+ conn
+ |> PlausibleWeb.Api.Helpers.not_found(
"Site does not exist or user does not have sufficient access."
)
+ |> halt()
_ ->
- PlausibleWeb.ControllerHelpers.render_error(conn, 404) |> halt
+ conn
+ |> PlausibleWeb.ControllerHelpers.render_error(404)
+ |> halt()
end
end
end
diff --git a/lib/plausible_web/router.ex b/lib/plausible_web/router.ex
index 45b368e764..d0265df9ee 100644
--- a/lib/plausible_web/router.ex
+++ b/lib/plausible_web/router.ex
@@ -42,7 +42,7 @@ defmodule PlausibleWeb.Router do
plug :accepts, ["json"]
plug :fetch_session
plug PlausibleWeb.AuthPlug
- plug PlausibleWeb.AuthorizeSiteAccess
+ plug PlausibleWeb.Plugs.AuthorizeSiteAccess
plug PlausibleWeb.Plugs.NoRobots
end
@@ -51,7 +51,7 @@ defmodule PlausibleWeb.Router do
plug :fetch_session
plug PlausibleWeb.AuthPlug
- plug PlausibleWeb.AuthorizeSiteAccess, [:admin, :super_admin, :owner]
+ plug PlausibleWeb.Plugs.AuthorizeSiteAccess, [:admin, :super_admin, :owner]
plug PlausibleWeb.Plugs.NoRobots
end
diff --git a/test/plausible_web/controllers/site_controller_test.exs b/test/plausible_web/controllers/site_controller_test.exs
index bd9523a4b8..066b45bdc8 100644
--- a/test/plausible_web/controllers/site_controller_test.exs
+++ b/test/plausible_web/controllers/site_controller_test.exs
@@ -1480,8 +1480,7 @@ defmodule PlausibleWeb.SiteControllerTest do
conn = delete(conn, "/sites/#{site.domain}/shared-links/#{link.slug}")
assert Repo.one(Plausible.Site.SharedLink)
- assert redirected_to(conn, 302) =~ "/#{URI.encode_www_form(site.domain)}/settings"
- assert Phoenix.Flash.get(conn.assigns.flash, :error) == "Could not find Shared Link"
+ assert html_response(conn, 404)
end
end
diff --git a/test/plausible_web/plugs/authorise_site_access_test.exs b/test/plausible_web/plugs/authorise_site_access_test.exs
deleted file mode 100644
index ddc8d91ad5..0000000000
--- a/test/plausible_web/plugs/authorise_site_access_test.exs
+++ /dev/null
@@ -1,39 +0,0 @@
-defmodule PlausibleWeb.AuthorizeSiteAccessTest do
- use PlausibleWeb.ConnCase, async: true
- alias PlausibleWeb.AuthorizeSiteAccess
-
- setup [:create_user, :log_in]
-
- test "doesn't allow :website bypass with :domain in body", %{conn: conn, user: me} do
- my_site = insert(:site, memberships: [build(:site_membership, user: me, role: :owner)])
-
- other_site =
- insert(:site, memberships: [build(:site_membership, user: insert(:user), role: :owner)])
-
- conn =
- conn
- |> bypass_through(PlausibleWeb.Router)
- |> get("/#{other_site.domain}/settings", %{"domain" => my_site.domain})
- |> AuthorizeSiteAccess.call([:admin, :owner])
-
- assert conn.halted
- assert conn.status == 404
- assert conn.path_params == %{"website" => other_site.domain}
- end
-
- test "returns 404 with custom error message for failed API routes", %{conn: conn, user: user} do
- site = insert(:site, memberships: [build(:site_membership, user: user, role: :viewer)])
-
- conn =
- conn
- |> bypass_through(PlausibleWeb.Router)
- |> get("/api/stats/#{site.domain}/main-graph")
- |> AuthorizeSiteAccess.call([:admin, :owner, :super_admin])
-
- assert conn.halted
- assert conn.status == 404
-
- assert conn.resp_body ==
- "{\"error\":\"Site does not exist or user does not have sufficient access.\"}"
- end
-end
diff --git a/test/plausible_web/plugs/authorize_site_access_test.exs b/test/plausible_web/plugs/authorize_site_access_test.exs
new file mode 100644
index 0000000000..2d9beb3264
--- /dev/null
+++ b/test/plausible_web/plugs/authorize_site_access_test.exs
@@ -0,0 +1,254 @@
+defmodule PlausibleWeb.Plugs.AuthorizeSiteAccessTest do
+ use PlausibleWeb.ConnCase, async: false
+ alias PlausibleWeb.Plugs.AuthorizeSiteAccess
+
+ setup [:create_user, :log_in, :create_site]
+
+ test "init rejects invalid role names" do
+ assert_raise ArgumentError, fn ->
+ AuthorizeSiteAccess.init(_allowed_roles = [:admin, :invalid])
+ end
+ end
+
+ test "returns 404 on non-existent site", %{conn: conn} do
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/invalid.domain")
+ |> AuthorizeSiteAccess.call(_all_allowed_roles = [])
+
+ assert conn.halted
+ assert html_response(conn, 404)
+ end
+
+ test "rejects user completely unrelated to the site", %{conn: conn} do
+ site = insert(:site, members: [build(:user)])
+
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/#{site.domain}")
+ |> AuthorizeSiteAccess.call(_all_allowed_roles = [])
+
+ assert conn.halted
+ assert html_response(conn, 404)
+ end
+
+ test "doesn't allow bypassing :domain in path with :website or :domain in query param", %{
+ conn: conn,
+ site: site
+ } do
+ other_site = insert(:site, members: [build(:user)])
+
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/#{other_site.domain}/export", %{
+ "domain" => site.domain,
+ "website" => site.domain
+ })
+ |> AuthorizeSiteAccess.call(_allowed_roles = [:admin, :owner])
+
+ assert conn.halted
+ assert html_response(conn, 404)
+ assert conn.path_params == %{"domain" => other_site.domain}
+ end
+
+ test "doesn't allow bypassing :website in path with :website or :domain in query param", %{
+ conn: conn,
+ site: site
+ } do
+ other_site = insert(:site, members: [build(:user)])
+
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/sites/#{other_site.domain}/change-domain", %{
+ "domain" => site.domain,
+ "website" => site.domain
+ })
+ |> AuthorizeSiteAccess.call(_allowed_roles = [:admin, :owner])
+
+ assert conn.halted
+ assert conn.status == 404
+ assert conn.path_params == %{"website" => other_site.domain}
+ end
+
+ test "returns 404 with custom error message for failed API routes", %{conn: conn, user: user} do
+ site = insert(:site, memberships: [build(:site_membership, user: user, role: :viewer)])
+
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/api/stats/#{site.domain}/main-graph")
+ |> AuthorizeSiteAccess.call([:admin, :owner, :super_admin])
+
+ assert conn.halted
+
+ assert json_response(conn, 404) == %{
+ "error" => "Site does not exist or user does not have sufficient access."
+ }
+ end
+
+ test "rejects unrelated shared link slug even if user is permitted for site", %{
+ conn: conn,
+ site: site
+ } do
+ shared_link_other_site = insert(:shared_link, site: build(:site))
+
+ params = %{"shared_link" => %{"name" => "some name"}}
+
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> put("/sites/#{site.domain}/shared-links/#{shared_link_other_site.slug}", params)
+ |> AuthorizeSiteAccess.call(_allowed_roles = [:super_admin, :admin, :owner])
+
+ assert conn.halted
+ assert conn.status == 404
+ end
+
+ test "rejects user not permitted to site trying to use unrelated shared link for another one",
+ %{
+ conn: conn,
+ user: user,
+ site: site
+ } do
+ shared_link = insert(:shared_link, site: site)
+ other_site = insert(:site, members: [user])
+
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/#{other_site.domain}", %{"auth" => shared_link.slug})
+ |> AuthorizeSiteAccess.call(_all_allowed_roles = [])
+
+ assert conn.halted
+ assert conn.status == 404
+ end
+
+ test "doesn't allow bypassing :slug in path with :slug or :auth in query param", %{
+ conn: conn,
+ site: site
+ } do
+ shared_link = insert(:shared_link, site: site)
+ shared_link_other_site = insert(:shared_link, site: build(:site))
+
+ params = %{
+ "shared_link" => %{"name" => "some name"},
+ "slug" => shared_link.slug,
+ "auth" => shared_link.slug
+ }
+
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> put("/sites/#{site.domain}/shared-links/#{shared_link_other_site.slug}", params)
+ |> AuthorizeSiteAccess.call(_allowed_roles = [:super_admin, :admin, :owner])
+
+ assert conn.halted
+ assert conn.status == 404
+ end
+
+ test "rejects user on mismatched membership role", %{conn: conn, user: user} do
+ site =
+ insert(:site, memberships: [build(:site_membership, user: user, role: :admin)])
+
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/#{site.domain}")
+ |> AuthorizeSiteAccess.call(_all_allowed_roles = [:owner])
+
+ assert conn.halted
+ assert html_response(conn, 404)
+ end
+
+ for role <- [:viewer, :admin, :owner] do
+ test "allows user based on their #{role} membership", %{conn: conn, user: user} do
+ site =
+ insert(:site, memberships: [build(:site_membership, user: user, role: unquote(role))])
+
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/#{site.domain}")
+ |> AuthorizeSiteAccess.call(_all_allowed_roles = [unquote(role)])
+
+ refute conn.halted
+ assert conn.assigns.site.id == site.id
+ assert conn.assigns.current_user_role == unquote(role)
+ end
+ end
+
+ @tag :ee_only
+ test "allows user based on their superadmin status", %{conn: conn, user: user} do
+ site = insert(:site, members: [build(:user)])
+
+ patch_env(:super_admin_user_ids, [user.id])
+
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/#{site.domain}")
+ |> AuthorizeSiteAccess.call(_all_allowed_roles = [:super_admin])
+
+ refute conn.halted
+ assert conn.assigns.site.id == site.id
+ assert conn.assigns.current_user_role == :super_admin
+ end
+
+ test "allows user based on website visibility (authenticated user)", %{conn: conn} do
+ site = insert(:site, members: [build(:user)], public: true)
+
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/#{site.domain}")
+ |> AuthorizeSiteAccess.call(_all_allowed_roles = [:public])
+
+ refute conn.halted
+ assert conn.assigns.site.id == site.id
+ end
+
+ test "allows user based on website visibility (anonymous request)" do
+ site = insert(:site, members: [build(:user)], public: true)
+
+ conn =
+ build_conn()
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/#{site.domain}")
+ |> AuthorizeSiteAccess.call(_all_allowed_roles = [:public])
+
+ refute conn.halted
+ assert conn.assigns.site.id == site.id
+ end
+
+ test "allows user based on shared link auth (authenticated user)", %{conn: conn} do
+ site = insert(:site, members: [build(:user)])
+ shared_link = insert(:shared_link, site: site)
+
+ conn =
+ conn
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/#{site.domain}", %{"auth" => shared_link.slug})
+ |> AuthorizeSiteAccess.call(_all_allowed_roles = [:public])
+
+ refute conn.halted
+ assert conn.assigns.site.id == site.id
+ end
+
+ test "allows user based on shared link auth (anonymous request)" do
+ site = insert(:site, members: [build(:user)])
+ shared_link = insert(:shared_link, site: site)
+
+ conn =
+ build_conn()
+ |> bypass_through(PlausibleWeb.Router)
+ |> get("/#{site.domain}", %{"auth" => shared_link.slug})
+ |> AuthorizeSiteAccess.call(_all_allowed_roles = [:public])
+
+ refute conn.halted
+ assert conn.assigns.site.id == site.id
+ end
+end