/src/postgres/src/backend/libpq/auth.c

Source
/*-------------------------------------------------------------------------
 *
 * auth.c
 *    Routines to handle network authentication
 *
 * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    src/backend/libpq/auth.c
 *
 *-------------------------------------------------------------------------
 */

#include "postgres.h"

#include <sys/param.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <pwd.h>
#include <unistd.h>

#include "commands/user.h"
#include "common/ip.h"
#include "common/md5.h"
#include "libpq/auth.h"
#include "libpq/crypt.h"
#include "libpq/libpq.h"
#include "libpq/oauth.h"
#include "libpq/pqformat.h"
#include "libpq/sasl.h"
#include "libpq/scram.h"
#include "miscadmin.h"
#include "port/pg_bswap.h"
#include "postmaster/postmaster.h"
#include "replication/walsender.h"
#include "storage/ipc.h"
#include "tcop/backend_startup.h"
#include "utils/memutils.h"

/*----------------------------------------------------------------
 * Global authentication functions
 *----------------------------------------------------------------
 */
static void auth_failed(Port *port, int elevel, int status,
            const char *logdetail);
static char *recv_password_packet(Port *port);
static bool md5_password_warning_enabled(void);
static void queue_md5_password_warning(void);


/*----------------------------------------------------------------
 * Password-based authentication methods (password, md5, and scram-sha-256)
 *----------------------------------------------------------------
 */
static int  CheckPasswordAuth(Port *port, const char **logdetail);
static int  CheckPWChallengeAuth(Port *port, const char **logdetail);

static int  CheckMD5Auth(Port *port, char *shadow_pass,
             const char **logdetail);


/*----------------------------------------------------------------
 * Ident authentication
 *----------------------------------------------------------------
 */
/* Max size of username ident server can return (per RFC 1413) */
#define IDENT_USERNAME_MAX 512

/* Standard TCP port number for Ident service.  Assigned by IANA */
#define IDENT_PORT 113

static int  ident_inet(Port *port);


/*----------------------------------------------------------------
 * Peer authentication
 *----------------------------------------------------------------
 */
static int  auth_peer(Port *port);


/*----------------------------------------------------------------
 * PAM authentication
 *----------------------------------------------------------------
 */
#ifdef USE_PAM
#ifdef HAVE_PAM_PAM_APPL_H
#include <pam/pam_appl.h>
#endif
#ifdef HAVE_SECURITY_PAM_APPL_H
#include <security/pam_appl.h>
#endif

#define PGSQL_PAM_SERVICE "postgresql"  /* Service name passed to PAM */

/* Work around original Solaris' lack of "const" in the conv_proc signature */
#ifdef _PAM_LEGACY_NONCONST
#define PG_PAM_CONST
#else
#define PG_PAM_CONST const
#endif

static int  CheckPAMAuth(Port *port, const char *user, const char *password);
static int  pam_passwd_conv_proc(int num_msg,
                 PG_PAM_CONST struct pam_message **msg,
                 struct pam_response **resp, void *appdata_ptr);

static struct pam_conv pam_passw_conv = {
  &pam_passwd_conv_proc,
  NULL
};

static const char *pam_passwd = NULL; /* Workaround for Solaris 2.6
                     * brokenness */
static Port *pam_port_cludge; /* Workaround for passing "Port *port" into
                 * pam_passwd_conv_proc */
static bool pam_no_password;  /* For detecting no-password-given */
#endif              /* USE_PAM */


/*----------------------------------------------------------------
 * BSD authentication
 *----------------------------------------------------------------
 */
#ifdef USE_BSD_AUTH
#include <bsd_auth.h>

static int  CheckBSDAuth(Port *port, char *user);
#endif              /* USE_BSD_AUTH */


/*----------------------------------------------------------------
 * LDAP authentication
 *----------------------------------------------------------------
 */
#ifdef USE_LDAP
#ifndef WIN32
/* We use a deprecated function to keep the codepath the same as win32. */
#define LDAP_DEPRECATED 1
#include <ldap.h>
#else
#include <winldap.h>

#endif

static int  CheckLDAPAuth(Port *port);

/* LDAP_OPT_DIAGNOSTIC_MESSAGE is the newer spelling */
#ifndef LDAP_OPT_DIAGNOSTIC_MESSAGE
#define LDAP_OPT_DIAGNOSTIC_MESSAGE LDAP_OPT_ERROR_STRING
#endif

/* Default LDAP password mutator hook, can be overridden by a shared library */
static char *dummy_ldap_password_mutator(char *input);
auth_password_hook_typ ldap_password_hook = dummy_ldap_password_mutator;

#endif              /* USE_LDAP */

/*----------------------------------------------------------------
 * Cert authentication
 *----------------------------------------------------------------
 */
#ifdef USE_SSL
static int  CheckCertAuth(Port *port);
#endif


/*----------------------------------------------------------------
 * Kerberos and GSSAPI GUCs
 *----------------------------------------------------------------
 */
char     *pg_krb_server_keyfile;
bool    pg_krb_caseins_users;
bool    pg_gss_accept_delegation;


/*----------------------------------------------------------------
 * GSSAPI Authentication
 *----------------------------------------------------------------
 */
#ifdef ENABLE_GSS
#include "libpq/be-gssapi-common.h"

static int  pg_GSS_checkauth(Port *port);
static int  pg_GSS_recvauth(Port *port);
#endif              /* ENABLE_GSS */


/*----------------------------------------------------------------
 * SSPI Authentication
 *----------------------------------------------------------------
 */
#ifdef ENABLE_SSPI
typedef SECURITY_STATUS
      (WINAPI * QUERY_SECURITY_CONTEXT_TOKEN_FN) (PCtxtHandle, void **);
static int  pg_SSPI_recvauth(Port *port);
static int  pg_SSPI_make_upn(char *accountname,
               size_t accountnamesize,
               char *domainname,
               size_t domainnamesize,
               bool update_accountname);
#endif


/*----------------------------------------------------------------
 * Global authentication functions
 *----------------------------------------------------------------
 */

/*
 * This hook allows plugins to get control following client authentication,
 * but before the user has been informed about the results.  It could be used
 * to record login events, insert a delay after failed authentication, etc.
 */
ClientAuthentication_hook_type ClientAuthentication_hook = NULL;

/*
 * Tell the user the authentication failed, but not (much about) why.
 *
 * There is a tradeoff here between security concerns and making life
 * unnecessarily difficult for legitimate users.  We would not, for example,
 * want to report the password we were expecting to receive...
 * But it seems useful to report the username and authorization method
 * in use, and these are items that must be presumed known to an attacker
 * anyway.
 * Note that many sorts of failure report additional information in the
 * postmaster log, which we hope is only readable by good guys.  In
 * particular, if logdetail isn't NULL, we send that string to the log
 * when the elevel allows.
 */
static void
auth_failed(Port *port, int elevel, int status, const char *logdetail)
{
  const char *errstr;
  char     *cdetail;
  int     errcode_return = ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION;

  Assert(elevel >= FATAL);  /* we must exit here */

  /*
   * If we failed due to EOF from client, just quit; there's no point in
   * trying to send a message to the client, and not much point in logging
   * the failure in the postmaster log.  (Logging the failure might be
   * desirable, were it not for the fact that libpq closes the connection
   * unceremoniously if challenged for a password when it hasn't got one to
   * send.  We'll get a useless log entry for every psql connection under
   * password auth, even if it's perfectly successful, if we log STATUS_EOF
   * events.)
   */
  if (status == STATUS_EOF)
    proc_exit(0);

  switch (port->hba->auth_method)
  {
    case uaReject:
    case uaImplicitReject:
      errstr = gettext_noop("authentication failed for user \"%s\": host rejected");
      break;
    case uaTrust:
      errstr = gettext_noop("\"trust\" authentication failed for user \"%s\"");
      break;
    case uaIdent:
      errstr = gettext_noop("Ident authentication failed for user \"%s\"");
      break;
    case uaPeer:
      errstr = gettext_noop("Peer authentication failed for user \"%s\"");
      break;
    case uaPassword:
    case uaMD5:
    case uaSCRAM:
      errstr = gettext_noop("password authentication failed for user \"%s\"");
      /* We use it to indicate if a .pgpass password failed. */
      errcode_return = ERRCODE_INVALID_PASSWORD;
      break;
    case uaGSS:
      errstr = gettext_noop("GSSAPI authentication failed for user \"%s\"");
      break;
    case uaSSPI:
      errstr = gettext_noop("SSPI authentication failed for user \"%s\"");
      break;
    case uaPAM:
      errstr = gettext_noop("PAM authentication failed for user \"%s\"");
      break;
    case uaBSD:
      errstr = gettext_noop("BSD authentication failed for user \"%s\"");
      break;
    case uaLDAP:
      errstr = gettext_noop("LDAP authentication failed for user \"%s\"");
      break;
    case uaCert:
      errstr = gettext_noop("certificate authentication failed for user \"%s\"");
      break;
    case uaOAuth:
      errstr = gettext_noop("OAuth bearer authentication failed for user \"%s\"");
      break;
    default:
      errstr = gettext_noop("authentication failed for user \"%s\": invalid authentication method");
      break;
  }

  cdetail = psprintf(_("Connection matched file \"%s\" line %d: \"%s\""),
             port->hba->sourcefile, port->hba->linenumber,
             port->hba->rawline);
  if (logdetail)
    logdetail = psprintf("%s\n%s", logdetail, cdetail);
  else
    logdetail = cdetail;

  ereport(elevel,
      (errcode(errcode_return),
       errmsg(errstr, port->user_name),
       logdetail ? errdetail_log("%s", logdetail) : 0));

  /* doesn't return */
  pg_unreachable();
}


/*
 * Sets the authenticated identity for the current user.  The provided string
 * will be stored into MyClientConnectionInfo, alongside the current HBA
 * method in use.  The ID will be logged if log_connections has the
 * 'authentication' option specified.
 *
 * Auth methods should call this routine exactly once, as soon as the user is
 * successfully authenticated, even if they have reasons to know that
 * authorization will fail later.
 *
 * The provided string will be copied into TopMemoryContext, to match the
 * lifetime of MyClientConnectionInfo, so it is safe to pass a string that is
 * managed by an external library.
 */
