aboutsummaryrefslogtreecommitdiff
path: root/lib
diff options
context:
space:
mode:
Diffstat (limited to 'lib')
-rw-r--r--lib/pleroma/application.ex10
-rw-r--r--lib/pleroma/captcha/captcha.ex87
-rw-r--r--lib/pleroma/captcha/captcha_service.ex21
-rw-r--r--lib/pleroma/captcha/kocaptcha.ex58
-rw-r--r--lib/pleroma/user.ex1
-rw-r--r--lib/pleroma/web/activity_pub/activity_pub_controller.ex52
-rw-r--r--lib/pleroma/web/federator/retry_queue.ex3
-rw-r--r--lib/pleroma/web/rich_media/controllers/rich_media_controller.ex17
-rw-r--r--lib/pleroma/web/rich_media/parser.ex26
-rw-r--r--lib/pleroma/web/rich_media/parsers/ogp.ex30
-rw-r--r--lib/pleroma/web/router.ex6
-rw-r--r--lib/pleroma/web/twitter_api/twitter_api.ex16
12 files changed, 228 insertions, 99 deletions
diff --git a/lib/pleroma/application.ex b/lib/pleroma/application.ex
index 4542ed623..cb3e6b69b 100644
--- a/lib/pleroma/application.ex
+++ b/lib/pleroma/application.ex
@@ -32,6 +32,16 @@ defmodule Pleroma.Application do
worker(
Cachex,
[
+ :used_captcha_cache,
+ [
+ ttl_interval: :timer.seconds(Pleroma.Config.get!([Pleroma.Captcha, :seconds_valid]))
+ ]
+ ],
+ id: :cachex_used_captcha_cache
+ ),
+ worker(
+ Cachex,
+ [
:user_cache,
[
default_ttl: 25000,
diff --git a/lib/pleroma/captcha/captcha.ex b/lib/pleroma/captcha/captcha.ex
index 133a9fd68..0207bcbea 100644
--- a/lib/pleroma/captcha/captcha.ex
+++ b/lib/pleroma/captcha/captcha.ex
@@ -3,9 +3,11 @@
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Captcha do
- use GenServer
+ alias Plug.Crypto.KeyGenerator
+ alias Plug.Crypto.MessageEncryptor
+ alias Calendar.DateTime
- @ets_options [:ordered_set, :private, :named_table, {:read_concurrency, true}]
+ use GenServer
@doc false
def start_link() do
@@ -14,14 +16,6 @@ defmodule Pleroma.Captcha do
@doc false
def init(_) do
- # Create a ETS table to store captchas
- ets_name = Module.concat(method(), Ets)
- ^ets_name = :ets.new(Module.concat(method(), Ets), @ets_options)
-
- # Clean up old captchas every few minutes
- seconds_retained = Pleroma.Config.get!([__MODULE__, :seconds_retained])
- Process.send_after(self(), :cleanup, 1000 * seconds_retained)
-
{:ok, nil}
end
@@ -35,8 +29,8 @@ defmodule Pleroma.Captcha do
@doc """
Ask the configured captcha service to validate the captcha
"""
- def validate(token, captcha) do
- GenServer.call(__MODULE__, {:validate, token, captcha})
+ def validate(token, captcha, answer_data) do
+ GenServer.call(__MODULE__, {:validate, token, captcha, answer_data})
end
@doc false
@@ -46,24 +40,71 @@ defmodule Pleroma.Captcha do
if !enabled do
{:reply, %{type: :none}, state}
else
- {:reply, method().new(), state}
+ new_captcha = method().new()
+
+ secret_key_base = Pleroma.Config.get!([Pleroma.Web.Endpoint, :secret_key_base])
+
+ # This make salt a little different for two keys
+ token = new_captcha[:token]
+ secret = KeyGenerator.generate(secret_key_base, token <> "_encrypt")
+ sign_secret = KeyGenerator.generate(secret_key_base, token <> "_sign")
+ # Basicallty copy what Phoenix.Token does here, add the time to
+ # the actual data and make it a binary to then encrypt it
+ encrypted_captcha_answer =
+ %{
+ at: DateTime.now_utc(),
+ answer_data: new_captcha[:answer_data]
+ }
+ |> :erlang.term_to_binary()
+ |> MessageEncryptor.encrypt(secret, sign_secret)
+
+ {
+ :reply,
+ # Repalce the answer with the encrypted answer
+ %{new_captcha | answer_data: encrypted_captcha_answer},
+ state
+ }
end
end
@doc false
- def handle_call({:validate, token, captcha}, _from, state) do
- {:reply, method().validate(token, captcha), state}
- end
+ def handle_call({:validate, token, captcha, answer_data}, _from, state) do
+ secret_key_base = Pleroma.Config.get!([Pleroma.Web.Endpoint, :secret_key_base])
+ secret = KeyGenerator.generate(secret_key_base, token <> "_encrypt")
+ sign_secret = KeyGenerator.generate(secret_key_base, token <> "_sign")
- @doc false
- def handle_info(:cleanup, state) do
- :ok = method().cleanup()
+ # If the time found is less than (current_time - seconds_valid), then the time has already passed.
+ # Later we check that the time found is more than the presumed invalidatation time, that means
+ # that the data is still valid and the captcha can be checked
+ seconds_valid = Pleroma.Config.get!([Pleroma.Captcha, :seconds_valid])
+ valid_if_after = DateTime.subtract!(DateTime.now_utc(), seconds_valid)
+
+ result =
+ with {:ok, data} <- MessageEncryptor.decrypt(answer_data, secret, sign_secret),
+ %{at: at, answer_data: answer_md5} <- :erlang.binary_to_term(data) do
+ try do
+ if DateTime.before?(at, valid_if_after), do: throw({:error, "CAPTCHA expired"})
+
+ if not is_nil(Cachex.get!(:used_captcha_cache, token)),
+ do: throw({:error, "CAPTCHA already used"})
+
+ res = method().validate(token, captcha, answer_md5)
+ # Throw if an error occurs
+ if res != :ok, do: throw(res)
+
+ # Mark this captcha as used
+ {:ok, _} =
+ Cachex.put(:used_captcha_cache, token, true, ttl: :timer.seconds(seconds_valid))
- seconds_retained = Pleroma.Config.get!([__MODULE__, :seconds_retained])
- # Schedule the next clenup
- Process.send_after(self(), :cleanup, 1000 * seconds_retained)
+ :ok
+ catch
+ :throw, e -> e
+ end
+ else
+ _ -> {:error, "Invalid answer data"}
+ end
- {:noreply, state}
+ {:reply, result, state}
end
defp method, do: Pleroma.Config.get!([__MODULE__, :method])
diff --git a/lib/pleroma/captcha/captcha_service.ex b/lib/pleroma/captcha/captcha_service.ex
index a820751a8..8d27c04f1 100644
--- a/lib/pleroma/captcha/captcha_service.ex
+++ b/lib/pleroma/captcha/captcha_service.ex
@@ -8,9 +8,14 @@ defmodule Pleroma.Captcha.Service do
Returns:
- Service-specific data for using the newly created captcha
+ Type/Name of the service, the token to identify the captcha,
+ the data of the answer and service-specific data to use the newly created captcha
"""
- @callback new() :: map
+ @callback new() :: %{
+ type: atom(),
+ token: String.t(),
+ answer_data: any()
+ }
@doc """
Validated the provided captcha solution.
@@ -18,15 +23,15 @@ defmodule Pleroma.Captcha.Service do
Arguments:
* `token` the captcha is associated with
* `captcha` solution of the captcha to validate
+ * `answer_data` is the data needed to validate the answer (presumably encrypted)
Returns:
`true` if captcha is valid, `false` if not
"""
- @callback validate(token :: String.t(), captcha :: String.t()) :: boolean
-
- @doc """
- This function is called periodically to clean up old captchas
- """
- @callback cleanup() :: :ok
+ @callback validate(
+ token :: String.t(),
+ captcha :: String.t(),
+ answer_data :: any()
+ ) :: :ok | {:error, String.t()}
end
diff --git a/lib/pleroma/captcha/kocaptcha.ex b/lib/pleroma/captcha/kocaptcha.ex
index 66f9ce754..34a611492 100644
--- a/lib/pleroma/captcha/kocaptcha.ex
+++ b/lib/pleroma/captcha/kocaptcha.ex
@@ -3,13 +3,9 @@
# SPDX-License-Identifier: AGPL-3.0-only
defmodule Pleroma.Captcha.Kocaptcha do
- alias Calendar.DateTime
-
alias Pleroma.Captcha.Service
@behaviour Service
- @ets __MODULE__.Ets
-
@impl Service
def new() do
endpoint = Pleroma.Config.get!([__MODULE__, :endpoint])
@@ -21,51 +17,21 @@ defmodule Pleroma.Captcha.Kocaptcha do
{:ok, res} ->
json_resp = Poison.decode!(res.body)
- token = json_resp["token"]
-
- true =
- :ets.insert(
- @ets,
- {token, json_resp["md5"], DateTime.now_utc() |> DateTime.Format.unix()}
- )
-
- %{type: :kocaptcha, token: token, url: endpoint <> json_resp["url"]}
- end
- end
-
- @impl Service
- def validate(token, captcha) do
- with false <- is_nil(captcha),
- [{^token, saved_md5, _}] <- :ets.lookup(@ets, token),
- true <- :crypto.hash(:md5, captcha) |> Base.encode16() == String.upcase(saved_md5) do
- # Clear the saved value
- :ets.delete(@ets, token)
-
- true
- else
- _ -> false
+ %{
+ type: :kocaptcha,
+ token: json_resp["token"],
+ url: endpoint <> json_resp["url"],
+ answer_data: json_resp["md5"]
+ }
end
end
@impl Service
- def cleanup() do
- seconds_retained = Pleroma.Config.get!([Pleroma.Captcha, :seconds_retained])
- # If the time in ETS is less than current_time - seconds_retained, then the time has
- # already passed
- delete_after =
- DateTime.subtract!(DateTime.now_utc(), seconds_retained) |> DateTime.Format.unix()
-
- :ets.select_delete(
- @ets,
- [
- {
- {:_, :_, :"$1"},
- [{:<, :"$1", {:const, delete_after}}],
- [true]
- }
- ]
- )
-
- :ok
+ def validate(_token, captcha, answer_data) do
+ # Here the token is unsed, because the unencrypted captcha answer is just passed to method
+ if not is_nil(captcha) and
+ :crypto.hash(:md5, captcha) |> Base.encode16() == String.upcase(answer_data),
+ do: :ok,
+ else: {:error, "Invalid CAPTCHA"}
end
end
diff --git a/lib/pleroma/user.ex b/lib/pleroma/user.ex
index 892f4e483..1edded415 100644
--- a/lib/pleroma/user.ex
+++ b/lib/pleroma/user.ex
@@ -495,6 +495,7 @@ defmodule Pleroma.User do
Enum.map(reqs, fn req -> req.actor end)
|> Enum.uniq()
|> Enum.map(fn ap_id -> get_by_ap_id(ap_id) end)
+ |> Enum.filter(fn u -> !is_nil(u) end)
|> Enum.filter(fn u -> !following?(u, user) end)
{:ok, users}
diff --git a/lib/pleroma/web/activity_pub/activity_pub_controller.ex b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
index fc7972eaf..a3f736fee 100644
--- a/lib/pleroma/web/activity_pub/activity_pub_controller.ex
+++ b/lib/pleroma/web/activity_pub/activity_pub_controller.ex
@@ -165,9 +165,39 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
end
end
+ def handle_user_activity(user, %{"type" => "Create"} = params) do
+ object =
+ params["object"]
+ |> Map.merge(Map.take(params, ["to", "cc"]))
+ |> Map.put("attributedTo", user.ap_id())
+ |> Transmogrifier.fix_object()
+
+ ActivityPub.create(%{
+ to: params["to"],
+ actor: user,
+ context: object["context"],
+ object: object,
+ additional: Map.take(params, ["cc"])
+ })
+ end
+
+ def handle_user_activity(user, %{"type" => "Delete"} = params) do
+ with %Object{} = object <- Object.normalize(params["object"]),
+ true <- user.info.is_moderator || user.ap_id == object.data["actor"],
+ {:ok, delete} <- ActivityPub.delete(object) do
+ {:ok, delete}
+ else
+ _ -> {:error, "Can't delete object"}
+ end
+ end
+
+ def handle_user_activity(_, _) do
+ {:error, "Unhandled activity type"}
+ end
+
def update_outbox(
%{assigns: %{user: user}} = conn,
- %{"nickname" => nickname, "type" => "Create"} = params
+ %{"nickname" => nickname} = params
) do
if nickname == user.nickname do
actor = user.ap_id()
@@ -178,24 +208,16 @@ defmodule Pleroma.Web.ActivityPub.ActivityPubController do
|> Map.put("actor", actor)
|> Transmogrifier.fix_addressing()
- object =
- params["object"]
- |> Map.merge(Map.take(params, ["to", "cc"]))
- |> Map.put("attributedTo", actor)
- |> Transmogrifier.fix_object()
-
- with {:ok, %Activity{} = activity} <-
- ActivityPub.create(%{
- to: params["to"],
- actor: user,
- context: object["context"],
- object: object,
- additional: Map.take(params, ["cc"])
- }) do
+ with {:ok, %Activity{} = activity} <- handle_user_activity(user, params) do
conn
|> put_status(:created)
|> put_resp_header("location", activity.data["id"])
|> json(activity.data)
+ else
+ {:error, message} ->
+ conn
+ |> put_status(:bad_request)
+ |> json(message)
end
else
conn
diff --git a/lib/pleroma/web/federator/retry_queue.ex b/lib/pleroma/web/federator/retry_queue.ex
index 230a2c939..e0ce251d2 100644
--- a/lib/pleroma/web/federator/retry_queue.ex
+++ b/lib/pleroma/web/federator/retry_queue.ex
@@ -87,9 +87,8 @@ defmodule Pleroma.Web.Federator.RetryQueue do
)
popped
- |> List.foldl(true, fn e, acc ->
+ |> Enum.each(fn e ->
:ets.delete_object(table, e)
- acc
end)
popped
diff --git a/lib/pleroma/web/rich_media/controllers/rich_media_controller.ex b/lib/pleroma/web/rich_media/controllers/rich_media_controller.ex
new file mode 100644
index 000000000..91019961d
--- /dev/null
+++ b/lib/pleroma/web/rich_media/controllers/rich_media_controller.ex
@@ -0,0 +1,17 @@
+defmodule Pleroma.Web.RichMedia.RichMediaController do
+ use Pleroma.Web, :controller
+
+ import Pleroma.Web.ControllerHelper, only: [json_response: 3]
+
+ def parse(conn, %{"url" => url}) do
+ case Pleroma.Web.RichMedia.Parser.parse(url) do
+ {:ok, data} ->
+ conn
+ |> json_response(200, data)
+
+ {:error, msg} ->
+ conn
+ |> json_response(404, msg)
+ end
+ end
+end
diff --git a/lib/pleroma/web/rich_media/parser.ex b/lib/pleroma/web/rich_media/parser.ex
new file mode 100644
index 000000000..477a38196
--- /dev/null
+++ b/lib/pleroma/web/rich_media/parser.ex
@@ -0,0 +1,26 @@
+defmodule Pleroma.Web.RichMedia.Parser do
+ @parsers [Pleroma.Web.RichMedia.Parsers.OGP]
+
+ def parse(url) do
+ {:ok, %Tesla.Env{body: html}} = Pleroma.HTTP.get(url)
+
+ html |> maybe_parse() |> get_parsed_data()
+ end
+
+ defp maybe_parse(html) do
+ Enum.reduce_while(@parsers, %{}, fn parser, acc ->
+ case parser.parse(html, acc) do
+ {:ok, data} -> {:halt, data}
+ {:error, _msg} -> {:cont, acc}
+ end
+ end)
+ end
+
+ defp get_parsed_data(data) when data == %{} do
+ {:error, "No metadata found"}
+ end
+
+ defp get_parsed_data(data) do
+ {:ok, data}
+ end
+end
diff --git a/lib/pleroma/web/rich_media/parsers/ogp.ex b/lib/pleroma/web/rich_media/parsers/ogp.ex
new file mode 100644
index 000000000..5773a5263
--- /dev/null
+++ b/lib/pleroma/web/rich_media/parsers/ogp.ex
@@ -0,0 +1,30 @@
+defmodule Pleroma.Web.RichMedia.Parsers.OGP do
+ def parse(html, data) do
+ with elements = [_ | _] <- get_elements(html),
+ ogp_data =
+ Enum.reduce(elements, data, fn el, acc ->
+ attributes = normalize_attributes(el)
+
+ Map.merge(acc, attributes)
+ end) do
+ {:ok, ogp_data}
+ else
+ _e -> {:error, "No OGP metadata found"}
+ end
+ end
+
+ defp get_elements(html) do
+ html |> Floki.find("meta[property^='og:']")
+ end
+
+ defp normalize_attributes(html_node) do
+ {_tag, attributes, _children} = html_node
+
+ data =
+ Enum.into(attributes, %{}, fn {name, value} ->
+ {name, String.trim_leading(value, "og:")}
+ end)
+
+ %{String.to_atom(data["property"]) => data["content"]}
+ end
+end
diff --git a/lib/pleroma/web/router.ex b/lib/pleroma/web/router.ex
index 1f929ee21..8df45bf4d 100644
--- a/lib/pleroma/web/router.ex
+++ b/lib/pleroma/web/router.ex
@@ -232,6 +232,12 @@ defmodule Pleroma.Web.Router do
put("/settings", MastodonAPIController, :put_settings)
end
+ scope "/api", Pleroma.Web.RichMedia do
+ pipe_through(:authenticated_api)
+
+ get("/rich_media/parse", RichMediaController, :parse)
+ end
+
scope "/api/v1", Pleroma.Web.MastodonAPI do
pipe_through(:api)
get("/instance", MastodonAPIController, :masto_instance)
diff --git a/lib/pleroma/web/twitter_api/twitter_api.ex b/lib/pleroma/web/twitter_api/twitter_api.ex
index 0aa4a8d23..ecf81d492 100644
--- a/lib/pleroma/web/twitter_api/twitter_api.ex
+++ b/lib/pleroma/web/twitter_api/twitter_api.ex
@@ -140,22 +140,28 @@ defmodule Pleroma.Web.TwitterAPI.TwitterAPI do
password: params["password"],
password_confirmation: params["confirm"],
captcha_solution: params["captcha_solution"],
- captcha_token: params["captcha_token"]
+ captcha_token: params["captcha_token"],
+ captcha_answer_data: params["captcha_answer_data"]
}
captcha_enabled = Pleroma.Config.get([Pleroma.Captcha, :enabled])
# true if captcha is disabled or enabled and valid, false otherwise
captcha_ok =
if !captcha_enabled do
- true
+ :ok
else
- Pleroma.Captcha.validate(params[:captcha_token], params[:captcha_solution])
+ Pleroma.Captcha.validate(
+ params[:captcha_token],
+ params[:captcha_solution],
+ params[:captcha_answer_data]
+ )
end
# Captcha invalid
- if not captcha_ok do
+ if captcha_ok != :ok do
+ {:error, error} = captcha_ok
# I have no idea how this error handling works
- {:error, %{error: Jason.encode!(%{captcha: ["Invalid CAPTCHA"]})}}
+ {:error, %{error: Jason.encode!(%{captcha: [error]})}}
else
registrations_open = Pleroma.Config.get([:instance, :registrations_open])
generated by cgit v1.2.3 (git 2.26.2) at 2025-04-25 14:14:39 +0000