captcha.ex 3.46 KB
Newer Older
1
# Pleroma: A lightweight social networking server
kaniini's avatar
kaniini committed
2
# Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
3
4
# SPDX-License-Identifier: AGPL-3.0-only

5
defmodule Pleroma.Captcha do
6
  alias Calendar.DateTime
Haelwenn's avatar
Haelwenn committed
7
8
  alias Plug.Crypto.KeyGenerator
  alias Plug.Crypto.MessageEncryptor
9
10
11
12

  use GenServer

  @doc false
13
  def start_link do
14
15
16
17
18
19
20
21
22
23
24
    GenServer.start_link(__MODULE__, [], name: __MODULE__)
  end

  @doc false
  def init(_) do
    {:ok, nil}
  end

  @doc """
  Ask the configured captcha service for a new captcha
  """
25
  def new do
26
27
28
29
30
31
    GenServer.call(__MODULE__, :new)
  end

  @doc """
  Ask the configured captcha service to validate the captcha
  """
vaartis's avatar
vaartis committed
32
33
  def validate(token, captcha, answer_data) do
    GenServer.call(__MODULE__, {:validate, token, captcha, answer_data})
34
35
36
37
38
39
40
41
42
  end

  @doc false
  def handle_call(:new, _from, state) do
    enabled = Pleroma.Config.get([__MODULE__, :enabled])

    if !enabled do
      {:reply, %{type: :none}, state}
    else
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
      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
      }
67
68
69
70
    end
  end

  @doc false
vaartis's avatar
vaartis committed
71
  def handle_call({:validate, token, captcha, answer_data}, _from, state) do
72
73
74
    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")
75

76
    # If the time found is less than (current_time-seconds_valid) then the time has already passed
77
78
79
80
81
82
83
84
    # 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
85
86
87
88
89
90
91
92
93
94
95
96
97
        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))
98

99
100
101
102
          :ok
        catch
          :throw, e -> e
        end
103
104
105
      else
        _ -> {:error, "Invalid answer data"}
      end
106

107
    {:reply, result, state}
108
109
  end

110
111
  defp method, do: Pleroma.Config.get!([__MODULE__, :method])
end