Git of dcc - anni/blob - lib/pleroma/web/activity_pub/mrf.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2023 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.MRF do
   6   require Logger
   7
   8   @behaviour Pleroma.Web.ActivityPub.MRF.PipelineFiltering
   9
  10   @mrf_config_descriptions [
  11     %{
  12       group: :pleroma,
  13       key: :mrf,
  14       tab: :mrf,
  15       label: "MRF",
  16       type: :group,
  17       description: "General MRF settings",
  18       children: [
  19         %{
  20           key: :policies,
  21           type: [:module, {:list, :module}],
  22           description:
  23             "A list of MRF policies enabled. Module names are shortened (removed leading `Pleroma.Web.ActivityPub.MRF.` part), but on adding custom module you need to use full name.",
  24           suggestions: {:list_behaviour_implementations, Pleroma.Web.ActivityPub.MRF.Policy}
  25         },
  26         %{
  27           key: :transparency,
  28           label: "MRF transparency",
  29           type: :boolean,
  30           description:
  31             "Make the content of your Message Rewrite Facility settings public (via nodeinfo)"
  32         },
  33         %{
  34           key: :transparency_exclusions,
  35           label: "MRF transparency exclusions",
  36           type: {:list, :tuple},
  37           key_placeholder: "instance",
  38           value_placeholder: "reason",
  39           description:
  40             "Exclude specific instance names from MRF transparency. The use of the exclusions feature will be disclosed in nodeinfo as a boolean value. You can also provide a reason for excluding these instance names. The instances and reasons won't be publicly disclosed.",
  41           suggestions: [
  42             "exclusion.com"
  43           ]
  44         }
  45       ]
  46     }
  47   ]
  48
  49   @default_description %{
  50     label: "",
  51     description: ""
  52   }
  53
  54   @required_description_keys [:key, :related_policy]
  55
  56   def filter_one(policy, message) do
  57     Code.ensure_loaded(policy)
  58
  59     should_plug_history? =
  60       if function_exported?(policy, :history_awareness, 0) do
  61         policy.history_awareness()
  62       else
  63         :manual
  64       end
  65       |> Kernel.==(:auto)
  66
  67     if not should_plug_history? do
  68       policy.filter(message)
  69     else
  70       main_result = policy.filter(message)
  71
  72       with {_, {:ok, main_message}} <- {:main, main_result},
  73            {_,
  74             %{
  75               "formerRepresentations" => %{
  76                 "orderedItems" => [_ | _]
  77               }
  78             }} = {_, object} <- {:object, message["object"]},
  79            {_, {:ok, new_history}} <-
  80              {:history,
  81               Pleroma.Object.Updater.for_each_history_item(
  82                 object["formerRepresentations"],
  83                 object,
  84                 fn item ->
  85                   with {:ok, filtered} <- policy.filter(Map.put(message, "object", item)) do
  86                     {:ok, filtered["object"]}
  87                   else
  88                     e -> e
  89                   end
  90                 end
  91               )} do
  92         {:ok, put_in(main_message, ["object", "formerRepresentations"], new_history)}
  93       else
  94         {:main, _} -> main_result
  95         {:object, _} -> main_result
  96         {:history, e} -> e
  97       end
  98     end
  99   end
 100
 101   def filter(policies, %{} = message) do
 102     policies
 103     |> Enum.reduce({:ok, message}, fn
 104       policy, {:ok, message} -> filter_one(policy, message)
 105       _, error -> error
 106     end)
 107   end
 108
 109   def filter(%{} = object), do: get_policies() |> filter(object)
 110
 111   @impl true
 112   def pipeline_filter(%{} = message, meta) do
 113     object = meta[:object_data]
 114     ap_id = message["object"]
 115
 116     if object && ap_id do
 117       with {:ok, message} <- filter(Map.put(message, "object", object)) do
 118         meta = Keyword.put(meta, :object_data, message["object"])
 119         {:ok, Map.put(message, "object", ap_id), meta}
 120       else
 121         {err, message} -> {err, message, meta}
 122       end
 123     else
 124       {err, message} = filter(message)
 125
 126       {err, message, meta}
 127     end
 128   end
 129
 130   def get_policies do
 131     Pleroma.Config.get([:mrf, :policies], [])
 132     |> get_policies()
 133     |> Enum.concat([Pleroma.Web.ActivityPub.MRF.HashtagPolicy])
 134   end
 135
 136   defp get_policies(policy) when is_atom(policy), do: [policy]
 137   defp get_policies(policies) when is_list(policies), do: policies
 138   defp get_policies(_), do: []
 139
 140   @spec subdomains_regex([String.t()]) :: [Regex.t()]
 141   def subdomains_regex(domains) when is_list(domains) do
 142     for domain <- domains do
 143       try do
 144         target = String.replace(domain, "*.", "(.*\\.)*")
 145         ~r<^#{target}$>i
 146       rescue
 147         e ->
 148           Logger.error("MRF: Invalid subdomain Regex: #{domain}")
 149           reraise e, __STACKTRACE__
 150       end
 151     end
 152   end
 153
 154   @spec subdomain_match?([Regex.t()], String.t()) :: boolean()
 155   def subdomain_match?(domains, host) do
 156     Enum.any?(domains, fn domain -> Regex.match?(domain, host) end)
 157   end
 158
 159   @spec instance_list_from_tuples([{String.t(), String.t()}]) :: [String.t()]
 160   def instance_list_from_tuples(list) do
 161     Enum.map(list, fn {instance, _} -> instance end)
 162   end
 163
 164   def describe(policies) do
 165     {:ok, policy_configs} =
 166       policies
 167       |> Enum.reduce({:ok, %{}}, fn
 168         policy, {:ok, data} ->
 169           {:ok, policy_data} = policy.describe()
 170           {:ok, Map.merge(data, policy_data)}
 171
 172         _, error ->
 173           error
 174       end)
 175
 176     mrf_policies =
 177       get_policies()
 178       |> Enum.map(fn policy -> to_string(policy) |> String.split(".") |> List.last() end)
 179
 180     exclusions = Pleroma.Config.get([:mrf, :transparency_exclusions])
 181
 182     base =
 183       %{
 184         mrf_policies: mrf_policies,
 185         exclusions: length(exclusions) > 0
 186       }
 187       |> Map.merge(policy_configs)
 188
 189     {:ok, base}
 190   end
 191
 192   def describe, do: get_policies() |> describe()
 193
 194   def config_descriptions do
 195     Pleroma.Web.ActivityPub.MRF.Policy
 196     |> Pleroma.Docs.Generator.list_behaviour_implementations()
 197     |> config_descriptions()
 198   end
 199
 200   def config_descriptions(policies) do
 201     Enum.reduce(policies, @mrf_config_descriptions, fn policy, acc ->
 202       Code.ensure_loaded(policy)
 203
 204       if function_exported?(policy, :config_description, 0) do
 205         description =
 206           @default_description
 207           |> Map.merge(policy.config_description)
 208           |> Map.put(:group, :pleroma)
 209           |> Map.put(:tab, :mrf)
 210           |> Map.put(:type, :group)
 211
 212         if Enum.all?(@required_description_keys, &Map.has_key?(description, &1)) do
 213           [description | acc]
 214         else
 215           Logger.warning(
 216             "#{policy} config description doesn't have one or all required keys #{inspect(@required_description_keys)}"
 217           )
 218
 219           acc
 220         end
 221       else
 222         Logger.debug(
 223           "#{policy} is excluded from config descriptions, because does not implement `config_description/0` method."
 224         )
 225
 226         acc
 227       end
 228     end)
 229   end
 230 end