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

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2020 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.ObjectValidator do
   6   @moduledoc """
   7   This module is responsible for validating an object (which can be an activity)
   8   and checking if it is both well formed and also compatible with our view of
   9   the system.
  10   """
  11
  12   alias Pleroma.Activity
  13   alias Pleroma.EctoType.ActivityPub.ObjectValidators
  14   alias Pleroma.Object
  15   alias Pleroma.Object.Containment
  16   alias Pleroma.User
  17   alias Pleroma.Web.ActivityPub.ObjectValidators.AcceptRejectValidator
  18   alias Pleroma.Web.ActivityPub.ObjectValidators.AnnounceValidator
  19   alias Pleroma.Web.ActivityPub.ObjectValidators.AnswerValidator
  20   alias Pleroma.Web.ActivityPub.ObjectValidators.ArticleNoteValidator
  21   alias Pleroma.Web.ActivityPub.ObjectValidators.AudioVideoValidator
  22   alias Pleroma.Web.ActivityPub.ObjectValidators.BlockValidator
  23   alias Pleroma.Web.ActivityPub.ObjectValidators.ChatMessageValidator
  24   alias Pleroma.Web.ActivityPub.ObjectValidators.CreateChatMessageValidator
  25   alias Pleroma.Web.ActivityPub.ObjectValidators.CreateGenericValidator
  26   alias Pleroma.Web.ActivityPub.ObjectValidators.DeleteValidator
  27   alias Pleroma.Web.ActivityPub.ObjectValidators.EmojiReactValidator
  28   alias Pleroma.Web.ActivityPub.ObjectValidators.EventValidator
  29   alias Pleroma.Web.ActivityPub.ObjectValidators.FollowValidator
  30   alias Pleroma.Web.ActivityPub.ObjectValidators.LikeValidator
  31   alias Pleroma.Web.ActivityPub.ObjectValidators.QuestionValidator
  32   alias Pleroma.Web.ActivityPub.ObjectValidators.UndoValidator
  33   alias Pleroma.Web.ActivityPub.ObjectValidators.UpdateValidator
  34
  35   @spec validate(map(), keyword()) :: {:ok, map(), keyword()} | {:error, any()}
  36   def validate(object, meta)
  37
  38   def validate(%{"type" => type} = object, meta)
  39       when type in ~w[Accept Reject] do
  40     with {:ok, object} <-
  41            object
  42            |> AcceptRejectValidator.cast_and_validate()
  43            |> Ecto.Changeset.apply_action(:insert) do
  44       object = stringify_keys(object)
  45       {:ok, object, meta}
  46     end
  47   end
  48
  49   def validate(%{"type" => "Event"} = object, meta) do
  50     with {:ok, object} <-
  51            object
  52            |> EventValidator.cast_and_validate()
  53            |> Ecto.Changeset.apply_action(:insert) do
  54       object = stringify_keys(object)
  55       {:ok, object, meta}
  56     end
  57   end
  58
  59   def validate(%{"type" => "Follow"} = object, meta) do
  60     with {:ok, object} <-
  61            object
  62            |> FollowValidator.cast_and_validate()
  63            |> Ecto.Changeset.apply_action(:insert) do
  64       object = stringify_keys(object)
  65       {:ok, object, meta}
  66     end
  67   end
  68
  69   def validate(%{"type" => "Block"} = block_activity, meta) do
  70     with {:ok, block_activity} <-
  71            block_activity
  72            |> BlockValidator.cast_and_validate()
  73            |> Ecto.Changeset.apply_action(:insert) do
  74       block_activity = stringify_keys(block_activity)
  75       outgoing_blocks = Pleroma.Config.get([:activitypub, :outgoing_blocks])
  76
  77       meta =
  78         if !outgoing_blocks do
  79           Keyword.put(meta, :do_not_federate, true)
  80         else
  81           meta
  82         end
  83
  84       {:ok, block_activity, meta}
  85     end
  86   end
  87
  88   def validate(%{"type" => "Update"} = update_activity, meta) do
  89     with {:ok, update_activity} <-
  90            update_activity
  91            |> UpdateValidator.cast_and_validate()
  92            |> Ecto.Changeset.apply_action(:insert) do
  93       update_activity = stringify_keys(update_activity)
  94       {:ok, update_activity, meta}
  95     end
  96   end
  97
  98   def validate(%{"type" => "Undo"} = object, meta) do
  99     with {:ok, object} <-
 100            object
 101            |> UndoValidator.cast_and_validate()
 102            |> Ecto.Changeset.apply_action(:insert) do
 103       object = stringify_keys(object)
 104       undone_object = Activity.get_by_ap_id(object["object"])
 105
 106       meta =
 107         meta
 108         |> Keyword.put(:object_data, undone_object.data)
 109
 110       {:ok, object, meta}
 111     end
 112   end
 113
 114   def validate(%{"type" => "Delete"} = object, meta) do
 115     with cng <- DeleteValidator.cast_and_validate(object),
 116          do_not_federate <- DeleteValidator.do_not_federate?(cng),
 117          {:ok, object} <- Ecto.Changeset.apply_action(cng, :insert) do
 118       object = stringify_keys(object)
 119       meta = Keyword.put(meta, :do_not_federate, do_not_federate)
 120       {:ok, object, meta}
 121     end
 122   end
 123
 124   def validate(%{"type" => "Like"} = object, meta) do
 125     with {:ok, object} <-
 126            object
 127            |> LikeValidator.cast_and_validate()
 128            |> Ecto.Changeset.apply_action(:insert) do
 129       object = stringify_keys(object)
 130       {:ok, object, meta}
 131     end
 132   end
 133
 134   def validate(%{"type" => "ChatMessage"} = object, meta) do
 135     with {:ok, object} <-
 136            object
 137            |> ChatMessageValidator.cast_and_validate()
 138            |> Ecto.Changeset.apply_action(:insert) do
 139       object = stringify_keys(object)
 140       {:ok, object, meta}
 141     end
 142   end
 143
 144   def validate(%{"type" => "Question"} = object, meta) do
 145     with {:ok, object} <-
 146            object
 147            |> QuestionValidator.cast_and_validate()
 148            |> Ecto.Changeset.apply_action(:insert) do
 149       object = stringify_keys(object)
 150       {:ok, object, meta}
 151     end
 152   end
 153
 154   def validate(%{"type" => type} = object, meta) when type in ~w[Audio Video] do
 155     with {:ok, object} <-
 156            object
 157            |> AudioVideoValidator.cast_and_validate()
 158            |> Ecto.Changeset.apply_action(:insert) do
 159       object = stringify_keys(object)
 160       {:ok, object, meta}
 161     end
 162   end
 163
 164   def validate(%{"type" => "Article"} = object, meta) do
 165     with {:ok, object} <-
 166            object
 167            |> ArticleNoteValidator.cast_and_validate()
 168            |> Ecto.Changeset.apply_action(:insert) do
 169       object = stringify_keys(object)
 170       {:ok, object, meta}
 171     end
 172   end
 173
 174   def validate(%{"type" => "Answer"} = object, meta) do
 175     with {:ok, object} <-
 176            object
 177            |> AnswerValidator.cast_and_validate()
 178            |> Ecto.Changeset.apply_action(:insert) do
 179       object = stringify_keys(object)
 180       {:ok, object, meta}
 181     end
 182   end
 183
 184   def validate(%{"type" => "EmojiReact"} = object, meta) do
 185     with {:ok, object} <-
 186            object
 187            |> EmojiReactValidator.cast_and_validate()
 188            |> Ecto.Changeset.apply_action(:insert) do
 189       object = stringify_keys(object)
 190       {:ok, object, meta}
 191     end
 192   end
 193
 194   def validate(
 195         %{"type" => "Create", "object" => %{"type" => "ChatMessage"} = object} = create_activity,
 196         meta
 197       ) do
 198     with {:ok, object_data} <- cast_and_apply(object),
 199          meta = Keyword.put(meta, :object_data, object_data |> stringify_keys),
 200          {:ok, create_activity} <-
 201            create_activity
 202            |> CreateChatMessageValidator.cast_and_validate(meta)
 203            |> Ecto.Changeset.apply_action(:insert) do
 204       create_activity = stringify_keys(create_activity)
 205       {:ok, create_activity, meta}
 206     end
 207   end
 208
 209   def validate(
 210         %{"type" => "Create", "object" => %{"type" => objtype} = object} = create_activity,
 211         meta
 212       )
 213       when objtype in ~w[Question Answer Audio Video Event Article] do
 214     with {:ok, object_data} <- cast_and_apply(object),
 215          meta = Keyword.put(meta, :object_data, object_data |> stringify_keys),
 216          {:ok, create_activity} <-
 217            create_activity
 218            |> CreateGenericValidator.cast_and_validate(meta)
 219            |> Ecto.Changeset.apply_action(:insert) do
 220       create_activity = stringify_keys(create_activity)
 221       {:ok, create_activity, meta}
 222     end
 223   end
 224
 225   def validate(%{"type" => "Announce"} = object, meta) do
 226     with {:ok, object} <-
 227            object
 228            |> AnnounceValidator.cast_and_validate()
 229            |> Ecto.Changeset.apply_action(:insert) do
 230       object = stringify_keys(object)
 231       {:ok, object, meta}
 232     end
 233   end
 234
 235   def cast_and_apply(%{"type" => "ChatMessage"} = object) do
 236     ChatMessageValidator.cast_and_apply(object)
 237   end
 238
 239   def cast_and_apply(%{"type" => "Question"} = object) do
 240     QuestionValidator.cast_and_apply(object)
 241   end
 242
 243   def cast_and_apply(%{"type" => "Answer"} = object) do
 244     AnswerValidator.cast_and_apply(object)
 245   end
 246
 247   def cast_and_apply(%{"type" => type} = object) when type in ~w[Audio Video] do
 248     AudioVideoValidator.cast_and_apply(object)
 249   end
 250
 251   def cast_and_apply(%{"type" => "Event"} = object) do
 252     EventValidator.cast_and_apply(object)
 253   end
 254
 255   def cast_and_apply(%{"type" => "Article"} = object) do
 256     ArticleNoteValidator.cast_and_apply(object)
 257   end
 258
 259   def cast_and_apply(o), do: {:error, {:validator_not_set, o}}
 260
 261   # is_struct/1 isn't present in Elixir 1.8.x
 262   def stringify_keys(%{__struct__: _} = object) do
 263     object
 264     |> Map.from_struct()
 265     |> stringify_keys
 266   end
 267
 268   def stringify_keys(object) when is_map(object) do
 269     object
 270     |> Map.new(fn {key, val} -> {to_string(key), stringify_keys(val)} end)
 271   end
 272
 273   def stringify_keys(object) when is_list(object) do
 274     object
 275     |> Enum.map(&stringify_keys/1)
 276   end
 277
 278   def stringify_keys(object), do: object
 279
 280   def fetch_actor(object) do
 281     with actor <- Containment.get_actor(object),
 282          {:ok, actor} <- ObjectValidators.ObjectID.cast(actor) do
 283       User.get_or_fetch_by_ap_id(actor)
 284     end
 285   end
 286
 287   def fetch_actor_and_object(object) do
 288     fetch_actor(object)
 289     Object.normalize(object["object"], true)
 290     :ok
 291   end
 292 end