git.squeep.com Git - akkoma/blob - lib/pleroma/web/activity_pub/transmogrifier.ex

   1 defmodule Pleroma.Web.ActivityPub.Transmogrifier do
   2   @moduledoc """
   3   A module to handle coding from internal to wire ActivityPub and back.
   4   """
   5   alias Pleroma.User
   6   alias Pleroma.Object
   7   alias Pleroma.Activity
   8   alias Pleroma.Repo
   9   alias Pleroma.Web.ActivityPub.ActivityPub
  10   alias Pleroma.Web.ActivityPub.Utils
  11
  12   import Ecto.Query
  13
  14   require Logger
  15
  16   @doc """
  17   Modifies an incoming AP object (mastodon format) to our internal format.
  18   """
  19   def fix_object(object) do
  20     object
  21     |> fix_actor
  22     |> fix_attachments
  23     |> fix_context
  24     |> fix_in_reply_to
  25     |> fix_emoji
  26     |> fix_tag
  27     |> fix_content_map
  28   end
  29
  30   def fix_actor(%{"attributedTo" => actor} = object) do
  31     # attributedTo can be a list in the case of peertube or plume
  32     actor =
  33       if is_list(actor) do
  34         Enum.at(actor, 0)
  35       else
  36         actor
  37       end
  38
  39     object
  40     |> Map.put("actor", actor)
  41   end
  42
  43   def fix_in_reply_to(%{"inReplyTo" => in_reply_to_id} = object)
  44       when not is_nil(in_reply_to_id) do
  45     case ActivityPub.fetch_object_from_id(in_reply_to_id) do
  46       {:ok, replied_object} ->
  47         with %Activity{} = activity <-
  48                Activity.get_create_activity_by_object_ap_id(replied_object.data["id"]) do
  49           object
  50           |> Map.put("inReplyTo", replied_object.data["id"])
  51           |> Map.put("inReplyToAtomUri", object["inReplyToAtomUri"] || in_reply_to_id)
  52           |> Map.put("inReplyToStatusId", activity.id)
  53           |> Map.put("conversation", replied_object.data["context"] || object["conversation"])
  54           |> Map.put("context", replied_object.data["context"] || object["conversation"])
  55         else
  56           e ->
  57             Logger.error("Couldn't fetch #{object["inReplyTo"]} #{inspect(e)}")
  58             object
  59         end
  60
  61       e ->
  62         Logger.error("Couldn't fetch #{object["inReplyTo"]} #{inspect(e)}")
  63         object
  64     end
  65   end
  66
  67   def fix_in_reply_to(object), do: object
  68
  69   def fix_context(object) do
  70     object
  71     |> Map.put("context", object["conversation"])
  72   end
  73
  74   def fix_attachments(object) do
  75     attachments =
  76       (object["attachment"] || [])
  77       |> Enum.map(fn data ->
  78         url = [%{"type" => "Link", "mediaType" => data["mediaType"], "href" => data["url"]}]
  79         Map.put(data, "url", url)
  80       end)
  81
  82     object
  83     |> Map.put("attachment", attachments)
  84   end
  85
  86   def fix_emoji(object) do
  87     tags = object["tag"] || []
  88     emoji = tags |> Enum.filter(fn data -> data["type"] == "Emoji" and data["icon"] end)
  89
  90     emoji =
  91       emoji
  92       |> Enum.reduce(%{}, fn data, mapping ->
  93         name = data["name"]
  94
  95         name =
  96           if String.starts_with?(name, ":") do
  97             name |> String.slice(1..-2)
  98           else
  99             name
 100           end
 101
 102         mapping |> Map.put(name, data["icon"]["url"])
 103       end)
 104
 105     # we merge mastodon and pleroma emoji into a single mapping, to allow for both wire formats
 106     emoji = Map.merge(object["emoji"] || %{}, emoji)
 107
 108     object
 109     |> Map.put("emoji", emoji)
 110   end
 111
 112   def fix_tag(object) do
 113     tags =
 114       (object["tag"] || [])
 115       |> Enum.filter(fn data -> data["type"] == "Hashtag" and data["name"] end)
 116       |> Enum.map(fn data -> String.slice(data["name"], 1..-1) end)
 117
 118     combined = (object["tag"] || []) ++ tags
 119
 120     object
 121     |> Map.put("tag", combined)
 122   end
 123
 124   # content map usually only has one language so this will do for now.
 125   def fix_content_map(%{"contentMap" => content_map} = object) do
 126     content_groups = Map.to_list(content_map)
 127     {_, content} = Enum.at(content_groups, 0)
 128
 129     object
 130     |> Map.put("content", content)
 131   end
 132
 133   def fix_content_map(object), do: object
 134
 135   # TODO: validate those with a Ecto scheme
 136   # - tags
 137   # - emoji
 138   def handle_incoming(%{"type" => "Create", "object" => %{"type" => objtype} = object} = data)
 139       when objtype in ["Article", "Note"] do
 140     with nil <- Activity.get_create_activity_by_object_ap_id(object["id"]),
 141          %User{} = user <- User.get_or_fetch_by_ap_id(data["actor"]) do
 142       # prefer the activity's actor instead of attributedTo
 143       object =
 144         fix_object(data["object"])
 145         |> Map.put("actor", data["actor"])
 146
 147       params = %{
 148         to: data["to"],
 149         object: object,
 150         actor: user,
 151         context: object["conversation"],
 152         local: false,
 153         published: data["published"],
 154         additional:
 155           Map.take(data, [
 156             "cc",
 157             "id"
 158           ])
 159       }
 160
 161       ActivityPub.create(params)
 162     else
 163       %Activity{} = activity -> {:ok, activity}
 164       _e -> :error
 165     end
 166   end
 167
 168   def handle_incoming(
 169         %{"type" => "Follow", "object" => followed, "actor" => follower, "id" => id} = data
 170       ) do
 171     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
 172          %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
 173          {:ok, activity} <- ActivityPub.follow(follower, followed, id, false) do
 174       if not User.locked?(followed) do
 175         ActivityPub.accept(%{
 176           to: [follower.ap_id],
 177           actor: followed.ap_id,
 178           object: data,
 179           local: true
 180         })
 181
 182         User.follow(follower, followed)
 183       end
 184
 185       {:ok, activity}
 186     else
 187       _e -> :error
 188     end
 189   end
 190
 191   defp mastodon_follow_hack(%{"id" => id, "actor" => follower_id}, followed) do
 192     with true <- id =~ "follows",
 193          %User{local: true} = follower <- User.get_cached_by_ap_id(follower_id),
 194          %Activity{} = activity <- Utils.fetch_latest_follow(follower, followed) do
 195       {:ok, activity}
 196     else
 197       _ -> {:error, nil}
 198     end
 199   end
 200
 201   defp mastodon_follow_hack(_), do: {:error, nil}
 202
 203   defp get_follow_activity(follow_object, followed) do
 204     with object_id when not is_nil(object_id) <- Utils.get_ap_id(follow_object),
 205          {_, %Activity{} = activity} <- {:activity, Activity.get_by_ap_id(object_id)} do
 206       {:ok, activity}
 207     else
 208       # Can't find the activity. This might a Mastodon 2.3 "Accept"
 209       {:activity, nil} ->
 210         mastodon_follow_hack(follow_object, followed)
 211
 212       _ ->
 213         {:error, nil}
 214     end
 215   end
 216
 217   def handle_incoming(
 218         %{"type" => "Accept", "object" => follow_object, "actor" => actor, "id" => id} = data
 219       ) do
 220     with %User{} = followed <- User.get_or_fetch_by_ap_id(actor),
 221          {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
 222          %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
 223          {:ok, activity} <-
 224            ActivityPub.accept(%{
 225              to: follow_activity.data["to"],
 226              type: "Accept",
 227              actor: followed.ap_id,
 228              object: follow_activity.data["id"],
 229              local: false
 230            }) do
 231       if not User.following?(follower, followed) do
 232         {:ok, follower} = User.follow(follower, followed)
 233       end
 234
 235       {:ok, activity}
 236     else
 237       _e -> :error
 238     end
 239   end
 240
 241   def handle_incoming(
 242         %{"type" => "Reject", "object" => follow_object, "actor" => actor, "id" => id} = data
 243       ) do
 244     with %User{} = followed <- User.get_or_fetch_by_ap_id(actor),
 245          {:ok, follow_activity} <- get_follow_activity(follow_object, followed),
 246          %User{local: true} = follower <- User.get_cached_by_ap_id(follow_activity.data["actor"]),
 247          {:ok, activity} <-
 248            ActivityPub.accept(%{
 249              to: follow_activity.data["to"],
 250              type: "Accept",
 251              actor: followed.ap_id,
 252              object: follow_activity.data["id"],
 253              local: false
 254            }) do
 255       User.unfollow(follower, followed)
 256
 257       {:ok, activity}
 258     else
 259       _e -> :error
 260     end
 261   end
 262
 263   def handle_incoming(
 264         %{"type" => "Like", "object" => object_id, "actor" => actor, "id" => id} = _data
 265       ) do
 266     with %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
 267          {:ok, object} <-
 268            get_obj_helper(object_id) || ActivityPub.fetch_object_from_id(object_id),
 269          {:ok, activity, _object} <- ActivityPub.like(actor, object, id, false) do
 270       {:ok, activity}
 271     else
 272       _e -> :error
 273     end
 274   end
 275
 276   def handle_incoming(
 277         %{"type" => "Announce", "object" => object_id, "actor" => actor, "id" => id} = _data
 278       ) do
 279     with %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
 280          {:ok, object} <-
 281            get_obj_helper(object_id) || ActivityPub.fetch_object_from_id(object_id),
 282          {:ok, activity, _object} <- ActivityPub.announce(actor, object, id, false) do
 283       {:ok, activity}
 284     else
 285       _e -> :error
 286     end
 287   end
 288
 289   def handle_incoming(
 290         %{"type" => "Update", "object" => %{"type" => "Person"} = object, "actor" => actor_id} =
 291           data
 292       ) do
 293     with %User{ap_id: ^actor_id} = actor <- User.get_by_ap_id(object["id"]) do
 294       {:ok, new_user_data} = ActivityPub.user_data_from_user_object(object)
 295
 296       banner = new_user_data[:info]["banner"]
 297       locked = new_user_data[:info]["locked"] || false
 298
 299       update_data =
 300         new_user_data
 301         |> Map.take([:name, :bio, :avatar])
 302         |> Map.put(:info, Map.merge(actor.info, %{"banner" => banner, "locked" => locked}))
 303
 304       actor
 305       |> User.upgrade_changeset(update_data)
 306       |> User.update_and_set_cache()
 307
 308       ActivityPub.update(%{
 309         local: false,
 310         to: data["to"] || [],
 311         cc: data["cc"] || [],
 312         object: object,
 313         actor: actor_id
 314       })
 315     else
 316       e ->
 317         Logger.error(e)
 318         :error
 319     end
 320   end
 321
 322   # TODO: Make secure.
 323   def handle_incoming(
 324         %{"type" => "Delete", "object" => object_id, "actor" => actor, "id" => _id} = _data
 325       ) do
 326     object_id = Utils.get_ap_id(object_id)
 327
 328     with %User{} = _actor <- User.get_or_fetch_by_ap_id(actor),
 329          {:ok, object} <-
 330            get_obj_helper(object_id) || ActivityPub.fetch_object_from_id(object_id),
 331          {:ok, activity} <- ActivityPub.delete(object, false) do
 332       {:ok, activity}
 333     else
 334       _e -> :error
 335     end
 336   end
 337
 338   def handle_incoming(
 339         %{
 340           "type" => "Undo",
 341           "object" => %{"type" => "Announce", "object" => object_id},
 342           "actor" => actor,
 343           "id" => id
 344         } = _data
 345       ) do
 346     with %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
 347          {:ok, object} <-
 348            get_obj_helper(object_id) || ActivityPub.fetch_object_from_id(object_id),
 349          {:ok, activity, _} <- ActivityPub.unannounce(actor, object, id, false) do
 350       {:ok, activity}
 351     else
 352       _e -> :error
 353     end
 354   end
 355
 356   def handle_incoming(
 357         %{
 358           "type" => "Undo",
 359           "object" => %{"type" => "Follow", "object" => followed},
 360           "actor" => follower,
 361           "id" => id
 362         } = _data
 363       ) do
 364     with %User{local: true} = followed <- User.get_cached_by_ap_id(followed),
 365          %User{} = follower <- User.get_or_fetch_by_ap_id(follower),
 366          {:ok, activity} <- ActivityPub.unfollow(follower, followed, id, false) do
 367       User.unfollow(follower, followed)
 368       {:ok, activity}
 369     else
 370       e -> :error
 371     end
 372   end
 373
 374   @ap_config Application.get_env(:pleroma, :activitypub)
 375   @accept_blocks Keyword.get(@ap_config, :accept_blocks)
 376
 377   def handle_incoming(
 378         %{
 379           "type" => "Undo",
 380           "object" => %{"type" => "Block", "object" => blocked},
 381           "actor" => blocker,
 382           "id" => id
 383         } = _data
 384       ) do
 385     with true <- @accept_blocks,
 386          %User{local: true} = blocked <- User.get_cached_by_ap_id(blocked),
 387          %User{} = blocker <- User.get_or_fetch_by_ap_id(blocker),
 388          {:ok, activity} <- ActivityPub.unblock(blocker, blocked, id, false) do
 389       User.unblock(blocker, blocked)
 390       {:ok, activity}
 391     else
 392       e -> :error
 393     end
 394   end
 395
 396   def handle_incoming(
 397         %{"type" => "Block", "object" => blocked, "actor" => blocker, "id" => id} = data
 398       ) do
 399     with true <- @accept_blocks,
 400          %User{local: true} = blocked = User.get_cached_by_ap_id(blocked),
 401          %User{} = blocker = User.get_or_fetch_by_ap_id(blocker),
 402          {:ok, activity} <- ActivityPub.block(blocker, blocked, id, false) do
 403       User.unfollow(blocker, blocked)
 404       User.block(blocker, blocked)
 405       {:ok, activity}
 406     else
 407       e -> :error
 408     end
 409   end
 410
 411   def handle_incoming(
 412         %{
 413           "type" => "Undo",
 414           "object" => %{"type" => "Like", "object" => object_id},
 415           "actor" => actor,
 416           "id" => id
 417         } = _data
 418       ) do
 419     with %User{} = actor <- User.get_or_fetch_by_ap_id(actor),
 420          {:ok, object} <-
 421            get_obj_helper(object_id) || ActivityPub.fetch_object_from_id(object_id),
 422          {:ok, activity, _, _} <- ActivityPub.unlike(actor, object, id, false) do
 423       {:ok, activity}
 424     else
 425       _e -> :error
 426     end
 427   end
 428
 429   def handle_incoming(_), do: :error
 430
 431   def get_obj_helper(id) do
 432     if object = Object.get_by_ap_id(id), do: {:ok, object}, else: nil
 433   end
 434
 435   def set_reply_to_uri(%{"inReplyTo" => inReplyTo} = object) do
 436     with false <- String.starts_with?(inReplyTo, "http"),
 437          {:ok, %{data: replied_to_object}} <- get_obj_helper(inReplyTo) do
 438       Map.put(object, "inReplyTo", replied_to_object["external_url"] || inReplyTo)
 439     else
 440       _e -> object
 441     end
 442   end
 443
 444   def set_reply_to_uri(obj), do: obj
 445
 446   # Prepares the object of an outgoing create activity.
 447   def prepare_object(object) do
 448     object
 449     |> set_sensitive
 450     |> add_hashtags
 451     |> add_mention_tags
 452     |> add_emoji_tags
 453     |> add_attributed_to
 454     |> prepare_attachments
 455     |> set_conversation
 456     |> set_reply_to_uri
 457   end
 458
 459   #  @doc
 460   #  """
 461   #  internal -> Mastodon
 462   #  """
 463
 464   def prepare_outgoing(%{"type" => "Create", "object" => %{"type" => "Note"} = object} = data) do
 465     object =
 466       object
 467       |> prepare_object
 468
 469     data =
 470       data
 471       |> Map.put("object", object)
 472       |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 473
 474     {:ok, data}
 475   end
 476
 477   # Mastodon Accept/Reject requires a non-normalized object containing the actor URIs,
 478   # because of course it does.
 479   def prepare_outgoing(%{"type" => "Accept"} = data) do
 480     follow_activity_id =
 481       if is_binary(data["object"]) do
 482         data["object"]
 483       else
 484         data["object"]["id"]
 485       end
 486
 487     with follow_activity <- Activity.get_by_ap_id(follow_activity_id) do
 488       object = %{
 489         "actor" => follow_activity.actor,
 490         "object" => follow_activity.data["object"],
 491         "id" => follow_activity.data["id"],
 492         "type" => "Follow"
 493       }
 494
 495       data =
 496         data
 497         |> Map.put("object", object)
 498         |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 499
 500       {:ok, data}
 501     end
 502   end
 503
 504   def prepare_outgoing(%{"type" => "Reject"} = data) do
 505     follow_activity_id =
 506       if is_binary(data["object"]) do
 507         data["object"]
 508       else
 509         data["object"]["id"]
 510       end
 511
 512     with follow_activity <- Activity.get_by_ap_id(follow_activity_id) do
 513       object = %{
 514         "actor" => follow_activity.actor,
 515         "object" => follow_activity.data["object"],
 516         "id" => follow_activity.data["id"],
 517         "type" => "Follow"
 518       }
 519
 520       data =
 521         data
 522         |> Map.put("object", object)
 523         |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 524
 525       {:ok, data}
 526     end
 527   end
 528
 529   def prepare_outgoing(%{"type" => _type} = data) do
 530     data =
 531       data
 532       |> maybe_fix_object_url
 533       |> Map.put("@context", "https://www.w3.org/ns/activitystreams")
 534
 535     {:ok, data}
 536   end
 537
 538   def maybe_fix_object_url(data) do
 539     if is_binary(data["object"]) and not String.starts_with?(data["object"], "http") do
 540       case ActivityPub.fetch_object_from_id(data["object"]) do
 541         {:ok, relative_object} ->
 542           if relative_object.data["external_url"] do
 543             _data =
 544               data
 545               |> Map.put("object", relative_object.data["external_url"])
 546           else
 547             data
 548           end
 549
 550         e ->
 551           Logger.error("Couldn't fetch #{data["object"]} #{inspect(e)}")
 552           data
 553       end
 554     else
 555       data
 556     end
 557   end
 558
 559   def add_hashtags(object) do
 560     tags =
 561       (object["tag"] || [])
 562       |> Enum.map(fn tag ->
 563         %{
 564           "href" => Pleroma.Web.Endpoint.url() <> "/tags/#{tag}",
 565           "name" => "##{tag}",
 566           "type" => "Hashtag"
 567         }
 568       end)
 569
 570     object
 571     |> Map.put("tag", tags)
 572   end
 573
 574   def add_mention_tags(object) do
 575     recipients = object["to"] ++ (object["cc"] || [])
 576
 577     mentions =
 578       recipients
 579       |> Enum.map(fn ap_id -> User.get_cached_by_ap_id(ap_id) end)
 580       |> Enum.filter(& &1)
 581       |> Enum.map(fn user ->
 582         %{"type" => "Mention", "href" => user.ap_id, "name" => "@#{user.nickname}"}
 583       end)
 584
 585     tags = object["tag"] || []
 586
 587     object
 588     |> Map.put("tag", tags ++ mentions)
 589   end
 590
 591   # TODO: we should probably send mtime instead of unix epoch time for updated
 592   def add_emoji_tags(object) do
 593     tags = object["tag"] || []
 594     emoji = object["emoji"] || []
 595
 596     out =
 597       emoji
 598       |> Enum.map(fn {name, url} ->
 599         %{
 600           "icon" => %{"url" => url, "type" => "Image"},
 601           "name" => ":" <> name <> ":",
 602           "type" => "Emoji",
 603           "updated" => "1970-01-01T00:00:00Z",
 604           "id" => url
 605         }
 606       end)
 607
 608     object
 609     |> Map.put("tag", tags ++ out)
 610   end
 611
 612   def set_conversation(object) do
 613     Map.put(object, "conversation", object["context"])
 614   end
 615
 616   def set_sensitive(object) do
 617     tags = object["tag"] || []
 618     Map.put(object, "sensitive", "nsfw" in tags)
 619   end
 620
 621   def add_attributed_to(object) do
 622     attributedTo = object["attributedTo"] || object["actor"]
 623
 624     object
 625     |> Map.put("attributedTo", attributedTo)
 626   end
 627
 628   def prepare_attachments(object) do
 629     attachments =
 630       (object["attachment"] || [])
 631       |> Enum.map(fn data ->
 632         [%{"mediaType" => media_type, "href" => href} | _] = data["url"]
 633         %{"url" => href, "mediaType" => media_type, "name" => data["name"], "type" => "Document"}
 634       end)
 635
 636     object
 637     |> Map.put("attachment", attachments)
 638   end
 639
 640   defp user_upgrade_task(user) do
 641     old_follower_address = User.ap_followers(user)
 642
 643     q =
 644       from(
 645         u in User,
 646         where: ^old_follower_address in u.following,
 647         update: [
 648           set: [
 649             following:
 650               fragment(
 651                 "array_replace(?,?,?)",
 652                 u.following,
 653                 ^old_follower_address,
 654                 ^user.follower_address
 655               )
 656           ]
 657         ]
 658       )
 659
 660     Repo.update_all(q, [])
 661
 662     maybe_retire_websub(user.ap_id)
 663
 664     # Only do this for recent activties, don't go through the whole db.
 665     # Only look at the last 1000 activities.
 666     since = (Repo.aggregate(Activity, :max, :id) || 0) - 1_000
 667
 668     q =
 669       from(
 670         a in Activity,
 671         where: ^old_follower_address in a.recipients,
 672         where: a.id > ^since,
 673         update: [
 674           set: [
 675             recipients:
 676               fragment(
 677                 "array_replace(?,?,?)",
 678                 a.recipients,
 679                 ^old_follower_address,
 680                 ^user.follower_address
 681               )
 682           ]
 683         ]
 684       )
 685
 686     Repo.update_all(q, [])
 687   end
 688
 689   def upgrade_user_from_ap_id(ap_id, async \\ true) do
 690     with %User{local: false} = user <- User.get_by_ap_id(ap_id),
 691          {:ok, data} <- ActivityPub.fetch_and_prepare_user_from_ap_id(ap_id) do
 692       data =
 693         data
 694         |> Map.put(:info, Map.merge(user.info, data[:info]))
 695
 696       already_ap = User.ap_enabled?(user)
 697
 698       {:ok, user} =
 699         User.upgrade_changeset(user, data)
 700         |> Repo.update()
 701
 702       if !already_ap do
 703         # This could potentially take a long time, do it in the background
 704         if async do
 705           Task.start(fn ->
 706             user_upgrade_task(user)
 707           end)
 708         else
 709           user_upgrade_task(user)
 710         end
 711       end
 712
 713       {:ok, user}
 714     else
 715       e -> e
 716     end
 717   end
 718
 719   def maybe_retire_websub(ap_id) do
 720     # some sanity checks
 721     if is_binary(ap_id) && String.length(ap_id) > 8 do
 722       q =
 723         from(
 724           ws in Pleroma.Web.Websub.WebsubClientSubscription,
 725           where: fragment("? like ?", ws.topic, ^"#{ap_id}%")
 726         )
 727
 728       Repo.delete_all(q)
 729     end
 730   end
 731
 732   def maybe_fix_user_url(data) do
 733     if is_map(data["url"]) do
 734       Map.put(data, "url", data["url"]["href"])
 735     else
 736       data
 737     end
 738   end
 739
 740   def maybe_fix_user_object(data) do
 741     data
 742     |> maybe_fix_user_url
 743   end
 744 end