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