total rebase
[anni] / 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