git.squeep.com Git - akkoma/blob - lib/pleroma/web/web_finger/web_finger.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.WebFinger do
   6   @httpoison Application.get_env(:pleroma, :httpoison)
   7
   8   alias Pleroma.User
   9   alias Pleroma.Web
  10   alias Pleroma.Web.Federator.Publisher
  11   alias Pleroma.Web.Salmon
  12   alias Pleroma.Web.XML
  13   alias Pleroma.XmlBuilder
  14   require Jason
  15   require Logger
  16
  17   def host_meta do
  18     base_url = Web.base_url()
  19
  20     {
  21       :XRD,
  22       %{xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0"},
  23       {
  24         :Link,
  25         %{
  26           rel: "lrdd",
  27           type: "application/xrd+xml",
  28           template: "#{base_url}/.well-known/webfinger?resource={uri}"
  29         }
  30       }
  31     }
  32     |> XmlBuilder.to_doc()
  33   end
  34
  35   def webfinger(resource, fmt) when fmt in ["XML", "JSON"] do
  36     host = Pleroma.Web.Endpoint.host()
  37     regex = ~r/(acct:)?(?<username>\w+)@#{host}/
  38
  39     with %{"username" => username} <- Regex.named_captures(regex, resource),
  40          %User{} = user <- User.get_cached_by_nickname(username) do
  41       {:ok, represent_user(user, fmt)}
  42     else
  43       _e ->
  44         with %User{} = user <- User.get_cached_by_ap_id(resource) do
  45           {:ok, represent_user(user, fmt)}
  46         else
  47           _e ->
  48             {:error, "Couldn't find user"}
  49         end
  50     end
  51   end
  52
  53   defp gather_links(%User{} = user) do
  54     [
  55       %{
  56         "rel" => "http://webfinger.net/rel/profile-page",
  57         "type" => "text/html",
  58         "href" => user.ap_id
  59       }
  60     ] ++ Publisher.gather_webfinger_links(user)
  61   end
  62
  63   def represent_user(user, "JSON") do
  64     {:ok, user} = ensure_keys_present(user)
  65
  66     %{
  67       "subject" => "acct:#{user.nickname}@#{Pleroma.Web.Endpoint.host()}",
  68       "aliases" => [user.ap_id],
  69       "links" => gather_links(user)
  70     }
  71   end
  72
  73   def represent_user(user, "XML") do
  74     {:ok, user} = ensure_keys_present(user)
  75
  76     links =
  77       gather_links(user)
  78       |> Enum.map(fn link -> {:Link, link} end)
  79
  80     {
  81       :XRD,
  82       %{xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0"},
  83       [
  84         {:Subject, "acct:#{user.nickname}@#{Pleroma.Web.Endpoint.host()}"},
  85         {:Alias, user.ap_id}
  86       ] ++ links
  87     }
  88     |> XmlBuilder.to_doc()
  89   end
  90
  91   # This seems a better fit in Salmon
  92   def ensure_keys_present(user) do
  93     info = user.info
  94
  95     if info.keys do
  96       {:ok, user}
  97     else
  98       {:ok, pem} = Salmon.generate_rsa_pem()
  99
 100       info_cng =
 101         info
 102         |> Pleroma.User.Info.set_keys(pem)
 103
 104       cng =
 105         Ecto.Changeset.change(user)
 106         |> Ecto.Changeset.put_embed(:info, info_cng)
 107
 108       User.update_and_set_cache(cng)
 109     end
 110   end
 111
 112   defp get_magic_key(magic_key) do
 113     "data:application/magic-public-key," <> magic_key = magic_key
 114     {:ok, magic_key}
 115   rescue
 116     MatchError -> {:error, "Missing magic key data."}
 117   end
 118
 119   defp webfinger_from_xml(doc) do
 120     with magic_key <- XML.string_from_xpath(~s{//Link[@rel="magic-public-key"]/@href}, doc),
 121          {:ok, magic_key} <- get_magic_key(magic_key),
 122          topic <-
 123            XML.string_from_xpath(
 124              ~s{//Link[@rel="http://schemas.google.com/g/2010#updates-from"]/@href},
 125              doc
 126            ),
 127          subject <- XML.string_from_xpath("//Subject", doc),
 128          salmon <- XML.string_from_xpath(~s{//Link[@rel="salmon"]/@href}, doc),
 129          subscribe_address <-
 130            XML.string_from_xpath(
 131              ~s{//Link[@rel="http://ostatus.org/schema/1.0/subscribe"]/@template},
 132              doc
 133            ),
 134          ap_id <-
 135            XML.string_from_xpath(
 136              ~s{//Link[@rel="self" and @type="application/activity+json"]/@href},
 137              doc
 138            ) do
 139       data = %{
 140         "magic_key" => magic_key,
 141         "topic" => topic,
 142         "subject" => subject,
 143         "salmon" => salmon,
 144         "subscribe_address" => subscribe_address,
 145         "ap_id" => ap_id
 146       }
 147
 148       {:ok, data}
 149     else
 150       {:error, e} ->
 151         {:error, e}
 152
 153       e ->
 154         {:error, e}
 155     end
 156   end
 157
 158   defp webfinger_from_json(doc) do
 159     data =
 160       Enum.reduce(doc["links"], %{"subject" => doc["subject"]}, fn link, data ->
 161         case {link["type"], link["rel"]} do
 162           {"application/activity+json", "self"} ->
 163             Map.put(data, "ap_id", link["href"])
 164
 165           {"application/ld+json; profile=\"https://www.w3.org/ns/activitystreams\"", "self"} ->
 166             Map.put(data, "ap_id", link["href"])
 167
 168           {_, "magic-public-key"} ->
 169             "data:application/magic-public-key," <> magic_key = link["href"]
 170             Map.put(data, "magic_key", magic_key)
 171
 172           {"application/atom+xml", "http://schemas.google.com/g/2010#updates-from"} ->
 173             Map.put(data, "topic", link["href"])
 174
 175           {_, "salmon"} ->
 176             Map.put(data, "salmon", link["href"])
 177
 178           {_, "http://ostatus.org/schema/1.0/subscribe"} ->
 179             Map.put(data, "subscribe_address", link["template"])
 180
 181           _ ->
 182             Logger.debug("Unhandled type: #{inspect(link["type"])}")
 183             data
 184         end
 185       end)
 186
 187     {:ok, data}
 188   end
 189
 190   def get_template_from_xml(body) do
 191     xpath = "//Link[@rel='lrdd']/@template"
 192
 193     with doc when doc != :error <- XML.parse_document(body),
 194          template when template != nil <- XML.string_from_xpath(xpath, doc) do
 195       {:ok, template}
 196     end
 197   end
 198
 199   def find_lrdd_template(domain) do
 200     with {:ok, %{status: status, body: body}} when status in 200..299 <-
 201            @httpoison.get("http://#{domain}/.well-known/host-meta", []) do
 202       get_template_from_xml(body)
 203     else
 204       _ ->
 205         with {:ok, %{body: body}} <- @httpoison.get("https://#{domain}/.well-known/host-meta", []) do
 206           get_template_from_xml(body)
 207         else
 208           e -> {:error, "Can't find LRDD template: #{inspect(e)}"}
 209         end
 210     end
 211   end
 212
 213   def finger(account) do
 214     account = String.trim_leading(account, "@")
 215
 216     domain =
 217       with [_name, domain] <- String.split(account, "@") do
 218         domain
 219       else
 220         _e ->
 221           URI.parse(account).host
 222       end
 223
 224     address =
 225       case find_lrdd_template(domain) do
 226         {:ok, template} ->
 227           String.replace(template, "{uri}", URI.encode(account))
 228
 229         _ ->
 230           "https://#{domain}/.well-known/webfinger?resource=acct:#{account}"
 231       end
 232
 233     with response <-
 234            @httpoison.get(
 235              address,
 236              Accept: "application/xrd+xml,application/jrd+json"
 237            ),
 238          {:ok, %{status: status, body: body}} when status in 200..299 <- response do
 239       doc = XML.parse_document(body)
 240
 241       if doc != :error do
 242         webfinger_from_xml(doc)
 243       else
 244         with {:ok, doc} <- Jason.decode(body) do
 245           webfinger_from_json(doc)
 246         else
 247           {:error, e} -> e
 248         end
 249       end
 250     else
 251       e ->
 252         Logger.debug(fn -> "Couldn't finger #{account}" end)
 253         Logger.debug(fn -> inspect(e) end)
 254         {:error, e}
 255     end
 256   end
 257 end