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 media_update_message = build_media_update_message()
30 local_message = build_local_message()
32 assert SimplePolicy.filter(media_message) == {:ok, media_message}
33 assert SimplePolicy.filter(media_update_message) == {:ok, media_update_message}
34 assert SimplePolicy.filter(local_message) == {:ok, local_message}
37 test "has a matching host" do
38 clear_config([:mrf_simple, :media_removal], [{"remote.instance", "Some reason"}])
39 media_message = build_media_message()
40 media_update_message = build_media_update_message()
41 local_message = build_local_message()
43 assert SimplePolicy.filter(media_message) ==
46 |> Map.put("object", Map.delete(media_message["object"], "attachment"))}
48 assert SimplePolicy.filter(media_update_message) ==
51 |> Map.put("object", Map.delete(media_update_message["object"], "attachment"))}
53 assert SimplePolicy.filter(local_message) == {:ok, local_message}
56 test "match with wildcard domain" do
57 clear_config([:mrf_simple, :media_removal], [{"*.remote.instance", "Whatever reason"}])
58 media_message = build_media_message()
59 media_update_message = build_media_update_message()
60 local_message = build_local_message()
62 assert SimplePolicy.filter(media_message) ==
65 |> Map.put("object", Map.delete(media_message["object"], "attachment"))}
67 assert SimplePolicy.filter(media_update_message) ==
70 |> Map.put("object", Map.delete(media_update_message["object"], "attachment"))}
72 assert SimplePolicy.filter(local_message) == {:ok, local_message}
76 describe "when :media_nsfw" do
78 clear_config([:mrf_simple, :media_nsfw], [])
79 media_message = build_media_message()
80 media_update_message = build_media_update_message()
81 local_message = build_local_message()
83 assert SimplePolicy.filter(media_message) == {:ok, media_message}
84 assert SimplePolicy.filter(media_update_message) == {:ok, media_update_message}
85 assert SimplePolicy.filter(local_message) == {:ok, local_message}
88 test "has a matching host" do
89 clear_config([:mrf_simple, :media_nsfw], [{"remote.instance", "Whetever"}])
90 media_message = build_media_message()
91 media_update_message = build_media_update_message()
92 local_message = build_local_message()
94 assert SimplePolicy.filter(media_message) ==
95 {:ok, put_in(media_message, ["object", "sensitive"], true)}
97 assert SimplePolicy.filter(media_update_message) ==
98 {:ok, put_in(media_update_message, ["object", "sensitive"], true)}
100 assert SimplePolicy.filter(local_message) == {:ok, local_message}
103 test "match with wildcard domain" do
104 clear_config([:mrf_simple, :media_nsfw], [{"*.remote.instance", "yeah yeah"}])
105 media_message = build_media_message()
106 media_update_message = build_media_update_message()
107 local_message = build_local_message()
109 assert SimplePolicy.filter(media_message) ==
110 {:ok, put_in(media_message, ["object", "sensitive"], true)}
112 assert SimplePolicy.filter(media_update_message) ==
113 {:ok, put_in(media_update_message, ["object", "sensitive"], true)}
115 assert SimplePolicy.filter(local_message) == {:ok, local_message}
119 defp build_media_message do
121 "actor" => "https://remote.instance/users/bob",
124 "attachment" => [%{}],
131 defp build_media_update_message do
133 "actor" => "https://remote.instance/users/bob",
136 "attachment" => [%{}],
143 describe "when :report_removal" do
145 clear_config([:mrf_simple, :report_removal], [])
146 report_message = build_report_message()
147 local_message = build_local_message()
149 assert SimplePolicy.filter(report_message) == {:ok, report_message}
150 assert SimplePolicy.filter(local_message) == {:ok, local_message}
153 test "has a matching host" do
154 clear_config([:mrf_simple, :report_removal], [{"remote.instance", "muh"}])
155 report_message = build_report_message()
156 local_message = build_local_message()
158 assert {:reject, _} = SimplePolicy.filter(report_message)
159 assert SimplePolicy.filter(local_message) == {:ok, local_message}
162 test "match with wildcard domain" do
163 clear_config([:mrf_simple, :report_removal], [{"*.remote.instance", "suya"}])
164 report_message = build_report_message()
165 local_message = build_local_message()
167 assert {:reject, _} = SimplePolicy.filter(report_message)
168 assert SimplePolicy.filter(local_message) == {:ok, local_message}
172 defp build_report_message do
174 "actor" => "https://remote.instance/users/bob",
179 describe "when :federated_timeline_removal" do
181 clear_config([:mrf_simple, :federated_timeline_removal], [])
182 {_, ftl_message} = build_ftl_actor_and_message()
183 local_message = build_local_message()
185 assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
186 assert SimplePolicy.filter(local_message) == {:ok, local_message}
189 test "has a matching host" do
190 {actor, ftl_message} = build_ftl_actor_and_message()
192 ftl_message_actor_host =
194 |> Map.fetch!("actor")
198 clear_config([:mrf_simple, :federated_timeline_removal], [{ftl_message_actor_host, "uwu"}])
199 local_message = build_local_message()
201 assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
202 assert actor.follower_address in ftl_message["to"]
203 refute actor.follower_address in ftl_message["cc"]
204 refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
205 assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
207 assert SimplePolicy.filter(local_message) == {:ok, local_message}
210 test "match with wildcard domain" do
211 {actor, ftl_message} = build_ftl_actor_and_message()
213 ftl_message_actor_host =
215 |> Map.fetch!("actor")
219 clear_config([:mrf_simple, :federated_timeline_removal], [
220 {"*." <> ftl_message_actor_host, "owo"}
223 local_message = build_local_message()
225 assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
226 assert actor.follower_address in ftl_message["to"]
227 refute actor.follower_address in ftl_message["cc"]
228 refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
229 assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
231 assert SimplePolicy.filter(local_message) == {:ok, local_message}
234 test "has a matching host but only as:Public in to" do
235 {_actor, ftl_message} = build_ftl_actor_and_message()
237 ftl_message_actor_host =
239 |> Map.fetch!("actor")
243 ftl_message = Map.put(ftl_message, "cc", [])
245 clear_config([:mrf_simple, :federated_timeline_removal], [
246 {ftl_message_actor_host, "spiderwaifu goes 88w88"}
249 assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
250 refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
251 assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
255 describe "describe/1" do
256 test "returns a description of the policy" do
257 clear_config([:mrf_simple, :reject], [
258 {"remote.instance", "did not give my catboy a burg"}
261 assert {:ok, %{mrf_simple: %{reject: ["remote.instance"]}}} = SimplePolicy.describe()
264 test "excludes domains listed in :transparency_exclusions" do
265 clear_config([:mrf, :transparency_exclusions], [{"remote.instance", ":("}])
267 clear_config([:mrf_simple, :reject], [
268 {"remote.instance", "did not give my catboy a burg"}
271 {:ok, description} = SimplePolicy.describe()
272 assert %{mrf_simple: %{reject: []}} = description
273 assert description[:mrf_simple_info][:reject] == nil
276 test "obfuscates domains listed in :transparency_obfuscate_domains" do
277 clear_config([:mrf, :transparency_obfuscate_domains], ["remote.instance", "a.b"])
279 clear_config([:mrf_simple, :reject], [
280 {"remote.instance", "did not give my catboy a burg"},
281 {"a.b", "spam-poked me on facebook in 2006"}
286 mrf_simple: %{reject: ["rem***.*****nce", "a.b"]},
287 mrf_simple_info: %{reject: %{"rem***.*****nce" => %{}}}
288 }} = SimplePolicy.describe()
292 defp build_ftl_actor_and_message do
293 actor = insert(:user)
297 "actor" => actor.ap_id,
298 "to" => ["https://www.w3.org/ns/activitystreams#Public", "http://foo.bar/baz"],
299 "cc" => [actor.follower_address, "http://foo.bar/qux"]
303 describe "when :reject" do
305 clear_config([:mrf_simple, :reject], [])
307 remote_message = build_remote_message()
309 assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
312 test "activity has a matching host" do
313 clear_config([:mrf_simple, :reject], [{"remote.instance", ""}])
315 remote_message = build_remote_message()
317 assert {:reject, _} = SimplePolicy.filter(remote_message)
320 test "activity matches with wildcard domain" do
321 clear_config([:mrf_simple, :reject], [{"*.remote.instance", ""}])
323 remote_message = build_remote_message()
325 assert {:reject, _} = SimplePolicy.filter(remote_message)
328 test "actor has a matching host" do
329 clear_config([:mrf_simple, :reject], [{"remote.instance", ""}])
331 remote_user = build_remote_user()
333 assert {:reject, _} = SimplePolicy.filter(remote_user)
336 test "reject Announce when object would be rejected" do
337 clear_config([:mrf_simple, :reject], [{"blocked.tld", ""}])
340 "type" => "Announce",
341 "actor" => "https://okay.tld/users/alice",
342 "object" => %{"type" => "Note", "actor" => "https://blocked.tld/users/bob"}
345 assert {:reject, _} = SimplePolicy.filter(announce)
348 test "reject by URI object" do
349 clear_config([:mrf_simple, :reject], [{"blocked.tld", ""}])
352 "type" => "Announce",
353 "actor" => "https://okay.tld/users/alice",
354 "object" => "https://blocked.tld/activities/1"
357 assert {:reject, _} = SimplePolicy.filter(announce)
360 test "accept by matching context URI if :handle_threads is disabled" do
361 clear_config([:mrf_simple, :reject], [{"blocked.tld", ""}])
362 clear_config([:mrf_simple, :handle_threads], false)
365 build_remote_message()
366 |> Map.put("context", "https://blocked.tld/contexts/abc")
368 assert {:ok, _} = SimplePolicy.filter(remote_message)
371 test "accept by matching conversation field if :handle_threads is disabled" do
372 clear_config([:mrf_simple, :reject], [{"blocked.tld", ""}])
373 clear_config([:mrf_simple, :handle_threads], false)
376 build_remote_message()
379 "tag:blocked.tld,1997-06-25:objectId=12345:objectType=Conversation"
382 assert {:ok, _} = SimplePolicy.filter(remote_message)
385 test "accept by matching reply ID if :handle_threads is disabled" do
386 clear_config([:mrf_simple, :reject], [{"blocked.tld", ""}])
387 clear_config([:mrf_simple, :handle_threads], false)
390 build_remote_message()
391 |> Map.put("type", "Create")
392 |> Map.put("object", %{
394 "inReplyTo" => "https://blocked.tld/objects/1"
397 assert {:ok, _} = SimplePolicy.filter(remote_message)
400 test "reject by matching context URI if :handle_threads is enabled" do
401 clear_config([:mrf_simple, :reject], [{"blocked.tld", ""}])
402 clear_config([:mrf_simple, :handle_threads], true)
405 build_remote_message()
406 |> Map.put("context", "https://blocked.tld/contexts/abc")
408 assert {:reject, _} = SimplePolicy.filter(remote_message)
411 test "reject by matching conversation field if :handle_threads is enabled" do
412 clear_config([:mrf_simple, :reject], [{"blocked.tld", ""}])
413 clear_config([:mrf_simple, :handle_threads], true)
416 build_remote_message()
419 "tag:blocked.tld,1997-06-25:objectId=12345:objectType=Conversation"
422 assert {:reject, _} = SimplePolicy.filter(remote_message)
425 test "reject by matching reply ID if :handle_threads is enabled" do
426 clear_config([:mrf_simple, :reject], [{"blocked.tld", ""}])
427 clear_config([:mrf_simple, :handle_threads], true)
430 build_remote_message()
431 |> Map.put("type", "Create")
432 |> Map.put("object", %{
434 "inReplyTo" => "https://blocked.tld/objects/1"
437 assert {:reject, _} = SimplePolicy.filter(remote_message)
441 describe "when :followers_only" do
443 clear_config([:mrf_simple, :followers_only], [])
444 {_, ftl_message} = build_ftl_actor_and_message()
445 local_message = build_local_message()
447 assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
448 assert SimplePolicy.filter(local_message) == {:ok, local_message}
451 test "has a matching host" do
452 actor = insert(:user)
453 following_user = insert(:user)
454 non_following_user = insert(:user)
456 {:ok, _, _, _} = CommonAPI.follow(following_user, actor)
459 "actor" => actor.ap_id,
461 "https://www.w3.org/ns/activitystreams#Public",
462 following_user.ap_id,
463 non_following_user.ap_id
465 "cc" => [actor.follower_address, "http://foo.bar/qux"]
469 "actor" => actor.ap_id,
471 following_user.ap_id,
472 non_following_user.ap_id
479 |> Map.fetch!("actor")
483 clear_config([:mrf_simple, :followers_only], [{actor_domain, ""}])
485 assert {:ok, new_activity} = SimplePolicy.filter(activity)
486 assert actor.follower_address in new_activity["cc"]
487 assert following_user.ap_id in new_activity["to"]
488 refute "https://www.w3.org/ns/activitystreams#Public" in new_activity["to"]
489 refute "https://www.w3.org/ns/activitystreams#Public" in new_activity["cc"]
490 refute non_following_user.ap_id in new_activity["to"]
491 refute non_following_user.ap_id in new_activity["cc"]
493 assert {:ok, new_dm_activity} = SimplePolicy.filter(dm_activity)
494 assert new_dm_activity["to"] == [following_user.ap_id]
495 assert new_dm_activity["cc"] == []
499 describe "when :accept" do
501 clear_config([:mrf_simple, :accept], [])
503 local_message = build_local_message()
504 remote_message = build_remote_message()
506 assert SimplePolicy.filter(local_message) == {:ok, local_message}
507 assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
510 test "is not empty but activity doesn't have a matching host" do
511 clear_config([:mrf_simple, :accept], [{"non.matching.remote", ""}])
513 local_message = build_local_message()
514 remote_message = build_remote_message()
516 assert SimplePolicy.filter(local_message) == {:ok, local_message}
517 assert {:reject, _} = SimplePolicy.filter(remote_message)
520 test "activity has a matching host" do
521 clear_config([:mrf_simple, :accept], [{"remote.instance", ""}])
523 local_message = build_local_message()
524 remote_message = build_remote_message()
526 assert SimplePolicy.filter(local_message) == {:ok, local_message}
527 assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
530 test "activity matches with wildcard domain" do
531 clear_config([:mrf_simple, :accept], [{"*.remote.instance", ""}])
533 local_message = build_local_message()
534 remote_message = build_remote_message()
536 assert SimplePolicy.filter(local_message) == {:ok, local_message}
537 assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
540 test "actor has a matching host" do
541 clear_config([:mrf_simple, :accept], [{"remote.instance", ""}])
543 remote_user = build_remote_user()
545 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
549 describe "when :avatar_removal" do
551 clear_config([:mrf_simple, :avatar_removal], [])
553 remote_user = build_remote_user()
555 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
558 test "is not empty but it doesn't have a matching host" do
559 clear_config([:mrf_simple, :avatar_removal], [{"non.matching.remote", ""}])
561 remote_user = build_remote_user()
563 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
566 test "has a matching host" do
567 clear_config([:mrf_simple, :avatar_removal], [{"remote.instance", ""}])
569 remote_user = build_remote_user()
570 {:ok, filtered} = SimplePolicy.filter(remote_user)
572 refute filtered["icon"]
575 test "match with wildcard domain" do
576 clear_config([:mrf_simple, :avatar_removal], [{"*.remote.instance", ""}])
578 remote_user = build_remote_user()
579 {:ok, filtered} = SimplePolicy.filter(remote_user)
581 refute filtered["icon"]
585 describe "when :banner_removal" do
587 clear_config([:mrf_simple, :banner_removal], [])
589 remote_user = build_remote_user()
591 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
594 test "is not empty but it doesn't have a matching host" do
595 clear_config([:mrf_simple, :banner_removal], [{"non.matching.remote", ""}])
597 remote_user = build_remote_user()
599 assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
602 test "has a matching host" do
603 clear_config([:mrf_simple, :banner_removal], [{"remote.instance", ""}])
605 remote_user = build_remote_user()
606 {:ok, filtered} = SimplePolicy.filter(remote_user)
608 refute filtered["image"]
611 test "match with wildcard domain" do
612 clear_config([:mrf_simple, :banner_removal], [{"*.remote.instance", ""}])
614 remote_user = build_remote_user()
615 {:ok, filtered} = SimplePolicy.filter(remote_user)
617 refute filtered["image"]
621 describe "when :reject_deletes is empty" do
622 setup do: clear_config([:mrf_simple, :reject_deletes], [])
624 test "it accepts deletions even from rejected servers" do
625 clear_config([:mrf_simple, :reject], [{"remote.instance", ""}])
627 deletion_message = build_remote_deletion_message()
629 assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
632 test "it accepts deletions even from non-whitelisted servers" do
633 clear_config([:mrf_simple, :accept], [{"non.matching.remote", ""}])
635 deletion_message = build_remote_deletion_message()
637 assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
641 describe "when :reject_deletes is not empty but it doesn't have a matching host" do
642 setup do: clear_config([:mrf_simple, :reject_deletes], [{"non.matching.remote", ""}])
644 test "it accepts deletions even from rejected servers" do
645 clear_config([:mrf_simple, :reject], [{"remote.instance", ""}])
647 deletion_message = build_remote_deletion_message()
649 assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
652 test "it accepts deletions even from non-whitelisted servers" do
653 clear_config([:mrf_simple, :accept], [{"non.matching.remote", ""}])
655 deletion_message = build_remote_deletion_message()
657 assert SimplePolicy.filter(deletion_message) == {:ok, deletion_message}
661 describe "when :reject_deletes has a matching host" do
662 setup do: clear_config([:mrf_simple, :reject_deletes], [{"remote.instance", ""}])
664 test "it rejects the deletion" do
665 deletion_message = build_remote_deletion_message()
667 assert {:reject, _} = SimplePolicy.filter(deletion_message)
671 describe "when :reject_deletes match with wildcard domain" do
672 setup do: clear_config([:mrf_simple, :reject_deletes], [{"*.remote.instance", ""}])
674 test "it rejects the deletion" do
675 deletion_message = build_remote_deletion_message()
677 assert {:reject, _} = SimplePolicy.filter(deletion_message)
681 defp build_local_message do
683 "actor" => "#{Pleroma.Web.Endpoint.url()}/users/alice",
689 defp build_remote_message do
690 %{"actor" => "https://remote.instance/users/bob"}
693 defp build_remote_user do
695 "id" => "https://remote.instance/users/bob",
697 "url" => "http://example.com/image.jpg",
701 "url" => "http://example.com/image.jpg",
708 defp build_remote_deletion_message do
711 "actor" => "https://remote.instance/users/bob"