void
set_authn_id(Port *port, const char *id)
{
  Assert(id);

  if (MyClientConnectionInfo.authn_id)
  {
    /*
     * An existing authn_id should never be overwritten; that means two
     * authentication providers are fighting (or one is fighting itself).
     * Don't leak any authn details to the client, but don't let the
     * connection continue, either.
     */
    ereport(FATAL,
        (errmsg("authentication identifier set more than once"),
         errdetail_log("previous identifier: \"%s\"; new identifier: \"%s\"",
                 MyClientConnectionInfo.authn_id, id)));
  }

  MyClientConnectionInfo.authn_id = MemoryContextStrdup(TopMemoryContext, id);
  MyClientConnectionInfo.auth_method = port->hba->auth_method;

  if (log_connections & LOG_CONNECTION_AUTHENTICATION)
  {
    ereport(LOG,
        errmsg("connection authenticated: identity=\"%s\" method=%s "
             "(%s:%d)",
             MyClientConnectionInfo.authn_id,
             hba_authname(MyClientConnectionInfo.auth_method),
             port->hba->sourcefile, port->hba->linenumber));
  }
}


/*
 * Client authentication starts here.  If there is an error, this
 * function does not return and the backend process is terminated.
 */
void
ClientAuthentication(Port *port)
{
  int     status = STATUS_ERROR;
  const char *logdetail = NULL;

  /*
   * "Abandoned" is a SASL-specific state similar to STATUS_EOF, in that we
   * don't want to generate any server logs. But it's caused by an in-band
   * client action that requires a server response, not an out-of-band
   * connection closure, so we can't just proc_exit() like we do with
   * STATUS_EOF.
   */
  bool    abandoned = false;

  /*
   * Get the authentication method to use for this frontend/database
   * combination.  Note: we do not parse the file at this point; this has
   * already been done elsewhere.  hba.c dropped an error message into the
   * server logfile if parsing the hba config file failed.
   */
  hba_getauthmethod(port);

  CHECK_FOR_INTERRUPTS();

  /*
   * This is the first point where we have access to the hba record for the
   * current connection, so perform any verifications based on the hba
   * options field that should be done *before* the authentication here.
   */
  if (port->hba->clientcert != clientCertOff)
  {
    /* If we haven't loaded a root certificate store, fail */
    if (!secure_loaded_verify_locations())
      ereport(FATAL,
          (errcode(ERRCODE_CONFIG_FILE_ERROR),
           errmsg("client certificates can only be checked if a root certificate store is available")));

    /*
     * If we loaded a root certificate store, and if a certificate is
     * present on the client, then it has been verified against our root
     * certificate store, and the connection would have been aborted
     * already if it didn't verify ok.
     */
    if (!port->peer_cert_valid)
      ereport(FATAL,
          (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
           errmsg("connection requires a valid client certificate")));
  }

  /*
   * Now proceed to do the actual authentication check
   */
  switch (port->hba->auth_method)
  {
    case uaReject:

      /*
       * An explicit "reject" entry in pg_hba.conf.  This report exposes
       * the fact that there's an explicit reject entry, which is
       * perhaps not so desirable from a security standpoint; but the
       * message for an implicit reject could confuse the DBA a lot when
       * the true situation is a match to an explicit reject.  And we
       * don't want to change the message for an implicit reject.  As
       * noted below, the additional information shown here doesn't
       * expose anything not known to an attacker.
       */
      {
        char    hostinfo[NI_MAXHOST];
        const char *encryption_state;

        pg_getnameinfo_all(&port->raddr.addr, port->raddr.salen,
                   hostinfo, sizeof(hostinfo),
                   NULL, 0,
                   NI_NUMERICHOST);

        encryption_state =
#ifdef ENABLE_GSS
          (port->gss && port->gss->enc) ? _("GSS encryption") :
#endif
#ifdef USE_SSL
          port->ssl_in_use ? _("SSL encryption") :
#endif
          _("no encryption");

        if (am_walsender && !am_db_walsender)
          ereport(FATAL,
              (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
          /* translator: last %s describes encryption state */
               errmsg("pg_hba.conf rejects replication connection for host \"%s\", user \"%s\", %s",
                  hostinfo, port->user_name,
                  encryption_state)));
        else
          ereport(FATAL,
              (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
          /* translator: last %s describes encryption state */
               errmsg("pg_hba.conf rejects connection for host \"%s\", user \"%s\", database \"%s\", %s",
                  hostinfo, port->user_name,
                  port->database_name,
                  encryption_state)));
        break;
      }

    case uaImplicitReject:

      /*
       * No matching entry, so tell the user we fell through.
       *
       * NOTE: the extra info reported here is not a security breach,
       * because all that info is known at the frontend and must be
       * assumed known to bad guys.  We're merely helping out the less
       * clueful good guys.
       */
      {
        char    hostinfo[NI_MAXHOST];
        const char *encryption_state;

        pg_getnameinfo_all(&port->raddr.addr, port->raddr.salen,
                   hostinfo, sizeof(hostinfo),
                   NULL, 0,
                   NI_NUMERICHOST);

        encryption_state =
#ifdef ENABLE_GSS
          (port->gss && port->gss->enc) ? _("GSS encryption") :
#endif
#ifdef USE_SSL
          port->ssl_in_use ? _("SSL encryption") :
#endif
          _("no encryption");

#define HOSTNAME_LOOKUP_DETAIL(port) \
        (port->remote_hostname ? \
         (port->remote_hostname_resolv == +1 ? \
          errdetail_log("Client IP address resolved to \"%s\", forward lookup matches.", \
                port->remote_hostname) : \
          port->remote_hostname_resolv == 0 ? \
          errdetail_log("Client IP address resolved to \"%s\", forward lookup not checked.", \
                port->remote_hostname) : \
          port->remote_hostname_resolv == -1 ? \
          errdetail_log("Client IP address resolved to \"%s\", forward lookup does not match.", \
                port->remote_hostname) : \
          port->remote_hostname_resolv == -2 ? \
          errdetail_log("Could not translate client host name \"%s\" to IP address: %s.", \
                port->remote_hostname, \
                gai_strerror(port->remote_hostname_errcode)) : \
          0) \
         : (port->remote_hostname_resolv == -2 ? \
          errdetail_log("Could not resolve client IP address to a host name: %s.", \
                  gai_strerror(port->remote_hostname_errcode)) : \
          0))

        if (am_walsender && !am_db_walsender)
          ereport(FATAL,
              (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
          /* translator: last %s describes encryption state */
               errmsg("no pg_hba.conf entry for replication connection from host \"%s\", user \"%s\", %s",
                  hostinfo, port->user_name,
                  encryption_state),
               HOSTNAME_LOOKUP_DETAIL(port)));
        else
          ereport(FATAL,
              (errcode(ERRCODE_INVALID_AUTHORIZATION_SPECIFICATION),
          /* translator: last %s describes encryption state */
               errmsg("no pg_hba.conf entry for host \"%s\", user \"%s\", database \"%s\", %s",
                  hostinfo, port->user_name,
                  port->database_name,
                  encryption_state),
               HOSTNAME_LOOKUP_DETAIL(port)));
        break;
      }

    case uaGSS:
#ifdef ENABLE_GSS
      /* We might or might not have the gss workspace already */
      if (port->gss == NULL)
        port->gss = (pg_gssinfo *)
          MemoryContextAllocZero(TopMemoryContext,
                       sizeof(pg_gssinfo));
      port->gss->auth = true;

      /*
       * If GSS state was set up while enabling encryption, we can just
       * check the client's principal.  Otherwise, ask for it.
       */
      if (port->gss->enc)
        status = pg_GSS_checkauth(port);
      else
      {
        sendAuthRequest(port, AUTH_REQ_GSS, NULL, 0);
        status = pg_GSS_recvauth(port);
      }
#else
      Assert(false);
#endif
      break;

    case uaSSPI:
#ifdef ENABLE_SSPI
      if (port->gss == NULL)
        port->gss = (pg_gssinfo *)
          MemoryContextAllocZero(TopMemoryContext,
                       sizeof(pg_gssinfo));
      sendAuthRequest(port, AUTH_REQ_SSPI, NULL, 0);
      status = pg_SSPI_recvauth(port);
#else
      Assert(false);
#endif
      break;

    case uaPeer:
      status = auth_peer(port);
      break;

    case uaIdent:
      status = ident_inet(port);
      break;

    case uaMD5:
    case uaSCRAM:
      status = CheckPWChallengeAuth(port, &logdetail);
      break;

    case uaPassword:
      status = CheckPasswordAuth(port, &logdetail);
      break;

    case uaPAM:
#ifdef USE_PAM
      status = CheckPAMAuth(port, port->user_name, "");
#else
      Assert(false);
#endif              /* USE_PAM */
      break;

    case uaBSD:
#ifdef USE_BSD_AUTH
      status = CheckBSDAuth(port, port->user_name);
#else
      Assert(false);
#endif              /* USE_BSD_AUTH */
      break;

    case uaLDAP:
#ifdef USE_LDAP
      status = CheckLDAPAuth(port);
#else
      Assert(false);
#endif
      break;
    case uaCert:
      /* uaCert will be treated as if clientcert=verify-full (uaTrust) */
    case uaTrust:
      status = STATUS_OK;
      break;
    case uaOAuth:
      status = CheckSASLAuth(&pg_be_oauth_mech, port, NULL, &logdetail,
                   &abandoned);
      break;
  }

  if ((status == STATUS_OK && port->hba->clientcert == clientCertFull)
    || port->hba->auth_method == uaCert)
  {
    /*
     * Make sure we only check the certificate if we use the cert method
     * or verify-full option.
     */
#ifdef USE_SSL
    status = CheckCertAuth(port);
#else
    Assert(false);
#endif
  }

  if ((log_connections & LOG_CONNECTION_AUTHENTICATION) &&
    status == STATUS_OK &&
    !MyClientConnectionInfo.authn_id)
  {
    /*
     * Normally, if log_connections is set, the call to set_authn_id()
     * will log the connection.  However, if that function is never
     * called, perhaps because the trust method is in use, then we handle
     * the logging here instead.
     */
    ereport(LOG,
        errmsg("connection authenticated: user=\"%s\" method=%s "
             "(%s:%d)",
             port->user_name, hba_authname(port->hba->auth_method),
             port->hba->sourcefile, port->hba->linenumber));
  }

  if (ClientAuthentication_hook)
    (*ClientAuthentication_hook) (port, status);

  if (status == STATUS_OK)
    sendAuthRequest(port, AUTH_REQ_OK, NULL, 0);
  else
    auth_failed(port,
          abandoned ? FATAL_CLIENT_ONLY : FATAL,
          status,
          logdetail);
}


/*
 * Send an authentication request packet to the frontend.
 */
