No OneTemporary
Actions

Size

58 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/lib/pleroma/web/ostatus/ostatus.ex b/lib/pleroma/web/ostatus/ostatus.ex
	index 7aa1ac4ac..f81751a25 100644
	--- a/lib/pleroma/web/ostatus/ostatus.ex
	+++ b/lib/pleroma/web/ostatus/ostatus.ex
	@@ -1,168 +1,189 @@
	defmodule Pleroma.Web.OStatus do
	import Ecto.Query
	import Pleroma.Web.XML
	require Logger

	alias Pleroma.{Repo, User, Web, Object}
	alias Pleroma.Web.ActivityPub.ActivityPub
	alias Pleroma.Web.{WebFinger, Websub}

	def feed_path(user) do
	"#{user.ap_id}/feed.atom"
	end

	def pubsub_path(user) do
	"#{Web.base_url}/push/hub/#{user.nickname}"
	end

	def salmon_path(user) do
	"#{user.ap_id}/salmon"
	end

	def handle_incoming(xml_string) do
	doc = parse_document(xml_string)
	entries = :xmerl_xpath.string('//entry', doc)

	activities = Enum.map(entries, fn (entry) ->
	{:xmlObj, :string, object_type } = :xmerl_xpath.string('string(/entry/activity:object-type[1])', entry)

	case object_type do
	'http://activitystrea.ms/schema/1.0/note' ->
	with {:ok, activity} <- handle_note(entry, doc), do: activity
	'http://activitystrea.ms/schema/1.0/comment' ->
	with {:ok, activity} <- handle_note(entry, doc), do: activity
	_ ->
	Logger.error("Couldn't parse incoming document")
	nil
	end
	end)
	{:ok, activities}
	end

	+ def get_attachments(entry) do
	+ :xmerl_xpath.string('/entry/link[@rel="enclosure"]', entry)
	+ \|> Enum.map(fn (enclosure) ->
	+ with href when not is_nil(href) <- string_from_xpath("/link/@href", enclosure),
	+ type when not is_nil(type) <- string_from_xpath("/link/@type", enclosure) do
	+ %{
	+ "type" => "Attachment",
	+ "url" => [%{
	+ "type" => "Link",
	+ "mediaType" => type,
	+ "href" => href
	+ }]
	+ }
	+ end
	+ end)
	+ \|> Enum.filter(&(&1))
	+ end
	+
	def handle_note(entry, doc \\ nil) do
	content_html = string_from_xpath("/entry/content[1]", entry)

	[author] = :xmerl_xpath.string('//author[1]', doc)
	{:ok, actor} = find_make_or_update_user(author)
	inReplyTo = string_from_xpath("/entry/thr:in-reply-to[1]/@ref", entry)

	context = (string_from_xpath("/entry/ostatus:conversation[1]", entry) \|\| "") \|> String.trim

	+ attachments = get_attachments(entry)
	+
	context = with %{data: %{"context" => context}} <- Object.get_cached_by_ap_id(inReplyTo) do
	context
	else _e ->
	if String.length(context) > 0 do
	context
	else
	ActivityPub.generate_context_id
	end
	end

	to = [
	"https://www.w3.org/ns/activitystreams#Public"
	]

	mentions = :xmerl_xpath.string('/entry/link[@rel="mentioned" and @ostatus:object-type="http://activitystrea.ms/schema/1.0/person"]', entry)
	\|> Enum.map(fn(person) -> string_from_xpath("@href", person) end)

	to = to ++ mentions

	date = string_from_xpath("/entry/published", entry)
	id = string_from_xpath("/entry/id", entry)

	object = %{
	"id" => id,
	"type" => "Note",
	"to" => to,
	"content" => content_html,
	"published" => date,
	"context" => context,
	- "actor" => actor.ap_id
	+ "actor" => actor.ap_id,
	+ "attachment" => attachments
	}

	object = if inReplyTo do
	Map.put(object, "inReplyTo", inReplyTo)
	else
	object
	end

	# TODO: Bail out sooner and use transaction.
	if Object.get_by_ap_id(id) do
	{:error, "duplicate activity"}
	else
	ActivityPub.create(to, actor, context, object, %{}, date, false)
	end
	end

	def find_make_or_update_user(doc) do
	uri = string_from_xpath("//author/uri[1]", doc)
	with {:ok, user} <- find_or_make_user(uri) do
	avatar = make_avatar_object(doc)
	if user.avatar != avatar do
	change = Ecto.Changeset.change(user, %{avatar: avatar})
	Repo.update(change)
	else
	{:ok, user}
	end
	end
	end

	def find_or_make_user(uri) do
	query = from user in User,
	where: user.local == false and fragment("? @> ?", user.info, ^%{uri: uri})

	user = Repo.one(query)

	if is_nil(user) do
	make_user(uri)
	else
	{:ok, user}
	end
	end

	def make_user(uri) do
	with {:ok, info} <- gather_user_info(uri) do
	data = %{
	local: false,
	- name: info.name,
	- nickname: info.nickname <> "@" <> info.host,
	- ap_id: info.uri,
	+ name: info["name"],
	+ nickname: info["nickname"] <> "@" <> info["host"],
	+ ap_id: info["uri"],
	info: info,
	- avatar: info.avatar
	+ avatar: info["avatar"]
	}
	# TODO: Make remote user changeset
	# SHould enforce fqn nickname
	Repo.insert(Ecto.Changeset.change(%User{}, data))
	end
	end

	# TODO: Just takes the first one for now.
	def make_avatar_object(author_doc) do
	href = string_from_xpath("//author[1]/link[@rel=\"avatar\"]/@href", author_doc)
	type = string_from_xpath("//author[1]/link[@rel=\"avatar\"]/@type", author_doc)

	if href do
	%{
	"type" => "Image",
	"url" =>
	[%{
	"type" => "Link",
	"mediaType" => type,
	"href" => href
	}]
	}
	else
	nil
	end
	end

	def gather_user_info(username) do
	with {:ok, webfinger_data} <- WebFinger.finger(username),
	- {:ok, feed_data} <- Websub.gather_feed_data(webfinger_data.topic) do
	- {:ok, Map.merge(webfinger_data, feed_data) \|> Map.put(:fqn, username)}
	+ {:ok, feed_data} <- Websub.gather_feed_data(webfinger_data["topic"]) do
	+ {:ok, Map.merge(webfinger_data, feed_data) \|> Map.put("fqn", username)}
	else e ->
	Logger.debug("Couldn't gather info for #{username}")
	{:error, e}
	end
	end
	end
	diff --git a/lib/pleroma/web/ostatus/ostatus_controller.ex b/lib/pleroma/web/ostatus/ostatus_controller.ex
	index c6700ae78..1f2dedd30 100644
	--- a/lib/pleroma/web/ostatus/ostatus_controller.ex
	+++ b/lib/pleroma/web/ostatus/ostatus_controller.ex
	@@ -1,59 +1,59 @@
	defmodule Pleroma.Web.OStatus.OStatusController do
	use Pleroma.Web, :controller

	alias Pleroma.{User, Activity}
	alias Pleroma.Web.OStatus.{FeedRepresenter, ActivityRepresenter}
	alias Pleroma.Repo
	alias Pleroma.Web.OStatus
	import Ecto.Query

	def feed_redirect(conn, %{"nickname" => nickname}) do
	user = User.get_cached_by_nickname(nickname)
	redirect conn, external: OStatus.feed_path(user)
	end

	def feed(conn, %{"nickname" => nickname}) do
	user = User.get_cached_by_nickname(nickname)
	query = from activity in Activity,
	where: fragment("? @> ?", activity.data, ^%{actor: user.ap_id}),
	limit: 20,
	order_by: [desc: :inserted_at]

	activities = query
	\|> Repo.all

	response = FeedRepresenter.to_simple_form(user, activities, [user])
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

	conn
	\|> put_resp_content_type("application/atom+xml")
	\|> send_resp(200, response)
	end

	def salmon_incoming(conn, params) do
	{:ok, body, _conn} = read_body(conn)
	- magic_key = Pleroma.Web.Salmon.fetch_magic_key(body)
	+ {:ok, magic_key} = Pleroma.Web.Salmon.fetch_magic_key(body)
	{:ok, doc} = Pleroma.Web.Salmon.decode_and_validate(magic_key, body)

	Pleroma.Web.OStatus.handle_incoming(doc)

	conn
	\|> send_resp(200, "")
	end

	def object(conn, %{"uuid" => uuid}) do
	id = o_status_url(conn, :object, uuid)
	activity = Activity.get_create_activity_by_object_ap_id(id)
	user = User.get_cached_by_ap_id(activity.data["actor"])

	response = ActivityRepresenter.to_simple_form(activity, user, true)
	\|> ActivityRepresenter.wrap_with_entry
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

	conn
	\|> put_resp_content_type("application/atom+xml")
	\|> send_resp(200, response)
	end
	end
	diff --git a/lib/pleroma/web/salmon/salmon.ex b/lib/pleroma/web/salmon/salmon.ex
	index b4f214d46..f02cb11dc 100644
	--- a/lib/pleroma/web/salmon/salmon.ex
	+++ b/lib/pleroma/web/salmon/salmon.ex
	@@ -1,157 +1,154 @@
	defmodule Pleroma.Web.Salmon do
	use Bitwise
	alias Pleroma.Web.XML
	alias Pleroma.Web.OStatus.ActivityRepresenter
	alias Pleroma.User
	require Logger

	def decode(salmon) do
	doc = XML.parse_document(salmon)

	{:xmlObj, :string, data} = :xmerl_xpath.string('string(//me:data[1])', doc)
	{:xmlObj, :string, sig} = :xmerl_xpath.string('string(//me:sig[1])', doc)
	{:xmlObj, :string, alg} = :xmerl_xpath.string('string(//me:alg[1])', doc)
	{:xmlObj, :string, encoding} = :xmerl_xpath.string('string(//me:encoding[1])', doc)
	{:xmlObj, :string, type} = :xmerl_xpath.string('string(//me:data[1]/@type)', doc)


	{:ok, data} = Base.url_decode64(to_string(data), ignore: :whitespace)
	{:ok, sig} = Base.url_decode64(to_string(sig), ignore: :whitespace)
	alg = to_string(alg)
	encoding = to_string(encoding)
	type = to_string(type)

	[data, type, encoding, alg, sig]
	end

	- # TODO rewrite in with-stile
	- # Make it fetch the key from the saved user if there is one
	def fetch_magic_key(salmon) do
	- [data, _, _, _, _] = decode(salmon)
	- doc = XML.parse_document(data)
	- uri = XML.string_from_xpath("/entry/author[1]/uri", doc)
	-
	- {:ok, info} = Pleroma.Web.OStatus.gather_user_info(uri)
	-
	- info.magic_key
	+ with [data, _, _, _, _] <- decode(salmon),
	+ doc <- XML.parse_document(data),
	+ uri when not is_nil(uri) <- XML.string_from_xpath("/entry/author[1]/uri", doc),
	+ {:ok, %{info: %{"magic_key" => magic_key}}} <- Pleroma.Web.OStatus.find_or_make_user(uri) do
	+ {:ok, magic_key}
	+ end
	end

	def decode_and_validate(magickey, salmon) do
	[data, type, encoding, alg, sig] = decode(salmon)

	signed_text = [data, type, encoding, alg]
	\|> Enum.map(&Base.url_encode64/1)
	\|> Enum.join(".")

	key = decode_key(magickey)

	verify = :public_key.verify(signed_text, :sha256, sig, key)

	if verify do
	{:ok, data}
	else
	:error
	end
	end

	def decode_key("RSA." <> magickey) do
	make_integer = fn(bin) ->
	list = :erlang.binary_to_list(bin)
	Enum.reduce(list, 0, fn (el, acc) -> (acc <<< 8) \|\|\| el end)
	end

	[modulus, exponent] = magickey
	\|> String.split(".")
	\|> Enum.map(&Base.url_decode64!/1)
	\|> Enum.map(make_integer)

	{:RSAPublicKey, modulus, exponent}
	end

	def encode_key({:RSAPublicKey, modulus, exponent}) do
	modulus_enc = :binary.encode_unsigned(modulus) \|> Base.url_encode64
	exponent_enc = :binary.encode_unsigned(exponent) \|> Base.url_encode64

	"RSA.#{modulus_enc}.#{exponent_enc}"
	end

	def generate_rsa_pem do
	port = Port.open({:spawn, "openssl genrsa"}, [:binary])
	{:ok, pem} = receive do
	{^port, {:data, pem}} -> {:ok, pem}
	end
	Port.close(port)
	if Regex.match?(~r/RSA PRIVATE KEY/, pem) do
	{:ok, pem}
	else
	:error
	end
	end

	def keys_from_pem(pem) do
	[private_key_code] = :public_key.pem_decode(pem)
	private_key = :public_key.pem_entry_decode(private_key_code)
	{:RSAPrivateKey, _, modulus, exponent, _, _, _, _, _, _, _} = private_key
	public_key = {:RSAPublicKey, modulus, exponent}
	{:ok, private_key, public_key}
	end

	def encode(private_key, doc) do
	type = "application/atom+xml"
	encoding = "base64url"
	alg = "RSA-SHA256"

	signed_text = [doc, type, encoding, alg]
	\|> Enum.map(&Base.url_encode64/1)
	\|> Enum.join(".")

	signature = :public_key.sign(signed_text, :sha256, private_key) \|> to_string \|> Base.url_encode64
	doc_base64= doc \|> Base.url_encode64

	# Don't need proper xml building, these strings are safe to leave unescaped
	salmon = """
	<?xml version="1.0" encoding="UTF-8"?>
	<me:env xmlns:me="http://salmon-protocol.org/ns/magic-env">
	<me:data type="application/atom+xml">#{doc_base64}</me:data>
	<me:encoding>#{encoding}</me:encoding>
	<me:alg>#{alg}</me:alg>
	<me:sig>#{signature}</me:sig>
	</me:env>
	"""

	{:ok, salmon}
	end

	def remote_users(%{data: %{"to" => to}}) do
	to
	\|> Enum.map(fn(id) -> User.get_cached_by_ap_id(id) end)
	\|> Enum.filter(fn(user) -> user && !user.local end)
	end

	defp send_to_user(%{info: %{"salmon" => salmon}}, feed, poster) do
	poster.(salmon, feed, [{"Content-Type", "application/magic-envelope+xml"}])
	end

	defp send_to_user(_,_,_), do: nil

	def publish(user, activity, poster \\ &HTTPoison.post/3)
	def publish(%{info: %{"keys" => keys}} = user, activity, poster) do
	feed = ActivityRepresenter.to_simple_form(activity, user, true)
	\|> ActivityRepresenter.wrap_with_entry
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

	if feed do
	{:ok, private, _} = keys_from_pem(keys)
	{:ok, feed} = encode(private, feed)

	remote_users(activity)
	\|> Enum.each(fn(remote_user) ->
	Logger.debug("sending salmon to #{remote_user.ap_id}")
	send_to_user(remote_user, feed, poster)
	end)
	end
	end

	def publish(%{id: id}, _, _), do: Logger.debug("Keys missing for user #{id}")
	end
	diff --git a/lib/pleroma/web/web.ex b/lib/pleroma/web/web.ex
	index a81e3e6e1..ee7ee78e9 100644
	--- a/lib/pleroma/web/web.ex
	+++ b/lib/pleroma/web/web.ex
	@@ -1,87 +1,67 @@
	defmodule Pleroma.Web do
	@moduledoc """
	A module that keeps using definitions for controllers,
	views and so on.

	This can be used in your application as:

	use Pleroma.Web, :controller
	use Pleroma.Web, :view

	The definitions below will be executed for every view,
	controller, etc, so keep them short and clean, focused
	on imports, uses and aliases.

	Do NOT define functions inside the quoted expressions
	below.
	"""

	def controller do
	quote do
	use Phoenix.Controller, namespace: Pleroma.Web
	import Plug.Conn
	import Pleroma.Web.Router.Helpers
	import Pleroma.Web.Gettext
	end
	end

	def view do
	quote do
	use Phoenix.View, root: "lib/pleroma/web/templates",
	namespace: Pleroma.Web

	# Import convenience functions from controllers
	import Phoenix.Controller, only: [get_csrf_token: 0, get_flash: 2, view_module: 1]

	import Pleroma.Web.Router.Helpers
	import Pleroma.Web.ErrorHelpers
	import Pleroma.Web.Gettext
	end
	end

	def router do
	quote do
	use Phoenix.Router
	import Plug.Conn
	import Phoenix.Controller
	end
	end

	def channel do
	quote do
	use Phoenix.Channel
	import Pleroma.Web.Gettext
	end
	end

	@doc """
	When used, dispatch to the appropriate controller/view/etc.
	"""
	defmacro __using__(which) when is_atom(which) do
	apply(__MODULE__, which, [])
	end

	- def host do
	- settings = Application.get_env(:pleroma, Pleroma.Web.Endpoint)
	- settings
	- \|> Keyword.fetch!(:url)
	- \|> Keyword.fetch!(:host)
	- end
	-
	def base_url do
	- settings = Application.get_env(:pleroma, Pleroma.Web.Endpoint)
	-
	- host = host()
	-
	- protocol = settings \|> Keyword.fetch!(:protocol)
	-
	- port_fragment = with {:ok, protocol_info} <- settings \|> Keyword.fetch(String.to_atom(protocol)),
	- {:ok, port} <- protocol_info \|> Keyword.fetch(:port)
	- do
	- ":#{port}"
	- else _e ->
	- ""
	- end
	- "#{protocol}://#{host}#{port_fragment}"
	+ Pleroma.Web.Endpoint.url
	end
	end
	diff --git a/lib/pleroma/web/web_finger/web_finger.ex b/lib/pleroma/web/web_finger/web_finger.ex
	index d16bdd982..5fa69c2c8 100644
	--- a/lib/pleroma/web/web_finger/web_finger.ex
	+++ b/lib/pleroma/web/web_finger/web_finger.ex
	@@ -1,109 +1,109 @@
	defmodule Pleroma.Web.WebFinger do
	alias Pleroma.XmlBuilder
	alias Pleroma.{Repo, User}
	alias Pleroma.Web.{XML, Salmon, OStatus}
	require Logger

	def host_meta() do
	base_url = Pleroma.Web.base_url
	{
	:XRD, %{ xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0" },
	{
	:Link, %{ rel: "lrdd", type: "application/xrd+xml", template: "#{base_url}/.well-known/webfinger?resource={uri}" }
	}
	}
	\|> XmlBuilder.to_doc
	end

	def webfinger(resource) do
	- host = Pleroma.Web.host
	+ host = Pleroma.Web.Endpoint.host
	regex = ~r/(acct:)?(?<username>\w+)@#{host}/
	with %{"username" => username} <- Regex.named_captures(regex, resource) do
	user = User.get_by_nickname(username)
	{:ok, represent_user(user)}
	else _e ->
	with user when not is_nil(user) <- User.get_cached_by_ap_id(resource) do
	{:ok, represent_user(user)}
	else _e ->
	{:error, "Couldn't find user"}
	end
	end
	end

	def represent_user(user) do
	{:ok, user} = ensure_keys_present(user)
	{:ok, _private, public} = Salmon.keys_from_pem(user.info["keys"])
	magic_key = Salmon.encode_key(public)
	{
	:XRD, %{xmlns: "http://docs.oasis-open.org/ns/xri/xrd-1.0"},
	[
	- {:Subject, "acct:#{user.nickname}@#{Pleroma.Web.host}"},
	+ {:Subject, "acct:#{user.nickname}@#{Pleroma.Web.Endpoint.host}"},
	{:Alias, user.ap_id},
	{:Link, %{rel: "http://schemas.google.com/g/2010#updates-from", type: "application/atom+xml", href: OStatus.feed_path(user)}},
	{:Link, %{rel: "http://webfinger.net/rel/profile-page", type: "text/html", href: user.ap_id}},
	{:Link, %{rel: "salmon", href: OStatus.salmon_path(user)}},
	{:Link, %{rel: "magic-public-key", href: "data:application/magic-public-key,#{magic_key}"}}
	]
	}
	\|> XmlBuilder.to_doc
	end

	# This seems a better fit in Salmon
	def ensure_keys_present(user) do
	info = user.info \|\| %{}
	if info["keys"] do
	{:ok, user}
	else
	{:ok, pem} = Salmon.generate_rsa_pem
	info = Map.put(info, "keys", pem)
	Repo.update(Ecto.Changeset.change(user, info: info))
	end
	end

	# FIXME: Make this call the host-meta to find the actual address.
	defp webfinger_address(domain) do
	"//#{domain}/.well-known/webfinger"
	end

	defp webfinger_from_xml(doc) do
	magic_key = XML.string_from_xpath(~s{//Link[@rel="magic-public-key"]/@href}, doc)
	"data:application/magic-public-key," <> magic_key = magic_key
	topic = XML.string_from_xpath(~s{//Link[@rel="http://schemas.google.com/g/2010#updates-from"]/@href}, doc)
	subject = XML.string_from_xpath("//Subject", doc)
	salmon = XML.string_from_xpath(~s{//Link[@rel="salmon"]/@href}, doc)
	data = %{
	- magic_key: magic_key,
	- topic: topic,
	- subject: subject,
	- salmon: salmon
	+ "magic_key" => magic_key,
	+ "topic" => topic,
	+ "subject" => subject,
	+ "salmon" => salmon
	}
	{:ok, data}
	end

	def finger(account, getter \\ &HTTPoison.get/3) do
	domain = with [_name, domain] <- String.split(account, "@") do
	domain
	else _e ->
	URI.parse(account).host
	end
	address = webfinger_address(domain)

	# try https first
	response = with {:ok, result} <- getter.("https:" <> address, ["Accept": "application/xrd+xml"], [params: [resource: account]]) do
	{:ok, result}
	else _ ->
	getter.("http:" <> address, ["Accept": "application/xrd+xml"], [params: [resource: account], follow_redirect: true])
	end

	with {:ok, %{status_code: status_code, body: body}} when status_code in 200..299 <- response,
	doc <- XML.parse_document(body),
	{:ok, data} <- webfinger_from_xml(doc) do
	{:ok, data}
	else
	e ->
	Logger.debug("Couldn't finger #{account}.")
	Logger.debug(inspect(e))
	{:error, e}
	end
	end
	end
	diff --git a/lib/pleroma/web/websub/websub.ex b/lib/pleroma/web/websub/websub.ex
	index 546bfb5a4..e32fc8817 100644
	--- a/lib/pleroma/web/websub/websub.ex
	+++ b/lib/pleroma/web/websub/websub.ex
	@@ -1,196 +1,196 @@
	defmodule Pleroma.Web.Websub do
	alias Pleroma.Repo
	alias Pleroma.Web.Websub.{WebsubServerSubscription, WebsubClientSubscription}
	alias Pleroma.Web.OStatus.FeedRepresenter
	alias Pleroma.Web.{XML, Endpoint, OStatus}
	alias Pleroma.Web.Router.Helpers
	require Logger

	import Ecto.Query

	def verify(subscription, getter \\ &HTTPoison.get/3 ) do
	challenge = Base.encode16(:crypto.strong_rand_bytes(8))
	lease_seconds = NaiveDateTime.diff(subscription.valid_until, subscription.updated_at) \|> to_string

	params = %{
	"hub.challenge": challenge,
	"hub.lease_seconds": lease_seconds,
	"hub.topic": subscription.topic,
	"hub.mode": "subscribe"
	}

	url = hd(String.split(subscription.callback, "?"))
	query = URI.parse(subscription.callback).query \|\| ""
	params = Map.merge(params, URI.decode_query(query))
	with {:ok, response} <- getter.(url, [], [params: params]),
	^challenge <- response.body
	do
	changeset = Ecto.Changeset.change(subscription, %{state: "active"})
	Repo.update(changeset)
	else _e ->
	changeset = Ecto.Changeset.change(subscription, %{state: "rejected"})
	{:ok, subscription } = Repo.update(changeset)
	{:error, subscription}
	end
	end

	def publish(topic, user, activity) do
	query = from sub in WebsubServerSubscription,
	where: sub.topic == ^topic and sub.state == "active"
	subscriptions = Repo.all(query)
	Enum.each(subscriptions, fn(sub) ->
	response = FeedRepresenter.to_simple_form(user, [activity], [user])
	\|> :xmerl.export_simple(:xmerl_xml)
	\|> to_string

	signature = sign(sub.secret, response)
	HTTPoison.post(sub.callback, response, [
	{"Content-Type", "application/atom+xml"},
	{"X-Hub-Signature", "sha1=#{signature}"}
	])
	end)
	end

	def sign(secret, doc) do
	:crypto.hmac(:sha, secret, to_string(doc)) \|> Base.encode16
	end

	def incoming_subscription_request(user, %{"hub.mode" => "subscribe"} = params) do
	with {:ok, topic} <- valid_topic(params, user),
	{:ok, lease_time} <- lease_time(params),
	secret <- params["hub.secret"],
	callback <- params["hub.callback"]
	do
	subscription = get_subscription(topic, callback)
	data = %{
	state: subscription.state \|\| "requested",
	topic: topic,
	secret: secret,
	callback: callback
	}

	change = Ecto.Changeset.change(subscription, data)
	websub = Repo.insert_or_update!(change)

	change = Ecto.Changeset.change(websub, %{valid_until: NaiveDateTime.add(websub.updated_at, lease_time)})
	websub = Repo.update!(change)

	Pleroma.Web.Federator.enqueue(:verify_websub, websub)

	{:ok, websub}
	else {:error, reason} ->
	Logger.debug("Couldn't create subscription.")
	Logger.debug(inspect(reason))

	{:error, reason}
	end
	end

	defp get_subscription(topic, callback) do
	Repo.get_by(WebsubServerSubscription, topic: topic, callback: callback) \|\| %WebsubServerSubscription{}
	end

	# Temp hack for mastodon.
	defp lease_time(%{"hub.lease_seconds" => ""}) do
	{:ok, 60 * 60 * 24 * 3} # three days
	end

	defp lease_time(%{"hub.lease_seconds" => lease_seconds}) do
	{:ok, String.to_integer(lease_seconds)}
	end

	defp lease_time(_) do
	{:ok, 60 * 60 * 24 * 3} # three days
	end

	defp valid_topic(%{"hub.topic" => topic}, user) do
	if topic == OStatus.feed_path(user) do
	{:ok, OStatus.feed_path(user)}
	else
	{:error, "Wrong topic requested, expected #{OStatus.feed_path(user)}, got #{topic}"}
	end
	end

	def subscribe(subscriber, subscribed, requester \\ &request_subscription/1) do
	topic = subscribed.info["topic"]
	# FIXME: Race condition, use transactions
	{:ok, subscription} = with subscription when not is_nil(subscription) <- Repo.get_by(WebsubClientSubscription, topic: topic) do
	subscribers = [subscriber.ap_id, subscription.subscribers] \|> Enum.uniq
	change = Ecto.Changeset.change(subscription, %{subscribers: subscribers})
	Repo.update(change)
	else _e ->
	subscription = %WebsubClientSubscription{
	topic: topic,
	hub: subscribed.info["hub"],
	subscribers: [subscriber.ap_id],
	state: "requested",
	secret: :crypto.strong_rand_bytes(8) \|> Base.url_encode64,
	user: subscribed
	}
	Repo.insert(subscription)
	end
	requester.(subscription)
	end

	def gather_feed_data(topic, getter \\ &HTTPoison.get/1) do
	with {:ok, response} <- getter.(topic),
	status_code when status_code in 200..299 <- response.status_code,
	body <- response.body,
	doc <- XML.parse_document(body),
	uri when not is_nil(uri) <- XML.string_from_xpath("/feed/author[1]/uri", doc),
	hub when not is_nil(hub) <- XML.string_from_xpath(~S{/feed/link[@rel="hub"]/@href}, doc) do

	name = XML.string_from_xpath("/feed/author[1]/name", doc)
	preferredUsername = XML.string_from_xpath("/feed/author[1]/poco:preferredUsername", doc)
	displayName = XML.string_from_xpath("/feed/author[1]/poco:displayName", doc)
	avatar = OStatus.make_avatar_object(doc)

	{:ok, %{
	- uri: uri,
	- hub: hub,
	- nickname: preferredUsername \|\| name,
	- name: displayName \|\| name,
	- host: URI.parse(uri).host,
	- avatar: avatar
	+ "uri" => uri,
	+ "hub" => hub,
	+ "nickname" => preferredUsername \|\| name,
	+ "name" => displayName \|\| name,
	+ "host" => URI.parse(uri).host,
	+ "avatar" => avatar
	}}
	else e ->
	{:error, e}
	end
	end

	def request_subscription(websub, poster \\ &HTTPoison.post/3, timeout \\ 10_000) do
	data = [
	"hub.mode": "subscribe",
	"hub.topic": websub.topic,
	"hub.secret": websub.secret,
	"hub.callback": Helpers.websub_url(Endpoint, :websub_subscription_confirmation, websub.id)
	]

	# This checks once a second if we are confirmed yet
	websub_checker = fn ->
	helper = fn (helper) ->
	:timer.sleep(1000)
	websub = Repo.get_by(WebsubClientSubscription, id: websub.id, state: "accepted")
	if websub, do: websub, else: helper.(helper)
	end
	helper.(helper)
	end

	task = Task.async(websub_checker)

	with {:ok, %{status_code: 202}} <- poster.(websub.hub, {:form, data}, ["Content-type": "application/x-www-form-urlencoded"]),
	{:ok, websub} <- Task.yield(task, timeout) do
	{:ok, websub}
	else e ->
	Task.shutdown(task)

	change = Ecto.Changeset.change(websub, %{state: "rejected"})
	{:ok, websub} = Repo.update(change)

	Logger.debug("Couldn't confirm subscription: #{inspect(websub)}")
	Logger.debug("error: #{inspect(e)}")

	{:error, websub}
	end
	end
	end
	diff --git a/test/fixtures/incoming_websub_gnusocial_attachments.xml b/test/fixtures/incoming_websub_gnusocial_attachments.xml
	new file mode 100644
	index 000000000..9d331ef32
	--- /dev/null
	+++ b/test/fixtures/incoming_websub_gnusocial_attachments.xml
	@@ -0,0 +1,59 @@
	+<?xml version="1.0" encoding="UTF-8"?>
	+<feed xml:lang="en-US" xmlns="http://www.w3.org/2005/Atom" xmlns:thr="http://purl.org/syndication/thread/1.0" xmlns:georss="http://www.georss.org/georss" xmlns:activity="http://activitystrea.ms/spec/1.0/" xmlns:media="http://purl.org/syndication/atommedia" xmlns:poco="http://portablecontacts.net/spec/1.0" xmlns:ostatus="http://ostatus.org/schema/1.0" xmlns:statusnet="http://status.net/schema/api/1/">
	+ <generator uri="https://gnu.io/social" version="1.0.2-dev">GNU social</generator>
	+ <id>https://social.heldscal.la/api/statuses/user_timeline/23211.atom</id>
	+ <title>lambadalambda timeline</title>
	+ <subtitle>Updates from lambadalambda on social.heldscal.la!</subtitle>
	+ <logo>https://social.heldscal.la/avatar/23211-96-20170416114255.jpeg</logo>
	+ <updated>2017-05-02T20:29:35+00:00</updated>
	+<author>
	+ <activity:object-type>http://activitystrea.ms/schema/1.0/person</activity:object-type>
	+ <uri>https://social.heldscal.la/user/23211</uri>
	+ <name>lambadalambda</name>
	+ <summary>Call me Deacon Blues.</summary>
	+ <link rel="alternate" type="text/html" href="https://social.heldscal.la/lambadalambda"/>
	+ <link rel="avatar" type="image/jpeg" media:width="236" media:height="236" href="https://social.heldscal.la/avatar/23211-original-20170416114255.jpeg"/>
	+ <link rel="avatar" type="image/jpeg" media:width="96" media:height="96" href="https://social.heldscal.la/avatar/23211-96-20170416114255.jpeg"/>
	+ <link rel="avatar" type="image/jpeg" media:width="48" media:height="48" href="https://social.heldscal.la/avatar/23211-48-20170416114255.jpeg"/>
	+ <link rel="avatar" type="image/jpeg" media:width="24" media:height="24" href="https://social.heldscal.la/avatar/23211-24-20170416114257.jpeg"/>
	+ <poco:preferredUsername>lambadalambda</poco:preferredUsername>
	+ <poco:displayName>Constance Variable</poco:displayName>
	+ <poco:note>Call me Deacon Blues.</poco:note>
	+ <poco:address>
	+ <poco:formatted>Berlin</poco:formatted>
	+ </poco:address>
	+ <poco:urls>
	+ <poco:type>homepage</poco:type>
	+ <poco:value>https://heldscal.la</poco:value>
	+ <poco:primary>true</poco:primary>
	+ </poco:urls>
	+ <followers url="https://social.heldscal.la/lambadalambda/subscribers"></followers>
	+ <statusnet:profile_info local_id="23211"></statusnet:profile_info>
	+</author>
	+ <link href="https://social.heldscal.la/lambadalambda" rel="alternate" type="text/html"/>
	+ <link href="https://social.heldscal.la/main/sup" rel="http://api.friendfeed.com/2008/03#sup" type="application/json"/>
	+ <link href="https://social.heldscal.la/main/push/hub" rel="hub"/>
	+ <link href="https://social.heldscal.la/main/salmon/user/23211" rel="salmon"/>
	+ <link href="https://social.heldscal.la/main/salmon/user/23211" rel="http://salmon-protocol.org/ns/salmon-replies"/>
	+ <link href="https://social.heldscal.la/main/salmon/user/23211" rel="http://salmon-protocol.org/ns/salmon-mention"/>
	+ <link href="https://social.heldscal.la/api/statuses/user_timeline/23211.atom" rel="self" type="application/atom+xml"/>
	+<entry>
	+ <activity:object-type>http://activitystrea.ms/schema/1.0/note</activity:object-type>
	+ <id>tag:social.heldscal.la,2017-05-02:noticeId=2020923:objectType=note</id>
	+ <title>New note by lambadalambda</title>
	+ <content type="html">Okay gonna stream some cool games!! <a href="https://social.heldscal.la/file/7ed5ee508e6376a6e3dd581e17e7ed0b7b638147c7e86784bf83abc2641ee3d4.gif" title="https://social.heldscal.la/file/7ed5ee508e6376a6e3dd581e17e7ed0b7b638147c7e86784bf83abc2641ee3d4.gif" rel="nofollow external noreferrer" class="attachment" id="attachment-423842">https://social.heldscal.la/attachment/423842</a> <a href="https://social.heldscal.la/file/4c209099cadfc5afd3e27a334aa0db96b3a7510dde1603305d68a2707e59a11f.png" title="https://social.heldscal.la/file/4c209099cadfc5afd3e27a334aa0db96b3a7510dde1603305d68a2707e59a11f.png" rel="nofollow external noreferrer" class="attachment" id="attachment-423843">https://social.heldscal.la/attachment/423843</a></content>
	+ <link rel="alternate" type="text/html" href="https://social.heldscal.la/notice/2020923"/>
	+ <status_net notice_id="2020923"></status_net>
	+ <activity:verb>http://activitystrea.ms/schema/1.0/post</activity:verb>
	+ <published>2017-05-02T20:29:35+00:00</published>
	+ <updated>2017-05-02T20:29:35+00:00</updated>
	+ <link rel="ostatus:conversation" href="https://social.heldscal.la/conversation/1038558"/>
	+ <ostatus:conversation href="https://social.heldscal.la/conversation/1038558" local_id="1038558" ref="tag:social.heldscal.la,2017-05-02:objectType=thread:nonce=26c7afdcbcf4ebd4">tag:social.heldscal.la,2017-05-02:objectType=thread:nonce=26c7afdcbcf4ebd4</ostatus:conversation>
	+ <link rel="mentioned" ostatus:object-type="http://activitystrea.ms/schema/1.0/collection" href="http://activityschema.org/collection/public"/>
	+ <link rel="enclosure" href="https://social.heldscal.la/file/7ed5ee508e6376a6e3dd581e17e7ed0b7b638147c7e86784bf83abc2641ee3d4.gif" type="image/gif" length="17283"/>
	+ <link rel="enclosure" href="https://social.heldscal.la/file/4c209099cadfc5afd3e27a334aa0db96b3a7510dde1603305d68a2707e59a11f.png" type="image/png" length="6965"/>
	+ <link rel="self" type="application/atom+xml" href="https://social.heldscal.la/api/statuses/show/2020923.atom"/>
	+ <link rel="edit" type="application/atom+xml" href="https://social.heldscal.la/api/statuses/show/2020923.atom"/>
	+ <statusnet:notice_info local_id="2020923" source="Pleroma FE"></statusnet:notice_info>
	+</entry>
	+</feed>
	diff --git a/test/user_test.exs b/test/user_test.exs
	index 1331ac971..7435e30e0 100644
	--- a/test/user_test.exs
	+++ b/test/user_test.exs
	@@ -1,115 +1,125 @@
	defmodule Pleroma.UserTest do
	alias Pleroma.Builders.UserBuilder
	alias Pleroma.User
	use Pleroma.DataCase

	import Pleroma.Factory

	test "ap_id returns the activity pub id for the user" do
	host =
	Application.get_env(:pleroma, Pleroma.Web.Endpoint)
	\|> Keyword.fetch!(:url)
	\|> Keyword.fetch!(:host)

	user = UserBuilder.build

	expected_ap_id = "https://#{host}/users/#{user.nickname}"

	assert expected_ap_id == User.ap_id(user)
	end

	test "ap_followers returns the followers collection for the user" do
	user = UserBuilder.build

	expected_followers_collection = "#{User.ap_id(user)}/followers"

	assert expected_followers_collection == User.ap_followers(user)
	end

	test "follow takes a user and another user" do
	user = insert(:user)
	followed = insert(:user)

	{:ok, user } = User.follow(user, followed)

	user = Repo.get(User, user.id)

	assert user.following == [User.ap_followers(followed)]
	end

	test "unfollow takes a user and another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	{:ok, user } = User.unfollow(user, followed)

	user = Repo.get(User, user.id)

	assert user.following == []
	end

	test "test if a user is following another user" do
	followed = insert(:user)
	user = insert(:user, %{following: [User.ap_followers(followed)]})

	assert User.following?(user, followed)
	refute User.following?(followed, user)
	end

	describe "user registration" do
	@full_user_data %{
	bio: "A guy",
	name: "my name",
	nickname: "nick",
	password: "test",
	password_confirmation: "test",
	email: "email@example.com"
	}

	test "it requires a bio, email, name, nickname and password" do
	@full_user_data
	\|> Map.keys
	\|> Enum.each(fn (key) ->
	params = Map.delete(@full_user_data, key)
	changeset = User.register_changeset(%User{}, params)
	assert changeset.valid? == false
	end)
	end

	test "it sets the password_hash, ap_id and following fields" do
	changeset = User.register_changeset(%User{}, @full_user_data)

	assert changeset.valid?

	assert is_binary(changeset.changes[:password_hash])
	assert changeset.changes[:ap_id] == User.ap_id(%User{nickname: @full_user_data.nickname})
	assert changeset.changes[:following] == [User.ap_followers(%User{nickname: @full_user_data.nickname})]
	end
	end

	describe "fetching a user from nickname or trying to build one" do
	test "gets an existing user" do
	user = insert(:user)
	fetched_user = User.get_or_fetch_by_nickname(user.nickname)

	assert user == fetched_user
	end

	# TODO: Make the test local.
	test "fetches an external user via ostatus if no user exists" do
	fetched_user = User.get_or_fetch_by_nickname("shp@social.heldscal.la")
	assert fetched_user.nickname == "shp@social.heldscal.la"
	end

	test "returns nil if no user could be fetched" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant@social.heldscal.la")
	assert fetched_user == nil
	end

	test "returns nil for nonexistant local user" do
	fetched_user = User.get_or_fetch_by_nickname("nonexistant")
	assert fetched_user == nil
	end
	end
	+
	+ test "returns an ap_id for a user" do
	+ user = insert(:user)
	+ assert User.ap_id(user) == Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :feed_redirect, user.nickname)
	+ end
	+
	+ test "returns an ap_followers link for a user" do
	+ user = insert(:user)
	+ assert User.ap_followers(user) == Pleroma.Web.Router.Helpers.o_status_url(Pleroma.Web.Endpoint, :feed_redirect, user.nickname) <> "/followers"
	+ end
	end

	diff --git a/test/web/ostatus/ostatus_test.exs b/test/web/ostatus/ostatus_test.exs
	index e39952807..94a735337 100644
	--- a/test/web/ostatus/ostatus_test.exs
	+++ b/test/web/ostatus/ostatus_test.exs
	@@ -1,158 +1,168 @@
	defmodule Pleroma.Web.OStatusTest do
	use Pleroma.DataCase
	alias Pleroma.Web.OStatus
	alias Pleroma.Web.XML
	alias Pleroma.{Object, Repo}

	test "don't insert create notes twice" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [_activity]} = OStatus.handle_incoming(incoming)
	assert {:ok, [{:error, "duplicate activity"}]} == OStatus.handle_incoming(incoming)
	end

	test "handle incoming note - GS, Salmon" do
	incoming = File.read!("test/fixtures/incoming_note_activity.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["id"] == "tag:gs.example.org:4040,2017-04-23:noticeId=29:objectType=note"
	assert activity.data["published"] == "2017-04-23T14:51:03+00:00"
	assert activity.data["context"] == "tag:gs.example.org:4040,2017-04-23:objectType=thread:nonce=f09e22f58abd5c7b"
	assert "http://pleroma.example.org:4000/users/lain3" in activity.data["to"]
	assert activity.local == false
	end

	test "handle incoming notes - GS, subscription" do
	incoming = File.read!("test/fixtures/ostatus_incoming_post.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"]["content"] == "Will it blend?"
	end

	+ test "handle incoming notes with attachments - GS, subscription" do
	+ incoming = File.read!("test/fixtures/incoming_websub_gnusocial_attachments.xml")
	+ {:ok, [activity]} = OStatus.handle_incoming(incoming)
	+
	+ assert activity.data["type"] == "Create"
	+ assert activity.data["object"]["type"] == "Note"
	+ assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	+ assert activity.data["object"]["attachment"] \|> length == 2
	+ end
	+
	test "handle incoming notes - Mastodon, salmon, reply" do
	# It uses the context of the replied to object
	Repo.insert!(%Object{
	data: %{
	"id" => "https://pleroma.soykaf.com/objects/c237d966-ac75-4fe3-a87a-d89d71a3a7a4",
	"context" => "2hu"
	}})
	incoming = File.read!("test/fixtures/incoming_reply_mastodon.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://mastodon.social/users/lambadalambda"
	assert activity.data["context"] == "2hu"
	end

	test "handle incoming notes - GS, subscription, reply" do
	incoming = File.read!("test/fixtures/ostatus_incoming_reply.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["actor"] == "https://social.heldscal.la/user/23211"
	assert activity.data["object"]["content"] == "@<a href=\"https://gs.archae.me/user/4687\" class=\"h-card u-url p-nickname mention\" title=\"shpbot\">shpbot</a> why not indeed."
	assert activity.data["object"]["inReplyTo"] == "tag:gs.archae.me,2017-04-30:noticeId=778260:objectType=note"
	end

	test "handle incoming replies" do
	incoming = File.read!("test/fixtures/incoming_note_activity_answer.xml")
	{:ok, [activity]} = OStatus.handle_incoming(incoming)

	assert activity.data["type"] == "Create"
	assert activity.data["object"]["type"] == "Note"
	assert activity.data["object"]["inReplyTo"] == "http://pleroma.example.org:4000/objects/55bce8fc-b423-46b1-af71-3759ab4670bc"
	assert "http://pleroma.example.org:4000/users/lain5" in activity.data["to"]
	end

	describe "new remote user creation" do
	test "tries to use the information in poco fields" do
	# TODO make test local
	uri = "https://social.heldscal.la/user/23211"

	{:ok, user} = OStatus.find_or_make_user(uri)

	user = Repo.get(Pleroma.User, user.id)
	assert user.name == "Constance Variable"
	assert user.nickname == "lambadalambda@social.heldscal.la"
	assert user.local == false
	assert user.info["uri"] == uri
	assert user.ap_id == uri
	assert user.avatar["type"] == "Image"

	{:ok, user_again} = OStatus.find_or_make_user(uri)

	assert user == user_again
	end

	test "find_make_or_update_user takes an author element and returns an updated user" do
	# TODO make test local
	uri = "https://social.heldscal.la/user/23211"

	{:ok, user} = OStatus.find_or_make_user(uri)
	change = Ecto.Changeset.change(user, %{avatar: nil})

	{:ok, user} = Repo.update(change)
	refute user.avatar

	doc = XML.parse_document(File.read!("test/fixtures/23211.atom"))
	[author] = :xmerl_xpath.string('//author[1]', doc)
	{:ok, user} = OStatus.find_make_or_update_user(author)
	assert user.avatar["type"] == "Image"

	{:ok, user_again} = OStatus.find_make_or_update_user(author)
	assert user_again == user
	end
	end

	describe "gathering user info from a user id" do
	test "it returns user info in a hash" do
	user = "shp@social.heldscal.la"

	# TODO: make test local
	{:ok, data} = OStatus.gather_user_info(user)

	expected = %{
	- hub: "https://social.heldscal.la/main/push/hub",
	- magic_key: "RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB",
	- name: "shp",
	- nickname: "shp",
	- salmon: "https://social.heldscal.la/main/salmon/user/29191",
	- subject: "acct:shp@social.heldscal.la",
	- topic: "https://social.heldscal.la/api/statuses/user_timeline/29191.atom",
	- uri: "https://social.heldscal.la/user/29191",
	- host: "social.heldscal.la",
	- fqn: user,
	- avatar: %{"type" => "Image", "url" => [%{"href" => "https://social.heldscal.la/avatar/29191-original-20170421154949.jpeg", "mediaType" => "image/jpeg", "type" => "Link"}]}
	+ "hub" => "https://social.heldscal.la/main/push/hub",
	+ "magic_key" => "RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB",
	+ "name" => "shp",
	+ "nickname" => "shp",
	+ "salmon" => "https://social.heldscal.la/main/salmon/user/29191",
	+ "subject" => "acct:shp@social.heldscal.la",
	+ "topic" => "https://social.heldscal.la/api/statuses/user_timeline/29191.atom",
	+ "uri" => "https://social.heldscal.la/user/29191",
	+ "host" => "social.heldscal.la",
	+ "fqn" => user,
	+ "avatar" => %{"type" => "Image", "url" => [%{"href" => "https://social.heldscal.la/avatar/29191-original-20170421154949.jpeg", "mediaType" => "image/jpeg", "type" => "Link"}]}
	}
	assert data == expected
	end

	test "it works with the uri" do
	user = "https://social.heldscal.la/user/29191"

	# TODO: make test local
	{:ok, data} = OStatus.gather_user_info(user)

	expected = %{
	- hub: "https://social.heldscal.la/main/push/hub",
	- magic_key: "RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB",
	- name: "shp",
	- nickname: "shp",
	- salmon: "https://social.heldscal.la/main/salmon/user/29191",
	- subject: "https://social.heldscal.la/user/29191",
	- topic: "https://social.heldscal.la/api/statuses/user_timeline/29191.atom",
	- uri: "https://social.heldscal.la/user/29191",
	- host: "social.heldscal.la",
	- fqn: user,
	- avatar: %{"type" => "Image", "url" => [%{"href" => "https://social.heldscal.la/avatar/29191-original-20170421154949.jpeg", "mediaType" => "image/jpeg", "type" => "Link"}]}
	+ "hub" => "https://social.heldscal.la/main/push/hub",
	+ "magic_key" => "RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB",
	+ "name" => "shp",
	+ "nickname" => "shp",
	+ "salmon" => "https://social.heldscal.la/main/salmon/user/29191",
	+ "subject" => "https://social.heldscal.la/user/29191",
	+ "topic" => "https://social.heldscal.la/api/statuses/user_timeline/29191.atom",
	+ "uri" => "https://social.heldscal.la/user/29191",
	+ "host" => "social.heldscal.la",
	+ "fqn" => user,
	+ "avatar" => %{"type" => "Image", "url" => [%{"href" => "https://social.heldscal.la/avatar/29191-original-20170421154949.jpeg", "mediaType" => "image/jpeg", "type" => "Link"}]}
	}
	assert data == expected
	end
	end
	end
	diff --git a/test/web/salmon/salmon_test.exs b/test/web/salmon/salmon_test.exs
	index 77dacc1c0..ed26ccf83 100644
	--- a/test/web/salmon/salmon_test.exs
	+++ b/test/web/salmon/salmon_test.exs
	@@ -1,92 +1,92 @@
	defmodule Pleroma.Web.Salmon.SalmonTest do
	use Pleroma.DataCase
	alias Pleroma.Web.Salmon
	alias Pleroma.{Repo, Activity, User}
	import Pleroma.Factory

	@magickey "RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwQhh-1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAB"

	@wrong_magickey "RSA.pu0s-halox4tu7wmES1FVSx6u-4wc0YrUFXcqWXZG4-27UmbCOpMQftRCldNRfyA-qLbz-eqiwQhh-1EwUvjsD4cYbAHNGHwTvDOyx5AKthQUP44ykPv7kjKGh3DWKySJvcs9tlUG87hlo7AvnMo9pwRS_Zz2CacQ-MKaXyDepk=.AQAA"

	test "decodes a salmon" do
	{:ok, salmon} = File.read("test/fixtures/salmon.xml")
	{:ok, doc} = Salmon.decode_and_validate(@magickey, salmon)
	assert Regex.match?(~r/xml/, doc)
	end

	test "errors on wrong magic key" do
	{:ok, salmon} = File.read("test/fixtures/salmon.xml")
	assert Salmon.decode_and_validate(@wrong_magickey, salmon) == :error
	end

	test "generates an RSA private key pem" do
	{:ok, key} = Salmon.generate_rsa_pem
	assert is_binary(key)
	assert Regex.match?(~r/RSA/, key)
	end

	test "it encodes a magic key from a public key" do
	key = Salmon.decode_key(@magickey)
	magic_key = Salmon.encode_key(key)

	assert @magickey == magic_key
	end

	test "returns a public and private key from a pem" do
	pem = File.read!("test/fixtures/private_key.pem")
	{:ok, private, public} = Salmon.keys_from_pem(pem)

	assert elem(private, 0) == :RSAPrivateKey
	assert elem(public, 0) == :RSAPublicKey
	end

	test "encodes an xml payload with a private key" do
	doc = File.read!("test/fixtures/incoming_note_activity.xml")
	pem = File.read!("test/fixtures/private_key.pem")
	{:ok, private, public} = Salmon.keys_from_pem(pem)

	# Let's try a roundtrip.
	{:ok, salmon} = Salmon.encode(private, doc)
	{:ok, decoded_doc} = Salmon.decode_and_validate(Salmon.encode_key(public), salmon)

	assert doc == decoded_doc
	end

	test "it gets a magic key" do
	# TODO: Make test local
	salmon = File.read!("test/fixtures/salmon2.xml")
	- key = Salmon.fetch_magic_key(salmon)
	+ {:ok, key} = Salmon.fetch_magic_key(salmon)

	assert key == "RSA.uzg6r1peZU0vXGADWxGJ0PE34WvmhjUmydbX5YYdOiXfODVLwCMi1umGoqUDm-mRu4vNEdFBVJU1CpFA7dKzWgIsqsa501i2XqElmEveXRLvNRWFB6nG03Q5OUY2as8eE54BJm0p20GkMfIJGwP6TSFb-ICp3QjzbatuSPJ6xCE=.AQAB"
	end

	test "it pushes an activity to remote accounts it's addressed to" do
	user_data = %{
	info: %{
	"salmon" => "http://example.org/salmon"
	},
	local: false
	}

	mentioned_user = insert(:user, user_data)
	note = insert(:note)
	activity_data = %{
	"id" => Pleroma.Web.ActivityPub.ActivityPub.generate_activity_id,
	"type" => "Create",
	"actor" => note.data["actor"],
	"to" => note.data["to"] ++ [mentioned_user.ap_id],
	"object" => note.data,
	"published_at" => DateTime.utc_now() \|> DateTime.to_iso8601,
	"context" => note.data["context"]
	}

	{:ok, activity} = Repo.insert(%Activity{data: activity_data})
	user = Repo.get_by(User, ap_id: activity.data["actor"])
	{:ok, user} = Pleroma.Web.WebFinger.ensure_keys_present(user)

	poster = fn (url, data, headers) ->
	assert url == "http://example.org/salmon"
	end
	Salmon.publish(user, activity, poster)
	end
	end
	diff --git a/test/web/web_finger/web_finger_test.exs b/test/web/web_finger/web_finger_test.exs
	index b48fdd0aa..495d3d50b 100644
	--- a/test/web/web_finger/web_finger_test.exs
	+++ b/test/web/web_finger/web_finger_test.exs
	@@ -1,61 +1,61 @@
	defmodule Pleroma.Web.WebFingerTest do
	use Pleroma.DataCase
	alias Pleroma.Web.WebFinger
	import Pleroma.Factory

	describe "host meta" do
	test "returns a link to the xml lrdd" do
	host_info = WebFinger.host_meta()

	assert String.contains?(host_info, Pleroma.Web.base_url)
	end
	end

	describe "incoming webfinger request" do
	test "works for fqns" do
	user = insert(:user)

	- {:ok, result} = WebFinger.webfinger("#{user.nickname}@#{Pleroma.Web.host}")
	+ {:ok, result} = WebFinger.webfinger("#{user.nickname}@#{Pleroma.Web.Endpoint.host}")
	assert is_binary(result)
	end

	test "works for ap_ids" do
	user = insert(:user)

	{:ok, result} = WebFinger.webfinger(user.ap_id)
	assert is_binary(result)
	end
	end

	describe "fingering" do
	test "returns the info for a user" do
	user = "shp@social.heldscal.la"

	getter = fn(_url, _headers, [params: [resource: ^user]]) ->
	{:ok, %{status_code: 200, body: File.read!("test/fixtures/webfinger.xml")}}
	end

	{:ok, data} = WebFinger.finger(user, getter)

	- assert data.magic_key == "RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB"
	- assert data.topic == "https://social.heldscal.la/api/statuses/user_timeline/29191.atom"
	- assert data.subject == "acct:shp@social.heldscal.la"
	- assert data.salmon == "https://social.heldscal.la/main/salmon/user/29191"
	+ assert data["magic_key"] == "RSA.wQ3i9UA0qmAxZ0WTIp4a-waZn_17Ez1pEEmqmqoooRsG1_BvpmOvLN0G2tEcWWxl2KOtdQMCiPptmQObeZeuj48mdsDZ4ArQinexY2hCCTcbV8Xpswpkb8K05RcKipdg07pnI7tAgQ0VWSZDImncL6YUGlG5YN8b5TjGOwk2VG8=.AQAB"
	+ assert data["topic"] == "https://social.heldscal.la/api/statuses/user_timeline/29191.atom"
	+ assert data["subject"] == "acct:shp@social.heldscal.la"
	+ assert data["salmon"] == "https://social.heldscal.la/main/salmon/user/29191"
	end
	end

	describe "ensure_keys_present" do
	test "it creates keys for a user and stores them in info" do
	user = insert(:user)
	refute is_binary(user.info["keys"])
	{:ok, user} = WebFinger.ensure_keys_present(user)
	assert is_binary(user.info["keys"])
	end

	test "it doesn't create keys if there already are some" do
	user = insert(:user, %{info: %{"keys" => "xxx"}})
	{:ok, user} = WebFinger.ensure_keys_present(user)
	assert user.info["keys"] == "xxx"
	end
	end
	end
	diff --git a/test/web/websub/websub_test.exs b/test/web/websub/websub_test.exs
	index 63acb3c43..065fb250a 100644
	--- a/test/web/websub/websub_test.exs
	+++ b/test/web/websub/websub_test.exs
	@@ -1,177 +1,177 @@
	defmodule Pleroma.Web.WebsubMock do
	def verify(sub) do
	{:ok, sub}
	end
	end

	defmodule Pleroma.Web.WebsubTest do
	use Pleroma.DataCase
	alias Pleroma.Web.Websub
	alias Pleroma.Web.Websub.WebsubServerSubscription
	import Pleroma.Factory
	alias Pleroma.Web.Router.Helpers

	test "a verification of a request that is accepted" do
	sub = insert(:websub_subscription)
	topic = sub.topic

	getter = fn (_path, _headers, options) ->
	%{
	"hub.challenge": challenge,
	"hub.lease_seconds": seconds,
	"hub.topic": ^topic,
	"hub.mode": "subscribe"
	} = Keyword.get(options, :params)

	assert String.to_integer(seconds) > 0

	{:ok, %HTTPoison.Response{
	status_code: 200,
	body: challenge
	}}
	end

	{:ok, sub} = Websub.verify(sub, getter)
	assert sub.state == "active"
	end

	test "a verification of a request that doesn't return 200" do
	sub = insert(:websub_subscription)

	getter = fn (_path, _headers, _options) ->
	{:ok, %HTTPoison.Response{
	status_code: 500,
	body: ""
	}}
	end

	{:error, sub} = Websub.verify(sub, getter)
	assert sub.state == "rejected"
	end

	test "an incoming subscription request" do
	user = insert(:user)

	data = %{
	"hub.callback" => "http://example.org/sub",
	"hub.mode" => "subscribe",
	"hub.topic" => Pleroma.Web.OStatus.feed_path(user),
	"hub.secret" => "a random secret",
	"hub.lease_seconds" => "100"
	}

	{:ok, subscription } = Websub.incoming_subscription_request(user, data)
	assert subscription.topic == Pleroma.Web.OStatus.feed_path(user)
	assert subscription.state == "requested"
	assert subscription.secret == "a random secret"
	assert subscription.callback == "http://example.org/sub"
	end

	test "an incoming subscription request for an existing subscription" do
	user = insert(:user)
	sub = insert(:websub_subscription, state: "accepted", topic: Pleroma.Web.OStatus.feed_path(user))

	data = %{
	"hub.callback" => sub.callback,
	"hub.mode" => "subscribe",
	"hub.topic" => Pleroma.Web.OStatus.feed_path(user),
	"hub.secret" => "a random secret",
	"hub.lease_seconds" => "100"
	}

	{:ok, subscription } = Websub.incoming_subscription_request(user, data)
	assert subscription.topic == Pleroma.Web.OStatus.feed_path(user)
	assert subscription.state == sub.state
	assert subscription.secret == "a random secret"
	assert subscription.callback == sub.callback
	assert length(Repo.all(WebsubServerSubscription)) == 1
	assert subscription.id == sub.id
	end

	def accepting_verifier(subscription) do
	{:ok, %{ subscription \| state: "accepted" }}
	end

	test "initiate a subscription for a given user and topic" do
	subscriber = insert(:user)
	user = insert(:user, %{info: %{ "topic" => "some_topic", "hub" => "some_hub"}})

	{:ok, websub} = Websub.subscribe(subscriber, user, &accepting_verifier/1)
	assert websub.subscribers == [subscriber.ap_id]
	assert websub.topic == "some_topic"
	assert websub.hub == "some_hub"
	assert is_binary(websub.secret)
	assert websub.user == user
	assert websub.state == "accepted"
	end

	test "discovers the hub and canonical url" do
	topic = "https://mastodon.social/users/lambadalambda.atom"

	getter = fn(^topic) ->
	doc = File.read!("test/fixtures/lambadalambda.atom")
	{:ok, %{status_code: 200, body: doc}}
	end

	{:ok, discovered} = Websub.gather_feed_data(topic, getter)
	expected = %{
	- hub: "https://mastodon.social/api/push",
	- uri: "https://mastodon.social/users/lambadalambda",
	- nickname: "lambadalambda",
	- name: "Critical Value",
	- host: "mastodon.social",
	- avatar: %{"type" => "Image", "url" => [%{"href" => "https://files.mastodon.social/accounts/avatars/000/000/264/original/1429214160519.gif?1492379244", "mediaType" => "image/gif", "type" => "Link"}]}
	+ "hub" => "https://mastodon.social/api/push",
	+ "uri" => "https://mastodon.social/users/lambadalambda",
	+ "nickname" => "lambadalambda",
	+ "name" => "Critical Value",
	+ "host" => "mastodon.social",
	+ "avatar" => %{"type" => "Image", "url" => [%{"href" => "https://files.mastodon.social/accounts/avatars/000/000/264/original/1429214160519.gif?1492379244", "mediaType" => "image/gif", "type" => "Link"}]}
	}

	assert expected == discovered
	end

	test "calls the hub, requests topic" do
	hub = "https://social.heldscal.la/main/push/hub"
	topic = "https://social.heldscal.la/api/statuses/user_timeline/23211.atom"
	websub = insert(:websub_client_subscription, %{hub: hub, topic: topic})

	poster = fn (^hub, {:form, data}, _headers) ->
	assert Keyword.get(data, :"hub.mode") == "subscribe"
	assert Keyword.get(data, :"hub.callback") == Helpers.websub_url(Pleroma.Web.Endpoint, :websub_subscription_confirmation, websub.id)
	{:ok, %{status_code: 202}}
	end

	task = Task.async(fn -> Websub.request_subscription(websub, poster) end)

	change = Ecto.Changeset.change(websub, %{state: "accepted"})
	{:ok, _} = Repo.update(change)

	{:ok, websub} = Task.await(task)

	assert websub.state == "accepted"
	end

	test "rejects the subscription if it can't be accepted" do
	hub = "https://social.heldscal.la/main/push/hub"
	topic = "https://social.heldscal.la/api/statuses/user_timeline/23211.atom"
	websub = insert(:websub_client_subscription, %{hub: hub, topic: topic})

	poster = fn (^hub, {:form, _data}, _headers) ->
	{:ok, %{status_code: 202}}
	end

	{:error, websub} = Websub.request_subscription(websub, poster, 1000)
	assert websub.state == "rejected"

	websub = insert(:websub_client_subscription, %{hub: hub, topic: topic})
	poster = fn (^hub, {:form, _data}, _headers) ->
	{:ok, %{status_code: 400}}
	end

	{:error, websub} = Websub.request_subscription(websub, poster, 1000)
	assert websub.state == "rejected"
	end

	test "sign a text" do
	signed = Websub.sign("secret", "text")
	assert signed == "B8392C23690CCF871F37EC270BE1582DEC57A503"

	signed = Websub.sign("secret", [["て"], ['す']])
	end
	end

File Metadata

Mime Type: text/x-diff
Expires: Sat, Oct 10, 11:29 PM (1 d, 10 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1785505
Default Alt Text: (58 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions