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
SSRF protection measures (multiple PRs) (#6512)
Adam Rutkowski11e25dfca0d2
diff --git a/.github/workflows/iana-registry-check.yml b/.github/workflows/iana-registry-check.ymlnew file mode 100644index 0000000000..947e642a9d--- /dev/null+++ b/.github/workflows/iana-registry-check.yml@@ -0,0 +1,57 @@+name: IANA registry check++on:+ schedule:+ # Runs at 09:00 UTC on the 1st of every month.+ - cron: "0 9 1 * *"+ workflow_dispatch:++permissions:+ contents: read++jobs:+ check-iana-registries:+ name: Check IANA IP registries up to date+ runs-on: ubuntu-latest+ steps:+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2++ - uses: marocchino/tool-versions-action@18a164fa2b0db1cc1edf7305fcb17ace36d1c306 # v1.2.0+ id: versions++ - uses: erlef/setup-beam@fc68ffb90438ef2936bbb3251622353b3dcb2f93 # v1.24.0+ with:+ elixir-version: ${{ steps.versions.outputs.elixir }}+ otp-version: ${{ steps.versions.outputs.erlang }}++ - run: mix deps.get++ - run: mix download_ip_registries++ - name: Fail if the downloaded registries differ from what's committed+ run: |+ # IANA serves these CSVs with CRLF line endings while the committed files use LF;+ # --ignore-space-at-eol treats that difference as a non-change so only real content changes fail the check.+ if ! git diff --exit-code --quiet --ignore-space-at-eol -- priv/ip/iana-ipv4-special-registry.csv priv/ip/iana-ipv6-special-registry.csv; then+ echo "IANA special-purpose registries are out of date. Run 'mix download_ip_registries' and commit the changes."+ git diff --ignore-space-at-eol -- priv/ip/iana-ipv4-special-registry.csv priv/ip/iana-ipv6-special-registry.csv+ exit 1+ fi++ - name: Notify team on success+ if: ${{ success() }}+ uses: fjogeleit/http-request-action@551353b829c3646756b2ec2b3694f819d7957495 # v2.0.0+ with:+ url: ${{ secrets.BUILD_NOTIFICATION_URL }}+ method: 'POST'+ customHeaders: '{"Content-Type": "application/json"}'+ data: '{"content": "<p>IANA IP registry is up to date.</p>"}'++ - name: Notify team on failure+ if: ${{ failure() }}+ uses: fjogeleit/http-request-action@551353b829c3646756b2ec2b3694f819d7957495 # v2.0.0+ with:+ url: ${{ secrets.BUILD_NOTIFICATION_URL }}+ method: 'POST'+ customHeaders: '{"Content-Type": "application/json"}'+ data: '{"content": "<p>⚠️ IANA IP registry check <a href=\"https://github.com/plausible/analytics/actions/runs/${{ github.run_id }}\">failed</a>.</p>"}'diff --git a/Makefile b/Makefileindex 167706e68a..ca8037a3a5 100644--- a/Makefile+++ b/Makefile@@ -92,6 +92,8 @@ sso:@echo "- [email protected] / plausible"@echo "- [email protected] / plausible"@echo "- [email protected] / plausible"+ @echo ""+ @echo "Run plausible application server with ALLOW_RESERVED_IPS=true"sso-stop:docker stop idpdiff --git a/config/runtime.exs b/config/runtime.exsindex 3992ddcdf9..91f056353d 100644--- a/config/runtime.exs+++ b/config/runtime.exs@@ -1100,3 +1100,8 @@ unless s3_disabled? doendconfig :plausible, Plausible.Cache.Adapter, sessions: [partitions: 100]++config :plausible, Plausible.IP.Tools,+ allow_reserved_ips?:+ config_env() in [:dev, :ce_dev] and+ get_bool_from_path_or_env(config_dir, "ALLOW_RESERVED_IPS", false)diff --git a/extra/lib/plausible/auth/sso/domain.ex b/extra/lib/plausible/auth/sso/domain.exindex 572026eba5..49b9820bc8 100644--- a/extra/lib/plausible/auth/sso/domain.ex+++ b/extra/lib/plausible/auth/sso/domain.ex@@ -46,13 +46,15 @@ defmodule Plausible.Auth.SSO.Domain dotimestamps()end- @spec create_changeset(SSO.Integration.t(), String.t() | nil) :: Ecto.Changeset.t()- def create_changeset(integration, domain) do+ @spec create_changeset(SSO.Integration.t(), String.t() | nil, Keyword.t()) :: Ecto.Changeset.t()+ def create_changeset(integration, domain, opts \\ []) do+ skip_checks? = Keyword.get(opts, :skip_checks?, false)+%__MODULE__{}|> cast(%{domain: domain}, [:domain])|> validate_required(:domain)|> normalize_domain(:domain)- |> validate_domain(:domain)+ |> validate_domain(:domain, skip_checks?)|> unique_constraint(:domain, message: "is already in use")|> put_change(:identifier, Ecto.UUID.generate())|> put_assoc(:sso_integration, integration)@@ -81,15 +83,14 @@ defmodule Plausible.Auth.SSO.Domain do|> put_change(:status, status)end- @spec valid_domain?(String.t()) :: boolean()- def valid_domain?(domain) do- # This is not a surefire way to ensure the domain is correct,- # but it should give a bit more confidence that it's at least- # resolvable.+ @spec valid_domain?(String.t(), Keyword.t()) :: boolean()+ def valid_domain?(domain, opts \\ []) do+ skip_checks? = Keyword.get(opts, :skip_checks?, false)+case URI.new("https://" <> domain) do{:ok, %{host: host, port: port, path: nil, query: nil, fragment: nil, userinfo: nil}}when is_binary(host) and port in [80, 443] ->- true+ skip_checks? or match?({:ok, _ips}, Plausible.SSRF.resolve_host(host))_ ->false@@ -119,9 +120,9 @@ defmodule Plausible.Auth.SSO.Domain doendend- defp validate_domain(changeset, field) do+ defp validate_domain(changeset, field, skip_checks?) doif domain = get_change(changeset, field) do- if valid_domain?(domain) do+ if valid_domain?(domain, skip_checks?: skip_checks?) dochangesetelseadd_error(changeset, field, "invalid domain", validation: :domain)diff --git a/extra/lib/plausible/auth/sso/domain/verification.ex b/extra/lib/plausible/auth/sso/domain/verification.exindex 329fec425d..ffa055d805 100644--- a/extra/lib/plausible/auth/sso/domain/verification.ex+++ b/extra/lib/plausible/auth/sso/domain/verification.ex@@ -40,7 +40,12 @@ defmodule Plausible.Auth.SSO.Domain.Verification do@spec url(String.t(), String.t(), Keyword.t()) :: boolean()def url(sso_domain, domain_identifier, opts \\ []) dourl_override = Keyword.get(opts, :url_override)- resp = run_request(url_override || "https://" <> Path.join(sso_domain, @prefix))++ resp =+ run_request(+ url_override || "https://" <> Path.join(sso_domain, @prefix),+ skip_checks?: not is_nil(url_override)+ )case resp do%Req.Response{body: body}@@ -57,7 +62,9 @@ defmodule Plausible.Auth.SSO.Domain.Verification dourl_override = Keyword.get(opts, :url_override)with %Req.Response{body: body} = response when is_binary(body) <-- run_request(url_override || "https://#{sso_domain}"),+ run_request(url_override || "https://#{sso_domain}",+ skip_checks?: not is_nil(url_override)+ ),true <- html?(response),html <- LazyHTML.from_document(body),[_ | _] <-@@ -103,22 +110,24 @@ defmodule Plausible.Auth.SSO.Domain.Verification do|> String.contains?("text/html")end- defp run_request(base_url) do- fetch_body_opts = Application.get_env(:plausible, __MODULE__)[:req_opts] || []-- opts =- Keyword.merge(- [- base_url: base_url,- max_redirects: 4,- max_retries: 3,- retry_log_level: :warning- ],- fetch_body_opts- )+ # skip_checks?: true is only ever supplied by url_override escape hatch+ # used by tests (e.g. to point at a local Bypass server)+ defp run_request(url, opts) do+ skip_checks? = Keyword.get(opts, :skip_checks?, false)+ base_opts = [max_redirects: 4, max_retries: 3, retry_log_level: :warning]++ result =+ if skip_checks? do+ Req.request(Keyword.merge(base_opts, url: url, method: :get))+ else+ fetch_body_opts = Application.get_env(:plausible, __MODULE__)[:req_opts] || []+ Plausible.SSRF.get(url, Keyword.merge(base_opts, fetch_body_opts))+ end- {_req, resp} = opts |> Req.new() |> Req.Request.run_request()- resp+ case result do+ {:ok, resp} -> resp+ {:error, _reason} -> nil+ endend@after_compile __MODULE__diff --git a/extra/lib/plausible/auth/sso/domains.ex b/extra/lib/plausible/auth/sso/domains.exindex dee39c5c93..3013d9df3d 100644--- a/extra/lib/plausible/auth/sso/domains.ex+++ b/extra/lib/plausible/auth/sso/domains.ex@@ -12,10 +12,10 @@ defmodule Plausible.Auth.SSO.Domains douse Plausible.Auth.SSO.Domain.Status- @spec add(SSO.Integration.t(), String.t()) ::+ @spec add(SSO.Integration.t(), String.t(), Keyword.t()) ::{:ok, SSO.Domain.t()} | {:error, Ecto.Changeset.t()}- def add(integration, domain) do- changeset = SSO.Domain.create_changeset(integration, domain)+ def add(integration, domain, opts \\ []) do+ changeset = SSO.Domain.create_changeset(integration, domain, opts)Repo.insert_with_audit(changeset, "sso_domain_added", %{team_id: integration.team_id})enddiff --git a/extra/lib/plausible/installation_support/checks/url.ex b/extra/lib/plausible/installation_support/checks/url.exindex 95dbd56fea..ea983c83e9 100644--- a/extra/lib/plausible/installation_support/checks/url.ex+++ b/extra/lib/plausible/installation_support/checks/url.ex@@ -1,8 +1,9 @@defmodule Plausible.InstallationSupport.Checks.Url do@moduledoc """- Checks if site domain has an A record.- If not, checks if prepending `www.` helps,- because we have specifically requested customers to register the domain with `www.` prefix.+ Checks if site domain resolves (either A or AAAA record) to a public address.+ If not, checks if prepending `www.` helps, because we have specifically+ requested customers to register the domain with `www.` prefix.+If not, skips all further checks."""@@ -15,11 +16,11 @@ defmodule Plausible.InstallationSupport.Checks.Url do@spec perform(State.t(), Keyword.t()) :: State.t()def perform(%State{url: url} = state, _opts) when is_binary(url) dowith {:ok, %URI{scheme: scheme} = uri} when scheme in ["http", "https"] <- URI.new(url),- :ok <- check_domain(uri.host) do+ :ok <- dns_lookup(uri.host) dostripped_url = URI.to_string(%URI{uri | query: nil, fragment: nil})%State{state | url: stripped_url}else- {:error, :no_a_record} ->+ {:error, :resolve_host_error} ->put_diagnostics(%State{state | skip_further_checks?: true},service_error: %{code: :domain_not_found})@@ -54,40 +55,19 @@ defmodule Plausible.InstallationSupport.Checks.Url do"www.#{domain_without_path}"]|> Enum.reduce_while({:error, :domain_not_found}, fn d, _acc ->+ # For local testing, run the server with ALLOW_RESERVED_IPS=truecase dns_lookup(d) do:ok -> {:halt, {:ok, "https://" <> unsplit_domain(d, rest)}}- {:error, :no_a_record} -> {:cont, {:error, :domain_not_found}}+ {:error, :resolve_host_error} -> {:cont, {:error, :domain_not_found}}endend)end- @spec dns_lookup(String.t()) :: :ok | {:error, :no_a_record}+ @spec dns_lookup(String.t()) :: :ok | {:error, :resolve_host_error}defp dns_lookup(domain) do- lookup_timeout = 1_000- resolve_timeout = 1_000-- case Plausible.DnsLookup.impl().lookup(- to_charlist(domain),- :in,- :a,- [timeout: resolve_timeout],- lookup_timeout- ) do- [{a, b, c, d} | _]- when is_integer(a) and is_integer(b) and is_integer(c) and is_integer(d) ->- :ok-- # this may mean timeout or no DNS record- [] ->- {:error, :no_a_record}- end- end-- defp check_domain(domain) do- if Application.get_env(:plausible, :environment) == "dev" and domain == "localhost" do- :ok- else- dns_lookup(domain)+ case Plausible.SSRF.resolve_host(domain) do+ {:ok, _ips} -> :ok+ {:error, _reason} -> {:error, :resolve_host_error}endenddiff --git a/lib/ip/tools.ex b/lib/ip/tools.exnew file mode 100644index 0000000000..e55a0709bf--- /dev/null+++ b/lib/ip/tools.ex@@ -0,0 +1,71 @@+defmodule Plausible.IP.Tools do+ @moduledoc """+ Recognizes reserved and private IPv4/IPv6 addresses.+ See: `Plausible.IP.Tools.Registry`+ """++ @external_resource Plausible.IP.Tools.Registry.ipv4_registry_path()+ @external_resource Plausible.IP.Tools.Registry.ipv6_registry_path()++ @clauses Plausible.IP.Tools.Registry.entries()++ require Logger++ @doc """+ Returns the ranges used in `reserved?/1`, for testing purposes.+ """+ @spec ranges() :: [%{cidr: String.t(), name: String.t(), reserved: boolean()}]+ def ranges do+ Enum.map(@clauses, &Map.take(&1, [:cidr, :name, :reserved]))+ end++ @doc """+ Determines whether IP falls within a reserved or private address range.+ Accepts already parsed `:inet` address tuples.++ IPv4-mapped IPv6 addresses (`::ffff:a.b.c.d`) are unwrapped and delegate to+ the IPv4 rules for the embedded address, rather than being uniformly+ treated as reserved.+ """+ @spec reserved?(:inet.ip_address()) :: boolean()+ for %{pattern: pattern, guard: guard, reserved: reserved} <- @clauses do+ def reserved?(unquote(pattern)) when unquote(guard), do: unquote(reserved)+ end++ def reserved?({0, 0, 0, 0, 0, 0xFFFF, hi, lo}) do+ reserved?({div(hi, 256), rem(hi, 256), div(lo, 256), rem(lo, 256)})+ end++ def reserved?(ip) when is_tuple(ip) and tuple_size(ip) == 4, do: false+ def reserved?(ip) when is_tuple(ip) and tuple_size(ip) == 8, do: false++ @doc """+ Determines if IP is allowed, i.e. valid and not reserved/private.+ """++ @spec allowed?(:inet.ip_address() | String.t()) :: boolean()+ def allowed?(ip) when is_binary(ip) do+ case :inet.parse_address(String.to_charlist(ip)) do+ {:ok, address} -> allowed?(address)+ {:error, _reason} -> false+ end+ end++ def allowed?(ip) when is_tuple(ip) and tuple_size(ip) in [4, 8] do+ if allow_reserved_ips?() do+ if reserved?(ip) do+ Logger.warning("IP #{inspect(ip)} forcibly allowed due to :allow_reserved_ips? env set. ")+ end++ true+ else+ not reserved?(ip)+ end+ end++ def allowed?(_ip), do: false++ defp allow_reserved_ips? do+ Application.get_env(:plausible, __MODULE__)[:allow_reserved_ips?] || false+ end+enddiff --git a/lib/ip/tools/registry.ex b/lib/ip/tools/registry.exnew file mode 100644index 0000000000..99c84aef52--- /dev/null+++ b/lib/ip/tools/registry.ex@@ -0,0 +1,149 @@+defmodule Plausible.IP.Tools.Registry do+ @moduledoc """+ Compile-time-only helpers for `Plausible.IP.Tools`.++ Parses IANA RFC4180 CSV plus supplemental multicast ranges+ into a list of function clause meta data.+ """++ import Bitwise++ def ipv4_registry_path,+ do: Application.app_dir(:plausible, "priv/ip/iana-ipv4-special-registry.csv")++ def ipv6_registry_path,+ do: Application.app_dir(:plausible, "priv/ip/iana-ipv6-special-registry.csv")++ def entries() do+ ipv4 = load(ipv4_registry_path())++ ipv6 =+ ipv6_registry_path()+ |> load()+ # IPv4-mapped IPv6 is excluded here: it isn't a range+ # that's uniformly reserved or public, it's a container for an entire+ # embedded IPv4 address. Plausible.IP.Tools handles it by unwrapping+ # the embedded address and delegating back to the IPv4 clauses instead.+ |> Enum.reject(&(&1.cidr == "::ffff:0:0/96"))++ (ipv4 ++ ipv6 ++ multicast())+ |> Enum.sort_by(& &1.prefix_len, :desc)+ |> Enum.map(&to_clause/1)+ end++ defp multicast do+ [+ entry_from_cidr("224.0.0.0/4", "Multicast", true),+ entry_from_cidr("ff00::/8", "Multicast", true)+ ]+ end++ defp rows_to_entries(rows), do: Enum.flat_map(rows, &row_to_entry/1)++ # Address Block,Name,RFC,Allocation Date,Termination Date,Source,+ # Destination,Forwardable,Globally Reachable,Reserved-by-Protocol+ defp row_to_entry(row) do+ address_block = Enum.at(row, 0)+ name = Enum.at(row, 1)+ termination_date = row |> Enum.at(4) |> strip_footnotes()+ globally_reachable = row |> Enum.at(8) |> strip_footnotes()++ reserved? = termination_date == "N/A" and globally_reachable == "False"++ address_block+ |> strip_footnotes()+ |> String.split(",")+ |> Enum.map(&String.trim/1)+ |> Enum.reject(&(&1 == ""))+ |> Enum.map(&entry_from_cidr(&1, name, reserved?))+ end++ defp strip_footnotes(nil), do: nil++ defp strip_footnotes(field) do+ field+ |> String.replace(~r/\s*\[\d+\]/, "")+ |> String.trim()+ end++ defp entry_from_cidr(cidr, name, reserved?) do+ [addr_str, prefix_str] = String.split(cidr, "/")+ {:ok, address} = :inet.parse_address(String.to_charlist(addr_str))++ %{+ cidr: cidr,+ name: name,+ words: Tuple.to_list(address),+ prefix_len: String.to_integer(prefix_str),+ reserved: reserved?+ }+ end++ defp to_clause(%{+ words: words,+ prefix_len: prefix_len,+ reserved: reserved,+ cidr: cidr,+ name: name+ }) do+ word_bits = if length(words) == 4, do: 8, else: 16+ indexed_words = Enum.with_index(words)++ pattern_words = Enum.map(indexed_words, &pattern_word(&1, word_bits, prefix_len))++ guard =+ indexed_words+ |> Enum.map(&guard_for_word(&1, word_bits, prefix_len))+ |> Enum.reject(&is_nil/1)+ |> combine_guards()++ %{pattern: {:{}, [], pattern_words}, guard: guard, reserved: reserved, cidr: cidr, name: name}+ end++ defp pattern_word({word, index}, word_bits, prefix_len) do+ bits_before = index * word_bits+ bits_after = bits_before + word_bits++ cond do+ bits_after <= prefix_len -> word+ bits_before >= prefix_len -> Macro.var(:"_w#{index}", nil)+ true -> Macro.var(:"w#{index}", nil)+ end+ end++ defp guard_for_word({word, index}, word_bits, prefix_len) do+ bits_before = index * word_bits+ bits_after = bits_before + word_bits++ if bits_before < prefix_len and bits_after > prefix_len do+ var = Macro.var(:"w#{index}", nil)+ bits_in_word = prefix_len - bits_before+ free_bits = word_bits - bits_in_word+ full_mask = (1 <<< word_bits) - 1+ mask = full_mask - ((1 <<< free_bits) - 1)+ masked_value = word &&& mask++ quote do+ band(unquote(var), unquote(mask)) === unquote(masked_value)+ end+ end+ end++ defp combine_guards([]), do: true+ defp combine_guards([guard]), do: guard++ defp combine_guards([guard | rest]) do+ Enum.reduce(rest, guard, fn g, acc ->+ quote do+ unquote(acc) and unquote(g)+ end+ end)+ end++ defp load(path) do+ path+ |> File.read!()+ |> NimbleCSV.RFC4180.parse_string()+ |> rows_to_entries()+ end+enddiff --git a/lib/mix/tasks/download_ip_registries.ex b/lib/mix/tasks/download_ip_registries.exnew file mode 100644index 0000000000..96cd7bd981--- /dev/null+++ b/lib/mix/tasks/download_ip_registries.ex@@ -0,0 +1,39 @@+defmodule Mix.Tasks.DownloadIpRegistries do+ @moduledoc """+ Refreshes the IANA special-purpose address registries used by+ `Plausible.IP.Tools` at compile time to recognize reserved/private IPs.+ """++ use Mix.Task+ require Logger++ alias Plausible.IP++ # coveralls-ignore-start++ @sources %{+ IP.Tools.Registry.ipv4_registry_path() =>+ "https://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-registry-1.csv",+ IP.Tools.Registry.ipv6_registry_path() =>+ "https://www.iana.org/assignments/iana-ipv6-special-registry/iana-ipv6-special-registry-1.csv"+ }++ def run(_) do+ Application.ensure_all_started(:req)++ for {path, url} <- @sources do+ path |> Path.dirname() |> File.mkdir_p!()++ Logger.notice("Downloading #{url}")++ case Req.get(url) do+ {:ok, %{status: 200, body: body}} ->+ File.write!(path, body)+ Logger.notice("Saved #{path}")++ other ->+ Logger.error("Unable to download #{url}. Response: #{inspect(other)}")+ end+ end+ end+enddiff --git a/lib/plausible/ssrf.ex b/lib/plausible/ssrf.exnew file mode 100644index 0000000000..a0585879bf--- /dev/null+++ b/lib/plausible/ssrf.ex@@ -0,0 +1,130 @@+defmodule Plausible.SSRF do+ @moduledoc """+ Guards outbound HTTP requests and DNS lookups against customer-supplied+ hostnames reaching internal, private or local network space+ """++ @type error_reason ::+ :invalid_url+ | :invalid_host+ | :dns_resolution_failed+ | :restricted_address+ | :too_many_redirects++ @redirect_statuses [301, 302, 303, 307, 308]+ @default_max_redirects 4+ @dns_timeout 1_000++ # Every distinct `connect_options: [hostname: ...]` value we pass below+ # makes Req start a brand new, dedicated Finch instance under the hood+ # (Req can't vary `conn_opts` per-request on a shared pool, so it forks one+ # per connect_options fingerprint) - and since these hostnames are+ # customer-controlled, that's an unbounded number of them over time.+ @default_pool_max_idle_time :timer.minutes(5)++ @doc """+ Resolves bare hostname or literal IP and returns its address(es),+ only if all are allowed+ """+ @spec resolve_host(String.t()) :: {:ok, [:inet.ip_address()]} | {:error, error_reason()}+ def resolve_host(host) when is_binary(host) do+ case :inet.parse_address(to_charlist(host)) do+ {:ok, ip} ->+ validate_ips([ip])++ {:error, :einval} ->+ if String.contains?(host, ".") do+ host |> dns_lookup() |> validate_ips()+ else+ {:error, :invalid_host}+ end+ end+ end++ @doc """+ Performs a GET request against arbitrary URL, refusing to connect to (or be+ redirected to) a restricted address+ """+ @spec get(String.t(), keyword()) ::+ {:ok, Req.Response.t()} | {:error, error_reason() | Exception.t()}+ def get(url, opts \\ []) do+ max_redirects = Keyword.get(opts, :max_redirects, @default_max_redirects)+ request(url, opts, max_redirects)+ end++ defp request(url, opts, redirects_left) do+ with {:ok, uri} <- parse_url(url),+ {:ok, ips} <- resolve_host(uri.host),+ {:ok, resp} <- do_request(uri, hd(ips), opts) do+ handle_response(resp, uri, opts, redirects_left)+ end+ end++ defp parse_url(url) do+ case URI.new(url) do+ {:ok, %URI{scheme: scheme, host: host} = uri}+ when scheme in ["http", "https"] and is_binary(host) and host != "" ->+ {:ok, uri}++ _ ->+ {:error, :invalid_url}+ end+ end++ defp do_request(uri, ip, opts) do+ host = uri.host+ pinned_url = %{uri | host: ip |> :inet.ntoa() |> to_string()}++ request_opts =+ opts+ |> Keyword.put_new(:pool_max_idle_time, @default_pool_max_idle_time)+ |> Keyword.merge(+ method: :get,+ url: pinned_url,+ headers: [{"host", host}],+ connect_options: [hostname: host],+ redirect: false+ )++ Req.request(request_opts)+ end++ defp handle_response(%Req.Response{status: status} = resp, uri, opts, redirects_left)+ when status in @redirect_statuses do+ case Req.Response.get_header(resp, "location") do+ [location | _] when redirects_left > 0 ->+ next_url = uri |> URI.merge(location) |> URI.to_string()+ request(next_url, opts, redirects_left - 1)++ [_ | _] ->+ {:error, :too_many_redirects}++ [] ->+ {:ok, resp}+ end+ end++ defp handle_response(resp, _uri, _opts, _redirects_left), do: {:ok, resp}++ defp dns_lookup(host) do+ charlist_host = to_charlist(host)+ opts = [timeout: @dns_timeout]++ a = Plausible.DnsLookup.impl().lookup(charlist_host, :in, :a, opts, @dns_timeout)+ aaaa = Plausible.DnsLookup.impl().lookup(charlist_host, :in, :aaaa, opts, @dns_timeout)++ a ++ aaaa+ end++ defp validate_ips([]) do+ {:error, :dns_resolution_failed}+ end++ defp validate_ips(ips) do+ if Enum.all?(ips, &Plausible.IP.Tools.allowed?/1) do+ {:ok, ips}+ else+ {:error, :restricted_address}+ end+ end+enddiff --git a/mix.exs b/mix.exsindex 052f80b294..63aa67da35 100644--- a/mix.exs+++ b/mix.exs@@ -103,6 +103,7 @@ defmodule Plausible.MixProject do{:location, git: "https://github.com/plausible/location.git"},{:mox, "~> 1.0", only: [:test, :ce_test, :e2e_test]},{:nanoid, "~> 2.1.0"},+ {:nimble_csv, "~> 1.3"},{:nimble_totp, "~> 1.0"},{:oban, "~> 2.20.1"},{:observer_cli, "~> 1.7"},diff --git a/mix.lock b/mix.lockindex 1ec2693e1f..e1c545d3f8 100644--- a/mix.lock+++ b/mix.lock@@ -7,7 +7,7 @@"bcrypt_elixir": {:hex, :bcrypt_elixir, "3.3.2", "d50091e3c9492d73e17fc1e1619a9b09d6a5ef99160eb4d736926fd475a16ca3", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "471be5151874ae7931911057d1467d908955f93554f7a6cd1b7d804cac8cef53"},"bunt": {:hex, :bunt, "1.0.0", "081c2c665f086849e6d57900292b3a161727ab40431219529f13c4ddcf3e7a44", [:mix], [], "hexpm", "dc5f86aa08a5f6fa6b8096f0735c4e76d54ae5c9fa2c143e5a1fc7c1cd9bb6b5"},"bypass": {:hex, :bypass, "2.1.0", "909782781bf8e20ee86a9cabde36b259d44af8b9f38756173e8f5e2e1fabb9b1", [:mix], [{:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.0", [hex: :plug_cowboy, repo: "hexpm", optional: false]}, {:ranch, "~> 1.3", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "d9b5df8fa5b7a6efa08384e9bbecfe4ce61c77d28a4282f79e02f1ef78d96b80"},- "castore": {:hex, :castore, "1.0.19", "6903cabdfd9d1af46454126e7c8385186659dd33ecfb74a885cae52221ad6109", [:mix], [], "hexpm", "3669e6cab13f54c2df26b3e6833745d647f35b6e30d8ddd5975df0d5c842ca98"},+ "castore": {:hex, :castore, "1.0.20", "455e48f7115eca98c9f2b0e7a152b5a2e8f2a8a4f964c96e95bd31645ee5fa59", [:mix], [], "hexpm", "940eafbfd8b14bee649f083bc11b3b54ec555b54c3e4ea8213351ff6fee39c10"},"cc_precompiler": {:hex, :cc_precompiler, "0.1.11", "8c844d0b9fb98a3edea067f94f616b3f6b29b959b6b3bf25fee94ffe34364768", [:mix], [{:elixir_make, "~> 0.7", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "3427232caf0835f94680e5bcf082408a70b48ad68a5f5c0b02a3bea9f3a075b9"},"certifi": {:hex, :certifi, "2.15.0", "0e6e882fcdaaa0a5a9f2b3db55b1394dba07e8d6d9bcad08318fb604c6839712", [:rebar3], [], "hexpm", "b147ed22ce71d72eafdad94f055165c1c182f61a2ff49df28bcc71d1d5b94a60"},"ch": {:hex, :ch, "0.7.1", "116c08094b30d095c3bd6a8fe4ebe19fdaaf3dce84e2413cfdd6af157baf6303", [:mix], [{:db_connection, "~> 2.9.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:ecto, "~> 3.13.0", [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", "3c1c900291ff9c4c077cd1dc0c265051a3f1d26320d58b37ed9e91b33d41a868"},@@ -83,7 +83,7 @@"metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm", "69b09adddc4f74a40716ae54d140f93beb0fb8978d8636eaded0c31b6f099f16"},"mime": {:hex, :mime, "2.0.7", "b8d739037be7cd402aee1ba0306edfdef982687ee7e9859bee6198c1e7e2f128", [:mix], [], "hexpm", "6171188e399ee16023ffc5b76ce445eb6d9672e2e241d2df6050f3c771e80ccd"},"mimerl": {:hex, :mimerl, "1.4.0", "3882a5ca67fbbe7117ba8947f27643557adec38fa2307490c4c4207624cb213b", [:rebar3], [], "hexpm", "13af15f9f68c65884ecca3a3891d50a7b57d82152792f3e19d88650aa126b144"},- "mint": {:hex, :mint, "1.9.1", "3bc120b743ed2e99ad920910f2613e9faebabb2257731b0e2ea4d8ccd9eceede", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0 or ~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "831101bd560b086316fab5f7adb21a4f3455717d8e4bc8368b052e09aa9163e0"},+ "mint": {:hex, :mint, "1.9.3", "3337184d69179695c7a9f1714d92c11e629d36c8c037a21cf490131d3d150554", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0 or ~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "5f7c9342480c069dbbc4eeac3490303c9e01870ff01a7f1d29b6107054fc1e74"},"mjml": {:hex, :mjml, "4.0.0", "3418c1a975112766f92b8786a17d53640a4a1c8c7dedb621016a08e1e1447d20", [:mix], [{:rustler, ">= 0.0.0", [hex: :rustler, repo: "hexpm", optional: true]}, {:rustler_precompiled, "~> 0.7.0", [hex: :rustler_precompiled, repo: "hexpm", optional: false]}], "hexpm", "0886a411f9a850bc4ac6b878c9c0dbea168669176fde1f6583acf55fa8b628dd"},"mjml_eex": {:hex, :mjml_eex, "0.12.0", "ee7e58a0b2f361812c024ddd2dd57ccd4107e486632016fcf707d4d0eaa04d62", [:mix], [{:erlexec, "~> 2.0.7", [hex: :erlexec, repo: "hexpm", optional: true]}, {:mjml, "~> 4.0", [hex: :mjml, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.2 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "6ca41f6252669b709d31d8b7c74db00c8bc3784dea1913b406a68c12763c5bcb"},"mox": {:hex, :mox, "1.2.0", "a2cd96b4b80a3883e3100a221e8adc1b98e4c3a332a8fc434c39526babafd5b3", [:mix], [{:nimble_ownership, "~> 1.0", [hex: :nimble_ownership, repo: "hexpm", optional: false]}], "hexpm", "c7b92b3cc69ee24a7eeeaf944cd7be22013c52fcb580c1f33f50845ec821089a"},@@ -129,7 +129,7 @@"phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"},"phoenix_view": {:hex, :phoenix_view, "2.0.4", "b45c9d9cf15b3a1af5fb555c674b525391b6a1fe975f040fb4d913397b31abf4", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}], "hexpm", "4e992022ce14f31fe57335db27a28154afcc94e9983266835bb3040243eb620b"},"php_serializer": {:hex, :php_serializer, "2.0.0", "b43f31aca22ed7321f32da2b94fe2ddf9b6739a965cb51541969119e572e821d", [:mix], [], "hexpm", "61e402e99d9062c0225a3f4fcf7e43b4cba1b8654944c0e7c139c3ca9de481da"},- "plug": {:hex, :plug, "1.20.2", "adbee2441232412e37fbb357fd5e4cd533fdd253b29f2e1992262b0f1fb01462", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b16baf55877d60891002ffc1ce0b3ff7d6f30a38a23e02e4d4293c4ac266f136"},+ "plug": {:hex, :plug, "1.20.3", "56c480c633ec2ce10140e236e15233bf576e1d323887d7c96711bd02ab5160db", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "be266aee1b8536ef6409d58cf39a3121319f0ec47cfa1b24024485aa0e76ad76"},"plug_cowboy": {:hex, :plug_cowboy, "2.8.1", "5aa391a5e8d1ac3192e36a3bcaff12b5fd6ef6c7e29b53a38e63a860783e77d0", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "4c200288673d5bc86a0ab7dc6a2a069176a74e5d573ef62740a1c517458a5f26"},"plug_crypto": {:hex, :plug_crypto, "1.2.5", "918772575e48e81e455818229bf719d4ab4181fcbf7f85b68a35620f78d89ced", [:mix], [], "hexpm", "26549a1d6345e2172eb1c233866756ae44a9609bd33ee6f99147ab3fd87fd842"},"polymorphic_embed": {:hex, :polymorphic_embed, "5.0.3", "37444e0af941026a2c29b0539b6471bdd6737a6492a19264bf2bb0118e3ac242", [:mix], [{:attrs, "~> 0.6", [hex: :attrs, repo: "hexpm", optional: false]}, {:ecto, "~> 3.12", [hex: :ecto, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 4.1", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_html_helpers, "~> 1.0", [hex: :phoenix_html_helpers, repo: "hexpm", optional: true]}, {:phoenix_live_view, "~> 0.20 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}], "hexpm", "2fed44f57abf0a0fc7642e0eb0807a55b65de1562712cc0620772cbbb80e49c1"},@@ -141,7 +141,7 @@"recon": {:hex, :recon, "2.5.4", "05dd52a119ee4059fa9daa1ab7ce81bc7a8161a2f12e9d42e9d551ffd2ba901c", [:mix, :rebar3], [], "hexpm", "e9ab01ac7fc8572e41eb59385efeb3fb0ff5bf02103816535bacaedf327d0263"},"ref_inspector": {:hex, :ref_inspector, "2.0.0", "f3e97e51d9782de4c792f56eed26c80903bc39174c878285392ce76d5e67fe98", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}, {:yamerl, "~> 0.7", [hex: :yamerl, repo: "hexpm", optional: false]}], "hexpm", "bf62f3f1a87d6b8b30f457a480668f965373e64f184611282b5e89d8dd81fd33"},"referrer_blocklist": {:git, "https://github.com/plausible/referrer-blocklist.git", "d6f52c225cccb4f04b80e3a5d588868ec234139d", []},- "req": {:hex, :req, "0.6.2", "b9b2024f35bcf60a92cc8cad2eaaf9d4e7aace463ff74be1afe5986830184413", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.21", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "cc9cd30a2ddd04989929b887178e1610c940456d962c6c3a52df6146d2eef9bf"},+ "req": {:hex, :req, "0.6.3", "7fe5e68792ff0546e45d5919104fa1764a13694cfe3e48c8a0f32ad051ae77e4", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.21", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "e85b5c6c990e6c3f52bbba68e6f099118f2b8252825f96c7c3636b97a3de307d"},"rustler_precompiled": {:hex, :rustler_precompiled, "0.7.3", "42cb9449785cd86c87453e39afdd27a0bdfa5c77a4ec5dc5ce45112e06b9f89b", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:rustler, "~> 0.23", [hex: :rustler, repo: "hexpm", optional: true]}], "hexpm", "cbc4b3777682e5f6f43ed39b0e0b4a42dccde8053aba91b4514e8f5ff9a5ac6d"},"saxy": {:hex, :saxy, "1.6.0", "02cb4e9bd045f25ac0c70fae8164754878327ee393c338a090288210b02317ee", [:mix], [], "hexpm", "ef42eb4ac983ca77d650fbdb68368b26570f6cc5895f0faa04d34a6f384abad3"},"sentry": {:hex, :sentry, "11.0.4", "60371c96cefd247e0fc98840bba2648f64f19aa0b8db8e938f5a98421f55b619", [:mix], [{:hackney, "~> 1.8", [hex: :hackney, repo: "hexpm", optional: true]}, {:igniter, "~> 0.5", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: true]}, {:nimble_options, "~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_ownership, "~> 0.3.0 or ~> 1.0", [hex: :nimble_ownership, repo: "hexpm", optional: false]}, {:opentelemetry, ">= 0.0.0", [hex: :opentelemetry, repo: "hexpm", optional: true]}, {:opentelemetry_api, ">= 0.0.0", [hex: :opentelemetry_api, repo: "hexpm", optional: true]}, {:opentelemetry_exporter, ">= 0.0.0", [hex: :opentelemetry_exporter, repo: "hexpm", optional: true]}, {:opentelemetry_semantic_conventions, ">= 0.0.0", [hex: :opentelemetry_semantic_conventions, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_live_view, "~> 0.20 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.6", [hex: :plug, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm", "feaafc284dc204c82aadaddc884227aeaa3480decb274d30e184b9d41a700c66"},diff --git a/priv/ip/iana-ipv4-special-registry.csv b/priv/ip/iana-ipv4-special-registry.csvnew file mode 100644index 0000000000..c5996a45a7--- /dev/null+++ b/priv/ip/iana-ipv4-special-registry.csv@@ -0,0 +1,27 @@+Address Block,Name,RFC,Allocation Date,Termination Date,Source,Destination,Forwardable,Globally Reachable,Reserved-by-Protocol+0.0.0.0/8,"""This network""","[RFC791], Section 3.2",1981-09,N/A,True,False,False,False,True+0.0.0.0/32,"""This host on this network""","[RFC1122], Section 3.2.1.3",1981-09,N/A,True,False,False,False,True+10.0.0.0/8,Private-Use,[RFC1918],1996-02,N/A,True,True,True,False,False+100.64.0.0/10,Shared Address Space,[RFC6598],2012-04,N/A,True,True,True,False,False+127.0.0.0/8,Loopback,"[RFC1122], Section 3.2.1.3",1981-09,N/A,False [1],False [1],False [1],False [1],True+169.254.0.0/16,Link Local,[RFC3927],2005-05,N/A,True,True,False,False,True+172.16.0.0/12,Private-Use,[RFC1918],1996-02,N/A,True,True,True,False,False+192.0.0.0/24 [2],IETF Protocol Assignments,"[RFC6890], Section 2.1",2010-01,N/A,False,False,False,False,False+192.0.0.0/29,IPv4 Service Continuity Prefix,[RFC7335],2011-06,N/A,True,True,True,False,False+192.0.0.8/32,IPv4 dummy address,[RFC7600],2015-03,N/A,True,False,False,False,False+192.0.0.9/32,Port Control Protocol Anycast,[RFC7723],2015-10,N/A,True,True,True,True,False+192.0.0.10/32,Traversal Using Relays around NAT Anycast,[RFC8155],2017-02,N/A,True,True,True,True,False+"192.0.0.170/32, 192.0.0.171/32",NAT64/DNS64 Discovery,"[RFC8880][RFC7050], Section 2.2",2013-02,N/A,False,False,False,False,True+192.0.2.0/24,Documentation (TEST-NET-1),[RFC5737],2010-01,N/A,False,False,False,False,False+192.31.196.0/24,AS112-v4,[RFC7535],2014-12,N/A,True,True,True,True,False+192.52.193.0/24,AMT,[RFC7450],2014-12,N/A,True,True,True,True,False+192.88.99.0/24,Deprecated (6to4 Relay Anycast),[RFC7526],2001-06,2015-03,,,,,+192.88.99.2/32,6a44-relay anycast address,[RFC6751],2012-10,N/A,True,True,True,False,False+192.168.0.0/16,Private-Use,[RFC1918],1996-02,N/A,True,True,True,False,False+192.175.48.0/24,Direct Delegation AS112 Service,[RFC7534],1996-01,N/A,True,True,True,True,False+198.18.0.0/15,Benchmarking,[RFC2544],1999-03,N/A,True,True,True,False,False+198.51.100.0/24,Documentation (TEST-NET-2),[RFC5737],2010-01,N/A,False,False,False,False,False+203.0.113.0/24,Documentation (TEST-NET-3),[RFC5737],2010-01,N/A,False,False,False,False,False+240.0.0.0/4,Reserved,"[RFC1112], Section 4",1989-08,N/A,False,False,False,False,True+255.255.255.255/32,Limited Broadcast,"[RFC8190]+ [RFC919], Section 7",1984-10,N/A,False,True,False,False,Truediff --git a/priv/ip/iana-ipv6-special-registry.csv b/priv/ip/iana-ipv6-special-registry.csvnew file mode 100644index 0000000000..93ead430ce--- /dev/null+++ b/priv/ip/iana-ipv6-special-registry.csv@@ -0,0 +1,28 @@+Address Block,Name,RFC,Allocation Date,Termination Date,Source,Destination,Forwardable,Globally Reachable,Reserved-by-Protocol+::1/128,Loopback Address,[RFC4291],2006-02,N/A,False,False,False,False,True+::/128,Unspecified Address,[RFC4291],2006-02,N/A,True,False,False,False,True+::ffff:0:0/96,IPv4-mapped Address,[RFC4291],2006-02,N/A,False,False,False,False,True+64:ff9b::/96,IPv4-IPv6 Translat.,[RFC6052],2010-10,N/A,True,True,True,True,False+64:ff9b:1::/48,IPv4-IPv6 Translat.,[RFC8215],2017-06,N/A,True,True,True,False,False+100::/64,Discard-Only Address Block,[RFC6666],2012-06,N/A,True,True,True,False,False+100:0:0:1::/64,Dummy IPv6 Prefix,[RFC9780],2025-04,N/A,True,False,False,False,False+2001::/23,IETF Protocol Assignments,[RFC2928],2000-09,N/A,False [1],False [1],False [1],False [1],False+2001::/32,TEREDO,"[RFC4380]+ [RFC8190]",2006-01,N/A,True,True,True,N/A [2],False+2001:1::1/128,Port Control Protocol Anycast,[RFC7723],2015-10,N/A,True,True,True,True,False+2001:1::2/128,Traversal Using Relays around NAT Anycast,[RFC8155],2017-02,N/A,True,True,True,True,False+2001:1::3/128,DNS-SD Service Registration Protocol Anycast,[RFC9665],2024-04,N/A,True,True,True,True,False+2001:2::/48,Benchmarking,[RFC5180][RFC Errata 1752],2008-04,N/A,True,True,True,False,False+2001:3::/32,AMT,[RFC7450],2014-12,N/A,True,True,True,True,False+2001:4:112::/48,AS112-v6,[RFC7535],2014-12,N/A,True,True,True,True,False+2001:10::/28,Deprecated (previously ORCHID),[RFC4843],2007-03,2014-03,,,,,+2001:20::/28,ORCHIDv2,[RFC7343],2014-07,N/A,True,True,True,True,False+2001:30::/28,Drone Remote ID Protocol Entity Tags (DETs) Prefix,[RFC9374],2022-12,N/A,True,True,True,True,False+2001:db8::/32,Documentation,[RFC3849],2004-07,N/A,False,False,False,False,False+2002::/16 [3],6to4,[RFC3056],2001-02,N/A,True,True,True,N/A [3],False+2620:4f:8000::/48,Direct Delegation AS112 Service,[RFC7534],2011-05,N/A,True,True,True,True,False+3fff::/20,Documentation,[RFC9637],2024-07,N/A,False,False,False,False,False+5f00::/16,Segment Routing (SRv6) SIDs,[RFC9602],2024-04,N/A,True,True,True,False,False+fc00::/7,Unique-Local,"[RFC4193]+ [RFC8190]",2005-10,N/A,True,True,True,False [4],False+fe80::/10,Link-Local Unicast,[RFC4291],2006-02,N/A,True,True,False,False,Truediff --git a/test/plausible/auth/sso/domain/verification_test.exs b/test/plausible/auth/sso/domain/verification_test.exsindex db52aebc6f..0ed2b39fcd 100644--- a/test/plausible/auth/sso/domain/verification_test.exs+++ b/test/plausible/auth/sso/domain/verification_test.exs@@ -4,6 +4,8 @@ defmodule Plausible.Auth.SSO.Domain.VerificationTest do@moduletag :ee_onlyon_ee do+ use Plausible.Test.Support.DNS+alias Plasusible.Test.Support.DNSServeralias Plausible.Auth.SSO.Domain.Verificationalias Plug.Conn@@ -40,6 +42,12 @@ defmodule Plausible.Auth.SSO.Domain.VerificationTest do)end+ test "url without url_override is protected against SSRF when DNS resolves to a private IP" do+ expect_dns_lookup("example.com", [{192, 168, 1, 1}])++ refute Verification.url("example.com", "ex4mpl3")+ end+test "meta_tag", %{bypass: bypass} doBypass.expect(bypass, "GET", "/test", fn conn ->conndiff --git a/test/plausible/auth/sso/domains_test.exs b/test/plausible/auth/sso/domains_test.exsindex 27f853e8b9..84192dead4 100644--- a/test/plausible/auth/sso/domains_test.exs+++ b/test/plausible/auth/sso/domains_test.exs@@ -6,6 +6,7 @@ defmodule Plausible.Auth.SSO.DomainsTest doon_ee douse Plausible.Auth.SSO.Domain.Statususe Oban.Testing, repo: Plausible.Repo+ use Plausible.Test.Support.DNSalias Plausible.Authalias Plausible.Auth.SSO@@ -24,6 +25,14 @@ defmodule Plausible.Auth.SSO.DomainsTest doenddescribe "add/2" do+ setup do+ # These tests exercise real add-time domain validation (including+ # resolvability), so - unlike the rest of this module, which passes+ # skip_checks?: true - they need DNS to actually resolve.+ stub_dns()+ :ok+ end+test "adds a new domain", %{integration: integration} dodomain = generate_domain()@@ -113,7 +122,7 @@ defmodule Plausible.Auth.SSO.DomainsTest dointegration: integration} dodomain = generate_domain()- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)verified_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)@@ -132,7 +141,7 @@ defmodule Plausible.Auth.SSO.DomainsTest dointegration: integration} dodomain = generate_domain()- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)unverified_domain = SSO.Domains.verify(sso_domain, verification_opts: [methods: []])@@ -150,7 +159,7 @@ defmodule Plausible.Auth.SSO.DomainsTest dotest "sets domain status to in progress", %{integration: integration} dodomain = generate_domain()- {:ok, _} = SSO.Domains.add(integration, domain)+ {:ok, _} = SSO.Domains.add(integration, domain, skip_checks?: true)assert {:ok, sso_domain} = SSO.Domains.start_verification(domain)assert sso_domain.status == Status.in_progress()@@ -162,7 +171,7 @@ defmodule Plausible.Auth.SSO.DomainsTest dotest "enqueues background work", %{integration: integration} dodomain = generate_domain()- {:ok, _} = SSO.Domains.add(integration, domain)+ {:ok, _} = SSO.Domains.add(integration, domain, skip_checks?: true)assert {:ok, _} = SSO.Domains.start_verification(domain)assert_enqueued(@@ -179,7 +188,7 @@ defmodule Plausible.Auth.SSO.DomainsTest dotest "sets domain status to unverified", %{integration: integration} dodomain = generate_domain()- {:ok, _} = SSO.Domains.add(integration, domain)+ {:ok, _} = SSO.Domains.add(integration, domain, skip_checks?: true)assert {:ok, sso_domain} = SSO.Domains.start_verification(domain)assert :ok = SSO.Domains.cancel_verification(domain)assert Repo.reload!(sso_domain).status == Status.unverified()@@ -194,7 +203,7 @@ defmodule Plausible.Auth.SSO.DomainsTest dodescribe "lookup/1" dotest "looks up domain by email", %{integration: integration} dodomain = generate_domain()- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)email = "mary.jane@" <> domain@@ -208,7 +217,7 @@ defmodule Plausible.Auth.SSO.DomainsTest dotest "looks up domain by plain domain", %{integration: integration} dodomain = generate_domain()- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)assert {:ok, found_sso_domain} = SSO.Domains.lookup(domain)@@ -217,7 +226,7 @@ defmodule Plausible.Auth.SSO.DomainsTest dotest "normalizes input removing whitespace and capitalizations", %{integration: integration} dodomain = generate_domain()- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)email = " maRy.jAnE@" <> String.upcase(domain) <> " "@@ -228,7 +237,7 @@ defmodule Plausible.Auth.SSO.DomainsTest dotest "returns error if matching domain is not verified", %{integration: integration} dodomain = generate_domain()- {:ok, _sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, _sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)assert {:error, :not_found} = SSO.Domains.lookup(domain)end@@ -243,7 +252,7 @@ defmodule Plausible.Auth.SSO.DomainsTest dodescribe "check_can_remove/1" dosetup %{integration: integration} dodomain = generate_domain()- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true){:ok, domain: domain, sso_domain: sso_domain}end@@ -254,7 +263,7 @@ defmodule Plausible.Auth.SSO.DomainsTest dosso_domain: sso_domain} doother_domain = generate_domain()- {:ok, other_sso_domain} = SSO.Domains.add(integration, other_domain)+ {:ok, other_sso_domain} = SSO.Domains.add(integration, other_domain, skip_checks?: true)_other_sso_domain = SSO.Domains.verify(other_sso_domain, skip_checks?: true)other_identity = new_identity("Mary Goodwill", "mary@" <> other_domain, integration){:ok, _, _, _other_sso_user} = SSO.provision_user(other_identity)@@ -296,7 +305,7 @@ defmodule Plausible.Auth.SSO.DomainsTest dodescribe "remove/1,2" dosetup %{integration: integration} dodomain = generate_domain()- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true){:ok, domain: domain, sso_domain: sso_domain}enddiff --git a/test/plausible/auth/sso_test.exs b/test/plausible/auth/sso_test.exsindex 6665f88f60..b8d90ab2e8 100644--- a/test/plausible/auth/sso_test.exs+++ b/test/plausible/auth/sso_test.exs@@ -275,7 +275,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true){:ok, team: team, integration: integration, domain: domain, sso_domain: sso_domain}@@ -312,7 +312,10 @@ defmodule Plausible.Auth.SSOTest doother_team = new_site().teamother_integration = SSO.initiate_saml_integration(other_team)other_domain = "other-example-#{Enum.random(1..10_000)}.com"- {:ok, other_sso_domain} = SSO.Domains.add(other_integration, other_domain)++ {:ok, other_sso_domain} =+ SSO.Domains.add(other_integration, other_domain, skip_checks?: true)+_other_sso_domain = SSO.Domains.verify(other_sso_domain, skip_checks?: true)identity = new_identity("Jane Sculley", "jane@" <> domain, other_integration)@@ -551,7 +554,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)identity = new_identity("Clarence Fortridge", "clarence@" <> domain, integration)@@ -678,7 +681,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)# Provisioned SSO identity@@ -703,7 +706,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)# Provisioned SSO identity@@ -725,7 +728,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)assert {:error, :no_sso_user} = SSO.check_force_sso(team, :all_but_owners)@@ -743,7 +746,7 @@ defmodule Plausible.Auth.SSOTest dodomain = "example-#{Enum.random(1..10_000)}.com"# Unverified domain- {:ok, _sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, _sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)assert {:error, :no_verified_domain} = SSO.check_force_sso(team, :all_but_owners)end@@ -789,7 +792,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)# Provisioned SSO identity@@ -825,7 +828,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)# Provisioned SSO identity@@ -865,7 +868,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)# Provisioned SSO identity@@ -893,7 +896,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)# Provisioned SSO identity@@ -918,7 +921,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)# Provisioned SSO identity@@ -946,7 +949,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)# Provisioned SSO identity@@ -970,7 +973,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)# Provisioned SSO identity@@ -1003,7 +1006,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)# Provisioned SSO identity@@ -1028,7 +1031,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)# Provisioned SSO identity@@ -1057,8 +1060,8 @@ defmodule Plausible.Auth.SSOTest dodomain1 = "example-#{Enum.random(1..10_000)}.com"domain2 = "test-#{Enum.random(1..10_000)}.com"- {:ok, d1} = SSO.Domains.add(integration, domain1)- {:ok, d2} = SSO.Domains.add(integration, domain2)+ {:ok, d1} = SSO.Domains.add(integration, domain1, skip_checks?: true)+ {:ok, d2} = SSO.Domains.add(integration, domain2, skip_checks?: true){:ok, _} = SSO.Domains.start_verification(domain1){:ok, _} = SSO.Domains.start_verification(domain2)@@ -1094,7 +1097,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)SSO.Domains.verify(sso_domain, skip_checks?: true)identity = new_identity("Test User", "test@" <> domain, integration)@@ -1130,7 +1133,7 @@ defmodule Plausible.Auth.SSOTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true){:ok,diff --git a/test/plausible/installation_support/checks/url_test.exs b/test/plausible/installation_support/checks/url_test.exsindex 28ac54b998..07f0cd0510 100644--- a/test/plausible/installation_support/checks/url_test.exs+++ b/test/plausible/installation_support/checks/url_test.exs@@ -7,9 +7,9 @@ defmodule Plausible.InstallationSupport.Checks.UrlTest douse Plausible.DataCase, async: trueon_ee do- import Mox+ use Plausible.Test.Support.DNS- alias Plausible.InstallationSupport.{State, Checks, Verification}+ alias Plausible.InstallationSupport.{Checks, State, Verification}@check Checks.Url@@ -20,14 +20,7 @@ defmodule Plausible.InstallationSupport.Checks.UrlTest do{"plausible.io/sites", ~c"plausible.io"}] dotest "guesses 'https://#{site_domain}' if A-record is found for '#{site_domain}'" do- Plausible.DnsLookup.Mock- |> expect(:lookup, fn unquote(expected_lookup_domain),- _type,- _record,- _opts,- _timeout ->- [{192, 168, 1, 1}]- end)+ expect_dns_lookup(unquote(expected_lookup_domain), [{93, 184, 216, 34}])state =@check.perform(@@ -48,13 +41,8 @@ defmodule Plausible.InstallationSupport.Checks.UrlTest dotest "guesses 'www.{domain}' if A record is not found for 'domain'" dosite_domain = "example.com/any/deeper/path"- Plausible.DnsLookup.Mock- |> expect(:lookup, fn ~c"example.com", _type, _record, _opts, _timeout ->- []- end)- |> expect(:lookup, fn ~c"www.example.com", _type, _record, _opts, _timeout ->- [{192, 168, 1, 2}]- end)+ expect_dns_lookup("example.com", [])+ expect_dns_lookup("www.example.com", [{93, 184, 216, 34}])state =@check.perform(@@ -72,15 +60,53 @@ defmodule Plausible.InstallationSupport.Checks.UrlTest doendtest "fails if no A-record is found for 'domain' or 'www.{domain}'" do- expected_lookups = 2+ domain = "any.example.com"++ expect_dns_lookup("any.example.com", [])+ expect_dns_lookup("www.any.example.com", [])++ state =+ @check.perform(+ %State{+ data_domain: domain,+ url: nil,+ diagnostics: %Verification.Diagnostics{}+ },+ []+ )++ assert state.url == nil+ assert state.diagnostics.service_error == %{code: :domain_not_found}+ assert state.skip_further_checks?+ end++ test "fails if 'domain' only resolves to a private/reserved address" do+ domain = "any.example.com"++ expect_dns_lookup("any.example.com", [{192, 168, 1, 1}])+ expect_dns_lookup("www.any.example.com", [])++ state =+ @check.perform(+ %State{+ data_domain: domain,+ url: nil,+ diagnostics: %Verification.Diagnostics{}+ },+ []+ )- Plausible.DnsLookup.Mock- |> expect(:lookup, expected_lookups, fn _domain, _type, _record, _opts, _timeout ->- []- end)+ assert state.url == nil+ assert state.diagnostics.service_error == %{code: :domain_not_found}+ assert state.skip_further_checks?+ end+ test "fails if 'domain' only resolves to a private/reserved AAAA address" dodomain = "any.example.com"+ expect_dns_lookup("any.example.com", [], [{0xFC00, 0, 0, 0, 0, 0, 0, 1}])+ expect_dns_lookup("www.any.example.com", [])+state =@check.perform(%State{@@ -102,10 +128,7 @@ defmodule Plausible.InstallationSupport.Checks.UrlTest dosite_domain = "example-com-rollup"url = "https://blog.example.com/recipes?foo=bar#baz"- Plausible.DnsLookup.Mock- |> expect(:lookup, fn ~c"blog.example.com", _type, _record, _opts, _timeout ->- [{192, 168, 1, 1}]- end)+ expect_dns_lookup("blog.example.com", [{93, 184, 216, 34}])state =@check.perform(@@ -142,10 +165,28 @@ defmodule Plausible.InstallationSupport.Checks.UrlTest dosite_domain = "example-com-rollup"url = "https://example.com/archives/news?p=any#fragment"- Plausible.DnsLookup.Mock- |> expect(:lookup, fn ~c"example.com", _type, _record, _opts, _timeout ->- []- end)+ expect_dns_lookup("example.com", [])++ state =+ @check.perform(+ %State{+ data_domain: site_domain,+ url: url,+ diagnostics: %Verification.Diagnostics{}+ },+ []+ )++ assert state.url == url+ assert state.diagnostics.service_error == %{code: :domain_not_found}+ assert state.skip_further_checks?+ end++ test "rejects urls whose host only resolves to a private/reserved address" do+ site_domain = "example-com-rollup"+ url = "https://example.com/archives/news?p=any#fragment"++ expect_dns_lookup("example.com", [{127, 0, 0, 1}])state =@check.perform(diff --git a/test/plausible/installation_support/detection/checks_observability_test.exs b/test/plausible/installation_support/detection/checks_observability_test.exsindex 6da95d9bf4..901df7c9fc 100644--- a/test/plausible/installation_support/detection/checks_observability_test.exs+++ b/test/plausible/installation_support/detection/checks_observability_test.exs@@ -34,7 +34,7 @@ defmodule Plausible.InstallationSupport.Detection.ChecksObservabilityTest doendtest "successful detection -> no logs, no sentry, telemetry :success" do- stub_lookup_a_records(@expected_domain)+ stub_dns()detection_stub =json_response_detection_stub(%{@@ -59,7 +59,7 @@ defmodule Plausible.InstallationSupport.Detection.ChecksObservabilityTest doendtest "domain not found -> customer website issue" do- stub_lookup_a_records(@expected_domain, [])+ expect_dns_unresolvable(@expected_domain)detection_counter =Req.Test.stub(Plausible.InstallationSupport.Checks.Detection, fn _conn ->@@ -88,7 +88,7 @@ defmodule Plausible.InstallationSupport.Detection.ChecksObservabilityTest dofor msg <- ["Execution context destroyed", "net::ERR_CONNECTION_REFUSED"] dotest "failure due to a known :browserless_client_error (#{msg}) -> customer website issue" do- stub_lookup_a_records(@expected_domain)+ stub_dns()detection_stub =json_response_detection_stub(%{@@ -112,7 +112,7 @@ defmodule Plausible.InstallationSupport.Detection.ChecksObservabilityTest doendtest "failure due to an unknown :browserless_client_error -> unknown failure" do- stub_lookup_a_records(@expected_domain)+ stub_dns()detection_stub =json_response_detection_stub(%{@@ -136,7 +136,7 @@ defmodule Plausible.InstallationSupport.Detection.ChecksObservabilityTest doendtest "failure hitting the catch-all interpret clause -> unknown failure" do- stub_lookup_a_records(@expected_domain)+ stub_dns()detection_stub = fn conn ->Req.Test.transport_error(conn, :econnrefused)@@ -158,7 +158,7 @@ defmodule Plausible.InstallationSupport.Detection.ChecksObservabilityTest doendtest "failure due to a flaky browserless issue -> browserless issue" do- stub_lookup_a_records(@expected_domain)+ stub_dns()detection_stub = fn conn ->conn@@ -182,7 +182,7 @@ defmodule Plausible.InstallationSupport.Detection.ChecksObservabilityTest doendtest "failure due to a browserless timeout -> browserless issue" do- stub_lookup_a_records(@expected_domain)+ stub_dns()detection_stub = fn conn ->Req.Test.transport_error(conn, :timeout)@@ -203,7 +203,7 @@ defmodule Plausible.InstallationSupport.Detection.ChecksObservabilityTest doendtest "failure due to internal_check_timeout -> browserless issue" do- stub_lookup_a_records(@expected_domain)+ stub_dns()detection_stub = fn _conn -># times outdiff --git a/test/plausible/installation_support/detection/checks_test.exs b/test/plausible/installation_support/detection/checks_test.exsindex 8f362a6425..70a3064a47 100644--- a/test/plausible/installation_support/detection/checks_test.exs+++ b/test/plausible/installation_support/detection/checks_test.exs@@ -17,7 +17,7 @@ defmodule Plausible.InstallationSupport.Detection.ChecksTest dotest "handles wordpress detection, retrying on 429" dourl_to_verify = niltest = self()- stub_lookup_a_records(@expected_domain)+ stub_dns()get_context_from_body = fn conn ->{:ok, body, _conn} = Plug.Conn.read_body(conn)diff --git a/test/plausible/installation_support/verification/checks_observability_test.exs b/test/plausible/installation_support/verification/checks_observability_test.exsindex 0e7bbd5a95..5464c08c01 100644--- a/test/plausible/installation_support/verification/checks_observability_test.exs+++ b/test/plausible/installation_support/verification/checks_observability_test.exs@@ -128,7 +128,7 @@ defmodule Plausible.InstallationSupport.Verification.ChecksObservabilityTest doProcess.sleep(1000)end- stub_lookup_a_records(@expected_domain)+ stub_dns()stub_verification_result(verification_stub)state =@@ -161,7 +161,7 @@ defmodule Plausible.InstallationSupport.Verification.ChecksObservabilityTest doenddefp run_checks(verification_stub) do- stub_lookup_a_records(@expected_domain)+ stub_dns()stub_verification_result(verification_stub)Checks.run(@url_to_verify, @expected_domain, "manual",diff --git a/test/plausible/installation_support/verification/checks_test.exs b/test/plausible/installation_support/verification/checks_test.exsindex a0b7ef39a8..01e01e4d79 100644--- a/test/plausible/installation_support/verification/checks_test.exs+++ b/test/plausible/installation_support/verification/checks_test.exs@@ -16,7 +16,7 @@ defmodule Plausible.InstallationSupport.Verification.ChecksTest dodescribe "URL check" dotest "returns error when DNS check fails with domain not found error, offers custom URL input" do- stub_lookup_a_records(@expected_domain, [])+ expect_dns_unresolvable(@expected_domain)assert_matches %Result{ok?: false,@@ -43,7 +43,7 @@ defmodule Plausible.InstallationSupport.Verification.ChecksTest dotest "returns error when DNS check fails with invalid URL error, offers custom URL input" dourl_to_verify = "file://#{@expected_domain}"- stub_lookup_a_records(@expected_domain, [])+ expect_dns_unresolvable(@expected_domain)assert_matches %Result{ok?: false,@@ -539,7 +539,7 @@ defmodule Plausible.InstallationSupport.Verification.ChecksTest doinstallation_type = Keyword.get(opts, :installation_type, "manual")expected_req_count = Keyword.get(opts, :expected_req_count)- stub_lookup_a_records(@expected_domain)+ stub_dns()if is_integer(expected_req_count) docounter = :atomics.new(1, [])diff --git a/test/plausible/ip/tools_test.exs b/test/plausible/ip/tools_test.exsnew file mode 100644index 0000000000..a27ac3e8a8--- /dev/null+++ b/test/plausible/ip/tools_test.exs@@ -0,0 +1,262 @@+defmodule Plausible.IP.ToolsTest do+ use ExUnit.Case, async: true++ alias Plausible.IP++ defp ip!(str) do+ {:ok, ip} = :inet.parse_address(String.to_charlist(str))+ ip+ end++ describe "reserved?/1 - IPv4" do+ test "RFC 1918 private-use ranges" do+ assert IP.Tools.reserved?(ip!("10.0.0.0"))+ assert IP.Tools.reserved?(ip!("10.255.255.255"))+ assert IP.Tools.reserved?(ip!("172.16.0.0"))+ assert IP.Tools.reserved?(ip!("172.31.255.255"))+ assert IP.Tools.reserved?(ip!("192.168.0.0"))+ assert IP.Tools.reserved?(ip!("192.168.255.255"))++ refute IP.Tools.reserved?(ip!("172.15.255.255"))+ refute IP.Tools.reserved?(ip!("172.32.0.0"))+ refute IP.Tools.reserved?(ip!("11.0.0.0"))+ refute IP.Tools.reserved?(ip!("192.167.255.255"))+ refute IP.Tools.reserved?(ip!("192.169.0.0"))+ end++ test "loopback 127.0.0.0/8" do+ assert IP.Tools.reserved?(ip!("127.0.0.1"))+ assert IP.Tools.reserved?(ip!("127.255.255.255"))+ refute IP.Tools.reserved?(ip!("126.255.255.255"))+ refute IP.Tools.reserved?(ip!("128.0.0.0"))+ end++ test "this-network 0.0.0.0/8" do+ assert IP.Tools.reserved?(ip!("0.0.0.0"))+ assert IP.Tools.reserved?(ip!("0.255.255.255"))+ end++ test "link-local 169.254.0.0/16" do+ assert IP.Tools.reserved?(ip!("169.254.0.0"))+ assert IP.Tools.reserved?(ip!("169.254.255.255"))+ refute IP.Tools.reserved?(ip!("169.253.255.255"))+ refute IP.Tools.reserved?(ip!("169.255.0.0"))+ end++ test "shared address space (CGNAT) 100.64.0.0/10" do+ assert IP.Tools.reserved?(ip!("100.64.0.0"))+ assert IP.Tools.reserved?(ip!("100.127.255.255"))+ refute IP.Tools.reserved?(ip!("100.63.255.255"))+ refute IP.Tools.reserved?(ip!("100.128.0.0"))+ end++ test "benchmarking 198.18.0.0/15" do+ assert IP.Tools.reserved?(ip!("198.18.0.0"))+ assert IP.Tools.reserved?(ip!("198.19.255.255"))+ refute IP.Tools.reserved?(ip!("198.17.255.255"))+ refute IP.Tools.reserved?(ip!("198.20.0.0"))+ end++ test "documentation TEST-NET ranges" do+ assert IP.Tools.reserved?(ip!("192.0.2.0"))+ assert IP.Tools.reserved?(ip!("192.0.2.255"))+ assert IP.Tools.reserved?(ip!("198.51.100.0"))+ assert IP.Tools.reserved?(ip!("198.51.100.255"))+ assert IP.Tools.reserved?(ip!("203.0.113.0"))+ assert IP.Tools.reserved?(ip!("203.0.113.255"))+ end++ test "reserved-for-future-use 240.0.0.0/4 (class E)" do+ assert IP.Tools.reserved?(ip!("240.0.0.0"))+ assert IP.Tools.reserved?(ip!("255.255.255.254"))+ end++ test "limited broadcast 255.255.255.255/32" do+ assert IP.Tools.reserved?(ip!("255.255.255.255"))+ end++ test "multicast 224.0.0.0/4" do+ assert IP.Tools.reserved?(ip!("224.0.0.0"))+ assert IP.Tools.reserved?(ip!("224.0.0.1"))+ assert IP.Tools.reserved?(ip!("239.255.255.255"))+ refute IP.Tools.reserved?(ip!("223.255.255.255"))+ end++ test "IETF protocol assignments 192.0.0.0/24 but not its globally reachable carve-outs" do+ assert IP.Tools.reserved?(ip!("192.0.0.0"))+ assert IP.Tools.reserved?(ip!("192.0.0.8"))+ assert IP.Tools.reserved?(ip!("192.0.0.170"))+ assert IP.Tools.reserved?(ip!("192.0.0.171"))++ refute IP.Tools.reserved?(ip!("192.0.0.9"))+ refute IP.Tools.reserved?(ip!("192.0.0.10"))+ end++ test "AS112/AMT anycast carve-outs are globally reachable, not reserved" do+ refute IP.Tools.reserved?(ip!("192.31.196.1"))+ refute IP.Tools.reserved?(ip!("192.52.193.1"))+ refute IP.Tools.reserved?(ip!("192.175.48.1"))+ end++ test "deprecated 6to4 relay anycast block reverted to ordinary space" do+ refute IP.Tools.reserved?(ip!("192.88.99.1"))+ assert IP.Tools.reserved?(ip!("192.88.99.2"))+ end++ test "well-known public addresses are not reserved" do+ refute IP.Tools.reserved?(ip!("8.8.8.8"))+ refute IP.Tools.reserved?(ip!("1.1.1.1"))+ refute IP.Tools.reserved?(ip!("93.184.216.34"))+ refute IP.Tools.reserved?(ip!("172.217.0.0"))+ end+ end++ describe "reserved?/1 - IPv6" do+ test "loopback and unspecified" do+ assert IP.Tools.reserved?(ip!("::1"))+ assert IP.Tools.reserved?(ip!("::"))+ end++ test "unique local addresses fc00::/7" do+ assert IP.Tools.reserved?(ip!("fc00::1"))+ assert IP.Tools.reserved?(ip!("fd00::1"))+ refute IP.Tools.reserved?(ip!("fe00::1"))+ end++ test "link-local unicast fe80::/10" do+ assert IP.Tools.reserved?(ip!("fe80::1"))+ assert IP.Tools.reserved?(ip!("febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))+ refute IP.Tools.reserved?(ip!("fec0::1"))+ end++ test "documentation ranges" do+ assert IP.Tools.reserved?(ip!("2001:db8::1"))+ assert IP.Tools.reserved?(ip!("3fff::1"))+ end++ test "benchmarking and discard-only blocks" do+ assert IP.Tools.reserved?(ip!("2001:2::1"))+ assert IP.Tools.reserved?(ip!("100::1"))+ end++ test "multicast ff00::/8" do+ assert IP.Tools.reserved?(ip!("ff02::1"))+ assert IP.Tools.reserved?(ip!("ff00::"))+ refute IP.Tools.reserved?(ip!("feff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"))+ end++ test "IETF protocol assignments 2001::/23 is reserved by default" do+ assert IP.Tools.reserved?(ip!("2001:5::1"))+ assert IP.Tools.reserved?(ip!("2001:1ff::1"))+ end++ test "carve-outs inside 2001::/23 that are globally reachable are not reserved" do+ refute IP.Tools.reserved?(ip!("2001:1::1"))+ refute IP.Tools.reserved?(ip!("2001:1::2"))+ refute IP.Tools.reserved?(ip!("2001:1::3"))+ refute IP.Tools.reserved?(ip!("2001:3::1"))+ refute IP.Tools.reserved?(ip!("2001:4:112::1"))+ refute IP.Tools.reserved?(ip!("2001:20::1"))+ refute IP.Tools.reserved?(ip!("2001:30::1"))+ end++ test "TEREDO 2001::/32 is not treated as reserved" do+ refute IP.Tools.reserved?(ip!("2001:0:4136:e378:8000:63bf:3fff:fdd2"))+ end++ test "6to4 2002::/16 is not treated as reserved" do+ refute IP.Tools.reserved?(ip!("2002:c000:0204::"))+ end++ test "deprecated ORCHID block reverted to ordinary space" do+ refute IP.Tools.reserved?(ip!("2001:10::1"))+ end++ test "well-known public addresses are not reserved" do+ refute IP.Tools.reserved?(ip!("2606:4700:4700::1111"))+ refute IP.Tools.reserved?(ip!("2001:4860:4860::8888"))+ end+ end++ describe "reserved?/1 - IPv4-mapped IPv6 (::ffff:a.b.c.d)" do+ test "delegates to the embedded IPv4 address instead of blanket-reserving ::ffff:0:0/96" do+ assert IP.Tools.reserved?(ip!("::ffff:127.0.0.1"))+ assert IP.Tools.reserved?(ip!("::ffff:10.0.0.1"))+ assert IP.Tools.reserved?(ip!("::ffff:192.168.1.1"))++ refute IP.Tools.reserved?(ip!("::ffff:8.8.8.8"))+ refute IP.Tools.reserved?(ip!("::ffff:1.1.1.1"))+ end++ test "matches reserved?/1 applied directly to the embedded address" do+ for str <- ["127.0.0.1", "10.1.2.3", "8.8.8.8", "192.0.2.1", "224.0.0.1"] do+ {a, b, c, d} = v4 = ip!(str)+ mapped = {0, 0, 0, 0, 0, 0xFFFF, a * 256 + b, c * 256 + d}++ assert IP.Tools.reserved?(mapped) == IP.Tools.reserved?(v4),+ "expected ::ffff:#{str} to match reserved?/1 of #{str}"+ end+ end+ end++ describe "allowed?/1" do+ test "accepts already-parsed tuples" do+ assert IP.Tools.allowed?({8, 8, 8, 8})+ refute IP.Tools.allowed?({127, 0, 0, 1})+ assert IP.Tools.allowed?({0x2606, 0x4700, 0x4700, 0, 0, 0, 0, 0x1111})+ refute IP.Tools.allowed?({0, 0, 0, 0, 0, 0, 0, 1})+ end++ test "accepts binaries" do+ assert IP.Tools.allowed?("8.8.8.8")+ refute IP.Tools.allowed?("192.168.1.1")+ assert IP.Tools.allowed?("2606:4700:4700::1111")+ refute IP.Tools.allowed?("::1")+ end++ test "disallows invalid inputs" do+ refute IP.Tools.allowed?({1, 2, 3})+ refute IP.Tools.allowed?({1, 2, 3, 4, 5})+ refute IP.Tools.allowed?(nil)+ refute IP.Tools.allowed?(:not_an_ip)+ refute IP.Tools.allowed?("not an ip")+ refute IP.Tools.allowed?("")+ refute IP.Tools.allowed?("999.999.999.999")+ end+ end++ describe "ranges/0" do+ test "every range is well formed" do+ ranges = IP.Tools.ranges()++ assert length(ranges) > 30++ for %{cidr: cidr, reserved: reserved, name: name} <- ranges do+ assert is_binary(cidr)+ assert is_binary(name)+ assert is_boolean(reserved)+ end+ end++ test "is sorted from most to least specific prefix" do+ prefix_lengths =+ Enum.map(IP.Tools.ranges(), fn %{cidr: cidr} ->+ [_addr, prefix] = String.split(cidr, "/")+ String.to_integer(prefix)+ end)++ assert prefix_lengths == Enum.sort(prefix_lengths, :desc)+ end++ test "includes the supplemental multicast ranges" do+ cidrs = Enum.map(IP.Tools.ranges(), & &1.cidr)++ assert "224.0.0.0/4" in cidrs+ assert "ff00::/8" in cidrs+ end++ test "excludes ::ffff:0:0/96 in favor of delegating to IPv4 rules" do+ refute "::ffff:0:0/96" in Enum.map(IP.Tools.ranges(), & &1.cidr)+ end+ end+enddiff --git a/test/plausible/ssrf_test.exs b/test/plausible/ssrf_test.exsnew file mode 100644index 0000000000..60a997822e--- /dev/null+++ b/test/plausible/ssrf_test.exs@@ -0,0 +1,198 @@+defmodule Plausible.SSRFTest do+ use ExUnit.Case, async: true+ use Plausible.TestUtils+ use Plausible.Test.Support.DNS++ alias Plausible.SSRF++ describe "resolve_host/1" do+ test "rejects bare single-label hosts (no dot)" do+ expect_no_dns_lookup()++ assert SSRF.resolve_host("localhost") == {:error, :invalid_host}+ assert SSRF.resolve_host("metadata") == {:error, :invalid_host}+ end++ test "validates a literal public IPv4 host directly, without any DNS lookup" do+ expect_no_dns_lookup()++ assert SSRF.resolve_host("93.184.216.34") == {:ok, [{93, 184, 216, 34}]}+ end++ test "rejects a literal private/loopback/link-local IPv4 host, without any DNS lookup" do+ expect_no_dns_lookup()++ assert SSRF.resolve_host("127.0.0.1") == {:error, :restricted_address}+ assert SSRF.resolve_host("10.0.0.1") == {:error, :restricted_address}+ assert SSRF.resolve_host("169.254.169.254") == {:error, :restricted_address}+ end++ test "rejects a literal private/loopback IPv6 host, without any DNS lookup" do+ expect_no_dns_lookup()++ assert SSRF.resolve_host("::1") == {:error, :restricted_address}+ assert SSRF.resolve_host("fc00::1") == {:error, :restricted_address}+ end++ test "resolves a domain via DNS to a public address" do+ stub_dns(%{"example.com" => {[{93, 184, 216, 34}], []}})++ assert SSRF.resolve_host("example.com") == {:ok, [{93, 184, 216, 34}]}+ end++ test "rejects a domain whose only DNS answer is a private/reserved address" do+ stub_dns(%{"example.com" => {[{192, 168, 1, 1}], []}})++ assert SSRF.resolve_host("example.com") == {:error, :restricted_address}+ end++ test "rejects a domain whose AAAA answer is a private/reserved address" do+ stub_dns(%{"example.com" => {[], [{0xFC00, 0, 0, 0, 0, 0, 0, 1}]}})++ assert SSRF.resolve_host("example.com") == {:error, :restricted_address}+ end++ test "rejects a domain when DNS returns a mix of public and private addresses" do+ stub_dns(%{"example.com" => {[{93, 184, 216, 34}, {169, 254, 169, 254}], []}})++ assert SSRF.resolve_host("example.com") == {:error, :restricted_address}+ end++ test "reports a domain with no A/AAAA records as unresolved" do+ stub_dns(%{"example.com" => {[], []}})++ assert SSRF.resolve_host("example.com") == {:error, :dns_resolution_failed}+ end+ end++ describe "get/2" do+ test "fetches a literal public IP host directly (no DNS lookup), pinning the Host header" do+ expect_no_dns_lookup()++ Req.Test.stub(__MODULE__, fn conn ->+ assert {"host", "93.184.216.34"} in conn.req_headers+ Plug.Conn.send_resp(conn, 200, "ok")+ end)++ assert {:ok, %Req.Response{status: 200, body: "ok"}} =+ SSRF.get("http://93.184.216.34/", plug: {Req.Test, __MODULE__})+ end++ test "resolves via DNS, fetches, and pins the Host header to the original hostname" do+ stub_dns(%{"good.example" => {[{93, 184, 216, 34}], []}})++ Req.Test.stub(__MODULE__, fn conn ->+ assert {"host", "good.example"} in conn.req_headers+ Plug.Conn.send_resp(conn, 200, "hello")+ end)++ assert {:ok, %Req.Response{status: 200, body: "hello"}} =+ SSRF.get("http://good.example/", plug: {Req.Test, __MODULE__})+ end++ test "rejects a host whose DNS answer is a private address, without ever reaching the plug" do+ stub_dns(%{"evil.example" => {[{127, 0, 0, 1}], []}})++ Req.Test.stub(__MODULE__, fn _conn ->+ raise "should never be called"+ end)++ assert SSRF.get("http://evil.example/", plug: {Req.Test, __MODULE__}) ==+ {:error, :restricted_address}+ end++ test "follows a redirect to a still-public host, re-validating before following" do+ stub_dns(%{+ "good.example" => {[{93, 184, 216, 34}], []},+ "still-good.example" => {[{93, 184, 216, 35}], []}+ })++ Req.Test.stub(__MODULE__, fn conn ->+ case conn.request_path do+ "/start" ->+ conn+ |> Plug.Conn.put_resp_header("location", "http://still-good.example/final")+ |> Plug.Conn.send_resp(302, "")++ "/final" ->+ Plug.Conn.send_resp(conn, 200, "done")+ end+ end)++ assert {:ok, %Req.Response{status: 200, body: "done"}} =+ SSRF.get("http://good.example/start", plug: {Req.Test, __MODULE__})+ end++ test "rejects a redirect to a host whose DNS answer is a private address" do+ stub_dns(%{+ "good.example" => {[{93, 184, 216, 34}], []},+ "internal.example" => {[{169, 254, 169, 254}], []}+ })++ Req.Test.stub(__MODULE__, fn conn ->+ case conn.request_path do+ "/start" ->+ conn+ |> Plug.Conn.put_resp_header("location", "http://internal.example/steal-secrets")+ |> Plug.Conn.send_resp(302, "")++ "/steal-secrets" ->+ raise "should never be called - redirect target must be rejected before follow-up"+ end+ end)++ assert SSRF.get("http://good.example/start", plug: {Req.Test, __MODULE__}) ==+ {:error, :restricted_address}+ end++ test "gives up after exceeding the redirect budget" do+ stub_dns(%{"loopy.example" => {[{93, 184, 216, 34}], []}})++ Req.Test.stub(__MODULE__, fn conn ->+ conn+ |> Plug.Conn.put_resp_header("location", "http://loopy.example/")+ |> Plug.Conn.send_resp(302, "")+ end)++ assert SSRF.get("http://loopy.example/", plug: {Req.Test, __MODULE__}, max_redirects: 2) ==+ {:error, :too_many_redirects}+ end+ end++ describe "pool_max_idle_time" do+ test "an idle Finch pool is reaped after pool_max_idle_time, instead of lingering forever" do+ # This exercises the same connect_options/pool_max_idle_time shape+ # SSRF.do_request/3 builds, via a real Finch pool - it can't be driven+ # through SSRF.get/2 itself because the only network target reachable+ # from a test is loopback, which SSRF.resolve_host/1 correctly (and+ # by design) rejects as a restricted address.+ test_pid = self()+ bypass = Bypass.open()++ handler_id = "ssrf-pool-idle-test-#{System.unique_integer()}"++ :telemetry.attach(+ handler_id,+ [:finch, :pool_max_idle_time_exceeded],+ fn _event, _measurements, metadata, _config ->+ if metadata.port == bypass.port, do: send(test_pid, :pool_reaped)+ end,+ nil+ )++ on_exit(fn -> :telemetry.detach(handler_id) end)++ Bypass.expect_once(bypass, "GET", "/", fn conn -> Plug.Conn.send_resp(conn, 200, "ok") end)++ assert {:ok, %Req.Response{status: 200}} =+ Req.request(+ method: :get,+ url: "http://localhost:#{bypass.port}/",+ connect_options: [hostname: "localhost"],+ pool_max_idle_time: 50+ )++ assert_receive :pool_reaped+ end+ end+enddiff --git a/test/plausible_web/controllers/auth_controller_test.exs b/test/plausible_web/controllers/auth_controller_test.exsindex 78ae1fc009..26208da92c 100644--- a/test/plausible_web/controllers/auth_controller_test.exs+++ b/test/plausible_web/controllers/auth_controller_test.exs@@ -635,7 +635,7 @@ defmodule PlausibleWeb.AuthControllerTest do# Setup SSOintegration = Auth.SSO.initiate_saml_integration(team)- {:ok, sso_domain} = Auth.SSO.Domains.add(integration, "example.com")+ {:ok, sso_domain} = Auth.SSO.Domains.add(integration, "example.com", skip_checks?: true)_sso_domain = Auth.SSO.Domains.verify(sso_domain, skip_checks?: true)identity = new_identity(owner.name, owner.email, integration)@@ -659,7 +659,7 @@ defmodule PlausibleWeb.AuthControllerTest do# Setup SSOintegration = Auth.SSO.initiate_saml_integration(team)- {:ok, sso_domain} = Auth.SSO.Domains.add(integration, "example.com")+ {:ok, sso_domain} = Auth.SSO.Domains.add(integration, "example.com", skip_checks?: true)_sso_domain = Auth.SSO.Domains.verify(sso_domain, skip_checks?: true)identity = new_identity(member.name, member.email, integration)@@ -683,7 +683,7 @@ defmodule PlausibleWeb.AuthControllerTest do# Setup SSOintegration = Auth.SSO.initiate_saml_integration(team)- {:ok, sso_domain} = Auth.SSO.Domains.add(integration, "example.com")+ {:ok, sso_domain} = Auth.SSO.Domains.add(integration, "example.com", skip_checks?: true)_sso_domain = Auth.SSO.Domains.verify(sso_domain, skip_checks?: true)identity = new_identity(member.name, member.email, integration)diff --git a/test/plausible_web/controllers/sso_controller_sync_test.exs b/test/plausible_web/controllers/sso_controller_sync_test.exsindex e9e3306a15..fcada7e443 100644--- a/test/plausible_web/controllers/sso_controller_sync_test.exs+++ b/test/plausible_web/controllers/sso_controller_sync_test.exs@@ -78,7 +78,7 @@ defmodule PlausibleWeb.SSOControllerSyncTest dodomain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true){:ok, team: team, integration: integration, domain: domain, sso_domain: sso_domain}@@ -167,7 +167,7 @@ defmodule PlausibleWeb.SSOControllerSyncTest dodomain = "plausible.test"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true){:ok, root_node} = @assertion |> SimpleXml.parse()diff --git a/test/plausible_web/controllers/sso_controller_test.exs b/test/plausible_web/controllers/sso_controller_test.exsindex 487c4199fb..874dc7a894 100644--- a/test/plausible_web/controllers/sso_controller_test.exs+++ b/test/plausible_web/controllers/sso_controller_test.exs@@ -14,7 +14,7 @@ defmodule PlausibleWeb.SSOControllerTest dointegration = SSO.initiate_saml_integration(team)domain = "example-#{Enum.random(1..10_000)}.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true){:ok,diff --git a/test/plausible_web/live/change_domain_test.exs b/test/plausible_web/live/change_domain_test.exsindex 80c5a430c6..84f902d3b4 100644--- a/test/plausible_web/live/change_domain_test.exs+++ b/test/plausible_web/live/change_domain_test.exs@@ -4,7 +4,7 @@ defmodule PlausibleWeb.Live.ChangeDomainTest doimport Phoenix.LiveViewTeston_ee do- import Mox+ use Plausible.Test.Support.DNSendalias Plausible.Repo@@ -14,11 +14,7 @@ defmodule PlausibleWeb.Live.ChangeDomainTest doon_ee dosetup do- # mock all domains resolve- Plausible.DnsLookup.Mock- |> stub(:lookup, fn _domain, _type, _record, _opts, _timeout ->- [{192, 168, 1, 2}]- end)+ stub_dns()# Stub detection by default to prevent async task race conditions# Tests that need specific detection results can override this stubdiff --git a/test/plausible_web/live/customer_support/teams_test.exs b/test/plausible_web/live/customer_support/teams_test.exsindex 2ffe3743f7..214be799ff 100644--- a/test/plausible_web/live/customer_support/teams_test.exs+++ b/test/plausible_web/live/customer_support/teams_test.exs@@ -911,8 +911,8 @@ defmodule PlausibleWeb.Live.CustomerSupport.TeamsTest dointegration = SSO.initiate_saml_integration(team)- SSO.Domains.add(integration, "sso1.example.com")- SSO.Domains.add(integration, "sso2.example.com")+ SSO.Domains.add(integration, "sso1.example.com", skip_checks?: true)+ SSO.Domains.add(integration, "sso2.example.com", skip_checks?: true){:ok, lv, _html} = live(conn, open_team(team.id, tab: :sso))@@ -927,7 +927,7 @@ defmodule PlausibleWeb.Live.CustomerSupport.TeamsTest dotest "delete domain", %{conn: conn, user: user} doteam = team_of(user)integration = SSO.initiate_saml_integration(team)- {:ok, domain} = SSO.Domains.add(integration, "sso1.example.com")+ {:ok, domain} = SSO.Domains.add(integration, "sso1.example.com", skip_checks?: true){:ok, lv, _html} = live(conn, open_team(team.id, tab: :sso))lv |> element("button#remove-sso-domain-#{domain.identifier}") |> render_click()@@ -937,7 +937,7 @@ defmodule PlausibleWeb.Live.CustomerSupport.TeamsTest dotest "deprovisioning users", %{conn: conn, user: user} doteam = team_of(user) |> Plausible.Teams.complete_setup()integration = SSO.initiate_saml_integration(team)- {:ok, sso_domain} = SSO.Domains.add(integration, "example.com")+ {:ok, sso_domain} = SSO.Domains.add(integration, "example.com", skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)diff --git a/test/plausible_web/live/customer_support_test.exs b/test/plausible_web/live/customer_support_test.exsindex 1e17697ad5..ff65980336 100644--- a/test/plausible_web/live/customer_support_test.exs+++ b/test/plausible_web/live/customer_support_test.exs@@ -128,7 +128,7 @@ defmodule PlausibleWeb.Live.CustomerSupportTest doteam3 = new_user(team: [name: "Team Three"]) |> team_of()integration = SSO.initiate_saml_integration(team2)- SSO.Domains.add(integration, "some-sso.example.com")+ SSO.Domains.add(integration, "some-sso.example.com", skip_checks?: true)SSO.initiate_saml_integration(team3){:ok, lv, _html} = live(conn, @cs_index)@@ -146,7 +146,7 @@ defmodule PlausibleWeb.Live.CustomerSupportTest doteam3 = new_user(team: [name: "Team Three"]) |> team_of()integration = SSO.initiate_saml_integration(team2)- SSO.Domains.add(integration, "some-sso.example.com")+ SSO.Domains.add(integration, "some-sso.example.com", skip_checks?: true){:ok, lv, _html} = live(conn, @cs_index)diff --git a/test/plausible_web/live/installation_test.exs b/test/plausible_web/live/installation_test.exsindex a3ac3aae5f..84e379b321 100644--- a/test/plausible_web/live/installation_test.exs+++ b/test/plausible_web/live/installation_test.exs@@ -37,7 +37,7 @@ defmodule PlausibleWeb.Live.InstallationTest dodescribe "LiveView" do@tag :ee_onlytest "detects installation type when mounted", %{conn: conn, site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_wordpress(){lv, _} = get_lv(conn, site)@@ -51,7 +51,7 @@ defmodule PlausibleWeb.Live.InstallationTest doconn: conn,site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual(){lv, _} = get_lv(conn, site, "?type=wordpress")@@ -65,7 +65,7 @@ defmodule PlausibleWeb.Live.InstallationTest doconn: conn,site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_wordpress(){lv, _} = get_lv(conn, site, "?type=gtm")@@ -79,7 +79,7 @@ defmodule PlausibleWeb.Live.InstallationTest doconn: conn,site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_wordpress(){lv, _} = get_lv(conn, site, "?type=npm")@@ -93,7 +93,7 @@ defmodule PlausibleWeb.Live.InstallationTest doconn: conn,site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_wordpress(){lv, _} = get_lv(conn, site, "?type=manual")@@ -104,7 +104,7 @@ defmodule PlausibleWeb.Live.InstallationTest do@tag :ee_onlytest "allows switching between installation tabs (EE)", %{conn: conn, site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual(){lv, _html} = get_lv(conn, site, "?type=manual")@@ -151,7 +151,7 @@ defmodule PlausibleWeb.Live.InstallationTest dotest "manual installations has script snippet with expected ID", %{conn: conn, site: site} doon_ee do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual()end@@ -171,7 +171,7 @@ defmodule PlausibleWeb.Live.InstallationTest dotest "manual installation shows optional measurements", %{conn: conn, site: site} doon_ee do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual()end@@ -187,7 +187,7 @@ defmodule PlausibleWeb.Live.InstallationTest dotest "manual installation shows advanced options in disclosure", %{conn: conn, site: site} doon_ee do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual()end@@ -208,7 +208,7 @@ defmodule PlausibleWeb.Live.InstallationTest dosite: site} doon_ee do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual()end@@ -250,7 +250,7 @@ defmodule PlausibleWeb.Live.InstallationTest doconn: conn,site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual(){lv, _html} = get_lv(conn, site, "?type=#{unquote(type)}")@@ -305,7 +305,7 @@ defmodule PlausibleWeb.Live.InstallationTest dotest "404 goal gets created regardless of user options", %{conn: conn, site: site} doon_ee do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual()end@@ -336,7 +336,7 @@ defmodule PlausibleWeb.Live.InstallationTest dosite: site} doon_ee do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual()end@@ -367,7 +367,7 @@ defmodule PlausibleWeb.Live.InstallationTest do@tag :ee_onlytest "detected WordPress installation shows special message", %{conn: conn, site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_wordpress(){lv, _} = get_lv(conn, site)@@ -379,7 +379,7 @@ defmodule PlausibleWeb.Live.InstallationTest do@tag :ee_onlytest "if ratelimit for detection is exceeded, does not make detection request and falls back to recommending manual installation",%{conn: conn, site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()# exceed the rate limit for site detectionPlausible.RateLimit.check_rate(@@ -403,7 +403,7 @@ defmodule PlausibleWeb.Live.InstallationTest do@tag :ee_onlytest "detected GTM installation shows special message", %{conn: conn, site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_gtm(){lv, _} = get_lv(conn, site)@@ -416,7 +416,7 @@ defmodule PlausibleWeb.Live.InstallationTest do@tag :ee_onlytest "detected NPM installation shows npm tab", %{conn: conn, site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_result(%{"v1Detected" => false,@@ -437,7 +437,7 @@ defmodule PlausibleWeb.Live.InstallationTest doconn: conn,site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual_with_v1(){lv, _} = get_lv(conn, site, "?type=manual")@@ -461,7 +461,7 @@ defmodule PlausibleWeb.Live.InstallationTest dosite: site} doon_ee do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_wordpress_with_v1()end@@ -477,7 +477,7 @@ defmodule PlausibleWeb.Live.InstallationTest doconn: conn,site: site} do- stub_lookup_a_records(site.domain, [])+ expect_dns_unresolvable(site.domain)ExUnit.CaptureLog.capture_log(fn ->{lv, _} = get_lv(conn, site)@@ -495,7 +495,7 @@ defmodule PlausibleWeb.Live.InstallationTest doconn: conn,site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_error()ExUnit.CaptureLog.capture_log(fn ->@@ -523,7 +523,7 @@ defmodule PlausibleWeb.Live.InstallationTest doadd_guest(site, user: user, role: :viewer)on_ee do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual()end@@ -538,7 +538,7 @@ defmodule PlausibleWeb.Live.InstallationTest doadd_guest(site, user: user, role: :editor)on_ee do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual()end@@ -556,7 +556,7 @@ defmodule PlausibleWeb.Live.InstallationTest dosite: site} doon_ee do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual()end@@ -571,7 +571,7 @@ defmodule PlausibleWeb.Live.InstallationTest dosite: site} doon_ee do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_manual()end@@ -586,7 +586,7 @@ defmodule PlausibleWeb.Live.InstallationTest do@describetag :ee_onlytest "When GTM + Wordpress detected, GTM takes precedence", %{conn: conn, site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_result(%{"v1Detected" => false,@@ -616,7 +616,7 @@ defmodule PlausibleWeb.Live.InstallationTest doform_submissions: true})- stub_lookup_a_records(site.domain)+ stub_dns()stub_detection_wordpress(){lv, _} = get_lv(conn, site, "?flow=review")diff --git a/test/plausible_web/live/sso_management_test.exs b/test/plausible_web/live/sso_management_test.exsindex f803984dbe..aeb8f64b4c 100644--- a/test/plausible_web/live/sso_management_test.exs+++ b/test/plausible_web/live/sso_management_test.exs@@ -6,6 +6,7 @@ defmodule PlausibleWeb.Live.SSOMangementTest doon_ee douse Bamboo.Test, shared: true+ use Plausible.Test.Support.DNSimport Phoenix.LiveViewTest@@ -64,6 +65,14 @@ defmodule PlausibleWeb.Live.SSOMangementTest dodescribe "live" dosetup [:create_user, :log_in, :create_team, :add_plan, :setup_team]+ setup do+ # Some tests below add a domain through the real LiveView form (not+ # a direct SSO.Domains.add/3 call we could pass skip_checks?: true+ # to), which goes through actual DNS-backed domain validation.+ stub_dns()+ :ok+ end+test "init setup - basic walk through", %{conn: conn} do{lv, _html} = get_lv(conn)lv |> element("form#sso-init") |> render_submit()@@ -288,7 +297,7 @@ defmodule PlausibleWeb.Live.SSOMangementTest dodefp setup_integration(team, domain) dointegration = SSO.initiate_saml_integration(team)- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)SSO.Domains.verify(sso_domain, skip_checks?: true){:ok, integration} =diff --git a/test/plausible_web/live/verification_test.exs b/test/plausible_web/live/verification_test.exsindex 4580e932e9..1e29283064 100644--- a/test/plausible_web/live/verification_test.exs+++ b/test/plausible_web/live/verification_test.exs@@ -42,7 +42,7 @@ defmodule PlausibleWeb.Live.VerificationTest dodescribe "LiveView" do@tag :ee_onlytest "LiveView mounts", %{conn: conn, site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_verification_result(%{"completed" => false,@@ -65,7 +65,7 @@ defmodule PlausibleWeb.Live.VerificationTest do@tag :ee_onlytest "from custom URL input form to verification", %{conn: conn, site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_verification_result(%{"completed" => false,@@ -94,7 +94,7 @@ defmodule PlausibleWeb.Live.VerificationTest do@tag :ee_onlytest "eventually verifies installation", %{conn: conn, site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_verification_result(%{"completed" => true,@@ -132,7 +132,7 @@ defmodule PlausibleWeb.Live.VerificationTest dobuild(:pageview)])- stub_lookup_a_records(site.domain)+ stub_dns()stub_verification_result(%{"completed" => true,@@ -165,7 +165,7 @@ defmodule PlausibleWeb.Live.VerificationTest doendtest "will redirect when first pageview arrives", %{conn: conn, site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_verification_result(%{"completed" => true,@@ -242,7 +242,7 @@ defmodule PlausibleWeb.Live.VerificationTest doconn: conn,site: site} do- stub_lookup_a_records(site.domain)+ stub_dns()stub_verification_result(%{"completed" => true,diff --git a/test/plausible_web/user_auth_test.exs b/test/plausible_web/user_auth_test.exsindex 657c23edab..67c27883ac 100644--- a/test/plausible_web/user_auth_test.exs+++ b/test/plausible_web/user_auth_test.exs@@ -49,7 +49,7 @@ defmodule PlausibleWeb.UserAuthTest douser = user |> Ecto.Changeset.change(email: "jane@" <> domain) |> Repo.update!()add_member(team, user: user, role: :editor)- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)identity = new_identity(user.name, user.email, integration)@@ -78,7 +78,7 @@ defmodule PlausibleWeb.UserAuthTest dointegration = 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)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)identity = new_identity(user.name, user.email, integration)@@ -108,7 +108,7 @@ defmodule PlausibleWeb.UserAuthTest douser = user |> Ecto.Changeset.change(email: "jane@" <> domain) |> Repo.update!()add_member(team, user: user, role: :editor)- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)identity = new_identity(user.name, user.email, integration)@@ -165,7 +165,7 @@ defmodule PlausibleWeb.UserAuthTest doadd_member(team, role: :viewer)add_member(team, role: :viewer)- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)identity = new_identity("Jane Doe", "jane@" <> domain, integration)@@ -200,7 +200,7 @@ defmodule PlausibleWeb.UserAuthTest doanother_team = new_site().team |> Plausible.Teams.complete_setup()add_member(another_team, user: user, role: :viewer)- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)identity = new_identity(user.name, user.email, integration)@@ -229,7 +229,7 @@ defmodule PlausibleWeb.UserAuthTest do# personal team with site creatednew_site(owner: user)- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true)_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true)identity = new_identity(user.name, user.email, integration)diff --git a/test/support/dns.ex b/test/support/dns.exindex c3e3800f2d..2ff0dced1d 100644--- a/test/support/dns.ex+++ b/test/support/dns.ex@@ -1,9 +1,41 @@defmodule Plausible.Test.Support.DNS do@moduledoc false+defmacro __using__(_) doquote doimport Mox+ def stub_dns do+ stub(Plausible.DnsLookup.Mock, :lookup, fn _domain, :in, type, _opts, _timeout ->+ case type do+ :a -> [{93, 184, 216, 34}]+ :aaaa -> []+ end+ end)+ end++ # `%{"domain" => {a_records, aaaa_records}}`+ def stub_dns(mapping) when is_map(mapping) do+ stub(Plausible.DnsLookup.Mock, :lookup, fn domain, :in, type, _opts, _timeout ->+ {a_records, aaaa_records} = Map.fetch!(mapping, List.to_string(domain))+ if type == :a, do: a_records, else: aaaa_records+ end)+ end++ def expect_dns_lookup(domain, a_records, aaaa_records \\ []) do+ lookup_domain = to_charlist(domain)++ Plausible.DnsLookup.Mock+ |> expect(:lookup, fn ^lookup_domain, :in, :a, _opts, _timeout -> a_records end)+ |> expect(:lookup, fn ^lookup_domain, :in, :aaaa, _opts, _timeout -> aaaa_records end)+ end++ def expect_dns_unresolvable(domain), do: expect_dns_lookup(domain, [], [])++ def expect_no_dns_lookup do+ expect(Plausible.DnsLookup.Mock, :lookup, 0, fn _, _, _, _, _ -> [] end)+ end+def stub_lookup_a_records(domain, a_records \\ [{192, 168, 1, 1}]) dolookup_domain = to_charlist(domain)diff --git a/test/support/test_utils.ex b/test/support/test_utils.exindex b4a7266b9f..f48c6bfbf0 100644--- a/test/support/test_utils.ex+++ b/test/support/test_utils.ex@@ -117,7 +117,9 @@ defmodule Plausible.TestUtils doteam = Plausible.Teams.complete_setup(team)integration = SSO.initiate_saml_integration(team)- {:ok, sso_domain} = SSO.Domains.add(integration, ctx[:domain] || "example.com")+ {:ok, sso_domain} =+ SSO.Domains.add(integration, ctx[:domain] || "example.com", skip_checks?: true)+_sso_domain = SSO.Domains.verify(sso_domain, skip_checks?: true){:ok, team: team, sso_integration: integration, sso_domain: sso_domain}diff --git a/test/workers/sso_domain_verification_worker_test.exs b/test/workers/sso_domain_verification_worker_test.exsindex d75a013cf6..4191946749 100644--- a/test/workers/sso_domain_verification_worker_test.exs+++ b/test/workers/sso_domain_verification_worker_test.exs@@ -38,7 +38,7 @@ defmodule Plausible.Auth.SSO.Domain.Verification.WorkerTest doteam = new_site(owner: owner).teamintegration = SSO.initiate_saml_integration(team)domain = "#{Enum.random(1..10_000)}.example.com"- {:ok, sso_domain} = SSO.Domains.add(integration, domain)+ {:ok, sso_domain} = SSO.Domains.add(integration, domain, skip_checks?: true){:ok,owner: owner,