void
sendAuthRequest(Port *port, AuthRequest areq, const void *extradata, int extralen)
{
  StringInfoData buf;

  CHECK_FOR_INTERRUPTS();

  pq_beginmessage(&buf, PqMsg_AuthenticationRequest);
  pq_sendint32(&buf, (int32) areq);
  if (extralen > 0)
    pq_sendbytes(&buf, extradata, extralen);

  pq_endmessage(&buf);

  /*
   * Flush message so client will see it, except for AUTH_REQ_OK and
   * AUTH_REQ_SASL_FIN, which need not be sent until we are ready for
   * queries.
   */
  if (areq != AUTH_REQ_OK && areq != AUTH_REQ_SASL_FIN)
    pq_flush();

  CHECK_FOR_INTERRUPTS();
}

/*
 * Collect password response packet from frontend.
 *
 * Returns NULL if couldn't get password, else palloc'd string.
 */
static char *
recv_password_packet(Port *port)
{
  StringInfoData buf;
  int     mtype;

  pq_startmsgread();

  /* Expect 'p' message type */
  mtype = pq_getbyte();
  if (mtype != PqMsg_PasswordMessage)
  {
    /*
     * If the client just disconnects without offering a password, don't
     * make a log entry.  This is legal per protocol spec and in fact
     * commonly done by psql, so complaining just clutters the log.
     */
    if (mtype != EOF)
      ereport(ERROR,
          (errcode(ERRCODE_PROTOCOL_VIOLATION),
           errmsg("expected password response, got message type %d",
              mtype)));
    return NULL;      /* EOF or bad message type */
  }

  initStringInfo(&buf);
  if (pq_getmessage(&buf, PG_MAX_AUTH_TOKEN_LENGTH))  /* receive password */
  {
    /* EOF - pq_getmessage already logged a suitable message */
    pfree(buf.data);
    return NULL;
  }

  /*
   * Apply sanity check: password packet length should agree with length of
   * contained string.  Note it is safe to use strlen here because
   * StringInfo is guaranteed to have an appended '\0'.
   */
  if (strlen(buf.data) + 1 != buf.len)
    ereport(ERROR,
        (errcode(ERRCODE_PROTOCOL_VIOLATION),
         errmsg("invalid password packet size")));

  /*
   * Don't allow an empty password. Libpq treats an empty password the same
   * as no password at all, and won't even try to authenticate. But other
   * clients might, so allowing it would be confusing.
   *
   * Note that this only catches an empty password sent by the client in
   * plaintext. There's also a check in CREATE/ALTER USER that prevents an
   * empty string from being stored as a user's password in the first place.
   * We rely on that for MD5 and SCRAM authentication, but we still need
   * this check here, to prevent an empty password from being used with
   * authentication methods that check the password against an external
   * system, like PAM and LDAP.
   */
  if (buf.len == 1)
    ereport(ERROR,
        (errcode(ERRCODE_INVALID_PASSWORD),
         errmsg("empty password returned by client")));

  /* Do not echo password to logs, for security. */
  elog(DEBUG5, "received password packet");

  /*
   * Return the received string.  Note we do not attempt to do any
   * character-set conversion on it; since we don't yet know the client's
   * encoding, there wouldn't be much point.
   */
  return buf.data;
}


/*----------------------------------------------------------------
 * Password-based authentication mechanisms
 *----------------------------------------------------------------
 */

/*
 * Plaintext password authentication.
 */
static int
CheckPasswordAuth(Port *port, const char **logdetail)
{
  char     *passwd;
  int     result;
  char     *shadow_pass;
  bool    md5_password = false;

  sendAuthRequest(port, AUTH_REQ_PASSWORD, NULL, 0);

  passwd = recv_password_packet(port);
  if (passwd == NULL)
    return STATUS_EOF;   /* client wouldn't send password */

  shadow_pass = get_role_password(port->user_name, logdetail);
  if (shadow_pass)
  {
    result = plain_crypt_verify(port->user_name, shadow_pass, passwd,
                  logdetail);
    md5_password = (get_password_type(shadow_pass) == PASSWORD_TYPE_MD5);
  }
  else
    result = STATUS_ERROR;

  if (shadow_pass)
    pfree(shadow_pass);
  pfree(passwd);

  if (result == STATUS_OK)
  {
    if (md5_password)
      queue_md5_password_warning();
    set_authn_id(port, port->user_name);
  }

  return result;
}

/*
 * MD5 and SCRAM authentication.
 */
static int
CheckPWChallengeAuth(Port *port, const char **logdetail)
{
  int     auth_result;
  char     *shadow_pass;
  PasswordType pwtype;

  Assert(port->hba->auth_method == uaSCRAM ||
       port->hba->auth_method == uaMD5);

  /* First look up the user's password. */
  shadow_pass = get_role_password(port->user_name, logdetail);

  /*
   * If the user does not exist, or has no password or it's expired, we
   * still go through the motions of authentication, to avoid revealing to
   * the client that the user didn't exist.  If 'md5' is allowed, we choose
   * whether to use 'md5' or 'scram-sha-256' authentication based on current
   * password_encryption setting.  The idea is that most genuine users
   * probably have a password of that type, and if we pretend that this user
   * had a password of that type, too, it "blends in" best.
   */
  if (!shadow_pass)
    pwtype = Password_encryption;
  else
    pwtype = get_password_type(shadow_pass);

  /*
   * If 'md5' authentication is allowed, decide whether to perform 'md5' or
   * 'scram-sha-256' authentication based on the type of password the user
   * has.  If it's an MD5 hash, we must do MD5 authentication, and if it's a
   * SCRAM secret, we must do SCRAM authentication.
   *
   * If MD5 authentication is not allowed, always use SCRAM.  If the user
   * had an MD5 password, CheckSASLAuth() with the SCRAM mechanism will
   * fail.
   */
  if (port->hba->auth_method == uaMD5 && pwtype == PASSWORD_TYPE_MD5)
    auth_result = CheckMD5Auth(port, shadow_pass, logdetail);
  else
    auth_result = CheckSASLAuth(&pg_be_scram_mech, port, shadow_pass,
                  logdetail, NULL /* can't abandon SCRAM */ );

  if (shadow_pass)
    pfree(shadow_pass);
  else
  {
    /*
     * If get_role_password() returned error, authentication better not
     * have succeeded.
     */
    Assert(auth_result != STATUS_OK);
  }

  if (auth_result == STATUS_OK)
    set_authn_id(port, port->user_name);

  return auth_result;
}

static int
CheckMD5Auth(Port *port, char *shadow_pass, const char **logdetail)
{
  uint8   md5Salt[4];   /* Password salt */
  char     *passwd;
  int     result;

  /* include the salt to use for computing the response */
  if (!pg_strong_random(md5Salt, 4))
  {
    ereport(LOG,
        (errmsg("could not generate random MD5 salt")));
    return STATUS_ERROR;
  }

  sendAuthRequest(port, AUTH_REQ_MD5, md5Salt, 4);

  passwd = recv_password_packet(port);
  if (passwd == NULL)
    return STATUS_EOF;   /* client wouldn't send password */

  if (shadow_pass)
    result = md5_crypt_verify(port->user_name, shadow_pass, passwd,
                  md5Salt, 4, logdetail);
  else
    result = STATUS_ERROR;

  pfree(passwd);

  if (result == STATUS_OK)
    queue_md5_password_warning();

  return result;
}

static bool
md5_password_warning_enabled(void)
{
  return md5_password_warnings;
}

static void
queue_md5_password_warning(void)
{
  MemoryContext oldcontext;
  char     *warning;
  char     *detail;

  oldcontext = MemoryContextSwitchTo(TopMemoryContext);

  warning = pstrdup(_("authenticated with an MD5-encrypted password"));
  detail = pstrdup(_("MD5 password support is deprecated and will be removed in a future release of PostgreSQL."));
  StoreConnectionWarning(warning, detail, md5_password_warning_enabled);

  MemoryContextSwitchTo(oldcontext);
}


/*----------------------------------------------------------------
 * GSSAPI authentication system
 *----------------------------------------------------------------
 */
#ifdef ENABLE_GSS
static int
pg_GSS_recvauth(Port *port)
{
  OM_uint32 maj_stat,
        min_stat,
        lmin_s,
        gflags;
  int     mtype;
  StringInfoData buf;
  gss_buffer_desc gbuf;
  gss_cred_id_t delegated_creds;

  /*
   * Use the configured keytab, if there is one.  As we now require MIT
   * Kerberos, we might consider using the credential store extensions in
   * the future instead of the environment variable.
   */
  if (pg_krb_server_keyfile != NULL && pg_krb_server_keyfile[0] != '\0')
  {
    if (setenv("KRB5_KTNAME", pg_krb_server_keyfile, 1) != 0)
    {
      /* The only likely failure cause is OOM, so use that errcode */
      ereport(FATAL,
          (errcode(ERRCODE_OUT_OF_MEMORY),
           errmsg("could not set environment: %m")));
    }
  }

  /*
   * We accept any service principal that's present in our keytab. This
   * increases interoperability between kerberos implementations that see
   * for example case sensitivity differently, while not really opening up
   * any vector of attack.
   */
  port->gss->cred = GSS_C_NO_CREDENTIAL;

  /*
   * Initialize sequence with an empty context
   */
  port->gss->ctx = GSS_C_NO_CONTEXT;

  delegated_creds = GSS_C_NO_CREDENTIAL;
  port->gss->delegated_creds = false;

  /*
   * Loop through GSSAPI message exchange. This exchange can consist of
   * multiple messages sent in both directions. First message is always from
   * the client. All messages from client to server are password packets
   * (type 'p').
   */
  do
  {
    pq_startmsgread();

    CHECK_FOR_INTERRUPTS();

    mtype = pq_getbyte();
    if (mtype != PqMsg_GSSResponse)
    {
      /* Only log error if client didn't disconnect. */
      if (mtype != EOF)
        ereport(ERROR,
            (errcode(ERRCODE_PROTOCOL_VIOLATION),
             errmsg("expected GSS response, got message type %d",
                mtype)));
      return STATUS_ERROR;
    }

    /* Get the actual GSS token */
    initStringInfo(&buf);
    if (pq_getmessage(&buf, PG_MAX_AUTH_TOKEN_LENGTH))
    {
      /* EOF - pq_getmessage already logged error */
      pfree(buf.data);
      return STATUS_ERROR;
    }

    /* Map to GSSAPI style buffer */
    gbuf.length = buf.len;
    gbuf.value = buf.data;

    elog(DEBUG4, "processing received GSS token of length %zu",
       gbuf.length);

    maj_stat = gss_accept_sec_context(&min_stat,
                      &port->gss->ctx,
                      port->gss->cred,
                      &gbuf,
                      GSS_C_NO_CHANNEL_BINDINGS,
                      &port->gss->name,
                      NULL,
                      &port->gss->outbuf,
                      &gflags,
                      NULL,
                      pg_gss_accept_delegation ? &delegated_creds : NULL);

    /* gbuf no longer used */
    pfree(buf.data);

    elog(DEBUG5, "gss_accept_sec_context major: %u, "
       "minor: %u, outlen: %zu, outflags: %x",
       maj_stat, min_stat,
       port->gss->outbuf.length, gflags);

    CHECK_FOR_INTERRUPTS();

    if (delegated_creds != GSS_C_NO_CREDENTIAL && gflags & GSS_C_DELEG_FLAG)
    {
      pg_store_delegated_credential(delegated_creds);
      port->gss->delegated_creds = true;
    }

    if (port->gss->outbuf.length != 0)
    {
      /*
       * Negotiation generated data to be sent to the client.
       */
      elog(DEBUG4, "sending GSS response token of length %zu",
         port->gss->outbuf.length);

      sendAuthRequest(port, AUTH_REQ_GSS_CONT,
              port->gss->outbuf.value, port->gss->outbuf.length);

      gss_release_buffer(&lmin_s, &port->gss->outbuf);
    }

    if (maj_stat != GSS_S_COMPLETE && maj_stat != GSS_S_CONTINUE_NEEDED)
    {
      gss_delete_sec_context(&lmin_s, &port->gss->ctx, GSS_C_NO_BUFFER);
      pg_GSS_error(_("accepting GSS security context failed"),
             maj_stat, min_stat);
      return STATUS_ERROR;
    }

    if (maj_stat == GSS_S_CONTINUE_NEEDED)
      elog(DEBUG4, "GSS continue needed");

  } while (maj_stat == GSS_S_CONTINUE_NEEDED);

  if (port->gss->cred != GSS_C_NO_CREDENTIAL)
  {
    /*
     * Release service principal credentials
     */
    gss_release_cred(&min_stat, &port->gss->cred);
  }
  return pg_GSS_checkauth(port);
}

