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 read_inbox(%{assigns: %{user: user}} = conn, %{"nickname" => nickname} = params) do
 202     if nickname == user.nickname do
 203       conn
 204       |> put_resp_header("content-type", "application/activity+json")
 205       |> json(UserView.render("inbox.json", %{user: user, max_id: params["max_id"]}))
 206     else
 207       conn
 208       |> put_status(:forbidden)
 209       |> json("can't read inbox of #{nickname} as #{user.nickname}")
 210     end
 211   end
 212
 213   def handle_user_activity(user, %{"type" => "Create"} = params) do
 214     object =
 215       params["object"]
 216       |> Map.merge(Map.take(params, ["to", "cc"]))
 217       |> Map.put("attributedTo", user.ap_id())
 218       |> Transmogrifier.fix_object()
 219
 220     ActivityPub.create(%{
 221       to: params["to"],
 222       actor: user,
 223       context: object["context"],
 224       object: object,
 225       additional: Map.take(params, ["cc"])
 226     })
 227   end
 228
 229   def handle_user_activity(user, %{"type" => "Delete"} = params) do
 230     with %Object{} = object <- Object.normalize(params["object"]),
 231          true <- user.info.is_moderator || user.ap_id == object.data["actor"],
 232          {:ok, delete} <- ActivityPub.delete(object) do
 233       {:ok, delete}
 234     else
 235       _ -> {:error, "Can't delete object"}
 236     end
 237   end
 238
 239   def handle_user_activity(user, %{"type" => "Like"} = params) do
 240     with %Object{} = object <- Object.normalize(params["object"]),
 241          {:ok, activity, _object} <- ActivityPub.like(user, object) do
 242       {:ok, activity}
 243     else
 244       _ -> {:error, "Can't like object"}
 245     end
 246   end
 247
 248   def handle_user_activity(_, _) do
 249     {:error, "Unhandled activity type"}
 250   end
 251
 252   def update_outbox(
 253         %{assigns: %{user: user}} = conn,
 254         %{"nickname" => nickname} = params
 255       ) do
 256     if nickname == user.nickname do
 257       actor = user.ap_id()
 258
 259       params =
 260         params
 261         |> Map.drop(["id"])
 262         |> Map.put("actor", actor)
 263         |> Transmogrifier.fix_addressing()
 264
 265       with {:ok, %Activity{} = activity} <- handle_user_activity(user, params) do
 266         conn
 267         |> put_status(:created)
 268         |> put_resp_header("location", activity.data["id"])
 269         |> json(activity.data)
 270       else
 271         {:error, message} ->
 272           conn
 273           |> put_status(:bad_request)
 274           |> json(message)
 275       end
 276     else
 277       conn
 278       |> put_status(:forbidden)
 279       |> json("can't update outbox of #{nickname} as #{user.nickname}")
 280     end
 281   end
 282
 283   def errors(conn, {:error, :not_found}) do
 284     conn
 285     |> put_status(404)
 286     |> json("Not found")
 287   end
 288
 289   def errors(conn, _e) do
 290     conn
 291     |> put_status(500)
 292     |> json("error")
 293   end
 294
 295   defp set_requester_reachable(%Plug.Conn{} = conn, _) do
 296     with actor <- conn.params["actor"],
 297          true <- is_binary(actor) do
 298       Pleroma.Instances.set_reachable(actor)
 299     end
 300
 301     conn
 302   end
 303 end