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
Remove support for legacy user sessions (#4540)
Adrian Gruntkowskif7bbbf8c337c
diff --git a/lib/plausible_web/live/reset_password_form.ex b/lib/plausible_web/live/reset_password_form.exindex 6b757d4ec0..7d60240360 100644--- a/lib/plausible_web/live/reset_password_form.ex+++ b/lib/plausible_web/live/reset_password_form.ex@@ -10,6 +10,7 @@ defmodule PlausibleWeb.Live.ResetPasswordForm doalias Plausible.Authalias Plausible.Repo+ alias PlausibleWeb.UserAuthdef mount(_params, %{"email" => email}, socket) dosocket =@@ -96,7 +97,8 @@ defmodule PlausibleWeb.Live.ResetPasswordForm doend)case result do- {:ok, _user} ->+ {:ok, user} ->+ UserAuth.revoke_all_user_sessions(user){:noreply, assign(socket, trigger_submit: true)}{:error, changeset} ->diff --git a/lib/plausible_web/plugs/session_timeout_plug.ex b/lib/plausible_web/plugs/session_timeout_plug.exdeleted file mode 100644index 0add19b18b..0000000000--- a/lib/plausible_web/plugs/session_timeout_plug.ex+++ /dev/null@@ -1,43 +0,0 @@-defmodule PlausibleWeb.SessionTimeoutPlug do- @moduledoc """- NOTE: This plug will be replaced with a different- session expiration mechanism once server-side persisted- sessions are rolled out.- """- import Plug.Conn-- def init(opts \\ []) do- opts- end-- def call(conn, opts) do- timeout_at = get_session(conn, :session_timeout_at)- user_id = get_session(conn, :current_user_id)-- cond do- user_id && timeout_at && now() > timeout_at ->- conn- |> PlausibleWeb.UserAuth.log_out_user()- |> Phoenix.Controller.redirect(to: "/login")- |> halt()-- user_id ->- put_session(- conn,- :session_timeout_at,- new_session_timeout_at(opts[:timeout_after_seconds])- )-- true ->- conn- end- end-- defp now do- DateTime.utc_now() |> DateTime.to_unix()- end-- defp new_session_timeout_at(timeout_after_seconds) do- now() + timeout_after_seconds- end-enddiff --git a/lib/plausible_web/plugs/user_session_touch.ex b/lib/plausible_web/plugs/user_session_touch.exindex 560b68be00..5802a0c231 100644--- a/lib/plausible_web/plugs/user_session_touch.ex+++ b/lib/plausible_web/plugs/user_session_touch.ex@@ -12,9 +12,6 @@ defmodule PlausibleWeb.Plugs.UserSessionTouch doenddef call(conn, _opts) do- # NOTE: Needed only during transitional 14-day period- conn = UserAuth.convert_legacy_session(conn)-if user_session = conn.assigns[:current_user_session] doassign(conn,diff --git a/lib/plausible_web/router.ex b/lib/plausible_web/router.exindex fb601c259d..45b368e764 100644--- a/lib/plausible_web/router.ex+++ b/lib/plausible_web/router.ex@@ -2,7 +2,6 @@ defmodule PlausibleWeb.Router douse PlausibleWeb, :routeruse Plausibleimport Phoenix.LiveView.Router- @two_weeks_in_seconds 60 * 60 * 24 * 14pipeline :browser doplug :accepts, ["html"]@@ -11,7 +10,6 @@ defmodule PlausibleWeb.Router doplug :put_secure_browser_headersplug PlausibleWeb.Plugs.NoRobotson_ee(do: nil, else: plug(PlausibleWeb.FirstLaunchPlug, redirect_to: "/register"))- plug PlausibleWeb.SessionTimeoutPlug, timeout_after_seconds: @two_weeks_in_secondsplug PlausibleWeb.AuthPlugplug PlausibleWeb.Plugs.UserSessionTouchenddiff --git a/lib/plausible_web/user_auth.ex b/lib/plausible_web/user_auth.exindex c850b2c087..02cec2c645 100644--- a/lib/plausible_web/user_auth.ex+++ b/lib/plausible_web/user_auth.ex@@ -1,15 +1,6 @@defmodule PlausibleWeb.UserAuth do@moduledoc """Functions for user session management.-- In it's current shape, both current (legacy) and soon to be implemented (new)- user sessions are supported side by side.-- The legacy token is still accepted from the session cookie. Once 14 days- pass (the current time window for which session cookie is valid without- any activity), the legacy cookies won't be accepted anymore (legacy token- retrieval is tracked with logging) and the logic will be cleaned of branching- for legacy session."""import Ecto.Query, only: [from: 2]@@ -61,12 +52,7 @@ defmodule PlausibleWeb.UserAuth doendend- @spec touch_user_session(Auth.UserSession.t()) :: Auth.UserSession.t()- def touch_user_session(%{token: nil} = user_session) do- # NOTE: Legacy token sessions can't be touched.- user_session- end-+ @spec touch_user_session(Auth.UserSession.t(), NaiveDateTime.t()) :: Auth.UserSession.t()def touch_user_session(user_session, now \\ NaiveDateTime.utc_now(:second)) doif NaiveDateTime.diff(now, user_session.last_used_at, :hour) >= 1 doPlausible.Users.bump_last_seen(user_session.user_id, now)@@ -79,6 +65,18 @@ defmodule PlausibleWeb.UserAuth doendend+ @spec revoke_all_user_sessions(Auth.User.t()) :: :ok+ def revoke_all_user_sessions(user) do+ {_count, tokens} =+ Repo.delete_all(+ from us in Auth.UserSession, where: us.user_id == ^user.id, select: us.token+ )++ Enum.each(tokens, fn token ->+ PlausibleWeb.Endpoint.broadcast(live_socket_id(token), "disconnect", %{})+ end)+ end+@doc """Sets the `logged_in` cookie share with the static site for determiningwhether client is authenticated.@@ -94,33 +92,7 @@ defmodule PlausibleWeb.UserAuth do)end- @spec convert_legacy_session(Plug.Conn.t()) :: Plug.Conn.t()- def convert_legacy_session(conn) do- current_user = conn.assigns[:current_user]-- if current_user && Plug.Conn.get_session(conn, :current_user_id) do- {token, user_session} = create_user_session(conn, current_user)-- conn- |> put_token_in_session(token)- |> Plug.Conn.delete_session(:current_user_id)- |> Plug.Conn.assign(:current_user_session, user_session)- else- conn- end- end-- defp get_session_by_token({:legacy, user_id}) do- case Plausible.Users.with_subscription(user_id) do- %Auth.User{} = user ->- {:ok, %Auth.UserSession{user_id: user.id, user: user}}-- nil ->- {:error, :session_not_found}- end- end-- defp get_session_by_token({:new, token}) do+ defp get_session_by_token(token) donow = NaiveDateTime.utc_now(:second)last_subscription_query = Plausible.Users.last_subscription_join_query()@@ -165,10 +137,14 @@ defmodule PlausibleWeb.UserAuth doPlug.Conn.delete_resp_cookie(conn, "logged_in")end- defp put_token_in_session(conn, {:new, token}) do+ defp put_token_in_session(conn, token) doconn|> Plug.Conn.put_session(:user_token, token)- |> Plug.Conn.put_session(:live_socket_id, "user_sessions:#{Base.url_encode64(token)}")+ |> Plug.Conn.put_session(:live_socket_id, live_socket_id(token))+ end++ defp live_socket_id(token) do+ "user_sessions:#{Base.url_encode64(token)}"enddefp get_user_token(%Plug.Conn{} = conn) do@@ -178,12 +154,7 @@ defmodule PlausibleWeb.UserAuth doenddefp get_user_token(%{"user_token" => token}) when is_binary(token) do- {:ok, {:new, token}}- end-- defp get_user_token(%{"current_user_id" => user_id}) when is_integer(user_id) do- Logger.warning("Legacy user session detected (user: #{user_id})")- {:ok, {:legacy, user_id}}+ {:ok, token}enddefp get_user_token(_) do@@ -198,12 +169,10 @@ defmodule PlausibleWeb.UserAuth do|> Auth.UserSession.new_session(device_name)|> Repo.insert!()- {{:new, user_session.token}, user_session}+ {user_session.token, user_session}end- defp remove_user_session({:legacy, _}), do: :ok-- defp remove_user_session({:new, token}) do+ defp remove_user_session(token) doRepo.delete_all(from us in Auth.UserSession, where: us.token == ^token):okenddiff --git a/test/plausible_web/live/reset_password_form_test.exs b/test/plausible_web/live/reset_password_form_test.exsindex 3acaedfc39..2f0f8f9d6f 100644--- a/test/plausible_web/live/reset_password_form_test.exs+++ b/test/plausible_web/live/reset_password_form_test.exs@@ -1,6 +1,7 @@defmodule PlausibleWeb.Live.ResetPasswordFormTest douse PlausibleWeb.ConnCase, async: true+ import Phoenix.ChannelTestimport Phoenix.LiveViewTestimport Plausible.Test.Support.HTML@@ -60,6 +61,32 @@ defmodule PlausibleWeb.Live.ResetPasswordFormTest doendend+ describe "/password/reset with logged in user" do+ setup [:create_user, :log_in]++ test "revokes all active user sessions when present", %{conn: conn, user: user} do+ assert [active_session] = Repo.preload(user, :sessions).sessions+ live_socket_id = "user_sessions:" <> Base.url_encode64(active_session.token)+ Phoenix.PubSub.subscribe(Plausible.PubSub, live_socket_id)++ another_session =+ user+ |> Plausible.Auth.UserSession.new_session("Some Device")+ |> Repo.insert!()++ token = Token.sign_password_reset(user.email)++ lv = get_liveview(conn, "/password/reset?token=#{token}")++ type_into_passowrd(lv, "very-secret-and-very-long-123")+ lv |> element("form") |> render_submit()++ assert [] = Repo.preload(user, :sessions).sessions+ assert_broadcast "disconnect", %{}+ refute Repo.reload(another_session)+ end+ end+defp get_liveview(conn, url) doconn = assign(conn, :live_module, PlausibleWeb.Live.ResetPasswordForm){:ok, lv, _html} = live(conn, url)diff --git a/test/plausible_web/plugs/session_timeout_plug_test.exs b/test/plausible_web/plugs/session_timeout_plug_test.exsdeleted file mode 100644index 8a95fc75b9..0000000000--- a/test/plausible_web/plugs/session_timeout_plug_test.exs+++ /dev/null@@ -1,47 +0,0 @@-defmodule PlausibleWeb.SessionTimeoutPlugTest do- use Plausible.DataCase, async: true- use Plug.Test-- import Plausible.Factory-- alias PlausibleWeb.SessionTimeoutPlug-- @opts %{timeout_after_seconds: 10}-- @moduletag :capture_log-- test "does nothing if user is not logged in" do- conn =- conn(:get, "/")- |> init_test_session(%{})- |> SessionTimeoutPlug.call(@opts)-- refute get_session(conn, :session_timeout_at)- end-- test "sets session timeout if user is logged in" do- user = insert(:user)-- conn =- conn(:get, "/")- |> init_test_session(%{current_user_id: user.id})- |> SessionTimeoutPlug.call(@opts)-- timeout = get_session(conn, :session_timeout_at)- now = DateTime.utc_now() |> DateTime.to_unix()- assert timeout > now- end-- test "logs user out if timeout passed" do- user = insert(:user)-- conn =- conn(:get, "/")- |> init_test_session(%{current_user_id: user.id, session_timeout_at: 1})- |> SessionTimeoutPlug.call(@opts)-- assert conn.private[:plug_session_info] == :renew- assert conn.halted- assert Phoenix.ConnTest.redirected_to(conn, 302) == "/login"- end-enddiff --git a/test/plausible_web/plugs/user_session_touch_test.exs b/test/plausible_web/plugs/user_session_touch_test.exsindex 085d7dc780..b28ab37552 100644--- a/test/plausible_web/plugs/user_session_touch_test.exs+++ b/test/plausible_web/plugs/user_session_touch_test.exs@@ -7,8 +7,6 @@ defmodule PlausibleWeb.Plugs.UserSessionTouchTest dosetup [:create_user, :log_in]- @moduletag :capture_log-test "refreshes session", %{conn: conn, user: user} donow = NaiveDateTime.utc_now(:second)one_day_ago = NaiveDateTime.shift(now, day: -1)@@ -36,24 +34,6 @@ defmodule PlausibleWeb.Plugs.UserSessionTouchTest dorefute conn.haltedassert get_session(conn, :login_dest) == "/"- refute get_session(conn, :current_user_id)refute get_session(conn, :user_token)end-- test "converts legacy session when present", %{user: user} do- %{sessions: [other_session]} = Repo.preload(user, :sessions)-- conn =- build_conn()- |> init_session()- |> put_session(:current_user_id, user.id)- |> AuthPlug.call([])- |> UserSessionTouch.call([])-- refute get_session(conn, :current_user_id)- assert user_token = get_session(conn, :user_token)- assert conn.assigns.current_user_session.id- assert conn.assigns.current_user_session.id != other_session.id- assert conn.assigns.current_user_session.token == user_token- endenddiff --git a/test/plausible_web/user_auth_test.exs b/test/plausible_web/user_auth_test.exsindex a79c8ab0ad..60d0416e05 100644--- a/test/plausible_web/user_auth_test.exs+++ b/test/plausible_web/user_auth_test.exs@@ -2,7 +2,7 @@ defmodule PlausibleWeb.UserAuthTest douse PlausibleWeb.ConnCase, async: trueimport Ecto.Query, only: [from: 2]- import ExUnit.CaptureLog+ import Phoenix.ChannelTestalias Plausible.Authalias Plausible.Repo@@ -10,8 +10,6 @@ defmodule PlausibleWeb.UserAuthTest doalias PlausibleWeb.Router.Helpers, as: Routes- @moduletag capture_log: true-describe "log_in_user/2,3" dosetup [:create_user]@@ -86,7 +84,6 @@ defmodule PlausibleWeb.UserAuthTest doassert another_session.token == another_session_tokenassert conn.private[:plug_session_info] == :renewassert conn.resp_cookies["logged_in"].max_age == 0- assert get_session(conn, :current_user_id) == nilassert get_session(conn, :login_dest) == nilendend@@ -100,27 +97,22 @@ defmodule PlausibleWeb.UserAuthTest doendtest "gets session from session data map", %{user: user} do- user_id = user.id%{sessions: [user_session]} = Repo.preload(user, :sessions)assert {:ok, session_from_token} =UserAuth.get_user_session(%{"user_token" => user_session.token})assert session_from_token.id == user_session.id-- capture_log(fn ->- assert {:ok, %Auth.UserSession{user_id: ^user_id, token: nil}} =- UserAuth.get_user_session(%{"current_user_id" => user.id})- end) =~ "Legacy user session detected"endtest "returns error on invalid or missing session data" doconn = init_session(build_conn())assert {:error, :no_valid_token} = UserAuth.get_user_session(conn)assert {:error, :no_valid_token} = UserAuth.get_user_session(%{})+ assert {:error, :no_valid_token} = UserAuth.get_user_session(%{"current_user_id" => 123})end- test "returns error on missing session (new token scaffold; to be revised)", %{+ test "returns error on missing session", %{conn: conn,user: user} do@@ -229,64 +221,37 @@ defmodule PlausibleWeb.UserAuthTest dorefute Repo.reload(user_session)end-- test "skips refreshing legacy session", %{user: user} do- user_session = %Auth.UserSession{user_id: user.id}-- assert UserAuth.touch_user_session(user_session) == user_session- endend- describe "convert_legacy_session/1" do+ describe "revoke_all_user_sessions/1" dosetup [:create_user, :log_in]- test "does nothing when there's no authenticated session" do- conn =- build_conn()- |> init_session()- |> UserAuth.convert_legacy_session()-- refute get_session(conn, :user_token)- refute get_session(conn, :live_socket_id)- refute conn.assigns[:current_user_session]+ test "deletes and disconnects all user's sessions", %{user: user} do+ assert [active_session] = Repo.preload(user, :sessions).sessions+ live_socket_id = "user_sessions:" <> Base.url_encode64(active_session.token)+ Phoenix.PubSub.subscribe(Plausible.PubSub, live_socket_id)++ another_session =+ user+ |> Auth.UserSession.new_session("Some Device")+ |> Repo.insert!()++ unrelated_session =+ insert(:user)+ |> Auth.UserSession.new_session("Some Device")+ |> Repo.insert!()++ assert :ok = UserAuth.revoke_all_user_sessions(user)+ assert [] = Repo.preload(user, :sessions).sessions+ assert_broadcast "disconnect", %{}+ refute Repo.reload(another_session)+ assert Repo.reload(unrelated_session)end- test "does nothing when there's a new token-based session already", %{conn: conn, user: user} do- %{sessions: [user_session]} = Repo.preload(user, :sessions)+ test "executes gracefully when user has no sessions" do+ user = insert(:user)- conn =- conn- |> UserAuth.convert_legacy_session()- |> PlausibleWeb.AuthPlug.call([])-- assert get_session(conn, :user_token) == user_session.token-- assert get_session(conn, :live_socket_id) ==- "user_sessions:#{Base.url_encode64(user_session.token)}"-- assert conn.assigns.current_user_session.id == user_session.id- end-- test "converts legacy session to a new one", %{user: user} do- %{sessions: [existing_session]} = Repo.preload(user, :sessions)-- conn =- build_conn()- |> init_session()- |> put_session(:current_user_id, user.id)- |> PlausibleWeb.AuthPlug.call([])- |> UserAuth.convert_legacy_session()-- assert conn.assigns.current_user_session.id- assert conn.assigns.current_user_session.id != existing_session.id- assert conn.assigns.current_user_session.token != existing_session.token- assert conn.assigns.current_user_session.user_id == user.id- assert conn.assigns.current_user.id == user.id- refute get_session(conn, :current_user_id)- assert get_session(conn, :user_token) == conn.assigns.current_user_session.token-- assert get_session(conn, :live_socket_id) ==- "user_sessions:#{Base.url_encode64(conn.assigns.current_user_session.token)}"+ assert :ok = UserAuth.revoke_all_user_sessions(user)endend