/*
 * Check whether the GSSAPI-authenticated user is allowed to connect as the
 * claimed username.
 */
static int
pg_GSS_checkauth(Port *port)
{
  int     ret;
  OM_uint32 maj_stat,
        min_stat,
        lmin_s;
  gss_buffer_desc gbuf;
  char     *princ;

  /*
   * Get the name of the user that authenticated, and compare it to the pg
   * username that was specified for the connection.
   */
  maj_stat = gss_display_name(&min_stat, port->gss->name, &gbuf, NULL);
  if (maj_stat != GSS_S_COMPLETE)
  {
    pg_GSS_error(_("retrieving GSS user name failed"),
           maj_stat, min_stat);
    return STATUS_ERROR;
  }

  /*
   * gbuf.value might not be null-terminated, so turn it into a regular
   * null-terminated string.
   */
  princ = palloc(gbuf.length + 1);
  memcpy(princ, gbuf.value, gbuf.length);
  princ[gbuf.length] = '\0';
  gss_release_buffer(&lmin_s, &gbuf);

  /*
   * Copy the original name of the authenticated principal into our backend
   * memory for display later.
   *
   * This is also our authenticated identity.  Set it now, rather than
   * waiting for the usermap check below, because authentication has already
   * succeeded and we want the log file to reflect that.
   */
  port->gss->princ = MemoryContextStrdup(TopMemoryContext, princ);
  set_authn_id(port, princ);

  /*
   * Split the username at the realm separator
   */
  if (strchr(princ, '@'))
  {
    char     *cp = strchr(princ, '@');

    /*
     * If we are not going to include the realm in the username that is
     * passed to the ident map, destructively modify it here to remove the
     * realm. Then advance past the separator to check the realm.
     */
    if (!port->hba->include_realm)
      *cp = '\0';
    cp++;

    if (port->hba->krb_realm != NULL && strlen(port->hba->krb_realm))
    {
      /*
       * Match the realm part of the name first
       */
      if (pg_krb_caseins_users)
        ret = pg_strcasecmp(port->hba->krb_realm, cp);
      else
        ret = strcmp(port->hba->krb_realm, cp);

      if (ret)
      {
        /* GSS realm does not match */
        elog(DEBUG2,
           "GSSAPI realm (%s) and configured realm (%s) don't match",
           cp, port->hba->krb_realm);
        pfree(princ);
        return STATUS_ERROR;
      }
    }
  }
  else if (port->hba->krb_realm && strlen(port->hba->krb_realm))
  {
    elog(DEBUG2,
       "GSSAPI did not return realm but realm matching was requested");
    pfree(princ);
    return STATUS_ERROR;
  }

  ret = check_usermap(port->hba->usermap, port->user_name, princ,
            pg_krb_caseins_users);

  pfree(princ);

  return ret;
}
#endif              /* ENABLE_GSS */


/*----------------------------------------------------------------
 * SSPI authentication system
 *----------------------------------------------------------------
 */
#ifdef ENABLE_SSPI

/*
 * Generate an error for SSPI authentication.  The caller should apply
 * _() to errmsg to make it translatable.
 */
static void
pg_SSPI_error(int severity, const char *errmsg, SECURITY_STATUS r)
{
  char    sysmsg[256];

  if (FormatMessage(FORMAT_MESSAGE_IGNORE_INSERTS |
            FORMAT_MESSAGE_FROM_SYSTEM,
            NULL, r, 0,
            sysmsg, sizeof(sysmsg), NULL) == 0)
    ereport(severity,
        (errmsg_internal("%s", errmsg),
         errdetail_internal("SSPI error %x", (unsigned int) r)));
  else
    ereport(severity,
        (errmsg_internal("%s", errmsg),
         errdetail_internal("%s (%x)", sysmsg, (unsigned int) r)));
}

static int
pg_SSPI_recvauth(Port *port)
{
  int     mtype;
  StringInfoData buf;
  SECURITY_STATUS r;
  CredHandle  sspicred;
  CtxtHandle *sspictx = NULL,
        newctx;
  TimeStamp expiry;
  ULONG   contextattr;
  SecBufferDesc inbuf;
  SecBufferDesc outbuf;
  SecBuffer OutBuffers[1];
  SecBuffer InBuffers[1];
  HANDLE    token;
  TOKEN_USER *tokenuser;
  DWORD   retlen;
  char    accountname[MAXPGPATH];
  char    domainname[MAXPGPATH];
  DWORD   accountnamesize = sizeof(accountname);
  DWORD   domainnamesize = sizeof(domainname);
  SID_NAME_USE accountnameuse;
  char     *authn_id;

  /*
   * Acquire a handle to the server credentials.
   */
  r = AcquireCredentialsHandle(NULL,
                 "negotiate",
                 SECPKG_CRED_INBOUND,
                 NULL,
                 NULL,
                 NULL,
                 NULL,
                 &sspicred,
                 &expiry);
  if (r != SEC_E_OK)
    pg_SSPI_error(ERROR, _("could not acquire SSPI credentials"), r);

  /*
   * Loop through SSPI message exchange. This exchange can consist of
   * multiple messages sent in both directions. First message is always from
   * the client. All messages from client to server are password packets
   * (type 'p').
   */
  do
  {
    pq_startmsgread();
    mtype = pq_getbyte();
    if (mtype != PqMsg_GSSResponse)
    {
      if (sspictx != NULL)
      {
        DeleteSecurityContext(sspictx);
        free(sspictx);
      }
      FreeCredentialsHandle(&sspicred);

      /* Only log error if client didn't disconnect. */
      if (mtype != EOF)
        ereport(ERROR,
            (errcode(ERRCODE_PROTOCOL_VIOLATION),
             errmsg("expected SSPI response, got message type %d",
                mtype)));
      return STATUS_ERROR;
    }

    /* Get the actual SSPI token */
    initStringInfo(&buf);
    if (pq_getmessage(&buf, PG_MAX_AUTH_TOKEN_LENGTH))
    {
      /* EOF - pq_getmessage already logged error */
      pfree(buf.data);
      if (sspictx != NULL)
      {
        DeleteSecurityContext(sspictx);
        free(sspictx);
      }
      FreeCredentialsHandle(&sspicred);
      return STATUS_ERROR;
    }

    /* Map to SSPI style buffer */
    inbuf.ulVersion = SECBUFFER_VERSION;
    inbuf.cBuffers = 1;
    inbuf.pBuffers = InBuffers;
    InBuffers[0].pvBuffer = buf.data;
    InBuffers[0].cbBuffer = buf.len;
    InBuffers[0].BufferType = SECBUFFER_TOKEN;

    /* Prepare output buffer */
    OutBuffers[0].pvBuffer = NULL;
    OutBuffers[0].BufferType = SECBUFFER_TOKEN;
    OutBuffers[0].cbBuffer = 0;
    outbuf.cBuffers = 1;
    outbuf.pBuffers = OutBuffers;
    outbuf.ulVersion = SECBUFFER_VERSION;

    elog(DEBUG4, "processing received SSPI token of length %u",
       (unsigned int) buf.len);

    r = AcceptSecurityContext(&sspicred,
                  sspictx,
                  &inbuf,
                  ASC_REQ_ALLOCATE_MEMORY,
                  SECURITY_NETWORK_DREP,
                  &newctx,
                  &outbuf,
                  &contextattr,
                  NULL);

    /* input buffer no longer used */
    pfree(buf.data);

    if (outbuf.cBuffers > 0 && outbuf.pBuffers[0].cbBuffer > 0)
    {
      /*
       * Negotiation generated data to be sent to the client.
       */
      elog(DEBUG4, "sending SSPI response token of length %u",
         (unsigned int) outbuf.pBuffers[0].cbBuffer);

      port->gss->outbuf.length = outbuf.pBuffers[0].cbBuffer;
      port->gss->outbuf.value = outbuf.pBuffers[0].pvBuffer;

      sendAuthRequest(port, AUTH_REQ_GSS_CONT,
              port->gss->outbuf.value, port->gss->outbuf.length);

      FreeContextBuffer(outbuf.pBuffers[0].pvBuffer);
    }

    if (r != SEC_E_OK && r != SEC_I_CONTINUE_NEEDED)
    {
      if (sspictx != NULL)
      {
        DeleteSecurityContext(sspictx);
        free(sspictx);
      }
      FreeCredentialsHandle(&sspicred);
      pg_SSPI_error(ERROR,
              _("could not accept SSPI security context"), r);
    }

    /*
     * Overwrite the current context with the one we just received. If
     * sspictx is NULL it was the first loop and we need to allocate a
     * buffer for it. On subsequent runs, we can just overwrite the buffer
     * contents since the size does not change.
     */
    if (sspictx == NULL)
    {
      sspictx = malloc(sizeof(CtxtHandle));
      if (sspictx == NULL)
        ereport(ERROR,
            (errmsg("out of memory")));
    }

    memcpy(sspictx, &newctx, sizeof(CtxtHandle));

    if (r == SEC_I_CONTINUE_NEEDED)
      elog(DEBUG4, "SSPI continue needed");

  } while (r == SEC_I_CONTINUE_NEEDED);


  /*
   * Release service principal credentials
   */
  FreeCredentialsHandle(&sspicred);


  /*
   * SEC_E_OK indicates that authentication is now complete.
   *
   * Get the name of the user that authenticated, and compare it to the pg
   * username that was specified for the connection.
   */

  r = QuerySecurityContextToken(sspictx, &token);
  if (r != SEC_E_OK)
    pg_SSPI_error(ERROR,
            _("could not get token from SSPI security context"), r);

  /*
   * No longer need the security context, everything from here on uses the
   * token instead.
   */
  DeleteSecurityContext(sspictx);
  free(sspictx);

  if (!GetTokenInformation(token, TokenUser, NULL, 0, &retlen) && GetLastError() != 122)
    ereport(ERROR,
        (errmsg_internal("could not get token information buffer size: error code %lu",
                 GetLastError())));

  tokenuser = malloc(retlen);
  if (tokenuser == NULL)
    ereport(ERROR,
        (errmsg("out of memory")));

  if (!GetTokenInformation(token, TokenUser, tokenuser, retlen, &retlen))
    ereport(ERROR,
        (errmsg_internal("could not get token information: error code %lu",
                 GetLastError())));

  CloseHandle(token);

  if (!LookupAccountSid(NULL, tokenuser->User.Sid, accountname, &accountnamesize,
              domainname, &domainnamesize, &accountnameuse))
    ereport(ERROR,
        (errmsg_internal("could not look up account SID: error code %lu",
                 GetLastError())));

  free(tokenuser);

  if (!port->hba->compat_realm)
  {
    int     status = pg_SSPI_make_upn(accountname, sizeof(accountname),
                        domainname, sizeof(domainname),
                        port->hba->upn_username);

    if (status != STATUS_OK)
      /* Error already reported from pg_SSPI_make_upn */
      return status;
  }

  /*
   * We have all of the information necessary to construct the authenticated
   * identity.  Set it now, rather than waiting for check_usermap below,
   * because authentication has already succeeded and we want the log file
   * to reflect that.
   */
  if (port->hba->compat_realm)
  {
    /* SAM-compatible format. */
    authn_id = psprintf("%s\\%s", domainname, accountname);
  }
  else
  {
    /* Kerberos principal format. */
    authn_id = psprintf("%s@%s", accountname, domainname);
  }

  set_authn_id(port, authn_id);
  pfree(authn_id);

  /*
   * Compare realm/domain if requested. In SSPI, always compare case
   * insensitive.
   */
  if (port->hba->krb_realm && strlen(port->hba->krb_realm))
  {
    if (pg_strcasecmp(port->hba->krb_realm, domainname) != 0)
    {
      elog(DEBUG2,
         "SSPI domain (%s) and configured domain (%s) don't match",
         domainname, port->hba->krb_realm);

      return STATUS_ERROR;
    }
  }

  /*
   * We have the username (without domain/realm) in accountname, compare to
   * the supplied value. In SSPI, always compare case insensitive.
   *
   * If set to include realm, append it in <username>@<realm> format.
   */
  if (port->hba->include_realm)
  {
    char     *namebuf;
    int     retval;

    namebuf = psprintf("%s@%s", accountname, domainname);
    retval = check_usermap(port->hba->usermap, port->user_name, namebuf, true);
    pfree(namebuf);
    return retval;
  }
  else
    return check_usermap(port->hba->usermap, port->user_name, accountname, true);
}

