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 core logic for TOTP support (#3525)
Adrian Gruntkowski65cc8980e092
diff --git a/config/.env.dev b/config/.env.devindex 575b699749..64e3239e25 100644--- a/config/.env.dev+++ b/config/.env.dev@@ -3,6 +3,7 @@ SECURE_COOKIE=falseDATABASE_URL=postgres://postgres:[email protected]:5432/plausible_devCLICKHOUSE_DATABASE_URL=http://127.0.0.1:8123/plausible_events_dbSECRET_KEY_BASE=/njrhntbycvastyvtk1zycwfm981vpo/0xrvwjjvemdakc/vsvbrevlwsc6u8rcg+TOTP_VAULT_KEY=Q3BD4nddbkVJIPXgHuo5NthGKSIH0yesRfG05J88HIo=ENVIRONMENT=devMAILER_ADAPTER=Bamboo.LocalAdapterLOG_LEVEL=debugdiff --git a/config/.env.test b/config/.env.testindex cf4f019e84..050d6f8799 100644--- a/config/.env.test+++ b/config/.env.test@@ -1,6 +1,7 @@DATABASE_URL=postgres://postgres:[email protected]:5432/plausible_test?pool_size=40CLICKHOUSE_DATABASE_URL=http://127.0.0.1:8123/plausible_testSECRET_KEY_BASE=/njrhntbycvastyvtk1zycwfm981vpo/0xrvwjjvemdakc/vsvbrevlwsc6u8rcg+TOTP_VAULT_KEY=1Jah1HEOnCEnmBE+4/OgbJRraJIppPmYCNbZoFJboZs=BASE_URL=http://localhost:8000CRON_ENABLED=falseLOG_LEVEL=warningdiff --git a/config/runtime.exs b/config/runtime.exsindex 3c10b42377..ef71eb492a 100644--- a/config/runtime.exs+++ b/config/runtime.exs@@ -145,6 +145,20 @@ ch_db_url =|> get_var_from_path_or_env("CLICKHOUSE_MAX_BUFFER_SIZE", "10000")|> Integer.parse()+# Can be generated with `Base.encode64(:crypto.strong_rand_bytes(32))` from+# iex shell or `openssl rand -base64 32` from command line.+totp_vault_key = get_var_from_path_or_env(config_dir, "TOTP_VAULT_KEY", nil)++case totp_vault_key do+ nil ->+ raise "TOTP_VAULT_KEY configuration option is required. See https://plausible.io/docs/self-hosting-configuration#server"++ key ->+ if byte_size(Base.decode64!(key)) != 32 do+ raise "TOTP_VAULT_KEY must exactly 32 bytes long. See https://plausible.io/docs/self-hosting-configuration#server"+ end+end+### Mandatory params Endbuild_metadata_raw = get_var_from_path_or_env(config_dir, "BUILD_METADATA", "{}")@@ -177,6 +191,8 @@ runtime_metadata = [config :plausible, :runtime_metadata, runtime_metadata+config :plausible, Plausible.Auth.TOTP, vault_key: totp_vault_key+sentry_dsn = get_var_from_path_or_env(config_dir, "SENTRY_DSN")honeycomb_api_key = get_var_from_path_or_env(config_dir, "HONEYCOMB_API_KEY")honeycomb_dataset = get_var_from_path_or_env(config_dir, "HONEYCOMB_DATASET")diff --git a/lib/plausible/application.ex b/lib/plausible/application.exindex 1ad972dd95..b5a91296fb 100644--- a/lib/plausible/application.ex+++ b/lib/plausible/application.ex@@ -28,6 +28,7 @@ defmodule Plausible.Application do{Plausible.Site.Cache, []},{Plausible.Site.Cache.Warmer.All, []},{Plausible.Site.Cache.Warmer.RecentlyUpdated, []},+ {Plausible.Auth.TOTP.Vault, key: totp_vault_key()},PlausibleWeb.Endpoint,{Oban, Application.get_env(:plausible, Oban)},Plausible.PromEx@@ -50,6 +51,13 @@ defmodule Plausible.Application do:okend+ defp totp_vault_key() do+ :plausible+ |> Application.fetch_env!(Plausible.Auth.TOTP)+ |> Keyword.fetch!(:vault_key)+ |> Base.decode64!()+ end+defp finch_pool_config() dobase_config = %{"https://icons.duckduckgo.com" => [diff --git a/lib/plausible/auth/totp.ex b/lib/plausible/auth/totp.exnew file mode 100644index 0000000000..a6a64b88d8--- /dev/null+++ b/lib/plausible/auth/totp.ex@@ -0,0 +1,282 @@+defmodule Plausible.Auth.TOTP do+ @moduledoc """+ TOTP auth context++ Handles all the aspects of TOTP setup, management and validation for users.++ ## Setup++ TOTP setup is started with `initiate/1`. At this stage, a random secret+ binary is generated for user and stored under `User.totp_secret`. The secret+ is additionally encrypted while stored in the database using `Cloak`. The+ vault for safe storage is configured in `Plausible.Auth.TOTP.Vault` via+ a dedicated `Ecto` type defined in `Plausible.Auth.TOTP.EncryptedBinary`.+ The function returns updated user along with TOTP URI and a readable form+ of secret. Both - the URI and readable secret - are meant for exposure+ in the user's setup screen. The URI should be encoded as a QR code.++ After initiation, user is expected to confirm valid setup with `enable/2`,+ providing TOTP code from their authenticator app. After code validation+ passes successfully, the `User.totp_enabled` flag is set to `true`.++ Finally, the user must be immediately presented with a list of recovery codes+ generated with `generate_recovery_codes/1`. The codes should be presented+ in copy/paste friendly form, ideally also with a print-friendly view option.+ The function can be run more than once, giving the user ability to regenerate+ codes from the final stage of setup if needed.++ The `initiate/1` and `enable/1` functions can be safely called multiple+ times, allowing user to abort and restart setup up to these stages.++ ## Management++ State of TOTP for a particular user can be chcecked by calling `enabled?/1`.++ TOTP can be disabled with `disable/2`. User is expected to provide their+ current password for safety. Once disabled, all TOTP user settings are+ cleared and any remaining generated recovery codes are removed. The function+ can be safely run more than once.++ If the user needs to regenerate the recovery codes outside of setup procedure,+ they must do it via `generate_recovery_codes_protected/2`, providing+ their current password for safety. They must be warned that any existing+ recovery codes will be invalidated.++ ## Validation++ After logging in, user's TOTP state must be checked with `enabled?/1`.++ If enabled, user must be presented with TOTP code input form accepting+ 6 digit characters. The code must be checked using `validate_code/2`.++ User must have an option to alternatively input one of their recovery+ codes. Those codes must be checked with `use_recovery_code/2`.++ ## Code validity++ In case of TOTP codes, a grace period of 30 seconds is applied, which+ allows user to use their current and previous TOTP code, assuming 30+ second validity window of each. This allows user to use code that was+ about to expire before the submission. Regardless of that, each TOTP+ code can be used only once. Validation procedure rejects repeat use+ of the same code for safety. It's done by tracking last time a TOTP+ code was used successfully, stored under `User.totp_last_used_at`.++ In case of recovery codes, each code is deleted immediately after use.+ They are strictly one-time use only.++ """++ import Ecto.Changeset, only: [change: 2]+ import Ecto.Query, only: [from: 2]++ alias Plausible.Auth+ alias Plausible.Auth.TOTP+ alias Plausible.Repo++ @issuer_name "Plausible Analytics"+ @recovery_codes_count 10++ @spec enabled?(Auth.User.t()) :: boolean()+ def enabled?(user) do+ user.totp_enabled and not is_nil(user.totp_secret)+ end++ @spec initiate(Auth.User.t()) ::+ {:ok, Auth.User.t(), %{totp_uri: String.t(), secret: String.t()}}+ | {:error, :not_verified | :already_setup}+ def initiate(%{email_verified: false}) do+ {:error, :not_verified}+ end++ def initiate(%{totp_enabled: true}) do+ {:error, :already_setup}+ end++ def initiate(user) do+ secret = NimbleTOTP.secret()++ user =+ user+ |> change(+ totp_enabled: false,+ totp_secret: secret+ )+ |> Repo.update!()++ {:ok, user, %{totp_uri: totp_uri(user), secret: readable_secret(user)}}+ end++ @spec enable(Auth.User.t(), String.t(), Keyword.t()) ::+ {:ok, Auth.User.t()} | {:error, :invalid_code | :not_initiated}+ def enable(user, code, opts \\ [])++ def enable(%{totp_secret: nil}, _, _) do+ {:error, :not_initiated}+ end++ def enable(user, code, opts) do+ with {:ok, user} <- do_validate_code(user, code, opts) do+ user =+ user+ |> change(totp_enabled: true)+ |> Repo.update!()++ {:ok, user}+ end+ end++ @spec disable(Auth.User.t(), String.t()) :: {:ok, Auth.User.t()} | {:error, :invalid_password}+ def disable(user, password) do+ if Auth.Password.match?(password, user.password_hash) do+ Repo.transaction(fn ->+ {_, _} =+ user+ |> recovery_codes_query()+ |> Repo.delete_all()++ user+ |> change(+ totp_enabled: false,+ totp_secret: nil,+ totp_last_used_at: nil+ )+ |> Repo.update!()+ end)+ else+ {:error, :invalid_password}+ end+ end++ @spec generate_recovery_codes_protected(Auth.User.t(), String.t()) ::+ {:ok, [String.t()]} | {:error, :invalid_password | :not_enabled}+ def generate_recovery_codes_protected(%{totp_enabled: false}) do+ {:error, :not_enabled}+ end++ def generate_recovery_codes_protected(user, password) do+ if Auth.Password.match?(password, user.password_hash) do+ generate_recovery_codes(user)+ else+ {:error, :invalid_password}+ end+ end++ @spec generate_recovery_codes(Auth.User.t()) :: {:ok, [String.t()]} | {:error, :not_enabled}+ def generate_recovery_codes(%{totp_enabled: false}) do+ {:error, :not_enabled}+ end++ def generate_recovery_codes(user) do+ Repo.transaction(fn ->+ {_, _} =+ user+ |> recovery_codes_query()+ |> Repo.delete_all()++ plain_codes = TOTP.RecoveryCode.generate_codes(@recovery_codes_count)++ now =+ NaiveDateTime.utc_now()+ |> NaiveDateTime.truncate(:second)++ codes =+ plain_codes+ |> Enum.map(fn plain_code ->+ user+ |> TOTP.RecoveryCode.changeset(plain_code)+ |> TOTP.RecoveryCode.changeset_to_map(now)+ end)++ {_, _} = Repo.insert_all(TOTP.RecoveryCode, codes)++ plain_codes+ end)+ end++ @spec validate_code(Auth.User.t(), String.t()) ::+ {:ok, Auth.User.t(), Keyword.t()} | {:error, :invalid_code | :not_enabled}+ def validate_code(user, code, opts \\ [])++ def validate_code(%{totp_enabled: false}, _, _) do+ {:error, :not_enabled}+ end++ def validate_code(user, code, opts) do+ do_validate_code(user, code, opts)+ end++ @spec use_recovery_code(Auth.User.t(), String.t()) ::+ :ok | {:error, :invalid_code | :not_enabled}+ def user_recovery_code(%{totp_enabled: false}, _) do+ {:error, :not_enabled}+ end++ def use_recovery_code(user, code) do+ matching_code =+ user+ |> recovery_codes_query()+ |> Repo.all()+ |> Enum.find(&TOTP.RecoveryCode.match?(&1, code))++ if matching_code do+ Repo.delete!(matching_code)+ :ok+ else+ {:error, :invalid_code}+ end+ end++ defp totp_uri(user) do+ NimbleTOTP.otpauth_uri("#{@issuer_name}:#{user.email}", user.totp_secret,+ issuer: @issuer_name+ )+ end++ defp readable_secret(user) do+ Base.encode32(user.totp_secret, padding: false)+ end++ defp recovery_codes_query(user) do+ from(rc in TOTP.RecoveryCode, where: rc.user_id == ^user.id)+ end++ defp do_validate_code(user, code, opts) do+ # Necessary because we must be sure the timestamp is current.+ # User struct stored in liveview context on mount might be+ # pretty out of date, for instance.+ last_used =+ if Keyword.get(opts, :allow_reuse?) do+ nil+ else+ fetch_last_used(user)+ end++ time = System.os_time(:second)++ if NimbleTOTP.valid?(user.totp_secret, code, since: last_used, time: time) or+ NimbleTOTP.valid?(user.totp_secret, code, since: last_used, time: time - 30) do+ {:ok, bump_last_used!(user)}+ else+ {:error, :invalid_code}+ end+ end++ defp fetch_last_used(user) do+ datetime =+ from(u in Plausible.Auth.User, where: u.id == ^user.id, select: u.totp_last_used_at)+ |> Repo.one()++ if datetime do+ Timex.to_unix(datetime)+ end+ end++ defp bump_last_used!(user) do+ now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)++ user+ |> change(totp_last_used_at: now)+ |> Repo.update!()+ end+enddiff --git a/lib/plausible/auth/totp/encrypted_binary.ex b/lib/plausible/auth/totp/encrypted_binary.exnew file mode 100644index 0000000000..6683fab1e3--- /dev/null+++ b/lib/plausible/auth/totp/encrypted_binary.ex@@ -0,0 +1,7 @@+defmodule Plausible.Auth.TOTP.EncryptedBinary do+ @moduledoc """+ Defines an Ecto type so Cloak.Ecto can encrypt/decrypt a binary field.+ """++ use Cloak.Ecto.Binary, vault: Plausible.Auth.TOTP.Vault+enddiff --git a/lib/plausible/auth/totp/recovery_code.ex b/lib/plausible/auth/totp/recovery_code.exnew file mode 100644index 0000000000..0065c6825d--- /dev/null+++ b/lib/plausible/auth/totp/recovery_code.ex@@ -0,0 +1,79 @@+defmodule Plausible.Auth.TOTP.RecoveryCode do+ @moduledoc """+ Schema for TOTP recovery codes.+ """++ use Ecto.Schema++ alias Plausible.Auth++ import Ecto.Changeset++ @type t :: %__MODULE__{}++ @code_length 10++ schema "totp_recovery_codes" do+ field :code_digest, :string++ belongs_to :user, Plausible.Auth.User++ timestamps(updated_at: false)+ end++ @doc """+ Generates `count` unique recovery codes, each alphanumeric+ and #{@code_length} characters long.+ """+ @spec generate_codes(non_neg_integer()) :: [String.t()]+ def generate_codes(count) do+ Stream.repeatedly(&generate_code/0)+ |> Stream.map(&disambiguate/1)+ |> Stream.uniq()+ |> Enum.take(count)+ end++ @spec match?(t(), String.t()) :: boolean()+ def match?(recovery_code, input_code) do+ Bcrypt.verify_pass(input_code, recovery_code.code_digest)+ end++ @spec changeset(Auth.User.t(), String.t()) :: Ecto.Changeset.t()+ def changeset(user, code) do+ %__MODULE__{}+ |> change()+ |> put_assoc(:user, user)+ |> put_change(:code_digest, hash(code))+ end++ @spec changeset_to_map(Ecto.Changeset.t(), NaiveDateTime.t()) :: map()+ def changeset_to_map(changeset, now) do+ changeset+ |> apply_changes()+ |> Map.take([:user_id, :code_digest])+ |> Map.put(:inserted_at, now)+ end++ @safe_disambiguations %{+ "O" => "8",+ "I" => "7"+ }++ @doc false+ # Exposed for testing only+ def disambiguate(code) do+ String.replace(+ code,+ Map.keys(@safe_disambiguations),+ &Map.fetch!(@safe_disambiguations, &1)+ )+ end++ defp generate_code() do+ Base.encode32(:crypto.strong_rand_bytes(6), padding: false)+ end++ defp hash(code) when byte_size(code) == @code_length do+ Bcrypt.hash_pwd_salt(code)+ end+enddiff --git a/lib/plausible/auth/totp/vault.ex b/lib/plausible/auth/totp/vault.exnew file mode 100644index 0000000000..cb4862d7de--- /dev/null+++ b/lib/plausible/auth/totp/vault.ex@@ -0,0 +1,19 @@+defmodule Plausible.Auth.TOTP.Vault do+ @moduledoc """+ Provides a vault that will be used to encrypt/decrypt the TOTP secrets of users who enable it.+ """++ use Cloak.Vault, otp_app: :plausible++ @impl GenServer+ def init(config) do+ {key, config} = Keyword.pop!(config, :key)++ config =+ Keyword.put(config, :ciphers,+ default: {Cloak.Ciphers.AES.GCM, tag: "AES.GCM.V1", iv_length: 12, key: key}+ )++ {:ok, config}+ end+enddiff --git a/lib/plausible/auth/user.ex b/lib/plausible/auth/user.exindex 99a94e7c74..6980da2a0d 100644--- a/lib/plausible/auth/user.ex+++ b/lib/plausible/auth/user.ex@@ -29,6 +29,12 @@ defmodule Plausible.Auth.User dofield :theme, Ecto.Enum, values: [:system, :light, :dark]field :email_verified, :booleanfield :previous_email, :string++ # Fields for TOTP authentication. See `Plausible.Auth.TOTP`.+ field :totp_enabled, :boolean, default: false+ field :totp_secret, Plausible.Auth.TOTP.EncryptedBinary+ field :totp_last_used_at, :naive_datetime+embeds_one :grace_period, Plausible.Auth.GracePeriod, on_replace: :updatehas_many :site_memberships, Plausible.Site.Membershipdiff --git a/mix.exs b/mix.exsindex 85e69019bb..c4b558a0b9 100644--- a/mix.exs+++ b/mix.exs@@ -68,6 +68,8 @@ defmodule Plausible.MixProject do{:bypass, "~> 2.1", only: [:dev, :test, :small_test]},{:cachex, "~> 3.4"},{:ecto_ch, "~> 0.1.10"},+ {:cloak, "~> 1.1"},+ {:cloak_ecto, "~> 1.2"},{:combination, "~> 0.0.3"},{:connection, "~> 1.1", override: true},{:cors_plug, "~> 3.0"},@@ -94,6 +96,7 @@ defmodule Plausible.MixProject do{:location, git: "https://github.com/plausible/location.git"},{:mox, "~> 1.0", only: [:test, :small_test]},{:nanoid, "~> 2.0.2"},+ {:nimble_totp, "~> 1.0"},{:oauther, "~> 1.3"},{:oban, "~> 2.12.0"},{:observer_cli, "~> 1.7"},diff --git a/mix.lock b/mix.lockindex 59363c97b1..d2621cecad 100644--- a/mix.lock+++ b/mix.lock@@ -13,6 +13,8 @@"ch": {:hex, :ch, "0.1.14", "c53489b66eeb83dca63e63155c3e0de74f99ba30a15e90d0cd6b38db86be5891", [:mix], [{:db_connection, "~> 2.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:ecto, "~> 3.5", [hex: :ecto, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mint, "~> 1.0", [hex: :mint, repo: "hexpm", optional: false]}], "hexpm", "306357bd9a92662713b6b9b4244eb94e1ef93ececa3906dbbef7392c4001c8ef"},"chatterbox": {:hex, :ts_chatterbox, "0.13.0", "6f059d97bcaa758b8ea6fffe2b3b81362bd06b639d3ea2bb088335511d691ebf", [:rebar3], [{:hpack, "~> 0.2.3", [hex: :hpack_erl, repo: "hexpm", optional: false]}], "hexpm", "b93d19104d86af0b3f2566c4cba2a57d2e06d103728246ba1ac6c3c0ff010aa7"},"cldr_utils": {:hex, :cldr_utils, "2.24.1", "5ff8c8c55f96666228827bcf85a23d632022def200566346545d01d15e4c30dc", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:certifi, "~> 2.5", [hex: :certifi, repo: "hexpm", optional: true]}, {:decimal, "~> 1.9 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}], "hexpm", "1820300531b5b849d0bc468e5a87cd64f8f2c5191916f548cbe69b2efc203780"},+ "cloak": {:hex, :cloak, "1.1.2", "7e0006c2b0b98d976d4f559080fabefd81f0e0a50a3c4b621f85ceeb563e80bb", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "940d5ac4fcd51b252930fd112e319ea5ae6ab540b722f3ca60a85666759b9585"},+ "cloak_ecto": {:hex, :cloak_ecto, "1.2.0", "e86a3df3bf0dc8980f70406bcb0af2858bac247d55494d40bc58a152590bd402", [:mix], [{:cloak, "~> 1.1.1", [hex: :cloak, repo: "hexpm", optional: false]}, {:ecto, "~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}], "hexpm", "8bcc677185c813fe64b786618bd6689b1707b35cd95acaae0834557b15a0c62f"},"combination": {:hex, :combination, "0.0.3", "746aedca63d833293ec6e835aa1f34974868829b1486b1e1cb0685f0b2ae1f41", [:mix], [], "hexpm", "72b099f463df42ef7dc6371d250c7070b57b6c5902853f69deb894f79eda18ca"},"combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm", "1b1dbc1790073076580d0d1d64e42eae2366583e7aecd455d1215b0d16f2451b"},"comeonin": {:hex, :comeonin, "5.3.3", "2c564dac95a35650e9b6acfe6d2952083d8a08e4a89b93a481acb552b325892e", [:mix], [], "hexpm", "3e38c9c2cb080828116597ca8807bb482618a315bfafd98c90bc22a821cc84df"},@@ -86,6 +88,7 @@"nimble_options": {:hex, :nimble_options, "1.0.2", "92098a74df0072ff37d0c12ace58574d26880e522c22801437151a159392270e", [:mix], [], "hexpm", "fd12a8db2021036ce12a309f26f564ec367373265b53e25403f0ee697380f1b8"},"nimble_parsec": {:hex, :nimble_parsec, "1.3.1", "2c54013ecf170e249e9291ed0a62e5832f70a476c61da16f6aac6dca0189f2af", [:mix], [], "hexpm", "2682e3c0b2eb58d90c6375fc0cc30bc7be06f365bf72608804fb9cffa5e1b167"},"nimble_pool": {:hex, :nimble_pool, "1.0.0", "5eb82705d138f4dd4423f69ceb19ac667b3b492ae570c9f5c900bb3d2f50a847", [:mix], [], "hexpm", "80be3b882d2d351882256087078e1b1952a28bf98d0a287be87e4a24a710b67a"},+ "nimble_totp": {:hex, :nimble_totp, "1.0.0", "79753bae6ce59fd7cacdb21501a1dbac249e53a51c4cd22b34fa8438ee067283", [:mix], [], "hexpm", "6ce5e4c068feecdb782e85b18237f86f66541523e6bad123e02ee1adbe48eda9"},"oauther": {:hex, :oauther, "1.3.0", "82b399607f0ca9d01c640438b34d74ebd9e4acd716508f868e864537ecdb1f76", [:mix], [], "hexpm", "78eb888ea875c72ca27b0864a6f550bc6ee84f2eeca37b093d3d833fbcaec04e"},"oban": {:hex, :oban, "2.12.1", "f604d7e6a8be9fda4a9b0f6cebbd633deba569f85dbff70c4d25d99a6f023177", [:mix], [{:ecto_sql, "~> 3.6", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16", [hex: :postgrex, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "9b1844c2b74e0d788b73e5144b0c9d5674cb775eae29d88a36f3c3b48d42d058"},"observer_cli": {:hex, :observer_cli, "1.7.3", "25d094d485f47239f218b53df0691a102fef13071dfd0d04922b5142297cfc93", [:mix, :rebar3], [{:recon, "~>2.5.1", [hex: :recon, repo: "hexpm", optional: false]}], "hexpm", "a41b6d3e11a3444e063e09cc225f7f3e631ce14019e5fbcaebfda89b1bd788ea"},diff --git a/test/plausible/auth/totp/recovery_code_test.exs b/test/plausible/auth/totp/recovery_code_test.exsnew file mode 100644index 0000000000..d3cbb4ee0f--- /dev/null+++ b/test/plausible/auth/totp/recovery_code_test.exs@@ -0,0 +1,87 @@+defmodule Plausible.Auth.TOTP.RecoveryCodeTest do+ use Plausible.DataCase, async: true++ alias Plausible.Auth.TOTP.RecoveryCode++ describe "generate_codes/1" do+ test "generates random codes conforming agreed upon format" do+ codes = RecoveryCode.generate_codes(3)++ Enum.each(codes, fn code ->+ assert Regex.match?(~r/[A-Z0-9]{10}/, code)+ end)++ assert codes == Enum.uniq(codes)+ end+ end++ describe "match?/1" do+ test "verifies that provided code matches against a digest of stored recovery code" do+ [plain_code] = RecoveryCode.generate_codes(1)++ recovery_code =+ build(:user)+ |> RecoveryCode.changeset(plain_code)+ |> Ecto.Changeset.apply_changes()++ assert RecoveryCode.match?(recovery_code, plain_code)+ refute RecoveryCode.match?(recovery_code, "INVALID")+ end+ end++ describe "changeset/2" do+ test "builds a valid changeset when provided valid code format" do+ [plain_code] = RecoveryCode.generate_codes(1)++ changeset = RecoveryCode.changeset(build(:user), plain_code)++ assert changeset.valid?+ assert changeset.changes.user+ assert changeset.changes.code_digest++ assert RecoveryCode.match?(Ecto.Changeset.apply_changes(changeset), plain_code)+ end++ test "crashes when code in invalid format is passed" do+ user = build(:user)++ assert_raise FunctionClauseError, fn ->+ RecoveryCode.changeset(user, "INVALID")+ end++ assert_raise FunctionClauseError, fn ->+ RecoveryCode.changeset(user, 123)+ end+ end+ end++ describe "changeset_to_map/2" do+ test "converts changeset to a map suitable for Repo.insert_all/3" do+ user = %{id: user_id} = insert(:user)+ [plain_code] = RecoveryCode.generate_codes(1)++ changeset =+ %{changes: %{code_digest: code_digest}} = RecoveryCode.changeset(user, plain_code)++ now = NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second)++ assert %{+ user_id: ^user_id,+ code_digest: ^code_digest,+ inserted_at: ^now+ } = RecoveryCode.changeset_to_map(changeset, now)+ end+ end++ describe "disambiguate/1" do+ test "disambiguates strings with hard to discern letters" do+ assert RecoveryCode.disambiguate("ABDIZL12") == "ABD7ZL12"+ assert RecoveryCode.disambiguate("ABDIZLO12") == "ABD7ZL812"+ assert RecoveryCode.disambiguate("AOBDIZLO12I") == "A8BD7ZL8127"+ end++ test "leaves strings that have no sunch letters intact" do+ assert RecoveryCode.disambiguate("N0D0UBT") == "N0D0UBT"+ end+ end+enddiff --git a/test/plausible/auth/totp/vault_test.exs b/test/plausible/auth/totp/vault_test.exsnew file mode 100644index 0000000000..4647ff21fc--- /dev/null+++ b/test/plausible/auth/totp/vault_test.exs@@ -0,0 +1,30 @@+defmodule Plausible.Auth.TOTP.VaultTest do+ use Plausible.DataCase, async: true++ alias Plausible.Auth.TOTP.Vault++ describe "encrypting secrets" do+ test "encryption works" do+ plain_secret = "super secret"+ encrypted_secret = Vault.encrypt!(plain_secret)+ decrypted_secret = Vault.decrypt!(encrypted_secret)++ assert encrypted_secret != plain_secret+ assert decrypted_secret == plain_secret+ end++ test "TOTP secret is stored encrypted and decrypted on read" do+ secret = NimbleTOTP.secret()++ user = insert(:user, totp_secret: secret)+ user = Repo.reload!(user)++ assert user.totp_secret == secret++ {:ok, %{rows: [[totp_secret_in_db]]}} =+ Repo.query("SELECT totp_secret from users where id = $1", [user.id])++ assert totp_secret_in_db != secret+ end+ end+enddiff --git a/test/plausible/auth/totp_test.exs b/test/plausible/auth/totp_test.exsnew file mode 100644index 0000000000..64059418ef--- /dev/null+++ b/test/plausible/auth/totp_test.exs@@ -0,0 +1,321 @@+defmodule Plausible.Auth.TOTPTest do+ use Plausible.DataCase, async: true++ alias Plausible.Auth.TOTP+ alias Plausible.Auth.TOTP.RecoveryCode++ alias Plausible.Repo++ describe "enabled?/1" do+ test "Returns user's TOTP state" do+ assert TOTP.enabled?(insert(:user, totp_enabled: true, totp_secret: "secret"))+ refute TOTP.enabled?(insert(:user, totp_enabled: false, totp_secret: nil))+ # these shouldn't happen under normal circumstances but we do check+ # totp_secret presence just to be safe and avoid undefined behavior+ refute TOTP.enabled?(insert(:user, totp_enabled: false, totp_secret: "secret"))+ refute TOTP.enabled?(insert(:user, totp_enabled: true, totp_secret: nil))+ end+ end++ describe "initiate/1" do+ test "initiates TOTP setup for user" do+ user = insert(:user)++ assert {:ok, updated_user, params} = TOTP.initiate(user)++ assert updated_user.id == user.id+ refute updated_user.totp_enabled+ assert byte_size(updated_user.totp_secret) > 0++ assert Regex.match?(~r/[0-9A-Z]+/, params.secret)+ assert String.starts_with?(params.totp_uri, "otpauth://totp")+ end++ test "reinitiates setup for user with unfinished TOTP setup" do+ user = insert(:user)+ {:ok, user, params} = TOTP.initiate(user)++ assert {:ok, updated_user, new_params} = TOTP.initiate(user)++ assert new_params.totp_uri != params.totp_uri+ assert new_params.secret != params.secret++ refute updated_user.totp_enabled+ assert byte_size(updated_user.totp_secret) > 0+ assert updated_user.totp_secret != user.totp_secret+ end++ test "does not initiate setup for user with TOTP already enabled" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)+ {:ok, user} = TOTP.enable(user, code)++ assert TOTP.initiate(user) == {:error, :already_setup}+ end++ test "does not initiate setup for user with unverified email" do+ user = insert(:user, email_verified: false)++ assert TOTP.initiate(user) == {:error, :not_verified}+ end+ end++ describe "enable/2" do+ test "finishes setting up TOTP for user" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)++ assert {:ok, user} = TOTP.enable(user, code)++ assert user.totp_enabled+ assert byte_size(user.totp_secret) > 0+ end++ test "succeeds for user who has TOTP enabled already" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret, time: System.os_time(:second) - 30)+ {:ok, user} = TOTP.enable(user, code)++ assert {:ok, updated_user} = TOTP.enable(user, code, allow_reuse?: true)++ assert updated_user.id == user.id+ assert updated_user.totp_enabled+ assert updated_user.totp_secret == user.totp_secret+ end++ test "fails when TOTP setup is not initiated" do+ user = insert(:user)++ assert {:error, :not_initiated} = TOTP.enable(user, "123456")+ end++ test "fails when invalid code is provided" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)++ assert {:error, :invalid_code} = TOTP.enable(user, "1234")+ end+ end++ describe "disable/2" do+ test "disables TOTP for user who has it enabled" do+ user = insert(:user, password: "VeryStrongVerySecret")+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)+ {:ok, user} = TOTP.enable(user, code)++ assert {:ok, updated_user} = TOTP.disable(user, "VeryStrongVerySecret")++ assert updated_user.id == user.id+ refute updated_user.totp_enabled+ assert is_nil(updated_user.totp_secret)++ assert Repo.all(RecoveryCode) == []+ end++ test "succeeds for user who does not have TOTP enabled" do+ user = insert(:user, password: "VeryStrongVerySecret")++ assert {:ok, updated_user} = TOTP.disable(user, "VeryStrongVerySecret")++ assert updated_user.id == user.id+ refute updated_user.totp_enabled+ assert is_nil(updated_user.totp_secret)+ end++ test "fails when invalid password is provided" do+ user = insert(:user, password: "VeryStrongVerySecret")+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)+ {:ok, user} = TOTP.enable(user, code)++ assert {:error, :invalid_password} = TOTP.disable(user, "invalid")+ end+ end++ describe "generate_recovery_codes/1" do+ test "generates recovery codes for user with enabled TOTP" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)+ {:ok, user} = TOTP.enable(user, code)++ assert {:ok, codes} = TOTP.generate_recovery_codes(user)++ persisted_codes = Repo.all(RecoveryCode)++ assert length(codes) == 10+ assert length(persisted_codes) == 10++ Enum.each(persisted_codes, fn recovery_code ->+ assert recovery_code.user_id == user.id+ assert byte_size(recovery_code.code_digest) > 0+ end)++ Enum.each(codes, fn code ->+ assert byte_size(code) > 0+ assert :ok = TOTP.use_recovery_code(user, code)+ end)+ end++ test "regenerates recovery codes when generated already" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)+ {:ok, user} = TOTP.enable(user, code)++ assert {:ok, [code | codes]} = TOTP.generate_recovery_codes(user)+ assert :ok = TOTP.use_recovery_code(user, code)++ assert {:ok, new_codes} = TOTP.generate_recovery_codes(user)++ assert Enum.uniq(codes ++ new_codes) == codes ++ new_codes++ assert length(new_codes) == 10++ Enum.each(new_codes, fn code ->+ assert byte_size(code) > 0+ assert :ok = TOTP.use_recovery_code(user, code)+ end)+ end++ test "fails when user has TOTP disabled" do+ user = insert(:user)++ assert {:error, :not_enabled} = TOTP.generate_recovery_codes(user)+ end+ end++ describe "generate_recovery_codes_protected/1" do+ test "generates recovery codes for user with enabled TOTP" do+ user = insert(:user, password: "VeryStrongVerySecret")+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)+ {:ok, user} = TOTP.enable(user, code)++ assert {:ok, codes} = TOTP.generate_recovery_codes_protected(user, "VeryStrongVerySecret")++ persisted_codes = Repo.all(RecoveryCode)++ assert length(codes) == 10+ assert length(persisted_codes) == 10++ Enum.each(persisted_codes, fn recovery_code ->+ assert recovery_code.user_id == user.id+ assert byte_size(recovery_code.code_digest) > 0+ end)++ Enum.each(codes, fn code ->+ assert byte_size(code) > 0+ assert :ok = TOTP.use_recovery_code(user, code)+ end)+ end++ test "fails when user has TOTP disabled" do+ user = insert(:user, password: "VeryStrongVerySecret")++ assert {:error, :not_enabled} =+ TOTP.generate_recovery_codes_protected(user, "VeryStrongVerySecret")+ end++ test "fails when invalid password provided" do+ user = insert(:user, password: "VeryStrongVerySecret")+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)+ {:ok, user} = TOTP.enable(user, code)++ assert {:error, :invalid_password} = TOTP.generate_recovery_codes_protected(user, "invalid")+ end+ end++ describe "validate_code/2" do+ test "succeeds when valid code provided and respects grace period" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret, time: System.os_time(:second) - 30)+ {:ok, user} = TOTP.enable(user, code)+ new_code = NimbleTOTP.verification_code(user.totp_secret)++ # making sure that generated OTP codes are different+ assert code != new_code++ assert {:ok, user} = TOTP.validate_code(user, code, allow_reuse?: true)++ assert_in_delta Timex.to_unix(user.totp_last_used_at), System.os_time(:second), 2+ end++ test "fails when trying to reuse the same code twice" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret, time: System.os_time(:second) - 30)+ {:ok, user} = TOTP.enable(user, code)++ assert {:error, :invalid_code} = TOTP.validate_code(user, code)+ end++ test "fails when invalid code provided" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)+ {:ok, user} = TOTP.enable(user, code)++ assert {:error, :invalid_code} = TOTP.validate_code(user, "1234")+ end++ test "fails when user has TOTP initiated but not enabled" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)++ assert {:error, :not_enabled} = TOTP.validate_code(user, code)+ end+ end++ describe "use_recovery_code/2" do+ test "succeeds when valid recovery code provided but fails when trying to reuse it" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)+ {:ok, user} = TOTP.enable(user, code)+ {:ok, [code | codes]} = TOTP.generate_recovery_codes(user)++ assert :ok = TOTP.use_recovery_code(user, code)+ assert {:error, :invalid_code} = TOTP.use_recovery_code(user, code)++ assert length(Repo.all(RecoveryCode)) == length(codes)+ end++ test "fails when provided code is invalid" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)+ {:ok, user} = TOTP.enable(user, code)+ {:ok, _} = TOTP.generate_recovery_codes(user)++ assert {:error, :invalid_code} = TOTP.use_recovery_code(user, "INVALID")+ end++ test "fails when there are no recovery codes to check against" do+ user = insert(:user)+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)+ {:ok, user} = TOTP.enable(user, code)++ assert {:error, :invalid_code} = TOTP.use_recovery_code(user, "INVALID")+ end++ test "fails when user has TOTP disabled even though provided code is valid" do+ user = insert(:user, password: "VeryStrongVerySecret")+ {:ok, user, _} = TOTP.initiate(user)+ code = NimbleTOTP.verification_code(user.totp_secret)+ {:ok, user} = TOTP.enable(user, code)+ {:ok, [code | _]} = TOTP.generate_recovery_codes(user)+ {:ok, user} = TOTP.disable(user, "VeryStrongVerySecret")++ assert {:error, :not_enabled} = TOTP.user_recovery_code(user, code)+ end+ end+end