git.squeep.com Git - akkoma/blob - test/web/activity_pub/mrf/simple_policy_test.exs

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.MRF.SimplePolicyTest do
   6   use Pleroma.DataCase
   7   import Pleroma.Factory
   8   alias Pleroma.Config
   9   alias Pleroma.Web.ActivityPub.MRF.SimplePolicy
  10
  11   clear_config([:mrf_simple]) do
  12     Config.put(:mrf_simple,
  13       media_removal: [],
  14       media_nsfw: [],
  15       federated_timeline_removal: [],
  16       report_removal: [],
  17       reject: [],
  18       accept: [],
  19       avatar_removal: [],
  20       banner_removal: []
  21     )
  22   end
  23
  24   describe "when :media_removal" do
  25     test "is empty" do
  26       Config.put([:mrf_simple, :media_removal], [])
  27       media_message = build_media_message()
  28       local_message = build_local_message()
  29
  30       assert SimplePolicy.filter(media_message) == {:ok, media_message}
  31       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  32     end
  33
  34     test "has a matching host" do
  35       Config.put([:mrf_simple, :media_removal], ["remote.instance"])
  36       media_message = build_media_message()
  37       local_message = build_local_message()
  38
  39       assert SimplePolicy.filter(media_message) ==
  40                {:ok,
  41                 media_message
  42                 |> Map.put("object", Map.delete(media_message["object"], "attachment"))}
  43
  44       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  45     end
  46
  47     test "match with wildcard domain" do
  48       Config.put([:mrf_simple, :media_removal], ["*.remote.instance"])
  49       media_message = build_media_message()
  50       local_message = build_local_message()
  51
  52       assert SimplePolicy.filter(media_message) ==
  53                {:ok,
  54                 media_message
  55                 |> Map.put("object", Map.delete(media_message["object"], "attachment"))}
  56
  57       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  58     end
  59   end
  60
  61   describe "when :media_nsfw" do
  62     test "is empty" do
  63       Config.put([:mrf_simple, :media_nsfw], [])
  64       media_message = build_media_message()
  65       local_message = build_local_message()
  66
  67       assert SimplePolicy.filter(media_message) == {:ok, media_message}
  68       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  69     end
  70
  71     test "has a matching host" do
  72       Config.put([:mrf_simple, :media_nsfw], ["remote.instance"])
  73       media_message = build_media_message()
  74       local_message = build_local_message()
  75
  76       assert SimplePolicy.filter(media_message) ==
  77                {:ok,
  78                 media_message
  79                 |> put_in(["object", "tag"], ["foo", "nsfw"])
  80                 |> put_in(["object", "sensitive"], true)}
  81
  82       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  83     end
  84
  85     test "match with wildcard domain" do
  86       Config.put([:mrf_simple, :media_nsfw], ["*.remote.instance"])
  87       media_message = build_media_message()
  88       local_message = build_local_message()
  89
  90       assert SimplePolicy.filter(media_message) ==
  91                {:ok,
  92                 media_message
  93                 |> put_in(["object", "tag"], ["foo", "nsfw"])
  94                 |> put_in(["object", "sensitive"], true)}
  95
  96       assert SimplePolicy.filter(local_message) == {:ok, local_message}
  97     end
  98   end
  99
 100   defp build_media_message do
 101     %{
 102       "actor" => "https://remote.instance/users/bob",
 103       "type" => "Create",
 104       "object" => %{
 105         "attachment" => [%{}],
 106         "tag" => ["foo"],
 107         "sensitive" => false
 108       }
 109     }
 110   end
 111
 112   describe "when :report_removal" do
 113     test "is empty" do
 114       Config.put([:mrf_simple, :report_removal], [])
 115       report_message = build_report_message()
 116       local_message = build_local_message()
 117
 118       assert SimplePolicy.filter(report_message) == {:ok, report_message}
 119       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 120     end
 121
 122     test "has a matching host" do
 123       Config.put([:mrf_simple, :report_removal], ["remote.instance"])
 124       report_message = build_report_message()
 125       local_message = build_local_message()
 126
 127       assert SimplePolicy.filter(report_message) == {:reject, nil}
 128       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 129     end
 130
 131     test "match with wildcard domain" do
 132       Config.put([:mrf_simple, :report_removal], ["*.remote.instance"])
 133       report_message = build_report_message()
 134       local_message = build_local_message()
 135
 136       assert SimplePolicy.filter(report_message) == {:reject, nil}
 137       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 138     end
 139   end
 140
 141   defp build_report_message do
 142     %{
 143       "actor" => "https://remote.instance/users/bob",
 144       "type" => "Flag"
 145     }
 146   end
 147
 148   describe "when :federated_timeline_removal" do
 149     test "is empty" do
 150       Config.put([:mrf_simple, :federated_timeline_removal], [])
 151       {_, ftl_message} = build_ftl_actor_and_message()
 152       local_message = build_local_message()
 153
 154       assert SimplePolicy.filter(ftl_message) == {:ok, ftl_message}
 155       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 156     end
 157
 158     test "has a matching host" do
 159       {actor, ftl_message} = build_ftl_actor_and_message()
 160
 161       ftl_message_actor_host =
 162         ftl_message
 163         |> Map.fetch!("actor")
 164         |> URI.parse()
 165         |> Map.fetch!(:host)
 166
 167       Config.put([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
 168       local_message = build_local_message()
 169
 170       assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
 171       assert actor.follower_address in ftl_message["to"]
 172       refute actor.follower_address in ftl_message["cc"]
 173       refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
 174       assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
 175
 176       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 177     end
 178
 179     test "match with wildcard domain" do
 180       {actor, ftl_message} = build_ftl_actor_and_message()
 181
 182       ftl_message_actor_host =
 183         ftl_message
 184         |> Map.fetch!("actor")
 185         |> URI.parse()
 186         |> Map.fetch!(:host)
 187
 188       Config.put([:mrf_simple, :federated_timeline_removal], ["*." <> ftl_message_actor_host])
 189       local_message = build_local_message()
 190
 191       assert {:ok, ftl_message} = SimplePolicy.filter(ftl_message)
 192       assert actor.follower_address in ftl_message["to"]
 193       refute actor.follower_address in ftl_message["cc"]
 194       refute "https://www.w3.org/ns/activitystreams#Public" in ftl_message["to"]
 195       assert "https://www.w3.org/ns/activitystreams#Public" in ftl_message["cc"]
 196
 197       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 198     end
 199
 200     test "has a matching host but only as:Public in to" do
 201       {_actor, ftl_message} = build_ftl_actor_and_message()
 202
 203       ftl_message_actor_host =
 204         ftl_message
 205         |> Map.fetch!("actor")
 206         |> URI.parse()
 207         |> Map.fetch!(:host)
 208
 209       ftl_message = Map.put(ftl_message, "cc", [])
 210
 211       Config.put([:mrf_simple, :federated_timeline_removal], [ftl_message_actor_host])
 212
 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"]
 216     end
 217   end
 218
 219   defp build_ftl_actor_and_message do
 220     actor = insert(:user)
 221
 222     {actor,
 223      %{
 224        "actor" => actor.ap_id,
 225        "to" => ["https://www.w3.org/ns/activitystreams#Public", "http://foo.bar/baz"],
 226        "cc" => [actor.follower_address, "http://foo.bar/qux"]
 227      }}
 228   end
 229
 230   describe "when :reject" do
 231     test "is empty" do
 232       Config.put([:mrf_simple, :reject], [])
 233
 234       remote_message = build_remote_message()
 235
 236       assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
 237     end
 238
 239     test "has a matching host" do
 240       Config.put([:mrf_simple, :reject], ["remote.instance"])
 241
 242       remote_message = build_remote_message()
 243
 244       assert SimplePolicy.filter(remote_message) == {:reject, nil}
 245     end
 246
 247     test "match with wildcard domain" do
 248       Config.put([:mrf_simple, :reject], ["*.remote.instance"])
 249
 250       remote_message = build_remote_message()
 251
 252       assert SimplePolicy.filter(remote_message) == {:reject, nil}
 253     end
 254   end
 255
 256   describe "when :accept" do
 257     test "is empty" do
 258       Config.put([:mrf_simple, :accept], [])
 259
 260       local_message = build_local_message()
 261       remote_message = build_remote_message()
 262
 263       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 264       assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
 265     end
 266
 267     test "is not empty but it doesn't have a matching host" do
 268       Config.put([:mrf_simple, :accept], ["non.matching.remote"])
 269
 270       local_message = build_local_message()
 271       remote_message = build_remote_message()
 272
 273       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 274       assert SimplePolicy.filter(remote_message) == {:reject, nil}
 275     end
 276
 277     test "has a matching host" do
 278       Config.put([:mrf_simple, :accept], ["remote.instance"])
 279
 280       local_message = build_local_message()
 281       remote_message = build_remote_message()
 282
 283       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 284       assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
 285     end
 286
 287     test "match with wildcard domain" do
 288       Config.put([:mrf_simple, :accept], ["*.remote.instance"])
 289
 290       local_message = build_local_message()
 291       remote_message = build_remote_message()
 292
 293       assert SimplePolicy.filter(local_message) == {:ok, local_message}
 294       assert SimplePolicy.filter(remote_message) == {:ok, remote_message}
 295     end
 296   end
 297
 298   describe "when :avatar_removal" do
 299     test "is empty" do
 300       Config.put([:mrf_simple, :avatar_removal], [])
 301
 302       remote_user = build_remote_user()
 303
 304       assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
 305     end
 306
 307     test "is not empty but it doesn't have a matching host" do
 308       Config.put([:mrf_simple, :avatar_removal], ["non.matching.remote"])
 309
 310       remote_user = build_remote_user()
 311
 312       assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
 313     end
 314
 315     test "has a matching host" do
 316       Config.put([:mrf_simple, :avatar_removal], ["remote.instance"])
 317
 318       remote_user = build_remote_user()
 319       {:ok, filtered} = SimplePolicy.filter(remote_user)
 320
 321       refute filtered["icon"]
 322     end
 323
 324     test "match with wildcard domain" do
 325       Config.put([:mrf_simple, :avatar_removal], ["*.remote.instance"])
 326
 327       remote_user = build_remote_user()
 328       {:ok, filtered} = SimplePolicy.filter(remote_user)
 329
 330       refute filtered["icon"]
 331     end
 332   end
 333
 334   describe "when :banner_removal" do
 335     test "is empty" do
 336       Config.put([:mrf_simple, :banner_removal], [])
 337
 338       remote_user = build_remote_user()
 339
 340       assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
 341     end
 342
 343     test "is not empty but it doesn't have a matching host" do
 344       Config.put([:mrf_simple, :banner_removal], ["non.matching.remote"])
 345
 346       remote_user = build_remote_user()
 347
 348       assert SimplePolicy.filter(remote_user) == {:ok, remote_user}
 349     end
 350
 351     test "has a matching host" do
 352       Config.put([:mrf_simple, :banner_removal], ["remote.instance"])
 353
 354       remote_user = build_remote_user()
 355       {:ok, filtered} = SimplePolicy.filter(remote_user)
 356
 357       refute filtered["image"]
 358     end
 359
 360     test "match with wildcard domain" do
 361       Config.put([:mrf_simple, :banner_removal], ["*.remote.instance"])
 362
 363       remote_user = build_remote_user()
 364       {:ok, filtered} = SimplePolicy.filter(remote_user)
 365
 366       refute filtered["image"]
 367     end
 368   end
 369
 370   defp build_local_message do
 371     %{
 372       "actor" => "#{Pleroma.Web.base_url()}/users/alice",
 373       "to" => [],
 374       "cc" => []
 375     }
 376   end
 377
 378   defp build_remote_message do
 379     %{"actor" => "https://remote.instance/users/bob"}
 380   end
 381
 382   defp build_remote_user do
 383     %{
 384       "id" => "https://remote.instance/users/bob",
 385       "icon" => %{
 386         "url" => "http://example.com/image.jpg",
 387         "type" => "Image"
 388       },
 389       "image" => %{
 390         "url" => "http://example.com/image.jpg",
 391         "type" => "Image"
 392       },
 393       "type" => "Person"
 394     }
 395   end
 396 end