/*
 * Replaces the domainname with the Kerberos realm name,
 * and optionally the accountname with the Kerberos user name.
 */
static int
pg_SSPI_make_upn(char *accountname,
         size_t accountnamesize,
         char *domainname,
         size_t domainnamesize,
         bool update_accountname)
{
  char     *samname;
  char     *upname = NULL;
  char     *p = NULL;
  ULONG   upnamesize = 0;
  size_t    upnamerealmsize;
  BOOLEAN   res;

  /*
   * Build SAM name (DOMAIN\user), then translate to UPN
   * (user@kerberos.realm). The realm name is returned in lower case, but
   * that is fine because in SSPI auth, string comparisons are always
   * case-insensitive.
   */

  samname = psprintf("%s\\%s", domainname, accountname);
  res = TranslateName(samname, NameSamCompatible, NameUserPrincipal,
            NULL, &upnamesize);

  if ((!res && GetLastError() != ERROR_INSUFFICIENT_BUFFER)
    || upnamesize == 0)
  {
    pfree(samname);
    ereport(LOG,
        (errcode(ERRCODE_INVALID_ROLE_SPECIFICATION),
         errmsg("could not translate name")));
    return STATUS_ERROR;
  }

  /* upnamesize includes the terminating NUL. */
  upname = palloc(upnamesize);

  res = TranslateName(samname, NameSamCompatible, NameUserPrincipal,
            upname, &upnamesize);

  pfree(samname);
  if (res)
    p = strchr(upname, '@');

  if (!res || p == NULL)
  {
    pfree(upname);
    ereport(LOG,
        (errcode(ERRCODE_INVALID_ROLE_SPECIFICATION),
         errmsg("could not translate name")));
    return STATUS_ERROR;
  }

  /* Length of realm name after the '@', including the NUL. */
  upnamerealmsize = upnamesize - (p - upname + 1);

  /* Replace domainname with realm name. */
  if (upnamerealmsize > domainnamesize)
  {
    pfree(upname);
    ereport(LOG,
        (errcode(ERRCODE_INVALID_ROLE_SPECIFICATION),
         errmsg("realm name too long")));
    return STATUS_ERROR;
  }

  /* Length is now safe. */
  strcpy(domainname, p + 1);

  /* Replace account name as well (in case UPN != SAM)? */
  if (update_accountname)
  {
    if ((p - upname + 1) > accountnamesize)
    {
      pfree(upname);
      ereport(LOG,
          (errcode(ERRCODE_INVALID_ROLE_SPECIFICATION),
           errmsg("translated account name too long")));
      return STATUS_ERROR;
    }

    *p = 0;
    strcpy(accountname, upname);
  }

  pfree(upname);
  return STATUS_OK;
}
#endif              /* ENABLE_SSPI */



/*----------------------------------------------------------------
 * Ident authentication system
 *----------------------------------------------------------------
 */

/*
 * Per RFC 1413, space and tab are whitespace in ident messages.
 */
static bool
is_ident_whitespace(const char c)
{
  return c == ' ' || c == '\t';
}

/*
 *  Parse the string "*ident_response" as a response from a query to an Ident
 *  server.  If it's a normal response indicating a user name, return true
 *  and store the user name at *ident_user. If it's anything else,
 *  return false.
 */
static bool
interpret_ident_response(const char *ident_response,
             char *ident_user)
{
  const char *cursor = ident_response;  /* Cursor into *ident_response */

  /*
   * Ident's response, in the telnet tradition, should end in crlf (\r\n).
   */
  if (strlen(ident_response) < 2)
    return false;
  else if (ident_response[strlen(ident_response) - 2] != '\r')
    return false;
  else
  {
    while (*cursor != ':' && *cursor != '\r')
      cursor++;     /* skip port field */

    if (*cursor != ':')
      return false;
    else
    {
      /* We're positioned to colon before response type field */
      char    response_type[80];
      int     i;    /* Index into *response_type */

      cursor++;     /* Go over colon */
      while (is_ident_whitespace(*cursor))
        cursor++;   /* skip blanks */
      i = 0;
      while (*cursor != ':' && *cursor != '\r' && !is_ident_whitespace(*cursor) &&
           i < (int) (sizeof(response_type) - 1))
        response_type[i++] = *cursor++;
      response_type[i] = '\0';
      while (is_ident_whitespace(*cursor))
        cursor++;   /* skip blanks */
      if (strcmp(response_type, "USERID") != 0)
        return false;
      else
      {
        /*
         * It's a USERID response.  Good.  "cursor" should be pointing
         * to the colon that precedes the operating system type.
         */
        if (*cursor != ':')
          return false;
        else
        {
          cursor++; /* Go over colon */
          /* Skip over operating system field. */
          while (*cursor != ':' && *cursor != '\r')
            cursor++;
          if (*cursor != ':')
            return false;
          else
          {
            cursor++; /* Go over colon */
            while (is_ident_whitespace(*cursor))
              cursor++; /* skip blanks */
            /* Rest of line is user name.  Copy it over. */
            i = 0;
            while (*cursor != '\r' && i < IDENT_USERNAME_MAX)
              ident_user[i++] = *cursor++;
            ident_user[i] = '\0';
            return true;
          }
        }
      }
    }
  }
}


/*
 *  Talk to the ident server on "remote_addr" and find out who
 *  owns the tcp connection to "local_addr"
 *  If the username is successfully retrieved, check the usermap.
 *
 *  XXX: Using WaitLatchOrSocket() and doing a CHECK_FOR_INTERRUPTS() if the
 *  latch was set would improve the responsiveness to timeouts/cancellations.
 */
