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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.ActivityPubController do
   6   use Pleroma.Web, :controller
   7
   8   alias Pleroma.{Activity, User, Object}
   9   alias Pleroma.Web.ActivityPub.{ObjectView, UserView}
  10   alias Pleroma.Web.ActivityPub.ActivityPub
  11   alias Pleroma.Web.ActivityPub.Relay
  12   alias Pleroma.Web.ActivityPub.Utils
  13   alias Pleroma.Web.ActivityPub.Transmogrifier
  14   alias Pleroma.Web.Federator
  15
  16   require Logger
  17
  18   action_fallback(:errors)
  19
  20   plug(Pleroma.Web.FederatingPlug when action in [:inbox, :relay])
  21   plug(:set_requester_reachable when action in [:inbox])
  22   plug(:relay_active? when action in [:relay])
  23
  24   def relay_active?(conn, _) do
  25     if Keyword.get(Application.get_env(:pleroma, :instance), :allow_relay) do
  26       conn
  27     else
  28       conn
  29       |> put_status(404)
  30       |> json(%{error: "not found"})
  31       |> halt
  32     end
  33   end
  34
  35   def user(conn, %{"nickname" => nickname}) do
  36     with %User{} = user <- User.get_cached_by_nickname(nickname),
  37          {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
  38       conn
  39       |> put_resp_header("content-type", "application/activity+json")
  40       |> json(UserView.render("user.json", %{user: user}))
  41     else
  42       nil -> {:error, :not_found}
  43     end
  44   end
  45
  46   def object(conn, %{"uuid" => uuid}) do
  47     with ap_id <- o_status_url(conn, :object, uuid),
  48          %Object{} = object <- Object.get_cached_by_ap_id(ap_id),
  49          {_, true} <- {:public?, ActivityPub.is_public?(object)} do
  50       conn
  51       |> put_resp_header("content-type", "application/activity+json")
  52       |> json(ObjectView.render("object.json", %{object: object}))
  53     else
  54       {:public?, false} ->
  55         {:error, :not_found}
  56     end
  57   end
  58
  59   def object_likes(conn, %{"uuid" => uuid, "page" => page}) do
  60     with ap_id <- o_status_url(conn, :object, uuid),
  61          %Object{} = object <- Object.get_cached_by_ap_id(ap_id),
  62          {_, true} <- {:public?, ActivityPub.is_public?(object)},
  63          likes <- Utils.get_object_likes(object) do
  64       {page, _} = Integer.parse(page)
  65
  66       conn
  67       |> put_resp_header("content-type", "application/activity+json")
  68       |> json(ObjectView.render("likes.json", ap_id, likes, page))
  69     else
  70       {:public?, false} ->
  71         {:error, :not_found}
  72     end
  73   end
  74
  75   def object_likes(conn, %{"uuid" => uuid}) do
  76     with ap_id <- o_status_url(conn, :object, uuid),
  77          %Object{} = object <- Object.get_cached_by_ap_id(ap_id),
  78          {_, true} <- {:public?, ActivityPub.is_public?(object)},
  79          likes <- Utils.get_object_likes(object) do
  80       conn
  81       |> put_resp_header("content-type", "application/activity+json")
  82       |> json(ObjectView.render("likes.json", ap_id, likes))
  83     else
  84       {:public?, false} ->
  85         {:error, :not_found}
  86     end
  87   end
  88
  89   def activity(conn, %{"uuid" => uuid}) do
  90     with ap_id <- o_status_url(conn, :activity, uuid),
  91          %Activity{} = activity <- Activity.normalize(ap_id),
  92          {_, true} <- {:public?, ActivityPub.is_public?(activity)} do
  93       conn
  94       |> put_resp_header("content-type", "application/activity+json")
  95       |> json(ObjectView.render("object.json", %{object: activity}))
  96     else
  97       {:public?, false} ->
  98         {:error, :not_found}
  99     end
 100   end
 101
 102   def following(conn, %{"nickname" => nickname, "page" => page}) do
 103     with %User{} = user <- User.get_cached_by_nickname(nickname),
 104          {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
 105       {page, _} = Integer.parse(page)
 106
 107       conn
 108       |> put_resp_header("content-type", "application/activity+json")
 109       |> json(UserView.render("following.json", %{user: user, page: page}))
 110     end
 111   end
 112
 113   def following(conn, %{"nickname" => nickname}) do
 114     with %User{} = user <- User.get_cached_by_nickname(nickname),
 115          {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
 116       conn
 117       |> put_resp_header("content-type", "application/activity+json")
 118       |> json(UserView.render("following.json", %{user: user}))
 119     end
 120   end
 121
 122   def followers(conn, %{"nickname" => nickname, "page" => page}) do
 123     with %User{} = user <- User.get_cached_by_nickname(nickname),
 124          {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
 125       {page, _} = Integer.parse(page)
 126
 127       conn
 128       |> put_resp_header("content-type", "application/activity+json")
 129       |> json(UserView.render("followers.json", %{user: user, page: page}))
 130     end
 131   end
 132
 133   def followers(conn, %{"nickname" => nickname}) do
 134     with %User{} = user <- User.get_cached_by_nickname(nickname),
 135          {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
 136       conn
 137       |> put_resp_header("content-type", "application/activity+json")
 138       |> json(UserView.render("followers.json", %{user: user}))
 139     end
 140   end
 141
 142   def outbox(conn, %{"nickname" => nickname} = params) do
 143     with %User{} = user <- User.get_cached_by_nickname(nickname),
 144          {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
 145       conn
 146       |> put_resp_header("content-type", "application/activity+json")
 147       |> json(UserView.render("outbox.json", %{user: user, max_id: params["max_id"]}))
 148     end
 149   end
 150
 151   def inbox(%{assigns: %{valid_signature: true}} = conn, %{"nickname" => nickname} = params) do
 152     with %User{} = user <- User.get_cached_by_nickname(nickname),
 153          true <- Utils.recipient_in_message(user.ap_id, params),
 154          params <- Utils.maybe_splice_recipient(user.ap_id, params) do
 155       Federator.enqueue(:incoming_ap_doc, params)
 156       json(conn, "ok")
 157     end
 158   end
 159
 160   def inbox(%{assigns: %{valid_signature: true}} = conn, params) do
 161     Federator.enqueue(:incoming_ap_doc, params)
 162     json(conn, "ok")
 163   end
 164
 165   # only accept relayed Creates
 166   def inbox(conn, %{"type" => "Create"} = params) do
 167     Logger.info(
 168       "Signature missing or not from author, relayed Create message, fetching object from source"
 169     )
 170
 171     ActivityPub.fetch_object_from_id(params["object"]["id"])
 172
 173     json(conn, "ok")
 174   end
 175
 176   def inbox(conn, params) do
 177     headers = Enum.into(conn.req_headers, %{})
 178
 179     if String.contains?(headers["signature"], params["actor"]) do
 180       Logger.info(
 181         "Signature validation error for: #{params["actor"]}, make sure you are forwarding the HTTP Host header!"
 182       )
 183
 184       Logger.info(inspect(conn.req_headers))
 185     end
 186
 187     json(conn, "error")
 188   end
 189
 190   def relay(conn, _params) do
 191     with %User{} = user <- Relay.get_actor(),
 192          {:ok, user} <- Pleroma.Web.WebFinger.ensure_keys_present(user) do
 193       conn
 194       |> put_resp_header("content-type", "application/activity+json")
 195       |> json(UserView.render("user.json", %{user: user}))
 196     else
 197       nil -> {:error, :not_found}
 198     end
 199   end
 200
 201   def whoami(%{assigns: %{user: %User{} = user}} = conn, _params) do
 202     conn
 203     |> put_resp_header("content-type", "application/activity+json")
 204     |> json(UserView.render("user.json", %{user: user}))
 205   end
 206
 207   def whoami(_conn, _params), do: {:error, :not_found}
 208
 209   def read_inbox(%{assigns: %{user: user}} = conn, %{"nickname" => nickname} = params) do
 210     if nickname == user.nickname do
 211       conn
 212       |> put_resp_header("content-type", "application/activity+json")
 213       |> json(UserView.render("inbox.json", %{user: user, max_id: params["max_id"]}))
 214     else
 215       conn
 216       |> put_status(:forbidden)
 217       |> json("can't read inbox of #{nickname} as #{user.nickname}")
 218     end
 219   end
 220
 221   def handle_user_activity(user, %{"type" => "Create"} = params) do
 222     object =
 223       params["object"]
 224       |> Map.merge(Map.take(params, ["to", "cc"]))
 225       |> Map.put("attributedTo", user.ap_id())
 226       |> Transmogrifier.fix_object()
 227
 228     ActivityPub.create(%{
 229       to: params["to"],
 230       actor: user,
 231       context: object["context"],
 232       object: object,
 233       additional: Map.take(params, ["cc"])
 234     })
 235   end
 236
 237   def handle_user_activity(user, %{"type" => "Delete"} = params) do
 238     with %Object{} = object <- Object.normalize(params["object"]),
 239          true <- user.info.is_moderator || user.ap_id == object.data["actor"],
 240          {:ok, delete} <- ActivityPub.delete(object) do
 241       {:ok, delete}
 242     else
 243       _ -> {:error, "Can't delete object"}
 244     end
 245   end
 246
 247   def handle_user_activity(user, %{"type" => "Like"} = params) do
 248     with %Object{} = object <- Object.normalize(params["object"]),
 249          {:ok, activity, _object} <- ActivityPub.like(user, object) do
 250       {:ok, activity}
 251     else
 252       _ -> {:error, "Can't like object"}
 253     end
 254   end
 255
 256   def handle_user_activity(_, _) do
 257     {:error, "Unhandled activity type"}
 258   end
 259
 260   def update_outbox(
 261         %{assigns: %{user: user}} = conn,
 262         %{"nickname" => nickname} = params
 263       ) do
 264     if nickname == user.nickname do
 265       actor = user.ap_id()
 266
 267       params =
 268         params
 269         |> Map.drop(["id"])
 270         |> Map.put("actor", actor)
 271         |> Transmogrifier.fix_addressing()
 272
 273       with {:ok, %Activity{} = activity} <- handle_user_activity(user, params) do
 274         conn
 275         |> put_status(:created)
 276         |> put_resp_header("location", activity.data["id"])
 277         |> json(activity.data)
 278       else
 279         {:error, message} ->
 280           conn
 281           |> put_status(:bad_request)
 282           |> json(message)
 283       end
 284     else
 285       conn
 286       |> put_status(:forbidden)
 287       |> json("can't update outbox of #{nickname} as #{user.nickname}")
 288     end
 289   end
 290
 291   def errors(conn, {:error, :not_found}) do
 292     conn
 293     |> put_status(404)
 294     |> json("Not found")
 295   end
 296
 297   def errors(conn, _e) do
 298     conn
 299     |> put_status(500)
 300     |> json("error")
 301   end
 302
 303   defp set_requester_reachable(%Plug.Conn{} = conn, _) do
 304     with actor <- conn.params["actor"],
 305          true <- is_binary(actor) do
 306       Pleroma.Instances.set_reachable(actor)
 307     end
 308
 309     conn
 310   end
 311 end