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