static int
ident_inet(Port *port)
{
  const SockAddr remote_addr = port->raddr;
  const SockAddr local_addr = port->laddr;
  char    ident_user[IDENT_USERNAME_MAX + 1];
  pgsocket  sock_fd = PGINVALID_SOCKET; /* for talking to Ident server */
  int     rc;       /* Return code from a locally called function */
  bool    ident_return;
  char    remote_addr_s[NI_MAXHOST];
  char    remote_port[NI_MAXSERV];
  char    local_addr_s[NI_MAXHOST];
  char    local_port[NI_MAXSERV];
  char    ident_port[NI_MAXSERV];
  char    ident_query[80];
  char    ident_response[80 + IDENT_USERNAME_MAX];
  struct addrinfo *ident_serv = NULL,
         *la = NULL,
        hints;

  /*
   * Might look a little weird to first convert it to text and then back to
   * sockaddr, but it's protocol independent.
   */
  pg_getnameinfo_all(&remote_addr.addr, remote_addr.salen,
             remote_addr_s, sizeof(remote_addr_s),
             remote_port, sizeof(remote_port),
             NI_NUMERICHOST | NI_NUMERICSERV);
  pg_getnameinfo_all(&local_addr.addr, local_addr.salen,
             local_addr_s, sizeof(local_addr_s),
             local_port, sizeof(local_port),
             NI_NUMERICHOST | NI_NUMERICSERV);

  snprintf(ident_port, sizeof(ident_port), "%d", IDENT_PORT);
  hints.ai_flags = AI_NUMERICHOST;
  hints.ai_family = remote_addr.addr.ss_family;
  hints.ai_socktype = SOCK_STREAM;
  hints.ai_protocol = 0;
  hints.ai_addrlen = 0;
  hints.ai_canonname = NULL;
  hints.ai_addr = NULL;
  hints.ai_next = NULL;
  rc = pg_getaddrinfo_all(remote_addr_s, ident_port, &hints, &ident_serv);
  if (rc || !ident_serv)
  {
    /* we don't expect this to happen */
    ident_return = false;
    goto ident_inet_done;
  }

  hints.ai_flags = AI_NUMERICHOST;
  hints.ai_family = local_addr.addr.ss_family;
  hints.ai_socktype = SOCK_STREAM;
  hints.ai_protocol = 0;
  hints.ai_addrlen = 0;
  hints.ai_canonname = NULL;
  hints.ai_addr = NULL;
  hints.ai_next = NULL;
  rc = pg_getaddrinfo_all(local_addr_s, NULL, &hints, &la);
  if (rc || !la)
  {
    /* we don't expect this to happen */
    ident_return = false;
    goto ident_inet_done;
  }

  sock_fd = socket(ident_serv->ai_family, ident_serv->ai_socktype,
           ident_serv->ai_protocol);
  if (sock_fd == PGINVALID_SOCKET)
  {
    ereport(LOG,
        (errcode_for_socket_access(),
         errmsg("could not create socket for Ident connection: %m")));
    ident_return = false;
    goto ident_inet_done;
  }

  /*
   * Bind to the address which the client originally contacted, otherwise
   * the ident server won't be able to match up the right connection. This
   * is necessary if the PostgreSQL server is running on an IP alias.
   */
  rc = bind(sock_fd, la->ai_addr, la->ai_addrlen);
  if (rc != 0)
  {
    ereport(LOG,
        (errcode_for_socket_access(),
         errmsg("could not bind to local address \"%s\": %m",
            local_addr_s)));
    ident_return = false;
    goto ident_inet_done;
  }

  rc = connect(sock_fd, ident_serv->ai_addr,
         ident_serv->ai_addrlen);
  if (rc != 0)
  {
    ereport(LOG,
        (errcode_for_socket_access(),
         errmsg("could not connect to Ident server at address \"%s\", port %s: %m",
            remote_addr_s, ident_port)));
    ident_return = false;
    goto ident_inet_done;
  }

  /* The query we send to the Ident server */
  snprintf(ident_query, sizeof(ident_query), "%s,%s\r\n",
       remote_port, local_port);

  /* loop in case send is interrupted */
  do
  {
    CHECK_FOR_INTERRUPTS();

    rc = send(sock_fd, ident_query, strlen(ident_query), 0);
  } while (rc < 0 && errno == EINTR);

  if (rc < 0)
  {
    ereport(LOG,
        (errcode_for_socket_access(),
         errmsg("could not send query to Ident server at address \"%s\", port %s: %m",
            remote_addr_s, ident_port)));
    ident_return = false;
    goto ident_inet_done;
  }

  do
  {
    CHECK_FOR_INTERRUPTS();

    rc = recv(sock_fd, ident_response, sizeof(ident_response) - 1, 0);
  } while (rc < 0 && errno == EINTR);

  if (rc < 0)
  {
    ereport(LOG,
        (errcode_for_socket_access(),
         errmsg("could not receive response from Ident server at address \"%s\", port %s: %m",
            remote_addr_s, ident_port)));
    ident_return = false;
    goto ident_inet_done;
  }

  ident_response[rc] = '\0';
  ident_return = interpret_ident_response(ident_response, ident_user);
  if (!ident_return)
    ereport(LOG,
        (errmsg("invalidly formatted response from Ident server: \"%s\"",
            ident_response)));

ident_inet_done:
  if (sock_fd != PGINVALID_SOCKET)
    closesocket(sock_fd);
  if (ident_serv)
    pg_freeaddrinfo_all(remote_addr.addr.ss_family, ident_serv);
  if (la)
    pg_freeaddrinfo_all(local_addr.addr.ss_family, la);

  if (ident_return)
  {
    /*
     * Success!  Store the identity, then check the usermap. Note that
     * setting the authenticated identity is done before checking the
     * usermap, because at this point authentication has succeeded.
     */
    set_authn_id(port, ident_user);
    return check_usermap(port->hba->usermap, port->user_name, ident_user, false);
  }
  return STATUS_ERROR;
}


/*----------------------------------------------------------------
 * Peer authentication system
 *----------------------------------------------------------------
 */

/*
 *  Ask kernel about the credentials of the connecting process,
 *  determine the symbolic name of the corresponding user, and check
 *  if valid per the usermap.
 *
 *  Iff authorized, return STATUS_OK, otherwise return STATUS_ERROR.
 */
static int
auth_peer(Port *port)
{
  uid_t   uid;
  gid_t   gid;
#ifndef WIN32
  struct passwd pwbuf;
  struct passwd *pw;
  char    buf[1024];
  int     rc;
  int     ret;
#endif

  if (getpeereid(port->sock, &uid, &gid) != 0)
  {
    /* Provide special error message if getpeereid is a stub */
    if (errno == ENOSYS)
      ereport(LOG,
          (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
           errmsg("peer authentication is not supported on this platform")));
    else
      ereport(LOG,
          (errcode_for_socket_access(),
           errmsg("could not get peer credentials: %m")));
    return STATUS_ERROR;
  }

#ifndef WIN32
  rc = getpwuid_r(uid, &pwbuf, buf, sizeof buf, &pw);
  if (rc != 0)
  {
    errno = rc;
    ereport(LOG,
        errmsg("could not look up local user ID %ld: %m", (long) uid));
    return STATUS_ERROR;
  }
  else if (!pw)
  {
    ereport(LOG,
        errmsg("local user with ID %ld does not exist", (long) uid));
    return STATUS_ERROR;
  }

  /*
   * Make a copy of static getpw*() result area; this is our authenticated
   * identity.  Set it before calling check_usermap, because authentication
   * has already succeeded and we want the log file to reflect that.
   */
  set_authn_id(port, pw->pw_name);

  ret = check_usermap(port->hba->usermap, port->user_name,
            MyClientConnectionInfo.authn_id, false);

  return ret;
#else
  /* should have failed with ENOSYS above */
  Assert(false);
  return STATUS_ERROR;
#endif
}


/*----------------------------------------------------------------
 * PAM authentication system
 *----------------------------------------------------------------
 */
#ifdef USE_PAM

/*
 * PAM conversation function
 */

static int
pam_passwd_conv_proc(int num_msg, PG_PAM_CONST struct pam_message **msg,
           struct pam_response **resp, void *appdata_ptr)
{
  const char *passwd;
  struct pam_response *reply;
  int     i;

  if (appdata_ptr)
    passwd = (char *) appdata_ptr;
  else
  {
    /*
     * Workaround for Solaris 2.6 where the PAM library is broken and does
     * not pass appdata_ptr to the conversation routine
     */
    passwd = pam_passwd;
  }

  *resp = NULL;       /* in case of error exit */

  if (num_msg <= 0 || num_msg > PAM_MAX_NUM_MSG)
    return PAM_CONV_ERR;

  /*
   * Explicitly not using palloc here - PAM will free this memory in
   * pam_end()
   */
  if ((reply = calloc(num_msg, sizeof(struct pam_response))) == NULL)
  {
    ereport(LOG,
        (errcode(ERRCODE_OUT_OF_MEMORY),
         errmsg("out of memory")));
    return PAM_CONV_ERR;
  }

  for (i = 0; i < num_msg; i++)
  {
    switch (msg[i]->msg_style)
    {
      case PAM_PROMPT_ECHO_OFF:
        if (strlen(passwd) == 0)
        {
          /*
           * Password wasn't passed to PAM the first time around -
           * let's go ask the client to send a password, which we
           * then stuff into PAM.
           */
          sendAuthRequest(pam_port_cludge, AUTH_REQ_PASSWORD, NULL, 0);
          passwd = recv_password_packet(pam_port_cludge);
          if (passwd == NULL)
          {
            /*
             * Client didn't want to send password.  We
             * intentionally do not log anything about this,
             * either here or at higher levels.
             */
            pam_no_password = true;
            goto fail;
          }
        }
        if ((reply[i].resp = strdup(passwd)) == NULL)
          goto fail;
        reply[i].resp_retcode = PAM_SUCCESS;
        break;
      case PAM_ERROR_MSG:
        ereport(LOG,
            (errmsg("error from underlying PAM layer: %s",
                msg[i]->msg)));
        pg_fallthrough;
      case PAM_TEXT_INFO:
        /* we don't bother to log TEXT_INFO messages */
        if ((reply[i].resp = strdup("")) == NULL)
          goto fail;
        reply[i].resp_retcode = PAM_SUCCESS;
        break;
      default:
        ereport(LOG,
            (errmsg("unsupported PAM conversation %d/\"%s\"",
                msg[i]->msg_style,
                msg[i]->msg ? msg[i]->msg : "(none)")));
        goto fail;
    }
  }

  *resp = reply;
  return PAM_SUCCESS;

fail:
  /* free up whatever we allocated */
  for (i = 0; i < num_msg; i++)
    free(reply[i].resp);
  free(reply);

  return PAM_CONV_ERR;
}


/*
 * Check authentication against PAM.
 */
