# Pleroma: A lightweight social networking server # Copyright © 2017-2019 Pleroma Authors # SPDX-License-Identifier: AGPL-3.0-only defmodule Pleroma.Plugs.RateLimiter do @moduledoc """ ## Configuration A keyword list of rate limiters where a key is a limiter name and value is the limiter configuration. The basic configuration is a tuple where: * The first element: `scale` (Integer). The time scale in milliseconds. * The second element: `limit` (Integer). How many requests to limit in the time scale provided. It is also possible to have different limits for unauthenticated and authenticated users: the keyword value must be a list of two tuples where the first one is a config for unauthenticated users and the second one is for authenticated. To disable a limiter set its value to `nil`. ### Example config :pleroma, :rate_limit, one: {1000, 10}, two: [{10_000, 10}, {10_000, 50}], foobar: nil Here we have three limiters: * `one` which is not over 10req/1s * `two` which has two limits: 10req/10s for unauthenticated users and 50req/10s for authenticated users * `foobar` which is disabled ## Usage AllowedSyntax: plug(Pleroma.Plugs.RateLimiter, name: :limiter_name) plug(Pleroma.Plugs.RateLimiter, options) # :name is a required option Allowed options: * `name` required, always used to fetch the limit values from the config * `bucket_name` overrides name for counting purposes (e.g. to have a separate limit for a set of actions) * `params` appends values of specified request params (e.g. ["id"]) to bucket name Inside a controller: plug(Pleroma.Plugs.RateLimiter, [name: :one] when action == :one) plug(Pleroma.Plugs.RateLimiter, [name: :two] when action in [:two, :three]) plug( Pleroma.Plugs.RateLimiter, [name: :status_id_action, bucket_name: "status_id_action:fav_unfav", params: ["id"]] when action in ~w(fav_status unfav_status)a ) or inside a router pipeline: pipeline :api do ... plug(Pleroma.Plugs.RateLimiter, name: :one) ... end """ import Pleroma.Web.TranslationHelpers import Plug.Conn alias Pleroma.Plugs.RateLimiter.LimiterSupervisor alias Pleroma.User require Logger def init(opts) do limiter_name = Keyword.get(opts, :name) case Pleroma.Config.get([:rate_limit, limiter_name]) do nil -> nil config -> name_root = Keyword.get(opts, :bucket_name, limiter_name) %{ name: name_root, limits: config, opts: opts } end end # Do not limit if there is no limiter configuration def call(conn, nil), do: conn def call(conn, settings) do case disabled?() do true -> if Pleroma.Config.get(:env) == :prod, do: Logger.warn("Rate limiter is disabled for localhost/socket") conn false -> settings |> incorporate_conn_info(conn) |> check_rate() |> case do {:ok, _count} -> conn {:error, _count} -> render_throttled_error(conn) end end end def disabled? do localhost_or_socket = Pleroma.Config.get([Pleroma.Web.Endpoint, :http, :ip]) |> Tuple.to_list() |> Enum.join(".") |> String.match?(~r/^local|^127.0.0.1/) remote_ip_disabled = not Pleroma.Config.get([Pleroma.Plugs.RemoteIp, :enabled]) localhost_or_socket and remote_ip_disabled end def inspect_bucket(conn, name_root, settings) do settings = settings |> incorporate_conn_info(conn) bucket_name = make_bucket_name(%{settings | name: name_root}) key_name = make_key_name(settings) limit = get_limits(settings) case Cachex.get(bucket_name, key_name) do {:error, :no_cache} -> {:err, :not_found} {:ok, nil} -> {0, limit} {:ok, value} -> {value, limit - value} end end defp check_rate(settings) do bucket_name = make_bucket_name(settings) key_name = make_key_name(settings) limit = get_limits(settings) case Cachex.get_and_update(bucket_name, key_name, &increment_value(&1, limit)) do {:commit, value} -> {:ok, value} {:ignore, value} -> {:error, value} {:error, :no_cache} -> initialize_buckets(settings) check_rate(settings) end end defp increment_value(nil, _limit), do: {:commit, 1} defp increment_value(val, limit) when val >= limit, do: {:ignore, val} defp increment_value(val, _limit), do: {:commit, val + 1} defp incorporate_conn_info(settings, %{assigns: %{user: %User{id: user_id}}, params: params}) do Map.merge(settings, %{ mode: :user, conn_params: params, conn_info: "#{user_id}" }) end defp incorporate_conn_info(settings, %{params: params} = conn) do Map.merge(settings, %{ mode: :anon, conn_params: params, conn_info: "#{ip(conn)}" }) end defp ip(%{remote_ip: remote_ip}) do remote_ip |> Tuple.to_list() |> Enum.join(".") end defp render_throttled_error(conn) do conn |> render_error(:too_many_requests, "Throttled") |> halt() end defp make_key_name(settings) do "" |> attach_params(settings) |> attach_identity(settings) end defp get_scale(_, {scale, _}), do: scale defp get_scale(:anon, [{scale, _}, {_, _}]), do: scale defp get_scale(:user, [{_, _}, {scale, _}]), do: scale defp get_limits(%{limits: {_scale, limit}}), do: limit defp get_limits(%{mode: :user, limits: [_, {_, limit}]}), do: limit defp get_limits(%{limits: [{_, limit}, _]}), do: limit defp make_bucket_name(%{mode: :user, name: name_root}), do: user_bucket_name(name_root) defp make_bucket_name(%{mode: :anon, name: name_root}), do: anon_bucket_name(name_root) defp attach_params(input, %{conn_params: conn_params, opts: opts}) do param_string = opts |> Keyword.get(:params, []) |> Enum.sort() |> Enum.map(&Map.get(conn_params, &1, "")) |> Enum.join(":") "#{input}#{param_string}" end defp initialize_buckets(%{name: _name, limits: nil}), do: :ok defp initialize_buckets(%{name: name, limits: limits}) do LimiterSupervisor.add_limiter(anon_bucket_name(name), get_scale(:anon, limits)) LimiterSupervisor.add_limiter(user_bucket_name(name), get_scale(:user, limits)) end defp attach_identity(base, %{mode: :user, conn_info: conn_info}), do: "user:#{base}:#{conn_info}" defp attach_identity(base, %{mode: :anon, conn_info: conn_info}), do: "ip:#{base}:#{conn_info}" defp user_bucket_name(name_root), do: "user:#{name_root}" |> String.to_atom() defp anon_bucket_name(name_root), do: "anon:#{name_root}" |> String.to_atom() end