1 # Pleroma: A lightweight social networking server
2 # Copyright © 2017-2021 Pleroma Authors <https://pleroma.social/>
3 # SPDX-License-Identifier: AGPL-3.0-only
5 defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest do
8 alias Pleroma.Web.ActivityPub.MRF.SimplePolicy
9 alias Pleroma.Web.CommonAPI
12 clear_config(:mrf_simple,
15 federated_timeline_removal: [],
25 describe "when :media_removal" do
27 clear_config([:mrf_simple, :media_removal], [])
28 media_message = build_media_message()
29 local_message = build_local_message()
31 assert SimplePolicy.filter(media_message) == {:ok, media_message}
32 assert SimplePolicy.filter(local_message) == {:ok, local_message}
35 test "has a matching host" do
36 clear_config([:mrf_simple, :media_removal], [{"remote.instance", "Some reason"}])
37 media_message = build_media_message()
38 local_message = build_local_message()
40 assert SimplePolicy.filter(media_message) ==
43 |> Map.put("object", Map.delete(media_message["object"], "attachment"))}
45 assert SimplePolicy.filter(local_message) == {:ok, local_message}
48 test "match with wildcard domain" do
49 clear_config([:mrf_simple, :media_removal], [{"*.remote.instance", "Whatever reason"}])
50 media_message = build_media_message()
51 local_message = build_local_message()
53 assert SimplePolicy.filter(media_message) ==
56 |> Map.put("object", Map.delete(media_message["object"], "attachment"))}
58 assert SimplePolicy.filter(local_message) == {:ok, local_message}
62 describe "when :media_nsfw" do
64 clear_config([:mrf_simple, :media_nsfw], [])
65 media_message = build_media_message()
66 local_message = build_local_message()
68 assert SimplePolicy.filter(media_message) == {:ok, media_message}
69 assert SimplePolicy.filter(local_message) == {:ok, local_message}
72 test "has a matching host" do
73 clear_config([:mrf_simple, :media_nsfw], [{"remote.instance", "Whetever"}])
74 media_message = build_media_message()
75 local_message = build_local_message()
77 assert SimplePolicy.filter(media_message) ==
78 {:ok, put_in(media_message, ["object", "sensitive"], true)}
80 assert SimplePolicy.filter(local_message) == {:ok, local_message}
83 test "match with wildcard domain" do
84 clear_config([:mrf_simple, :media_nsfw], [{"*.remote.instance", "yeah yeah"}])
85 media_message = build_media_message()
86 local_message = build_local_message()
88 assert SimplePolicy.filter(media_message) ==
89 {:ok, put_in(media_message, ["object", "sensitive"], true)}
91 assert SimplePolicy.filter(local_message) == {:ok, local_message}
95 defp build_media_message do
97 "actor" => "https://remote.instance/users/bob",
100 "attachment" => [%{}],
107 describe "when :report_removal" do
109 clear_config([:mrf_simple, :report_removal], [])
110 report_message = build_report_message()
111 local_message = build_local_message()
113 assert SimplePolicy.filter(report_message) == {:ok, report_message}
114 assert SimplePolicy.filter(local_message) == {:ok, local_message}
117 test "has a matching host" do
118 clear_config([:mrf_simple, :report_removal], [{"remote.instance", "muh"}])
119 report_message = build_report_message()
120 local_message = build_local_message()
122 assert {:reject, _} = SimplePolicy.filter(report_message)
123 assert SimplePolicy.filter(local_message) == {:ok, local_message}
126 test "match with wildcard domain" do
127 clear_config([:mrf_simple, :report_removal], [{"*.remote.instance", "suya"}])
128 report_message = build_report_message()
129 local_message = build_local_message()
131 assert {:reject, _} = SimplePolicy.filter(report_message)
132 assert SimplePolicy.filter(local_message) == {:ok, local_message}
136 defp build_report_message do
138 "actor" => "https://remote.instance/users/bob",
143 describe "when :federated_timeline_removal" do
145 clear_config([:mrf_simple, :federated_timeline_removal], [])
146 {_, ftl_message} = build_ftl_actor_and_message()
147 local_message = build_local_message()
149 assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
150 assert SimplePolicy.filter(local_message) == {:ok, local_message}
153 test "has a matching host" do
154 {actor, ftl_message} = build_ftl_actor_and_message()
156 ftl_message_actor_host =
158 |> Map.fetch!("actor")
162 clear_config([:mrf_simple, :federated_timeline_removal], [{ftl_message_actor_host, "uwu"}])
163 local_message = build_local_message()
165 assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
166 assert actor.follower_address in ftl_message["to"]
167 refute actor.follower_address in ftl_message["cc"]
168 refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
169 assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
171 assert SimplePolicy.filter(local_message) == {:ok, local_message}
174 test "match with wildcard domain" do
175 {actor, ftl_message} = build_ftl_actor_and_message()
177 ftl_message_actor_host =
179 |> Map.fetch!("actor")
183 clear_config([:mrf_simple, :federated_timeline_removal], [
184 {"*." <> ftl_message_actor_host, "owo"}
187 local_message = build_local_message()
189 assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
190 assert actor.follower_address in ftl_message["to"]
191 refute actor.follower_address in ftl_message["cc"]
192 refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
193 assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
195 assert SimplePolicy.filter(local_message) == {:ok, local_message}
198 test "has a matching host but only as:Public in to" do
199 {_actor, ftl_message} = build_ftl_actor_and_message()
201 ftl_message_actor_host =
203 |> Map.fetch!("actor")
207 ftl_message = Map.put(ftl_message, "cc", [])
209 clear_config([:mrf_simple, :federated_timeline_removal], [
210 {ftl_message_actor_host, "spiderwaifu goes 88w88"}
213 assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
214 refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
215 assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
219 describe "describe/1" do
220 test "returns a description of the policy" do
221 clear_config([:mrf_simple, :reject], [
222 {"remote.instance", "did not give my catboy a burg"}
225 assert {:ok, %{mrf_simple: %{reject: ["remote.instance"]}}} = SimplePolicy.describe()
228 test "excludes domains listed in :transparency_exclusions" do
229 clear_config([:mrf, :transparency_exclusions], [{"remote.instance", ":("}])
231 clear_config([:mrf_simple, :reject], [
232 {"remote.instance", "did not give my catboy a burg"}
235 {:ok, description} = SimplePolicy.describe()
236 assert %{mrf_simple: %{reject: []}} = description
237 assert description[:mrf_simple_info][:reject] == nil
240 test "obfuscates domains listed in :transparency_obfuscate_domains" do
241 clear_config([:mrf, :transparency_obfuscate_domains], ["remote.instance", "a.b"])
243 clear_config([:mrf_simple, :reject], [
244 {"remote.instance", "did not give my catboy a burg"},
245 {"a.b", "spam-poked me on facebook in 2006"}
250 mrf_simple: %{reject: ["rem***.*****nce", "a.b"]},
251 mrf_simple_info: %{reject: %{"rem***.*****nce" => %{}}}
252 }} = SimplePolicy.describe()
256 defp build_ftl_actor_and_message do
257 actor = insert(:user)
261 "actor" => actor.ap_id,
262 "to" => ["https://www.w3.org/ns/activitystreams#Public", "http://foo.bar/baz"],
263 "cc" => [actor.follower_address, "http://foo.bar/qux"]
267 describe "when :reject" do
269 clear_config([:mrf_simple, :reject], [])
271 remote_message = build_remote_message()
273 assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
276 test "activity has a matching host" do
277 clear_config([:mrf_simple, :reject], [{"remote.instance", ""}])
279 remote_message = build_remote_message()
281 assert {:reject, _} = SimplePolicy.filter(remote_message)
284 test "activity matches with wildcard domain" do
285 clear_config([:mrf_simple, :reject], [{"*.remote.instance", ""}])
287 remote_message = build_remote_message()
289 assert {:reject, _} = SimplePolicy.filter(remote_message)
292 test "actor has a matching host" do
293 clear_config([:mrf_simple, :reject], [{"remote.instance", ""}])
295 remote_user = build_remote_user()
297 assert {:reject, _} = SimplePolicy.filter(remote_user)
300 test "reject Announce when object would be rejected" do
301 clear_config([:mrf_simple, :reject], [{"blocked.tld", ""}])
304 "type" => "Announce",
305 "actor" => "https://okay.tld/users/alice",
306 "object" => %{"type" => "Note", "actor" => "https://blocked.tld/users/bob"}
309 assert {:reject, _} = SimplePolicy.filter(announce)
312 test "reject by URI object" do
313 clear_config([:mrf_simple, :reject], [{"blocked.tld", ""}])
316 "type" => "Announce",
317 "actor" => "https://okay.tld/users/alice",
318 "object" => "https://blocked.tld/activities/1"
321 assert {:reject, _} = SimplePolicy.filter(announce)
325 describe "when :followers_only" do
327 clear_config([:mrf_simple, :followers_only], [])
328 {_, ftl_message} = build_ftl_actor_and_message()
329 local_message = build_local_message()
331 assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
332 assert SimplePolicy.filter(local_message) == {:ok, local_message}
335 test "has a matching host" do
336 actor = insert(:user)
337 following_user = insert(:user)
338 non_following_user = insert(:user)
340 {:ok, _, _, _} = CommonAPI.follow(following_user, actor)
343 "actor" => actor.ap_id,
345 "https://www.w3.org/ns/activitystreams#Public",
346 following_user.ap_id,
347 non_following_user.ap_id
349 "cc" => [actor.follower_address, "http://foo.bar/qux"]
353 "actor" => actor.ap_id,
355 following_user.ap_id,
356 non_following_user.ap_id
363 |> Map.fetch!("actor")
367 clear_config([:mrf_simple, :followers_only], [{actor_domain, ""}])
369 assert {:ok, new_activity} = SimplePolicy.filter(activity)
370 assert actor.follower_address in new_activity["cc"]
371 assert following_user.ap_id in new_activity["to"]
372 refute "https://www.w3.org/ns/activitystreams#Public" in new_activity["to"]
373 refute "https://www.w3.org/ns/activitystreams#Public" in new_activity["cc"]
374 refute non_following_user.ap_id in new_activity["to"]
375 refute non_following_user.ap_id in new_activity["cc"]
377 assert {:ok, new_dm_activity} = SimplePolicy.filter(dm_activity)
378 assert new_dm_activity["to"] == [following_user.ap_id]
379 assert new_dm_activity["cc"] == []
383 describe "when :accept" do
385 clear_config([:mrf_simple, :accept], [])
387 local_message = build_local_message()
388 remote_message = build_remote_message()
390 assert SimplePolicy.filter(local_message) == {:ok, local_message}
391 assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
394 test "is not empty but activity doesn't have a matching host" do
395 clear_config([:mrf_simple, :accept], [{"non.matching.remote", ""}])
397 local_message = build_local_message()
398 remote_message = build_remote_message()
400 assert SimplePolicy.filter(local_message) == {:ok, local_message}
401 assert {:reject, _} = SimplePolicy.filter(remote_message)
404 test "activity has a matching host" do
405 clear_config([:mrf_simple, :accept], [{"remote.instance", ""}])
407 local_message = build_local_message()
408 remote_message = build_remote_message()
410 assert SimplePolicy.filter(local_message) == {:ok, local_message}
411 assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
414 test "activity matches with wildcard domain" do
415 clear_config([:mrf_simple, :accept], [{"*.remote.instance", ""}])
417 local_message = build_local_message()
418 remote_message = build_remote_message()
420 assert SimplePolicy.filter(local_message) == {:ok, local_message}
421 assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
424 test "actor has a matching host" do
425 clear_config([:mrf_simple, :accept], [{"remote.instance", ""}])
427 remote_user = build_remote_user()
429 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
433 describe "when :avatar_removal" do
435 clear_config([:mrf_simple, :avatar_removal], [])
437 remote_user = build_remote_user()
439 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
442 test "is not empty but it doesn't have a matching host" do
443 clear_config([:mrf_simple, :avatar_removal], [{"non.matching.remote", ""}])
445 remote_user = build_remote_user()
447 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
450 test "has a matching host" do
451 clear_config([:mrf_simple, :avatar_removal], [{"remote.instance", ""}])
453 remote_user = build_remote_user()
454 {:ok, filtered} = SimplePolicy.filter(remote_user)
456 refute filtered["icon"]
459 test "match with wildcard domain" do
460 clear_config([:mrf_simple, :avatar_removal], [{"*.remote.instance", ""}])
462 remote_user = build_remote_user()
463 {:ok, filtered} = SimplePolicy.filter(remote_user)
465 refute filtered["icon"]
469 describe "when :banner_removal" do
471 clear_config([:mrf_simple, :banner_removal], [])
473 remote_user = build_remote_user()
475 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
478 test "is not empty but it doesn't have a matching host" do
479 clear_config([:mrf_simple, :banner_removal], [{"non.matching.remote", ""}])
481 remote_user = build_remote_user()
483 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
486 test "has a matching host" do
487 clear_config([:mrf_simple, :banner_removal], [{"remote.instance", ""}])
489 remote_user = build_remote_user()
490 {:ok, filtered} = SimplePolicy.filter(remote_user)
492 refute filtered["image"]
495 test "match with wildcard domain" do
496 clear_config([:mrf_simple, :banner_removal], [{"*.remote.instance", ""}])
498 remote_user = build_remote_user()
499 {:ok, filtered} = SimplePolicy.filter(remote_user)
501 refute filtered["image"]
505 describe "when :reject_deletes is empty" do
506 setup do: clear_config([:mrf_simple, :reject_deletes], [])
508 test "it accepts deletions even from rejected servers" do
509 clear_config([:mrf_simple, :reject], [{"remote.instance", ""}])
511 deletion_message = build_remote_deletion_message()
513 assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
516 test "it accepts deletions even from non-whitelisted servers" do
517 clear_config([:mrf_simple, :accept], [{"non.matching.remote", ""}])
519 deletion_message = build_remote_deletion_message()
521 assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
525 describe "when :reject_deletes is not empty but it doesn't have a matching host" do
526 setup do: clear_config([:mrf_simple, :reject_deletes], [{"non.matching.remote", ""}])
528 test "it accepts deletions even from rejected servers" do
529 clear_config([:mrf_simple, :reject], [{"remote.instance", ""}])
531 deletion_message = build_remote_deletion_message()
533 assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
536 test "it accepts deletions even from non-whitelisted servers" do
537 clear_config([:mrf_simple, :accept], [{"non.matching.remote", ""}])
539 deletion_message = build_remote_deletion_message()
541 assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
545 describe "when :reject_deletes has a matching host" do
546 setup do: clear_config([:mrf_simple, :reject_deletes], [{"remote.instance", ""}])
548 test "it rejects the deletion" do
549 deletion_message = build_remote_deletion_message()
551 assert {:reject, _} = SimplePolicy.filter(deletion_message)
555 describe "when :reject_deletes match with wildcard domain" do
556 setup do: clear_config([:mrf_simple, :reject_deletes], [{"*.remote.instance", ""}])
558 test "it rejects the deletion" do
559 deletion_message = build_remote_deletion_message()
561 assert {:reject, _} = SimplePolicy.filter(deletion_message)
565 defp build_local_message do
567 "actor" => "#{Pleroma.Web.Endpoint.url()}/users/alice",
573 defp build_remote_message do
574 %{"actor" => "https://remote.instance/users/bob"}
577 defp build_remote_user do
579 "id" => "https://remote.instance/users/bob",
581 "url" => "http://example.com/image.jpg",
585 "url" => "http://example.com/image.jpg",
592 defp build_remote_deletion_message do
595 "actor" => "https://remote.instance/users/bob"