static int
CheckPAMAuth(Port *port, const char *user, const char *password)
{
  int     retval;
  pam_handle_t *pamh = NULL;

  /*
   * We can't entirely rely on PAM to pass through appdata --- it appears
   * not to work on at least Solaris 2.6.  So use these ugly static
   * variables instead.
   */
  pam_passwd = password;
  pam_port_cludge = port;
  pam_no_password = false;

  /*
   * Set the application data portion of the conversation struct.  This is
   * later used inside the PAM conversation to pass the password to the
   * authentication module.
   */
  pam_passw_conv.appdata_ptr = unconstify(char *, password);  /* from password above,
                                 * not allocated */

  /* Optionally, one can set the service name in pg_hba.conf */
  if (port->hba->pamservice && port->hba->pamservice[0] != '\0')
    retval = pam_start(port->hba->pamservice, "pgsql@",
               &pam_passw_conv, &pamh);
  else
    retval = pam_start(PGSQL_PAM_SERVICE, "pgsql@",
               &pam_passw_conv, &pamh);

  if (retval != PAM_SUCCESS)
  {
    ereport(LOG,
        (errmsg("could not create PAM authenticator: %s",
            pam_strerror(pamh, retval))));
    pam_passwd = NULL;    /* Unset pam_passwd */
    return STATUS_ERROR;
  }

  retval = pam_set_item(pamh, PAM_USER, user);

  if (retval != PAM_SUCCESS)
  {
    ereport(LOG,
        (errmsg("pam_set_item(PAM_USER) failed: %s",
            pam_strerror(pamh, retval))));
    pam_passwd = NULL;    /* Unset pam_passwd */
    return STATUS_ERROR;
  }

  if (port->hba->conntype != ctLocal)
  {
    char    hostinfo[NI_MAXHOST];
    int     flags;

    if (port->hba->pam_use_hostname)
      flags = 0;
    else
      flags = NI_NUMERICHOST | NI_NUMERICSERV;

    retval = pg_getnameinfo_all(&port->raddr.addr, port->raddr.salen,
                  hostinfo, sizeof(hostinfo), NULL, 0,
                  flags);
    if (retval != 0)
    {
      ereport(WARNING,
          (errmsg_internal("pg_getnameinfo_all() failed: %s",
                   gai_strerror(retval))));
      return STATUS_ERROR;
    }

    retval = pam_set_item(pamh, PAM_RHOST, hostinfo);

    if (retval != PAM_SUCCESS)
    {
      ereport(LOG,
          (errmsg("pam_set_item(PAM_RHOST) failed: %s",
              pam_strerror(pamh, retval))));
      pam_passwd = NULL;
      return STATUS_ERROR;
    }
  }

  retval = pam_set_item(pamh, PAM_CONV, &pam_passw_conv);

  if (retval != PAM_SUCCESS)
  {
    ereport(LOG,
        (errmsg("pam_set_item(PAM_CONV) failed: %s",
            pam_strerror(pamh, retval))));
    pam_passwd = NULL;    /* Unset pam_passwd */
    return STATUS_ERROR;
  }

  retval = pam_authenticate(pamh, 0);

  if (retval != PAM_SUCCESS)
  {
    /* If pam_passwd_conv_proc saw EOF, don't log anything */
    if (!pam_no_password)
      ereport(LOG,
          (errmsg("pam_authenticate failed: %s",
              pam_strerror(pamh, retval))));
    pam_passwd = NULL;    /* Unset pam_passwd */
    return pam_no_password ? STATUS_EOF : STATUS_ERROR;
  }

  retval = pam_acct_mgmt(pamh, 0);

  if (retval != PAM_SUCCESS)
  {
    /* If pam_passwd_conv_proc saw EOF, don't log anything */
    if (!pam_no_password)
      ereport(LOG,
          (errmsg("pam_acct_mgmt failed: %s",
              pam_strerror(pamh, retval))));
    pam_passwd = NULL;    /* Unset pam_passwd */
    return pam_no_password ? STATUS_EOF : STATUS_ERROR;
  }

  retval = pam_end(pamh, retval);

  if (retval != PAM_SUCCESS)
  {
    ereport(LOG,
        (errmsg("could not release PAM authenticator: %s",
            pam_strerror(pamh, retval))));
  }

  pam_passwd = NULL;      /* Unset pam_passwd */

  if (retval == PAM_SUCCESS)
    set_authn_id(port, user);

  return (retval == PAM_SUCCESS ? STATUS_OK : STATUS_ERROR);
}
#endif              /* USE_PAM */


/*----------------------------------------------------------------
 * BSD authentication system
 *----------------------------------------------------------------
 */
#ifdef USE_BSD_AUTH
static int
CheckBSDAuth(Port *port, char *user)
{
  char     *passwd;
  int     retval;

  /* Send regular password request to client, and get the response */
  sendAuthRequest(port, AUTH_REQ_PASSWORD, NULL, 0);

  passwd = recv_password_packet(port);
  if (passwd == NULL)
    return STATUS_EOF;

  /*
   * Ask the BSD auth system to verify password.  Note that auth_userokay
   * will overwrite the password string with zeroes, but it's just a
   * temporary string so we don't care.
   */
  retval = auth_userokay(user, NULL, "auth-postgresql", passwd);

  pfree(passwd);

  if (!retval)
    return STATUS_ERROR;

  set_authn_id(port, user);
  return STATUS_OK;
}
#endif              /* USE_BSD_AUTH */


/*----------------------------------------------------------------
 * LDAP authentication system
 *----------------------------------------------------------------
 */
#ifdef USE_LDAP

static int  errdetail_for_ldap(LDAP *ldap);

/*
 * Initialize a connection to the LDAP server, including setting up
 * TLS if requested.
 */
static int
InitializeLDAPConnection(Port *port, LDAP **ldap)
{
  const char *scheme;
  int     ldapversion = LDAP_VERSION3;
  int     r;

  scheme = port->hba->ldapscheme;
  if (scheme == NULL)
    scheme = "ldap";
#ifdef WIN32
  if (strcmp(scheme, "ldaps") == 0)
    *ldap = ldap_sslinit(port->hba->ldapserver, port->hba->ldapport, 1);
  else
    *ldap = ldap_init(port->hba->ldapserver, port->hba->ldapport);
  if (!*ldap)
  {
    ereport(LOG,
        (errmsg("could not initialize LDAP: error code %lu",
            LdapGetLastError())));

    return STATUS_ERROR;
  }
#else
#ifdef HAVE_LDAP_INITIALIZE

  /*
   * OpenLDAP provides a non-standard extension ldap_initialize() that takes
   * a list of URIs, allowing us to request "ldaps" instead of "ldap".  It
   * also provides ldap_domain2hostlist() to find LDAP servers automatically
   * using DNS SRV.  They were introduced in the same version, so for now we
   * don't have an extra configure check for the latter.
   */
  {
    StringInfoData uris;
    char     *hostlist = NULL;
    char     *p;
    bool    append_port;

    /* We'll build a space-separated scheme://hostname:port list here */
    initStringInfo(&uris);

    /*
     * If pg_hba.conf provided no hostnames, we can ask OpenLDAP to try to
     * find some by extracting a domain name from the base DN and looking
     * up DSN SRV records for _ldap._tcp.<domain>.
     */
    if (!port->hba->ldapserver || port->hba->ldapserver[0] == '\0')
    {
      char     *domain;

      /* ou=blah,dc=foo,dc=bar -> foo.bar */
      if (ldap_dn2domain(port->hba->ldapbasedn, &domain))
      {
        ereport(LOG,
            (errmsg("could not extract domain name from ldapbasedn")));
        return STATUS_ERROR;
      }

      /* Look up a list of LDAP server hosts and port numbers */
      if (ldap_domain2hostlist(domain, &hostlist))
      {
        ereport(LOG,
            (errmsg("LDAP authentication could not find DNS SRV records for \"%s\"",
                domain),
             (errhint("Set an LDAP server name explicitly."))));
        ldap_memfree(domain);
        return STATUS_ERROR;
      }
      ldap_memfree(domain);

      /* We have a space-separated list of host:port entries */
      p = hostlist;
      append_port = false;
    }
    else
    {
      /* We have a space-separated list of hosts from pg_hba.conf */
      p = port->hba->ldapserver;
      append_port = true;
    }

    /* Convert the list of host[:port] entries to full URIs */
    do
    {
      size_t    size;

      /* Find the span of the next entry */
      size = strcspn(p, " ");

      /* Append a space separator if this isn't the first URI */
      if (uris.len > 0)
        appendStringInfoChar(&uris, ' ');

      /* Append scheme://host:port */
      appendStringInfoString(&uris, scheme);
      appendStringInfoString(&uris, "://");
      appendBinaryStringInfo(&uris, p, size);
      if (append_port)
        appendStringInfo(&uris, ":%d", port->hba->ldapport);

      /* Step over this entry and any number of trailing spaces */
      p += size;
      while (*p == ' ')
        ++p;
    } while (*p);

    /* Free memory from OpenLDAP if we looked up SRV records */
    if (hostlist)
      ldap_memfree(hostlist);

    /* Finally, try to connect using the URI list */
    r = ldap_initialize(ldap, uris.data);
    pfree(uris.data);
    if (r != LDAP_SUCCESS)
    {
      ereport(LOG,
          (errmsg("could not initialize LDAP: %s",
              ldap_err2string(r))));

      return STATUS_ERROR;
    }
  }
#else
  if (strcmp(scheme, "ldaps") == 0)
  {
    ereport(LOG,
        (errmsg("ldaps not supported with this LDAP library")));

    return STATUS_ERROR;
  }
  *ldap = ldap_init(port->hba->ldapserver, port->hba->ldapport);
  if (!*ldap)
  {
    ereport(LOG,
        (errmsg("could not initialize LDAP: %m")));

    return STATUS_ERROR;
  }
#endif
#endif

  if ((r = ldap_set_option(*ldap, LDAP_OPT_PROTOCOL_VERSION, &ldapversion)) != LDAP_SUCCESS)
  {
    ereport(LOG,
        (errmsg("could not set LDAP protocol version: %s",
            ldap_err2string(r)),
         errdetail_for_ldap(*ldap)));
    ldap_unbind(*ldap);
    return STATUS_ERROR;
  }

  if (port->hba->ldaptls)
  {
#ifndef WIN32
    if ((r = ldap_start_tls_s(*ldap, NULL, NULL)) != LDAP_SUCCESS)
#else
    if ((r = ldap_start_tls_s(*ldap, NULL, NULL, NULL, NULL)) != LDAP_SUCCESS)
#endif
    {
      ereport(LOG,
          (errmsg("could not start LDAP TLS session: %s",
              ldap_err2string(r)),
           errdetail_for_ldap(*ldap)));
      ldap_unbind(*ldap);
      return STATUS_ERROR;
    }
  }

  return STATUS_OK;
}

/* Placeholders recognized by FormatSearchFilter.  For now just one. */
#define LPH_USERNAME "$username"
#define LPH_USERNAME_LEN (sizeof(LPH_USERNAME) - 1)

/* Not all LDAP implementations define this. */
#ifndef LDAP_NO_ATTRS
#define LDAP_NO_ATTRS "1.1"
#endif

/* Not all LDAP implementations define this. */
#ifndef LDAPS_PORT
#define LDAPS_PORT 636
#endif

static char *
dummy_ldap_password_mutator(char *input)
{
  return input;
}

/*
 * Return a newly allocated C string copied from "pattern" with all
 * occurrences of the placeholder "$username" replaced with "user_name".
 */
