git.squeep.com Git - akkoma/blob - lib/pleroma/web/auth/ldap_authenticator.ex

   1 # Pleroma: A lightweight social networking server
   2 # Copyright © 2017-2019 Pleroma Authors <https://pleroma.social/>
   3 # SPDX-License-Identifier: AGPL-3.0-only
   4
   5 defmodule Pleroma.Web.Auth.LDAPAuthenticator do
   6   alias Pleroma.User
   7
   8   require Logger
   9
  10   @behaviour Pleroma.Web.Auth.Authenticator
  11
  12   @connection_timeout 10_000
  13   @search_timeout 10_000
  14
  15   def get_user(%Plug.Conn{} = conn, params) do
  16     if Pleroma.Config.get([:ldap, :enabled]) do
  17       {name, password} =
  18         case params do
  19           %{"authorization" => %{"name" => name, "password" => password}} ->
  20             {name, password}
  21
  22           %{"grant_type" => "password", "username" => name, "password" => password} ->
  23             {name, password}
  24         end
  25
  26       case ldap_user(name, password) do
  27         %User{} = user ->
  28           {:ok, user}
  29
  30         {:error, {:ldap_connection_error, _}} ->
  31           # When LDAP is unavailable, try default authenticator
  32           Pleroma.Web.Auth.PleromaAuthenticator.get_user(conn, params)
  33
  34         error ->
  35           error
  36       end
  37     else
  38       # Fall back to default authenticator
  39       Pleroma.Web.Auth.PleromaAuthenticator.get_user(conn, params)
  40     end
  41   end
  42
  43   def get_by_external_registration(conn, params), do: get_user(conn, params)
  44
  45   def handle_error(%Plug.Conn{} = _conn, error) do
  46     error
  47   end
  48
  49   def auth_template, do: nil
  50
  51   defp ldap_user(name, password) do
  52     ldap = Pleroma.Config.get(:ldap, [])
  53     host = Keyword.get(ldap, :host, "localhost")
  54     port = Keyword.get(ldap, :port, 389)
  55     ssl = Keyword.get(ldap, :ssl, false)
  56     sslopts = Keyword.get(ldap, :sslopts, [])
  57
  58     options =
  59       [{:port, port}, {:ssl, ssl}, {:timeout, @connection_timeout}] ++
  60         if sslopts != [], do: [{:sslopts, sslopts}], else: []
  61
  62     case :eldap.open([to_charlist(host)], options) do
  63       {:ok, connection} ->
  64         try do
  65           if Keyword.get(ldap, :tls, false) do
  66             :application.ensure_all_started(:ssl)
  67
  68             case :eldap.start_tls(
  69                    connection,
  70                    Keyword.get(ldap, :tlsopts, []),
  71                    @connection_timeout
  72                  ) do
  73               :ok ->
  74                 :ok
  75
  76               error ->
  77                 Logger.error("Could not start TLS: #{inspect(error)}")
  78             end
  79           end
  80
  81           bind_user(connection, ldap, name, password)
  82         after
  83           :eldap.close(connection)
  84         end
  85
  86       {:error, error} ->
  87         Logger.error("Could not open LDAP connection: #{inspect(error)}")
  88         {:error, {:ldap_connection_error, error}}
  89     end
  90   end
  91
  92   defp bind_user(connection, ldap, name, password) do
  93     uid = Keyword.get(ldap, :uid, "cn")
  94     base = Keyword.get(ldap, :base)
  95
  96     case :eldap.simple_bind(connection, "#{uid}=#{name},#{base}", password) do
  97       :ok ->
  98         case User.get_by_nickname_or_email(name) do
  99           %User{} = user ->
 100             user
 101
 102           _ ->
 103             register_user(connection, base, uid, name, password)
 104         end
 105
 106       error ->
 107         error
 108     end
 109   end
 110
 111   defp register_user(connection, base, uid, name, password) do
 112     case :eldap.search(connection, [
 113            {:base, to_charlist(base)},
 114            {:filter, :eldap.equalityMatch(to_charlist(uid), to_charlist(name))},
 115            {:scope, :eldap.wholeSubtree()},
 116            {:attributes, ['mail', 'email']},
 117            {:timeout, @search_timeout}
 118          ]) do
 119       {:ok, {:eldap_search_result, [{:eldap_entry, _, attributes}], _}} ->
 120         with {_, [mail]} <- List.keyfind(attributes, 'mail', 0) do
 121           params = %{
 122             email: :erlang.list_to_binary(mail),
 123             name: name,
 124             nickname: name,
 125             password: password,
 126             password_confirmation: password
 127           }
 128
 129           changeset = User.register_changeset(%User{}, params)
 130
 131           case User.register(changeset) do
 132             {:ok, user} -> user
 133             error -> error
 134           end
 135         else
 136           _ ->
 137             Logger.error("Could not find LDAP attribute mail: #{inspect(attributes)}")
 138             {:error, :ldap_registration_missing_attributes}
 139         end
 140
 141       error ->
 142         error
 143     end
 144   end
 145 end