Git of dcc - anni/blob - lib/pleroma/web/activity_pub/object_validators/common_validations.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2022 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.ActivityPub.ObjectValidators.CommonValidations do
   6   import Ecto.Changeset
   7
   8   alias Pleroma.Activity
   9   alias Pleroma.Object
  10   alias Pleroma.User
  11
  12   @spec validate_any_presence(Ecto.Changeset.t(), [atom()]) :: Ecto.Changeset.t()
  13   def validate_any_presence(cng, fields) do
  14     non_empty =
  15       fields
  16       |> Enum.map(fn field -> get_field(cng, field) end)
  17       |> Enum.any?(fn
  18         nil -> false
  19         [] -> false
  20         _ -> true
  21       end)
  22
  23     if non_empty do
  24       cng
  25     else
  26       fields
  27       |> Enum.reduce(cng, fn field, cng ->
  28         cng
  29         |> add_error(field, "none of #{inspect(fields)} present")
  30       end)
  31     end
  32   end
  33
  34   @spec validate_actor_presence(Ecto.Changeset.t(), keyword()) :: Ecto.Changeset.t()
  35   def validate_actor_presence(cng, options \\ []) do
  36     field_name = Keyword.get(options, :field_name, :actor)
  37
  38     cng
  39     |> validate_change(field_name, fn field_name, actor ->
  40       case User.get_cached_by_ap_id(actor) do
  41         %User{is_active: false} ->
  42           [{field_name, "user is deactivated"}]
  43
  44         %User{} ->
  45           []
  46
  47         _ ->
  48           [{field_name, "can't find user"}]
  49       end
  50     end)
  51   end
  52
  53   @spec validate_object_presence(Ecto.Changeset.t(), keyword()) :: Ecto.Changeset.t()
  54   def validate_object_presence(cng, options \\ []) do
  55     field_name = Keyword.get(options, :field_name, :object)
  56     allowed_types = Keyword.get(options, :allowed_types, false)
  57
  58     cng
  59     |> validate_change(field_name, fn field_name, object_id ->
  60       object = Object.get_cached_by_ap_id(object_id) || Activity.get_by_ap_id(object_id)
  61
  62       cond do
  63         !object ->
  64           [{field_name, "can't find object"}]
  65
  66         object && allowed_types && object.data["type"] not in allowed_types ->
  67           [{field_name, "object not in allowed types"}]
  68
  69         true ->
  70           []
  71       end
  72     end)
  73   end
  74
  75   @spec validate_object_or_user_presence(Ecto.Changeset.t(), keyword()) :: Ecto.Changeset.t()
  76   def validate_object_or_user_presence(cng, options \\ []) do
  77     field_name = Keyword.get(options, :field_name, :object)
  78     options = Keyword.put(options, :field_name, field_name)
  79
  80     actor_cng =
  81       cng
  82       |> validate_actor_presence(options)
  83
  84     object_cng =
  85       cng
  86       |> validate_object_presence(options)
  87
  88     if actor_cng.valid?, do: actor_cng, else: object_cng
  89   end
  90
  91   @spec validate_host_match(Ecto.Changeset.t(), [atom()]) :: Ecto.Changeset.t()
  92   def validate_host_match(cng, fields \\ [:id, :actor]) do
  93     if same_domain?(cng, fields) do
  94       cng
  95     else
  96       fields
  97       |> Enum.reduce(cng, fn field, cng ->
  98         cng
  99         |> add_error(field, "hosts of #{inspect(fields)} aren't matching")
 100       end)
 101     end
 102   end
 103
 104   @spec validate_fields_match(Ecto.Changeset.t(), [atom()]) :: Ecto.Changeset.t()
 105   def validate_fields_match(cng, fields) do
 106     if map_unique?(cng, fields) do
 107       cng
 108     else
 109       fields
 110       |> Enum.reduce(cng, fn field, cng ->
 111         cng
 112         |> add_error(field, "Fields #{inspect(fields)} aren't matching")
 113       end)
 114     end
 115   end
 116
 117   defp map_unique?(cng, fields, func \\ & &1) do
 118     Enum.reduce_while(fields, nil, fn field, acc ->
 119       value =
 120         cng
 121         |> get_field(field)
 122         |> func.()
 123
 124       case {value, acc} do
 125         {value, nil} -> {:cont, value}
 126         {value, value} -> {:cont, value}
 127         _ -> {:halt, false}
 128       end
 129     end)
 130   end
 131
 132   @spec same_domain?(Ecto.Changeset.t(), [atom()]) :: boolean()
 133   def same_domain?(cng, fields \\ [:actor, :object]) do
 134     map_unique?(cng, fields, fn value -> URI.parse(value).host end)
 135   end
 136
 137   # This figures out if a user is able to create, delete or modify something
 138   # based on the domain and superuser status
 139   @spec validate_modification_rights(Ecto.Changeset.t(), atom()) :: Ecto.Changeset.t()
 140   def validate_modification_rights(cng, privilege) do
 141     actor = User.get_cached_by_ap_id(get_field(cng, :actor))
 142
 143     if User.privileged?(actor, privilege) || same_domain?(cng) do
 144       cng
 145     else
 146       cng
 147       |> add_error(:actor, "is not allowed to modify object")
 148     end
 149   end
 150 end