Merge branch 'develop' into refactor/gun-pool-registry
[akkoma] / lib / pleroma / web / activity_pub / publisher.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.Publisher do
6 alias Pleroma.Activity
7 alias Pleroma.Config
8 alias Pleroma.Delivery
9 alias Pleroma.HTTP
10 alias Pleroma.Instances
11 alias Pleroma.Object
12 alias Pleroma.Repo
13 alias Pleroma.User
14 alias Pleroma.Web.ActivityPub.Relay
15 alias Pleroma.Web.ActivityPub.Transmogrifier
16
17 require Pleroma.Constants
18
19 import Pleroma.Web.ActivityPub.Visibility
20
21 @behaviour Pleroma.Web.Federator.Publisher
22
23 require Logger
24
25 @moduledoc """
26 ActivityPub outgoing federation module.
27 """
28
29 @doc """
30 Determine if an activity can be represented by running it through Transmogrifier.
31 """
32 def is_representable?(%Activity{} = activity) do
33 with {:ok, _data} <- Transmogrifier.prepare_outgoing(activity.data) do
34 true
35 else
36 _e ->
37 false
38 end
39 end
40
41 @doc """
42 Publish a single message to a peer. Takes a struct with the following
43 parameters set:
44
45 * `inbox`: the inbox to publish to
46 * `json`: the JSON message body representing the ActivityPub message
47 * `actor`: the actor which is signing the message
48 * `id`: the ActivityStreams URI of the message
49 """
50 def publish_one(%{inbox: inbox, json: json, actor: %User{} = actor, id: id} = params) do
51 Logger.debug("Federating #{id} to #{inbox}")
52
53 uri = URI.parse(inbox)
54
55 digest = "SHA-256=" <> (:crypto.hash(:sha256, json) |> Base.encode64())
56
57 date = Pleroma.Signature.signed_date()
58
59 signature =
60 Pleroma.Signature.sign(actor, %{
61 "(request-target)": "post #{uri.path}",
62 host: signature_host(uri),
63 "content-length": byte_size(json),
64 digest: digest,
65 date: date
66 })
67
68 with {:ok, %{status: code}} when code in 200..299 <-
69 result =
70 HTTP.post(
71 inbox,
72 json,
73 [
74 {"Content-Type", "application/activity+json"},
75 {"Date", date},
76 {"signature", signature},
77 {"digest", digest}
78 ]
79 ) do
80 if not Map.has_key?(params, :unreachable_since) || params[:unreachable_since] do
81 Instances.set_reachable(inbox)
82 end
83
84 result
85 else
86 {_post_result, response} ->
87 unless params[:unreachable_since], do: Instances.set_unreachable(inbox)
88 {:error, response}
89 end
90 end
91
92 def publish_one(%{actor_id: actor_id} = params) do
93 actor = User.get_cached_by_id(actor_id)
94
95 params
96 |> Map.delete(:actor_id)
97 |> Map.put(:actor, actor)
98 |> publish_one()
99 end
100
101 defp signature_host(%URI{port: port, scheme: scheme, host: host}) do
102 if port == URI.default_port(scheme) do
103 host
104 else
105 "#{host}:#{port}"
106 end
107 end
108
109 defp should_federate?(inbox, public) do
110 if public do
111 true
112 else
113 %{host: host} = URI.parse(inbox)
114
115 quarantined_instances =
116 Config.get([:instance, :quarantined_instances], [])
117 |> Pleroma.Web.ActivityPub.MRF.subdomains_regex()
118
119 !Pleroma.Web.ActivityPub.MRF.subdomain_match?(quarantined_instances, host)
120 end
121 end
122
123 @spec recipients(User.t(), Activity.t()) :: list(User.t()) | []
124 defp recipients(actor, activity) do
125 followers =
126 if actor.follower_address in activity.recipients do
127 User.get_external_followers(actor)
128 else
129 []
130 end
131
132 fetchers =
133 with %Activity{data: %{"type" => "Delete"}} <- activity,
134 %Object{id: object_id} <- Object.normalize(activity),
135 fetchers <- User.get_delivered_users_by_object_id(object_id),
136 _ <- Delivery.delete_all_by_object_id(object_id) do
137 fetchers
138 else
139 _ ->
140 []
141 end
142
143 Pleroma.Web.Federator.Publisher.remote_users(actor, activity) ++ followers ++ fetchers
144 end
145
146 defp get_cc_ap_ids(ap_id, recipients) do
147 host = Map.get(URI.parse(ap_id), :host)
148
149 recipients
150 |> Enum.filter(fn %User{ap_id: ap_id} -> Map.get(URI.parse(ap_id), :host) == host end)
151 |> Enum.map(& &1.ap_id)
152 end
153
154 defp maybe_use_sharedinbox(%User{shared_inbox: nil, inbox: inbox}), do: inbox
155 defp maybe_use_sharedinbox(%User{shared_inbox: shared_inbox}), do: shared_inbox
156
157 @doc """
158 Determine a user inbox to use based on heuristics. These heuristics
159 are based on an approximation of the ``sharedInbox`` rules in the
160 [ActivityPub specification][ap-sharedinbox].
161
162 Please do not edit this function (or its children) without reading
163 the spec, as editing the code is likely to introduce some breakage
164 without some familiarity.
165
166 [ap-sharedinbox]: https://www.w3.org/TR/activitypub/#shared-inbox-delivery
167 """
168 def determine_inbox(
169 %Activity{data: activity_data},
170 %User{inbox: inbox} = user
171 ) do
172 to = activity_data["to"] || []
173 cc = activity_data["cc"] || []
174 type = activity_data["type"]
175
176 cond do
177 type == "Delete" ->
178 maybe_use_sharedinbox(user)
179
180 Pleroma.Constants.as_public() in to || Pleroma.Constants.as_public() in cc ->
181 maybe_use_sharedinbox(user)
182
183 length(to) + length(cc) > 1 ->
184 maybe_use_sharedinbox(user)
185
186 true ->
187 inbox
188 end
189 end
190
191 @doc """
192 Publishes an activity with BCC to all relevant peers.
193 """
194
195 def publish(%User{} = actor, %{data: %{"bcc" => bcc}} = activity)
196 when is_list(bcc) and bcc != [] do
197 public = is_public?(activity)
198 {:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
199
200 recipients = recipients(actor, activity)
201
202 inboxes =
203 recipients
204 |> Enum.filter(&User.ap_enabled?/1)
205 |> Enum.map(fn actor -> actor.inbox end)
206 |> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
207 |> Instances.filter_reachable()
208
209 Repo.checkout(fn ->
210 Enum.each(inboxes, fn {inbox, unreachable_since} ->
211 %User{ap_id: ap_id} = Enum.find(recipients, fn actor -> actor.inbox == inbox end)
212
213 # Get all the recipients on the same host and add them to cc. Otherwise, a remote
214 # instance would only accept a first message for the first recipient and ignore the rest.
215 cc = get_cc_ap_ids(ap_id, recipients)
216
217 json =
218 data
219 |> Map.put("cc", cc)
220 |> Jason.encode!()
221
222 Pleroma.Web.Federator.Publisher.enqueue_one(__MODULE__, %{
223 inbox: inbox,
224 json: json,
225 actor_id: actor.id,
226 id: activity.data["id"],
227 unreachable_since: unreachable_since
228 })
229 end)
230 end)
231 end
232
233 @doc """
234 Publishes an activity to all relevant peers.
235 """
236 def publish(%User{} = actor, %Activity{} = activity) do
237 public = is_public?(activity)
238
239 if public && Config.get([:instance, :allow_relay]) do
240 Logger.debug(fn -> "Relaying #{activity.data["id"]} out" end)
241 Relay.publish(activity)
242 end
243
244 {:ok, data} = Transmogrifier.prepare_outgoing(activity.data)
245 json = Jason.encode!(data)
246
247 recipients(actor, activity)
248 |> Enum.filter(fn user -> User.ap_enabled?(user) end)
249 |> Enum.map(fn %User{} = user ->
250 determine_inbox(activity, user)
251 end)
252 |> Enum.uniq()
253 |> Enum.filter(fn inbox -> should_federate?(inbox, public) end)
254 |> Instances.filter_reachable()
255 |> Enum.each(fn {inbox, unreachable_since} ->
256 Pleroma.Web.Federator.Publisher.enqueue_one(
257 __MODULE__,
258 %{
259 inbox: inbox,
260 json: json,
261 actor_id: actor.id,
262 id: activity.data["id"],
263 unreachable_since: unreachable_since
264 }
265 )
266 end)
267 end
268
269 def gather_webfinger_links(%User{} = user) do
270 [
271 %{"rel" => "self", "type" => "application/activity+json", "href" => user.ap_id},
272 %{
273 "rel" => "self",
274 "type" => "application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"",
275 "href" => user.ap_id
276 },
277 %{
278 "rel" => "http://ostatus.org/schema/1.0/subscribe",
279 "template" => "#{Pleroma.Web.base_url()}/ostatus_subscribe?acct={uri}"
280 }
281 ]
282 end
283
284 def gather_nodeinfo_protocol_names, do: ["activitypub"]
285 end