total rebase
[anni] / lib / pleroma / web / activity_pub / mrf / keyword_policy.ex
1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
4
5 defmodule Pleroma.Web.ActivityPub.MRF.KeywordPolicy do
6   require Pleroma.Constants
7
8   alias Pleroma.Web.ActivityPub.MRF.Utils
9
10   @moduledoc "Reject or Word-Replace messages with a keyword or regex"
11
12   @behaviour Pleroma.Web.ActivityPub.MRF.Policy
13
14   defp string_matches?(string, pattern) when is_binary(pattern) do
15     String.contains?(string, pattern)
16   end
17
18   defp string_matches?(string, %Regex{} = pattern) do
19     String.match?(string, pattern)
20   end
21
22   defp object_payload(%{} = object) do
23     [object["content"], object["summary"], object["name"]]
24     |> Enum.filter(& &1)
25     |> Enum.join("\n")
26   end
27
28   defp check_reject(%{"object" => %{} = object} = message) do
29     with {:ok, _new_object} <-
30            Pleroma.Object.Updater.do_with_history(object, fn object ->
31              payload = object_payload(object)
32
33              if Enum.any?(Pleroma.Config.get([:mrf_keyword, :reject]), fn pattern ->
34                   string_matches?(payload, pattern)
35                 end) do
36                {:reject, "[KeywordPolicy] Matches with rejected keyword"}
37              else
38                {:ok, message}
39              end
40            end) do
41       {:ok, message}
42     else
43       e -> e
44     end
45   end
46
47   defp check_ftl_removal(%{"type" => "Create", "to" => to, "object" => %{} = object} = message) do
48     check_keyword = fn object ->
49       payload = object_payload(object)
50
51       if Enum.any?(Pleroma.Config.get([:mrf_keyword, :federated_timeline_removal]), fn pattern ->
52            string_matches?(payload, pattern)
53          end) do
54         {:should_delist, nil}
55       else
56         {:ok, %{}}
57       end
58     end
59
60     should_delist? = fn object ->
61       with {:ok, _} <- Pleroma.Object.Updater.do_with_history(object, check_keyword) do
62         false
63       else
64         _ -> true
65       end
66     end
67
68     if Pleroma.Constants.as_public() in to and should_delist?.(object) do
69       to = List.delete(to, Pleroma.Constants.as_public())
70       cc = [Pleroma.Constants.as_public() | message["cc"] || []]
71
72       message =
73         message
74         |> Map.put("to", to)
75         |> Map.put("cc", cc)
76
77       {:ok, message}
78     else
79       {:ok, message}
80     end
81   end
82
83   defp check_ftl_removal(message) do
84     {:ok, message}
85   end
86
87   defp check_replace(%{"object" => %{} = object} = message) do
88     replace_kw = fn object ->
89       ["content", "name", "summary"]
90       |> Enum.filter(fn field -> Map.has_key?(object, field) && object[field] end)
91       |> Enum.reduce(object, fn field, object ->
92         data =
93           Enum.reduce(
94             Pleroma.Config.get([:mrf_keyword, :replace]),
95             object[field],
96             fn {pat, repl}, acc -> String.replace(acc, pat, repl) end
97           )
98
99         Map.put(object, field, data)
100       end)
101       |> (fn object -> {:ok, object} end).()
102     end
103
104     {:ok, object} = Pleroma.Object.Updater.do_with_history(object, replace_kw)
105
106     message = Map.put(message, "object", object)
107
108     {:ok, message}
109   end
110
111   @impl true
112   def filter(%{"type" => type, "object" => %{"content" => _content}} = message)
113       when type in ["Create", "Update"] do
114     with {:ok, message} <- check_reject(message),
115          {:ok, message} <- check_ftl_removal(message),
116          {:ok, message} <- check_replace(message) do
117       {:ok, message}
118     else
119       {:reject, nil} -> {:reject, "[KeywordPolicy] "}
120       {:reject, _} = e -> e
121       _e -> {:reject, "[KeywordPolicy] "}
122     end
123   end
124
125   @impl true
126   def filter(message), do: {:ok, message}
127
128   @impl true
129   def describe do
130     mrf_keyword =
131       Pleroma.Config.get(:mrf_keyword, [])
132       |> Enum.map(fn {key, value} ->
133         {key,
134          Enum.map(value, fn
135            {pattern, replacement} ->
136              %{
137                "pattern" => Utils.describe_regex_or_string(pattern),
138                "replacement" => replacement
139              }
140
141            pattern ->
142              Utils.describe_regex_or_string(pattern)
143          end)}
144       end)
145       |> Enum.into(%{})
146
147     {:ok, %{mrf_keyword: mrf_keyword}}
148   end
149
150   @impl true
151   def config_description do
152     %{
153       key: :mrf_keyword,
154       related_policy: "Pleroma.Web.ActivityPub.MRF.KeywordPolicy",
155       label: "MRF Keyword",
156       description:
157         "Reject or Word-Replace messages matching a keyword or [Regex](https://hexdocs.pm/elixir/Regex.html).",
158       children: [
159         %{
160           key: :reject,
161           type: {:list, :string},
162           description: """
163             A list of patterns which result in message being rejected.
164
165             Each pattern can be a string or [Regex](https://hexdocs.pm/elixir/Regex.html) in the format of `~r/PATTERN/`.
166           """,
167           suggestions: ["foo", ~r/foo/iu]
168         },
169         %{
170           key: :federated_timeline_removal,
171           type: {:list, :string},
172           description: """
173             A list of patterns which result in message being removed from federated timelines (a.k.a unlisted).
174
175             Each pattern can be a string or [Regex](https://hexdocs.pm/elixir/Regex.html) in the format of `~r/PATTERN/`.
176           """,
177           suggestions: ["foo", ~r/foo/iu]
178         },
179         %{
180           key: :replace,
181           type: {:list, :tuple},
182           key_placeholder: "instance",
183           value_placeholder: "reason",
184           description: """
185             **Pattern**: a string or [Regex](https://hexdocs.pm/elixir/Regex.html) in the format of `~r/PATTERN/`.
186
187             **Replacement**: a string. Leaving the field empty is permitted.
188           """
189         }
190       ]
191     }
192   end
193 end