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