static char *
FormatSearchFilter(const char *pattern, const char *user_name)
{
  StringInfoData output;

  initStringInfo(&output);
  while (*pattern != '\0')
  {
    if (strncmp(pattern, LPH_USERNAME, LPH_USERNAME_LEN) == 0)
    {
      appendStringInfoString(&output, user_name);
      pattern += LPH_USERNAME_LEN;
    }
    else
      appendStringInfoChar(&output, *pattern++);
  }

  return output.data;
}

/*
 * Perform LDAP authentication
 */
static int
CheckLDAPAuth(Port *port)
{
  char     *passwd;
  LDAP     *ldap;
  int     r;
  char     *fulluser;
  const char *server_name;

#ifdef HAVE_LDAP_INITIALIZE

  /*
   * For OpenLDAP, allow empty hostname if we have a basedn.  We'll look for
   * servers with DNS SRV records via OpenLDAP library facilities.
   */
  if ((!port->hba->ldapserver || port->hba->ldapserver[0] == '\0') &&
    (!port->hba->ldapbasedn || port->hba->ldapbasedn[0] == '\0'))
  {
    ereport(LOG,
        (errmsg("LDAP server not specified, and no ldapbasedn")));
    return STATUS_ERROR;
  }
#else
  if (!port->hba->ldapserver || port->hba->ldapserver[0] == '\0')
  {
    ereport(LOG,
        (errmsg("LDAP server not specified")));
    return STATUS_ERROR;
  }
#endif

  /*
   * If we're using SRV records, we don't have a server name so we'll just
   * show an empty string in error messages.
   */
  server_name = port->hba->ldapserver ? port->hba->ldapserver : "";

  if (port->hba->ldapport == 0)
  {
    if (port->hba->ldapscheme != NULL &&
      strcmp(port->hba->ldapscheme, "ldaps") == 0)
      port->hba->ldapport = LDAPS_PORT;
    else
      port->hba->ldapport = LDAP_PORT;
  }

  sendAuthRequest(port, AUTH_REQ_PASSWORD, NULL, 0);

  passwd = recv_password_packet(port);
  if (passwd == NULL)
    return STATUS_EOF;    /* client wouldn't send password */

  if (InitializeLDAPConnection(port, &ldap) == STATUS_ERROR)
  {
    /* Error message already sent */
    pfree(passwd);
    return STATUS_ERROR;
  }

  if (port->hba->ldapbasedn)
  {
    /*
     * First perform an LDAP search to find the DN for the user we are
     * trying to log in as.
     */
    char     *filter;
    LDAPMessage *search_message;
    LDAPMessage *entry;
    char     *attributes[] = {LDAP_NO_ATTRS, NULL};
    char     *dn;
    char     *c;
    int     count;

    /*
     * Disallow any characters that we would otherwise need to escape,
     * since they aren't really reasonable in a username anyway. Allowing
     * them would make it possible to inject any kind of custom filters in
     * the LDAP filter.
     */
    for (c = port->user_name; *c; c++)
    {
      if (*c == '*' ||
        *c == '(' ||
        *c == ')' ||
        *c == '\\' ||
        *c == '/')
      {
        ereport(LOG,
            (errmsg("invalid character in user name for LDAP authentication")));
        ldap_unbind(ldap);
        pfree(passwd);
        return STATUS_ERROR;
      }
    }

    /*
     * Bind with a pre-defined username/password (if available) for
     * searching. If none is specified, this turns into an anonymous bind.
     */
    r = ldap_simple_bind_s(ldap,
                 port->hba->ldapbinddn ? port->hba->ldapbinddn : "",
                 port->hba->ldapbindpasswd ? ldap_password_hook(port->hba->ldapbindpasswd) : "");
    if (r != LDAP_SUCCESS)
    {
      ereport(LOG,
          (errmsg("could not perform initial LDAP bind for ldapbinddn \"%s\" on server \"%s\": %s",
              port->hba->ldapbinddn ? port->hba->ldapbinddn : "",
              server_name,
              ldap_err2string(r)),
           errdetail_for_ldap(ldap)));
      ldap_unbind(ldap);
      pfree(passwd);
      return STATUS_ERROR;
    }

    /* Build a custom filter or a single attribute filter? */
    if (port->hba->ldapsearchfilter)
      filter = FormatSearchFilter(port->hba->ldapsearchfilter, port->user_name);
    else if (port->hba->ldapsearchattribute)
      filter = psprintf("(%s=%s)", port->hba->ldapsearchattribute, port->user_name);
    else
      filter = psprintf("(uid=%s)", port->user_name);

    search_message = NULL;
    r = ldap_search_s(ldap,
              port->hba->ldapbasedn,
              port->hba->ldapscope,
              filter,
              attributes,
              0,
              &search_message);

    if (r != LDAP_SUCCESS)
    {
      ereport(LOG,
          (errmsg("could not search LDAP for filter \"%s\" on server \"%s\": %s",
              filter, server_name, ldap_err2string(r)),
           errdetail_for_ldap(ldap)));
      if (search_message != NULL)
        ldap_msgfree(search_message);
      ldap_unbind(ldap);
      pfree(passwd);
      pfree(filter);
      return STATUS_ERROR;
    }

    count = ldap_count_entries(ldap, search_message);
    if (count != 1)
    {
      if (count == 0)
        ereport(LOG,
            (errmsg("LDAP user \"%s\" does not exist", port->user_name),
             errdetail("LDAP search for filter \"%s\" on server \"%s\" returned no entries.",
                   filter, server_name)));
      else
        ereport(LOG,
            (errmsg("LDAP user \"%s\" is not unique", port->user_name),
             errdetail_plural("LDAP search for filter \"%s\" on server \"%s\" returned %d entry.",
                      "LDAP search for filter \"%s\" on server \"%s\" returned %d entries.",
                      count,
                      filter, server_name, count)));

      ldap_unbind(ldap);
      pfree(passwd);
      pfree(filter);
      ldap_msgfree(search_message);
      return STATUS_ERROR;
    }

    entry = ldap_first_entry(ldap, search_message);
    dn = ldap_get_dn(ldap, entry);
    if (dn == NULL)
    {
      int     error;

      (void) ldap_get_option(ldap, LDAP_OPT_ERROR_NUMBER, &error);
      ereport(LOG,
          (errmsg("could not get dn for the first entry matching \"%s\" on server \"%s\": %s",
              filter, server_name,
              ldap_err2string(error)),
           errdetail_for_ldap(ldap)));
      ldap_unbind(ldap);
      pfree(passwd);
      pfree(filter);
      ldap_msgfree(search_message);
      return STATUS_ERROR;
    }
    fulluser = pstrdup(dn);

    pfree(filter);
    ldap_memfree(dn);
    ldap_msgfree(search_message);
  }
  else
    fulluser = psprintf("%s%s%s",
              port->hba->ldapprefix ? port->hba->ldapprefix : "",
              port->user_name,
              port->hba->ldapsuffix ? port->hba->ldapsuffix : "");

  r = ldap_simple_bind_s(ldap, fulluser, passwd);

  if (r != LDAP_SUCCESS)
  {
    ereport(LOG,
        (errmsg("LDAP login failed for user \"%s\" on server \"%s\": %s",
            fulluser, server_name, ldap_err2string(r)),
         errdetail_for_ldap(ldap)));
    ldap_unbind(ldap);
    pfree(passwd);
    pfree(fulluser);
    return STATUS_ERROR;
  }

  /* Save the original bind DN as the authenticated identity. */
  set_authn_id(port, fulluser);

  ldap_unbind(ldap);
  pfree(passwd);
  pfree(fulluser);

  return STATUS_OK;
}

/*
 * Add a detail error message text to the current error if one can be
 * constructed from the LDAP 'diagnostic message'.
 */
static int
errdetail_for_ldap(LDAP *ldap)
{
  char     *message;
  int     rc;

  rc = ldap_get_option(ldap, LDAP_OPT_DIAGNOSTIC_MESSAGE, &message);
  if (rc == LDAP_SUCCESS && message != NULL)
  {
    errdetail("LDAP diagnostics: %s", message);
    ldap_memfree(message);
  }

  return 0;
}

#endif              /* USE_LDAP */


/*----------------------------------------------------------------
 * SSL client certificate authentication
 *----------------------------------------------------------------
 */
#ifdef USE_SSL
static int
CheckCertAuth(Port *port)
{
  int     status_check_usermap = STATUS_ERROR;
  char     *peer_username = NULL;

  Assert(port->ssl);

  /* select the correct field to compare */
  switch (port->hba->clientcertname)
  {
    case clientCertDN:
      peer_username = port->peer_dn;
      break;
    case clientCertCN:
      peer_username = port->peer_cn;
  }

  /* Make sure we have received a username in the certificate */
  if (peer_username == NULL ||
    strlen(peer_username) <= 0)
  {
    ereport(LOG,
        (errmsg("certificate authentication failed for user \"%s\": client certificate contains no user name",
            port->user_name)));
    return STATUS_ERROR;
  }

  if (port->hba->auth_method == uaCert)
  {
    /*
     * For cert auth, the client's Subject DN is always our authenticated
     * identity, even if we're only using its CN for authorization.  Set
     * it now, rather than waiting for check_usermap() below, because
     * authentication has already succeeded and we want the log file to
     * reflect that.
     */
    if (!port->peer_dn)
    {
      /*
       * This should not happen as both peer_dn and peer_cn should be
       * set in this context.
       */
      ereport(LOG,
          (errmsg("certificate authentication failed for user \"%s\": unable to retrieve subject DN",
              port->user_name)));
      return STATUS_ERROR;
    }

    set_authn_id(port, port->peer_dn);
  }

  /* Just pass the certificate cn/dn to the usermap check */
  status_check_usermap = check_usermap(port->hba->usermap, port->user_name, peer_username, false);
  if (status_check_usermap != STATUS_OK)
  {
    /*
     * If clientcert=verify-full was specified and the authentication
     * method is other than uaCert, log the reason for rejecting the
     * authentication.
     */
    if (port->hba->clientcert == clientCertFull && port->hba->auth_method != uaCert)
    {
      switch (port->hba->clientcertname)
      {
        case clientCertDN:
          ereport(LOG,
              (errmsg("certificate validation (clientcert=verify-full) failed for user \"%s\": DN mismatch",
                  port->user_name)));
          break;
        case clientCertCN:
          ereport(LOG,
              (errmsg("certificate validation (clientcert=verify-full) failed for user \"%s\": CN mismatch",
                  port->user_name)));
      }
    }
  }
  return status_check_usermap;
}
#endif

Coverage Report

Created: 2026-10-16 06:48