git.squeep.com Git - akkoma/blob - lib/pleroma/captcha.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.Captcha do
   6   alias Calendar.DateTime
   7   alias Plug.Crypto.KeyGenerator
   8   alias Plug.Crypto.MessageEncryptor
   9
  10   @doc """
  11   Ask the configured captcha service for a new captcha
  12   """
  13   def new do
  14     if not enabled?() do
  15       %{type: :none}
  16     else
  17       new_captcha = method().new()
  18
  19       # This make salt a little different for two keys
  20       {secret, sign_secret} = secret_pair(new_captcha[:token])
  21
  22       # Basically copy what Phoenix.Token does here, add the time to
  23       # the actual data and make it a binary to then encrypt it
  24       encrypted_captcha_answer =
  25         %{
  26           at: DateTime.now_utc(),
  27           answer_data: new_captcha[:answer_data]
  28         }
  29         |> :erlang.term_to_binary()
  30         |> MessageEncryptor.encrypt(secret, sign_secret)
  31
  32       # Replace the answer with the encrypted answer
  33       %{new_captcha | answer_data: encrypted_captcha_answer}
  34     end
  35   end
  36
  37   @doc """
  38   Ask the configured captcha service to validate the captcha
  39   """
  40   def validate(token, captcha, answer_data) do
  41     with {:ok, %{at: at, answer_data: answer_md5}} <- validate_answer_data(token, answer_data),
  42          :ok <- validate_expiration(at),
  43          :ok <- validate_usage(token),
  44          :ok <- method().validate(token, captcha, answer_md5),
  45          {:ok, _} <- mark_captcha_as_used(token) do
  46       :ok
  47     end
  48   end
  49
  50   def enabled?, do: Pleroma.Config.get([__MODULE__, :enabled], false)
  51
  52   defp seconds_valid, do: Pleroma.Config.get!([__MODULE__, :seconds_valid])
  53
  54   defp secret_pair(token) do
  55     secret_key_base = Pleroma.Config.get!([Pleroma.Web.Endpoint, :secret_key_base])
  56     secret = KeyGenerator.generate(secret_key_base, token <> "_encrypt")
  57     sign_secret = KeyGenerator.generate(secret_key_base, token <> "_sign")
  58
  59     {secret, sign_secret}
  60   end
  61
  62   defp validate_answer_data(token, answer_data) do
  63     {secret, sign_secret} = secret_pair(token)
  64
  65     with false <- is_nil(answer_data),
  66          {:ok, data} <- MessageEncryptor.decrypt(answer_data, secret, sign_secret),
  67          %{at: at, answer_data: answer_md5} <- :erlang.binary_to_term(data) do
  68       {:ok, %{at: at, answer_data: answer_md5}}
  69     else
  70       _ -> {:error, :invalid_answer_data}
  71     end
  72   end
  73
  74   defp validate_expiration(created_at) do
  75     # If the time found is less than (current_time-seconds_valid) then the time has already passed
  76     # Later we check that the time found is more than the presumed invalidatation time, that means
  77     # that the data is still valid and the captcha can be checked
  78
  79     valid_if_after = DateTime.subtract!(DateTime.now_utc(), seconds_valid())
  80
  81     if DateTime.before?(created_at, valid_if_after) do
  82       {:error, :expired}
  83     else
  84       :ok
  85     end
  86   end
  87
  88   defp validate_usage(token) do
  89     if is_nil(Cachex.get!(:used_captcha_cache, token)) do
  90       :ok
  91     else
  92       {:error, :already_used}
  93     end
  94   end
  95
  96   defp mark_captcha_as_used(token) do
  97     ttl = seconds_valid() |> :timer.seconds()
  98     Cachex.put(:used_captcha_cache, token, true, ttl: ttl)
  99   end
 100
 101   defp method, do: Pleroma.Config.get!([__MODULE__, :method])
 102 end