fe-secure-openssl.c File Reference

#include "postgres_fe.h"
#include <signal.h>
#include <fcntl.h>
#include <ctype.h>
#include <limits.h>
#include "libpq-fe.h"
#include "fe-auth.h"
#include "fe-secure-common.h"
#include "libpq-int.h"
#include <sys/socket.h>
#include <unistd.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <sys/stat.h>
#include <pthread.h>
#include "common/openssl.h"
#include <openssl/ssl.h>
#include <openssl/conf.h>
#include <openssl/x509v3.h>

Include dependency graph for fe-secure-openssl.c:

Go to the source code of this file.

Macros
#define	SSL_ERR_LEN   128

Functions
static int	verify_cb (int ok, X509_STORE_CTX *ctx)
static int	openssl_verify_peer_name_matches_certificate_name (PGconn *conn, const ASN1_STRING *name_entry, char **store_name)
static int	openssl_verify_peer_name_matches_certificate_ip (PGconn *conn, ASN1_OCTET_STRING *addr_entry, char **store_name)
static int	initialize_SSL (PGconn *conn)
static PostgresPollingStatusType	open_client_SSL (PGconn *conn)
static char *	SSLerrmessage (unsigned long ecode)
static void	SSLerrfree (char *buf)
static int	PQssl_passwd_cb (char *buf, int size, int rwflag, void *userdata)
static int	pgconn_bio_read (BIO *h, char *buf, int size)
static int	pgconn_bio_write (BIO *h, const char *buf, int size)
static BIO_METHOD *	pgconn_bio_method (void)
static int	ssl_set_pgconn_bio (PGconn *conn)
static int	ssl_protocol_version_to_openssl (const char *protocol)
PostgresPollingStatusType	pgtls_open_client (PGconn *conn)
ssize_t	pgtls_read (PGconn *conn, void *ptr, size_t len)
ssize_t	pgtls_bytes_pending (PGconn *conn)
ssize_t	pgtls_write (PGconn *conn, const void *ptr, size_t len)
char *	pgtls_get_peer_certificate_hash (PGconn *conn, size_t *len)
static bool	is_ip_address (const char *host)
int	pgtls_verify_peer_name_matches_certificate_guts (PGconn *conn, int *names_examined, char **first_name)
void	pgtls_close (PGconn *conn)
void *	PQgetssl (PGconn *conn)
void *	PQsslStruct (PGconn *conn, const char *struct_name)
const char *const *	PQsslAttributeNames (PGconn *conn)
const char *	PQsslAttribute (PGconn *conn, const char *attribute_name)
static long	pgconn_bio_ctrl (BIO *h, int cmd, long num, void *ptr)
int	PQdefaultSSLKeyPassHook_OpenSSL (char *buf, int size, PGconn *conn)
PQsslKeyPassHook_OpenSSL_type	PQgetSSLKeyPassHook_OpenSSL (void)
void	PQsetSSLKeyPassHook_OpenSSL (PQsslKeyPassHook_OpenSSL_type hook)

Variables
static pthread_mutex_t	ssl_config_mutex = PTHREAD_MUTEX_INITIALIZER
static PQsslKeyPassHook_OpenSSL_type	PQsslKeyPassHook = NULL
static unsigned char	alpn_protos [] = PG_ALPN_PROTOCOL_VECTOR
static char	ssl_nomem [] = "out of memory allocating error description"
static BIO_METHOD *	pgconn_bio_method_ptr

Macro Definition Documentation

SSL_ERR_LEN

#define SSL_ERR_LEN   128

Definition at line 1583 of file fe-secure-openssl.c.

Function Documentation

initialize_SSL()

static int initialize_SSL ( PGconn *  conn )

static

Definition at line 771 of file fe-secure-openssl.c.

{
    SSL_CTX    *SSL_context;
    struct stat buf;
    char        homedir[MAXPGPATH];
    char        fnbuf[MAXPGPATH];
    char        sebuf[PG_STRERROR_R_BUFLEN];
    bool        have_homedir;
    bool        have_cert;
    bool        have_rootcert;
 
    /*
     * We'll need the home directory if any of the relevant parameters are
     * defaulted.  If pqGetHomeDirectory fails, act as though none of the
     * files could be found.
     */
    if (!(conn->sslcert && strlen(conn->sslcert) > 0) ||
        !(conn->sslkey && strlen(conn->sslkey) > 0) ||
        !(conn->sslrootcert && strlen(conn->sslrootcert) > 0) ||
        !((conn->sslcrl && strlen(conn->sslcrl) > 0) ||
          (conn->sslcrldir && strlen(conn->sslcrldir) > 0)))
        have_homedir = pqGetHomeDirectory(homedir, sizeof(homedir));
    else                        /* won't need it */
        have_homedir = false;
 
    /*
     * Create a new SSL_CTX object.
     *
     * We used to share a single SSL_CTX between all connections, but it was
     * complicated if connections used different certificates. So now we
     * create a separate context for each connection, and accept the overhead.
     */
    SSL_context = SSL_CTX_new(SSLv23_method());
    if (!SSL_context)
    {
        char       *err = SSLerrmessage(ERR_get_error());
 
        libpq_append_conn_error(conn, "could not create SSL context: %s", err);
        SSLerrfree(err);
        return -1;
    }
 
    /*
     * Delegate the client cert password prompt to the libpq wrapper callback
     * if any is defined.
     *
     * If the application hasn't installed its own and the sslpassword
     * parameter is non-null, we install ours now to make sure we supply
     * PGconn->sslpassword to OpenSSL instead of letting it prompt on stdin.
     *
     * This will replace OpenSSL's default PEM_def_callback (which prompts on
     * stdin), but we're only setting it for this SSL context so it's
     * harmless.
     */
    if (PQsslKeyPassHook
        || (conn->sslpassword && strlen(conn->sslpassword) > 0))
    {
        SSL_CTX_set_default_passwd_cb(SSL_context, PQssl_passwd_cb);
        SSL_CTX_set_default_passwd_cb_userdata(SSL_context, conn);
    }
 
#ifdef HAVE_SSL_CTX_SET_CERT_CB
    /* Set up a certificate selection callback. */
    SSL_CTX_set_cert_cb(SSL_context, cert_cb, conn);
#endif
 
    /* Disable old protocol versions */
    SSL_CTX_set_options(SSL_context, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
 
    /* Set the minimum and maximum protocol versions if necessary */
    if (conn->ssl_min_protocol_version &&
        strlen(conn->ssl_min_protocol_version) != 0)
    {
        int         ssl_min_ver;
 
        ssl_min_ver = ssl_protocol_version_to_openssl(conn->ssl_min_protocol_version);
 
        if (ssl_min_ver == -1)
        {
            libpq_append_conn_error(conn, "invalid value \"%s\" for minimum SSL protocol version",
                                    conn->ssl_min_protocol_version);
            SSL_CTX_free(SSL_context);
            return -1;
        }
 
        if (!SSL_CTX_set_min_proto_version(SSL_context, ssl_min_ver))
        {
            char       *err = SSLerrmessage(ERR_get_error());
 
            libpq_append_conn_error(conn, "could not set minimum SSL protocol version: %s", err);
            SSLerrfree(err);
            SSL_CTX_free(SSL_context);
            return -1;
        }
    }
 
    if (conn->ssl_max_protocol_version &&
        strlen(conn->ssl_max_protocol_version) != 0)
    {
        int         ssl_max_ver;
 
        ssl_max_ver = ssl_protocol_version_to_openssl(conn->ssl_max_protocol_version);
 
        if (ssl_max_ver == -1)
        {
            libpq_append_conn_error(conn, "invalid value \"%s\" for maximum SSL protocol version",
                                    conn->ssl_max_protocol_version);
            SSL_CTX_free(SSL_context);
            return -1;
        }
 
        if (!SSL_CTX_set_max_proto_version(SSL_context, ssl_max_ver))
        {
            char       *err = SSLerrmessage(ERR_get_error());
 
            libpq_append_conn_error(conn, "could not set maximum SSL protocol version: %s", err);
            SSLerrfree(err);
            SSL_CTX_free(SSL_context);
            return -1;
        }
    }
 
    /*
     * Disable OpenSSL's moving-write-buffer sanity check, because it causes
     * unnecessary failures in nonblocking send cases.
     */
    SSL_CTX_set_mode(SSL_context, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
 
    /*
     * If the root cert file exists, load it so we can perform certificate
     * verification. If sslmode is "verify-full" we will also do further
     * verification after the connection has been completed.
     */
    if (conn->sslrootcert && strlen(conn->sslrootcert) > 0)
        strlcpy(fnbuf, conn->sslrootcert, sizeof(fnbuf));
    else if (have_homedir)
        snprintf(fnbuf, sizeof(fnbuf), "%s/%s", homedir, ROOT_CERT_FILE);
    else
        fnbuf[0] = '\0';
 
    if (strcmp(fnbuf, "system") == 0)
    {
        /*
         * The "system" sentinel value indicates that we should load whatever
         * root certificates are installed for use by OpenSSL; these locations
         * differ by platform. Note that the default system locations may be
         * further overridden by the SSL_CERT_DIR and SSL_CERT_FILE
         * environment variables.
         */
        if (SSL_CTX_set_default_verify_paths(SSL_context) != 1)
        {
            char       *err = SSLerrmessage(ERR_get_error());
 
            libpq_append_conn_error(conn, "could not load system root certificate paths: %s",
                                    err);
            SSLerrfree(err);
            SSL_CTX_free(SSL_context);
            return -1;
        }
        have_rootcert = true;
    }
    else if (fnbuf[0] != '\0' &&
             stat(fnbuf, &buf) == 0)
    {
        X509_STORE *cvstore;
 
        if (SSL_CTX_load_verify_locations(SSL_context, fnbuf, NULL) != 1)
        {
            char       *err = SSLerrmessage(ERR_get_error());
 
            libpq_append_conn_error(conn, "could not read root certificate file \"%s\": %s",
                                    fnbuf, err);
            SSLerrfree(err);
            SSL_CTX_free(SSL_context);
            return -1;
        }
 
        if ((cvstore = SSL_CTX_get_cert_store(SSL_context)) != NULL)
        {
            char       *fname = NULL;
            char       *dname = NULL;
 
            if (conn->sslcrl && strlen(conn->sslcrl) > 0)
                fname = conn->sslcrl;
            if (conn->sslcrldir && strlen(conn->sslcrldir) > 0)
                dname = conn->sslcrldir;
 
            /* defaults to use the default CRL file */
            if (!fname && !dname && have_homedir)
            {
                snprintf(fnbuf, sizeof(fnbuf), "%s/%s", homedir, ROOT_CRL_FILE);
                fname = fnbuf;
            }
 
            /* Set the flags to check against the complete CRL chain */
            if ((fname || dname) &&
                X509_STORE_load_locations(cvstore, fname, dname) == 1)
            {
                X509_STORE_set_flags(cvstore,
                                     X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
            }
 
            /* if not found, silently ignore;  we do not require CRL */
            ERR_clear_error();
        }
        have_rootcert = true;
    }
    else
    {
        /*
         * stat() failed; assume root file doesn't exist.  If sslmode is
         * verify-ca or verify-full, this is an error.  Otherwise, continue
         * without performing any server cert verification.
         */
        if (conn->sslmode[0] == 'v')    /* "verify-ca" or "verify-full" */
        {
            /*
             * The only way to reach here with an empty filename is if
             * pqGetHomeDirectory failed.  That's a sufficiently unusual case
             * that it seems worth having a specialized error message for it.
             */
            if (fnbuf[0] == '\0')
                libpq_append_conn_error(conn, "could not get home directory to locate root certificate file\n"
                                        "Either provide the file, use the system's trusted roots with sslrootcert=system, or change sslmode to disable server certificate verification.");
            else
                libpq_append_conn_error(conn, "root certificate file \"%s\" does not exist\n"
                                        "Either provide the file, use the system's trusted roots with sslrootcert=system, or change sslmode to disable server certificate verification.", fnbuf);
            SSL_CTX_free(SSL_context);
            return -1;
        }
        have_rootcert = false;
    }
 
    /* Read the client certificate file */
    if (conn->sslcert && strlen(conn->sslcert) > 0)
        strlcpy(fnbuf, conn->sslcert, sizeof(fnbuf));
    else if (have_homedir)
        snprintf(fnbuf, sizeof(fnbuf), "%s/%s", homedir, USER_CERT_FILE);
    else
        fnbuf[0] = '\0';
 
    if (conn->sslcertmode[0] == 'd')    /* disable */
    {
        /* don't send a client cert even if we have one */
        have_cert = false;
    }
    else if (fnbuf[0] == '\0')
    {
        /* no home directory, proceed without a client cert */
        have_cert = false;
    }
    else if (stat(fnbuf, &buf) != 0)
    {
        /*
         * If file is not present, just go on without a client cert; server
         * might or might not accept the connection.  Any other error,
         * however, is grounds for complaint.
         */
        if (errno != ENOENT && errno != ENOTDIR)
        {
            libpq_append_conn_error(conn, "could not open certificate file \"%s\": %s",
                                    fnbuf, strerror_r(errno, sebuf, sizeof(sebuf)));
            SSL_CTX_free(SSL_context);
            return -1;
        }
        have_cert = false;
    }
    else
    {
        /*
         * Cert file exists, so load it. Since OpenSSL doesn't provide the
         * equivalent of "SSL_use_certificate_chain_file", we have to load it
         * into the SSL context, rather than the SSL object.
         */
        if (SSL_CTX_use_certificate_chain_file(SSL_context, fnbuf) != 1)
        {
            char       *err = SSLerrmessage(ERR_get_error());
 
            libpq_append_conn_error(conn, "could not read certificate file \"%s\": %s",
                                    fnbuf, err);
            SSLerrfree(err);
            SSL_CTX_free(SSL_context);
            return -1;
        }
 
        /* need to load the associated private key, too */
        have_cert = true;
    }
 
    /*
     * The SSL context is now loaded with the correct root and client
     * certificates. Create a connection-specific SSL object. The private key
     * is loaded directly into the SSL object. (We could load the private key
     * into the context, too, but we have done it this way historically, and
     * it doesn't really matter.)
     */
    if (!(conn->ssl = SSL_new(SSL_context)) ||
        !SSL_set_app_data(conn->ssl, conn) ||
        !ssl_set_pgconn_bio(conn))
    {
        char       *err = SSLerrmessage(ERR_get_error());
 
        libpq_append_conn_error(conn, "could not establish SSL connection: %s", err);
        SSLerrfree(err);
        SSL_CTX_free(SSL_context);
        return -1;
    }
    conn->ssl_in_use = true;
 
    /*
     * If SSL key logging is requested, set up the callback if a compatible
     * version of OpenSSL is used and libpq was compiled to support it.
     */
    if (conn->sslkeylogfile && strlen(conn->sslkeylogfile) > 0)
    {
#ifdef HAVE_SSL_CTX_SET_KEYLOG_CALLBACK
        SSL_CTX_set_keylog_callback(SSL_context, SSL_CTX_keylog_cb);
#else
#ifdef LIBRESSL_VERSION_NUMBER
        fprintf(stderr, libpq_gettext("WARNING: sslkeylogfile support requires OpenSSL\n"));
#else
        fprintf(stderr, libpq_gettext("WARNING: libpq was not built with sslkeylogfile support\n"));
#endif
#endif
    }
 
    /*
     * SSL contexts are reference counted by OpenSSL. We can free it as soon
     * as we have created the SSL object, and it will stick around for as long
     * as it's actually needed.
     */
    SSL_CTX_free(SSL_context);
    SSL_context = NULL;
 
    /*
     * Set Server Name Indication (SNI), if enabled by connection parameters.
     * Per RFC 6066, do not set it if the host is a literal IP address (IPv4
     * or IPv6).
     */
    if (conn->sslsni && conn->sslsni[0] == '1')
    {
        const char *host = conn->connhost[conn->whichhost].host;
 
        if (host && host[0] &&
            !(strspn(host, "0123456789.") == strlen(host) ||
              strchr(host, ':')))
        {
            if (SSL_set_tlsext_host_name(conn->ssl, host) != 1)
            {
                char       *err = SSLerrmessage(ERR_get_error());
 
                libpq_append_conn_error(conn, "could not set SSL Server Name Indication (SNI): %s", err);
                SSLerrfree(err);
                return -1;
            }
        }
    }
 
    /* Set ALPN */
    {
        int         retval;
 
        retval = SSL_set_alpn_protos(conn->ssl, alpn_protos, sizeof(alpn_protos));
 
        if (retval != 0)
        {
            char       *err = SSLerrmessage(ERR_get_error());
 
            libpq_append_conn_error(conn, "could not set SSL ALPN extension: %s", err);
            SSLerrfree(err);
            return -1;
        }
    }
 
    /*
     * Read the SSL key. If a key is specified, treat it as an engine:key
     * combination if there is colon present - we don't support files with
     * colon in the name. The exception is if the second character is a colon,
     * in which case it can be a Windows filename with drive specification.
     */
    if (have_cert && conn->sslkey && strlen(conn->sslkey) > 0)
    {
#ifdef USE_SSL_ENGINE
        if (strchr(conn->sslkey, ':')
#ifdef WIN32
            && conn->sslkey[1] != ':'
#endif
            )
        {
            /* Colon, but not in second character, treat as engine:key */
            char       *engine_str = strdup(conn->sslkey);
            char       *engine_colon;
            EVP_PKEY   *pkey;
 
            if (engine_str == NULL)
            {
                libpq_append_conn_error(conn, "out of memory");
                return -1;
            }
 
            /* cannot return NULL because we already checked before strdup */
            engine_colon = strchr(engine_str, ':');
 
            *engine_colon = '\0';   /* engine_str now has engine name */
            engine_colon++;     /* engine_colon now has key name */
 
            conn->engine = ENGINE_by_id(engine_str);
            if (conn->engine == NULL)
            {
                char       *err = SSLerrmessage(ERR_get_error());
 
                libpq_append_conn_error(conn, "could not load SSL engine \"%s\": %s",
                                        engine_str, err);
                SSLerrfree(err);
                free(engine_str);
                return -1;
            }
 
            if (ENGINE_init(conn->engine) == 0)
            {
                char       *err = SSLerrmessage(ERR_get_error());
 
                libpq_append_conn_error(conn, "could not initialize SSL engine \"%s\": %s",
                                        engine_str, err);
                SSLerrfree(err);
                ENGINE_free(conn->engine);
                conn->engine = NULL;
                free(engine_str);
                return -1;
            }
 
            pkey = ENGINE_load_private_key(conn->engine, engine_colon,
                                           NULL, NULL);
            if (pkey == NULL)
            {
                char       *err = SSLerrmessage(ERR_get_error());
 
                libpq_append_conn_error(conn, "could not read private SSL key \"%s\" from engine \"%s\": %s",
                                        engine_colon, engine_str, err);
                SSLerrfree(err);
                ENGINE_finish(conn->engine);
                ENGINE_free(conn->engine);
                conn->engine = NULL;
                free(engine_str);
                return -1;
            }
            if (SSL_use_PrivateKey(conn->ssl, pkey) != 1)
            {
                char       *err = SSLerrmessage(ERR_get_error());
 
                libpq_append_conn_error(conn, "could not load private SSL key \"%s\" from engine \"%s\": %s",
                                        engine_colon, engine_str, err);
                SSLerrfree(err);
                ENGINE_finish(conn->engine);
                ENGINE_free(conn->engine);
                conn->engine = NULL;
                free(engine_str);
                return -1;
            }
 
            free(engine_str);
 
            fnbuf[0] = '\0';    /* indicate we're not going to load from a
                                 * file */
        }
        else
#endif                          /* USE_SSL_ENGINE */
        {
            /* PGSSLKEY is not an engine, treat it as a filename */
            strlcpy(fnbuf, conn->sslkey, sizeof(fnbuf));
        }
    }
    else if (have_homedir)
    {
        /* No PGSSLKEY specified, load default file */
        snprintf(fnbuf, sizeof(fnbuf), "%s/%s", homedir, USER_KEY_FILE);
    }
    else
        fnbuf[0] = '\0';
 
    if (have_cert && fnbuf[0] != '\0')
    {
        /* read the client key from file */
 
        if (stat(fnbuf, &buf) != 0)
        {
            if (errno == ENOENT)
                libpq_append_conn_error(conn, "certificate present, but not private key file \"%s\"",
                                        fnbuf);
            else
                libpq_append_conn_error(conn, "could not stat private key file \"%s\": %m",
                                        fnbuf);
            return -1;
        }
 
        /* Key file must be a regular file */
        if (!S_ISREG(buf.st_mode))
        {
            libpq_append_conn_error(conn, "private key file \"%s\" is not a regular file",
                                    fnbuf);
            return -1;
        }
 
        /*
         * Refuse to load world-readable key files.  We accept root-owned
         * files with mode 0640 or less, so that we can access system-wide
         * certificates if we have a supplementary group membership that
         * allows us to read 'em.  For files with non-root ownership, require
         * mode 0600 or less.  We need not check the file's ownership exactly;
         * if we're able to read it despite it having such restrictive
         * permissions, it must have the right ownership.
         *
         * Note: be very careful about tightening these rules.  Some people
         * expect, for example, that a client process running as root should
         * be able to use a non-root-owned key file.
         *
         * Note that roughly similar checks are performed in
         * src/backend/libpq/be-secure-common.c so any changes here may need
         * to be made there as well.  However, this code caters for the case
         * of current user == root, while that code does not.
         *
         * Ideally we would do similar permissions checks on Windows, but it
         * is not clear how that would work since Unix-style permissions may
         * not be available.
         */
#if !defined(WIN32) && !defined(__CYGWIN__)
        if (buf.st_uid == 0 ?
            buf.st_mode & (S_IWGRP | S_IXGRP | S_IRWXO) :
            buf.st_mode & (S_IRWXG | S_IRWXO))
        {
            libpq_append_conn_error(conn,
                                    "private key file \"%s\" has group or world access; file must have permissions u=rw (0600) or less if owned by the current user, or permissions u=rw,g=r (0640) or less if owned by root",
                                    fnbuf);
            return -1;
        }
#endif
 
        if (SSL_use_PrivateKey_file(conn->ssl, fnbuf, SSL_FILETYPE_PEM) != 1)
        {
            char       *err = SSLerrmessage(ERR_get_error());
 
            /*
             * We'll try to load the file in DER (binary ASN.1) format, and if
             * that fails too, report the original error. This could mask
             * issues where there's something wrong with a DER-format cert,
             * but we'd have to duplicate openssl's format detection to be
             * smarter than this. We can't just probe for a leading -----BEGIN
             * because PEM can have leading non-matching lines and blanks.
             * OpenSSL doesn't expose its get_name(...) and its PEM routines
             * don't differentiate between failure modes in enough detail to
             * let us tell the difference between "not PEM, try DER" and
             * "wrong password".
             */
            if (SSL_use_PrivateKey_file(conn->ssl, fnbuf, SSL_FILETYPE_ASN1) != 1)
            {
                libpq_append_conn_error(conn, "could not load private key file \"%s\": %s",
                                        fnbuf, err);
                SSLerrfree(err);
                return -1;
            }
 
            SSLerrfree(err);
        }
    }
 
    /* verify that the cert and key go together */
    if (have_cert &&
        SSL_check_private_key(conn->ssl) != 1)
    {
        char       *err = SSLerrmessage(ERR_get_error());
 
        libpq_append_conn_error(conn, "certificate does not match private key file \"%s\": %s",
                                fnbuf, err);
        SSLerrfree(err);
        return -1;
    }
 
    /*
     * If a root cert was loaded, also set our certificate verification
     * callback.
     */
    if (have_rootcert)
        SSL_set_verify(conn->ssl, SSL_VERIFY_PEER, verify_cb);
 
    /*
     * Set compression option if necessary.
     */
    if (conn->sslcompression && conn->sslcompression[0] == '0')
        SSL_set_options(conn->ssl, SSL_OP_NO_COMPRESSION);
    else
        SSL_clear_options(conn->ssl, SSL_OP_NO_COMPRESSION);
 
    return 0;
}

References alpn_protos, buf, conn, pg_conn::connhost, err(), fb(), fprintf, free, pg_conn_host::host, libpq_append_conn_error(), libpq_gettext, MAXPGPATH, PG_STRERROR_R_BUFLEN, pqGetHomeDirectory(), PQssl_passwd_cb(), PQsslKeyPassHook, S_IRWXG, S_IRWXO, S_ISREG, S_IWGRP, S_IXGRP, snprintf, SSL_context, pg_conn::ssl_in_use, pg_conn::ssl_max_protocol_version, pg_conn::ssl_min_protocol_version, ssl_protocol_version_to_openssl(), ssl_set_pgconn_bio(), pg_conn::sslcert, pg_conn::sslcertmode, pg_conn::sslcompression, pg_conn::sslcrl, pg_conn::sslcrldir, SSLerrfree(), SSLerrmessage(), pg_conn::sslkey, pg_conn::sslkeylogfile, pg_conn::sslmode, pg_conn::sslpassword, pg_conn::sslrootcert, pg_conn::sslsni, stat, strerror_r, strlcpy(), verify_cb(), and pg_conn::whichhost.

Referenced by pgtls_open_client().

is_ip_address()

static bool is_ip_address ( const char *  host )

static

Definition at line 556 of file fe-secure-openssl.c.

{
    struct in_addr dummy4;
#ifdef HAVE_INET_PTON
    struct in6_addr dummy6;
#endif
 
    return inet_aton(host, &dummy4)
#ifdef HAVE_INET_PTON
        || (inet_pton(AF_INET6, host, &dummy6) == 1)
#endif
        ;
}

References fb(), and inet_aton().

Referenced by pgtls_verify_peer_name_matches_certificate_guts().

open_client_SSL()

static PostgresPollingStatusType open_client_SSL ( PGconn *  conn )

static

Definition at line 1370 of file fe-secure-openssl.c.

{
    int         r;
 
    SOCK_ERRNO_SET(0);
    ERR_clear_error();
    r = SSL_connect(conn->ssl);
    if (r <= 0)
    {
        int         save_errno = SOCK_ERRNO;
        int         err = SSL_get_error(conn->ssl, r);
        unsigned long ecode;
 
        ecode = ERR_get_error();
        switch (err)
        {
            case SSL_ERROR_WANT_READ:
                return PGRES_POLLING_READING;
 
            case SSL_ERROR_WANT_WRITE:
                return PGRES_POLLING_WRITING;
 
            case SSL_ERROR_SYSCALL:
                {
                    char        sebuf[PG_STRERROR_R_BUFLEN];
                    unsigned long vcode;
 
                    vcode = SSL_get_verify_result(conn->ssl);
 
                    /*
                     * If we get an X509 error here for failing to load the
                     * local issuer cert, without an error in the socket layer
                     * it means that verification failed due to a missing
                     * system CA pool without it being a protocol error. We
                     * inspect the sslrootcert setting to ensure that the user
                     * was using the system CA pool. For other errors, log
                     * them using the normal SYSCALL logging.
                     */
                    if (save_errno == 0 &&
                        vcode == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY &&
                        strcmp(conn->sslrootcert, "system") == 0)
                        libpq_append_conn_error(conn, "SSL error: certificate verify failed: %s",
                                                X509_verify_cert_error_string(vcode));
                    else if (r == -1 && save_errno != 0)
                        libpq_append_conn_error(conn, "SSL SYSCALL error: %s",
                                                SOCK_STRERROR(save_errno, sebuf, sizeof(sebuf)));
                    else
                        libpq_append_conn_error(conn, "SSL SYSCALL error: EOF detected");
                    pgtls_close(conn);
                    return PGRES_POLLING_FAILED;
                }
            case SSL_ERROR_SSL:
                {
                    char       *err = SSLerrmessage(ecode);
 
                    libpq_append_conn_error(conn, "SSL error: %s", err);
                    SSLerrfree(err);
                    switch (ERR_GET_REASON(ecode))
                    {
                            /*
                             * UNSUPPORTED_PROTOCOL, WRONG_VERSION_NUMBER, and
                             * TLSV1_ALERT_PROTOCOL_VERSION have been observed
                             * when trying to communicate with an old OpenSSL
                             * library, or when the client and server specify
                             * disjoint protocol ranges.
                             * NO_PROTOCOLS_AVAILABLE occurs if there's a
                             * local misconfiguration (which can happen
                             * despite our checks, if openssl.cnf injects a
                             * limit we didn't account for).  It's not very
                             * clear what would make OpenSSL return the other
                             * codes listed here, but a hint about protocol
                             * versions seems like it's appropriate for all.
                             */
                        case SSL_R_NO_PROTOCOLS_AVAILABLE:
                        case SSL_R_UNSUPPORTED_PROTOCOL:
                        case SSL_R_BAD_PROTOCOL_VERSION_NUMBER:
                        case SSL_R_UNKNOWN_PROTOCOL:
                        case SSL_R_UNKNOWN_SSL_VERSION:
                        case SSL_R_UNSUPPORTED_SSL_VERSION:
                        case SSL_R_WRONG_SSL_VERSION:
                        case SSL_R_WRONG_VERSION_NUMBER:
                        case SSL_R_TLSV1_ALERT_PROTOCOL_VERSION:
#ifdef SSL_R_VERSION_TOO_HIGH
                        case SSL_R_VERSION_TOO_HIGH:
                        case SSL_R_VERSION_TOO_LOW:
#endif
                            libpq_append_conn_error(conn, "This may indicate that the server does not support any SSL protocol version between %s and %s.",
                                                    conn->ssl_min_protocol_version ?
                                                    conn->ssl_min_protocol_version :
                                                    MIN_OPENSSL_TLS_VERSION,
                                                    conn->ssl_max_protocol_version ?
                                                    conn->ssl_max_protocol_version :
                                                    MAX_OPENSSL_TLS_VERSION);
                            break;
                        default:
                            break;
                    }
                    pgtls_close(conn);
                    return PGRES_POLLING_FAILED;
                }
 
            default:
                libpq_append_conn_error(conn, "unrecognized SSL error code: %d", err);
                pgtls_close(conn);
                return PGRES_POLLING_FAILED;
        }
    }
 
    /* ALPN is mandatory with direct SSL connections */
    if (conn->current_enc_method == ENC_SSL && conn->sslnegotiation[0] == 'd')
    {
        const unsigned char *selected;
        unsigned int len;
 
        SSL_get0_alpn_selected(conn->ssl, &selected, &len);
 
        if (selected == NULL)
        {
            libpq_append_conn_error(conn, "direct SSL connection was established without ALPN protocol negotiation extension");
            pgtls_close(conn);
            return PGRES_POLLING_FAILED;
        }
 
        /*
         * We only support one protocol so that's what the negotiation should
         * always choose, but doesn't hurt to check.
         */
        if (len != strlen(PG_ALPN_PROTOCOL) ||
            memcmp(selected, PG_ALPN_PROTOCOL, strlen(PG_ALPN_PROTOCOL)) != 0)
        {
            libpq_append_conn_error(conn, "SSL connection was established with unexpected ALPN protocol");
            pgtls_close(conn);
            return PGRES_POLLING_FAILED;
        }
    }
 
    /*
     * We already checked the server certificate in initialize_SSL() using
     * SSL_CTX_set_verify(), if root.crt exists.
     */
 
    /* get server certificate */
    conn->peer = SSL_get_peer_certificate(conn->ssl);
    if (conn->peer == NULL)
    {
        char       *err = SSLerrmessage(ERR_get_error());
 
        libpq_append_conn_error(conn, "certificate could not be obtained: %s", err);
        SSLerrfree(err);
        pgtls_close(conn);
        return PGRES_POLLING_FAILED;
    }
 
    if (!pq_verify_peer_name_matches_certificate(conn))
    {
        pgtls_close(conn);
        return PGRES_POLLING_FAILED;
    }
 
    /* SSL handshake is complete */
    return PGRES_POLLING_OK;
}

References conn, pg_conn::current_enc_method, ENC_SSL, err(), fb(), len, libpq_append_conn_error(), PG_ALPN_PROTOCOL, PG_STRERROR_R_BUFLEN, PGRES_POLLING_FAILED, PGRES_POLLING_OK, PGRES_POLLING_READING, PGRES_POLLING_WRITING, pgtls_close(), pq_verify_peer_name_matches_certificate(), SOCK_ERRNO, SOCK_ERRNO_SET, SOCK_STRERROR, pg_conn::ssl_max_protocol_version, pg_conn::ssl_min_protocol_version, SSLerrfree(), SSLerrmessage(), pg_conn::sslnegotiation, and pg_conn::sslrootcert.

Referenced by pgtls_open_client().

openssl_verify_peer_name_matches_certificate_ip()

static int openssl_verify_peer_name_matches_certificate_ip ( PGconn *  conn, ASN1_OCTET_STRING *  addr_entry, char **  store_name  )

static

Definition at line 531 of file fe-secure-openssl.c.

{
    int         len;
    const unsigned char *addrdata;
 
    /* Should not happen... */
    if (addr_entry == NULL)
    {
        libpq_append_conn_error(conn, "SSL certificate's address entry is missing");
        return -1;
    }
 
    /*
     * GEN_IPADD is an OCTET STRING containing an IP address in network byte
     * order.
     */
    addrdata = ASN1_STRING_get0_data(addr_entry);
    len = ASN1_STRING_length(addr_entry);
 
    return pq_verify_peer_name_matches_certificate_ip(conn, addrdata, len, store_name);
}

References conn, fb(), len, libpq_append_conn_error(), and pq_verify_peer_name_matches_certificate_ip().

Referenced by pgtls_verify_peer_name_matches_certificate_guts().

openssl_verify_peer_name_matches_certificate_name()

static int openssl_verify_peer_name_matches_certificate_name ( PGconn *  conn, const ASN1_STRING *  name_entry, char **  store_name  )

static

Definition at line 501 of file fe-secure-openssl.c.

{
    int         len;
    const unsigned char *namedata;
 
    /* Should not happen... */
    if (name_entry == NULL)
    {
        libpq_append_conn_error(conn, "SSL certificate's name entry is missing");
        return -1;
    }
 
    /*
     * GEN_DNS can be only IA5String, equivalent to US ASCII.
     */
    namedata = ASN1_STRING_get0_data(name_entry);
    len = ASN1_STRING_length(name_entry);
 
    /* OK to cast from unsigned to plain char, since it's all ASCII. */
    return pq_verify_peer_name_matches_certificate_name(conn, (const char *) namedata, len, store_name);
}

References conn, fb(), len, libpq_append_conn_error(), and pq_verify_peer_name_matches_certificate_name().

Referenced by pgtls_verify_peer_name_matches_certificate_guts().

pgconn_bio_ctrl()

static long pgconn_bio_ctrl ( BIO *  h, int  cmd, long  num, void *  ptr  )

static

Definition at line 1835 of file fe-secure-openssl.c.

{
    long        res;
    PGconn     *conn = (PGconn *) BIO_get_data(h);
 
    switch (cmd)
    {
        case BIO_CTRL_EOF:
 
            /*
             * This should not be needed. pgconn_bio_read already has a way to
             * signal EOF to OpenSSL. However, OpenSSL made an undocumented,
             * backwards-incompatible change and now expects EOF via BIO_ctrl.
             * See https://github.com/openssl/openssl/issues/8208
             */
            res = conn->last_read_was_eof;
            break;
        case BIO_CTRL_FLUSH:
            /* libssl expects all BIOs to support BIO_flush. */
            res = 1;
            break;
        default:
            res = 0;
            break;
    }
 
    return res;
}

References conn, fb(), and pg_conn::last_read_was_eof.

Referenced by pgconn_bio_method().

pgconn_bio_method()

static BIO_METHOD * pgconn_bio_method ( void  )

static

Definition at line 1865 of file fe-secure-openssl.c.

{
    BIO_METHOD *res;
 
    if (pthread_mutex_lock(&ssl_config_mutex))
        return NULL;
 
    res = pgconn_bio_method_ptr;
 
    if (!pgconn_bio_method_ptr)
    {
        int         my_bio_index;
 
        my_bio_index = BIO_get_new_index();
        if (my_bio_index == -1)
            goto err;
        my_bio_index |= BIO_TYPE_SOURCE_SINK;
        res = BIO_meth_new(my_bio_index, "libpq socket");
        if (!res)
            goto err;
 
        /*
         * As of this writing, these functions never fail. But check anyway,
         * like OpenSSL's own examples do.
         */
        if (!BIO_meth_set_write(res, pgconn_bio_write) ||
            !BIO_meth_set_read(res, pgconn_bio_read) ||
            !BIO_meth_set_ctrl(res, pgconn_bio_ctrl))
        {
            goto err;
        }
    }
 
    pgconn_bio_method_ptr = res;
    pthread_mutex_unlock(&ssl_config_mutex);
    return res;
 
err:
    if (res)
        BIO_meth_free(res);
    pthread_mutex_unlock(&ssl_config_mutex);
    return NULL;
}

References err(), fb(), pgconn_bio_ctrl(), pgconn_bio_method_ptr, pgconn_bio_read(), pgconn_bio_write(), pthread_mutex_lock(), pthread_mutex_unlock(), and ssl_config_mutex.

Referenced by ssl_set_pgconn_bio().

pgconn_bio_read()

static int pgconn_bio_read ( BIO *  h, char *  buf, int  size  )

static

Definition at line 1770 of file fe-secure-openssl.c.

{
    PGconn     *conn = (PGconn *) BIO_get_data(h);
    int         res;
 
    res = pqsecure_raw_read(conn, buf, size);
    BIO_clear_retry_flags(h);
    conn->last_read_was_eof = res == 0;
    if (res < 0)
    {
        /* If we were interrupted, tell caller to retry */
        switch (SOCK_ERRNO)
        {
#ifdef EAGAIN
            case EAGAIN:
#endif
#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
            case EWOULDBLOCK:
#endif
            case EINTR:
                BIO_set_retry_read(h);
                break;
 
            default:
                break;
        }
    }
 
    if (res > 0)
        conn->ssl_handshake_started = true;
 
    return res;
}

References buf, conn, EAGAIN, EINTR, EWOULDBLOCK, fb(), pg_conn::last_read_was_eof, pqsecure_raw_read(), SOCK_ERRNO, and pg_conn::ssl_handshake_started.

Referenced by pgconn_bio_method().

pgconn_bio_write()

static int pgconn_bio_write ( BIO *  h, const char *  buf, int  size  )

static

Definition at line 1805 of file fe-secure-openssl.c.

{
    int         res;
 
    res = pqsecure_raw_write((PGconn *) BIO_get_data(h), buf, size);
    BIO_clear_retry_flags(h);
    if (res < 0)
    {
        /* If we were interrupted, tell caller to retry */
        switch (SOCK_ERRNO)
        {
#ifdef EAGAIN
            case EAGAIN:
#endif
#if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
            case EWOULDBLOCK:
#endif
            case EINTR:
                BIO_set_retry_write(h);
                break;
 
            default:
                break;
        }
    }
 
    return res;
}

References buf, EAGAIN, EINTR, EWOULDBLOCK, fb(), pqsecure_raw_write(), and SOCK_ERRNO.

Referenced by pgconn_bio_method().

pgtls_bytes_pending()

ssize_t pgtls_bytes_pending

(

PGconn *

conn

)

Definition at line 235 of file fe-secure-openssl.c.

{
    int         pending;
 
    /*
     * OpenSSL readahead is documented to break SSL_pending().  Plus, we can't
     * afford to have OpenSSL take bytes off the socket without processing
     * them; that breaks the postconditions for pqsecure_drain_pending().
     */
    Assert(!SSL_get_read_ahead(conn->ssl));
 
    pending = SSL_pending(conn->ssl);
    if (pending < 0)
    {
        /* shouldn't be possible */
        Assert(false);
        libpq_append_conn_error(conn, "OpenSSL reports negative bytes pending");
        return -1;
    }
    else if (pending == INT_MAX)
    {
        /*
         * If we ever found a legitimate way to hit this, we'd need to loop
         * around in the caller to call pgtls_bytes_pending() again.  Throw an
         * error rather than complicate the code in that way, because
         * SSL_read() should be bounded to the size of a single TLS record,
         * and conn->inBuffer can't currently go past INT_MAX in size anyway.
         */
        libpq_append_conn_error(conn, "OpenSSL reports INT_MAX bytes pending");
        return -1;
    }
 
    return (ssize_t) pending;
}

References Assert, conn, fb(), and libpq_append_conn_error().

Referenced by pqsecure_bytes_pending().

pgtls_close()

void pgtls_close

(

PGconn *

conn

)

Definition at line 1534 of file fe-secure-openssl.c.

{
    if (conn->ssl_in_use)
    {
        if (conn->ssl)
        {
            /*
             * We can't destroy everything SSL-related here due to the
             * possible later calls to OpenSSL routines which may need our
             * thread callbacks, so set a flag here and check at the end.
             */
 
            SSL_shutdown(conn->ssl);
            SSL_free(conn->ssl);
            conn->ssl = NULL;
            conn->ssl_in_use = false;
            conn->ssl_handshake_started = false;
        }
 
        if (conn->peer)
        {
            X509_free(conn->peer);
            conn->peer = NULL;
        }
 
#ifdef USE_SSL_ENGINE
        if (conn->engine)
        {
            ENGINE_finish(conn->engine);
            ENGINE_free(conn->engine);
            conn->engine = NULL;
        }
#endif
    }
}

References conn, fb(), pg_conn::ssl_handshake_started, and pg_conn::ssl_in_use.

Referenced by open_client_SSL(), pgtls_open_client(), and pqsecure_close().

pgtls_get_peer_certificate_hash()

char * pgtls_get_peer_certificate_hash	(	PGconn *	conn,
		size_t *	len
	)

Definition at line 371 of file fe-secure-openssl.c.

{
    X509       *peer_cert;
    const EVP_MD *algo_type;
    unsigned char hash[EVP_MAX_MD_SIZE];    /* size for SHA-512 */
    unsigned int hash_size;
    int         algo_nid;
    char       *cert_hash;
 
    *len = 0;
 
    if (!conn->peer)
        return NULL;
 
    peer_cert = conn->peer;
 
    /*
     * Get the signature algorithm of the certificate to determine the hash
     * algorithm to use for the result.  Prefer X509_get_signature_info(),
     * introduced in OpenSSL 1.1.1, which can handle RSA-PSS signatures.
     */
#if HAVE_X509_GET_SIGNATURE_INFO
    if (!X509_get_signature_info(peer_cert, &algo_nid, NULL, NULL, NULL))
#else
    if (!OBJ_find_sigid_algs(X509_get_signature_nid(peer_cert),
                             &algo_nid, NULL))
#endif
    {
        libpq_append_conn_error(conn, "could not determine server certificate signature algorithm");
        return NULL;
    }
 
    /*
     * The TLS server's certificate bytes need to be hashed with SHA-256 if
     * its signature algorithm is MD5 or SHA-1 as per RFC 5929
     * (https://tools.ietf.org/html/rfc5929#section-4.1).  If something else
     * is used, the same hash as the signature algorithm is used.
     */
    switch (algo_nid)
    {
        case NID_md5:
        case NID_sha1:
            algo_type = EVP_sha256();
            break;
        default:
            algo_type = EVP_get_digestbynid(algo_nid);
            if (algo_type == NULL)
            {
                libpq_append_conn_error(conn, "could not find digest for NID %s",
                                        OBJ_nid2sn(algo_nid));
                return NULL;
            }
            break;
    }
 
    if (!X509_digest(peer_cert, algo_type, hash, &hash_size))
    {
        libpq_append_conn_error(conn, "could not generate peer certificate hash");
        return NULL;
    }
 
    /* save result */
    cert_hash = malloc(hash_size);
    if (cert_hash == NULL)
    {
        libpq_append_conn_error(conn, "out of memory");
        return NULL;
    }
    memcpy(cert_hash, hash, hash_size);
    *len = hash_size;
 
    return cert_hash;
}

References conn, fb(), hash(), len, libpq_append_conn_error(), malloc, and memcpy().

Referenced by build_client_final_message().

pgtls_open_client()

PostgresPollingStatusType pgtls_open_client

(

PGconn *

conn

)

Definition at line 97 of file fe-secure-openssl.c.

{
    /* First time through? */
    if (conn->ssl == NULL)
    {
        /*
         * Create a connection-specific SSL object, and load client
         * certificate, private key, and trusted CA certs.
         */
        if (initialize_SSL(conn) != 0)
        {
            /* initialize_SSL already put a message in conn->errorMessage */
            pgtls_close(conn);
            return PGRES_POLLING_FAILED;
        }
    }
 
    /* Begin or continue the actual handshake */
    return open_client_SSL(conn);
}

References conn, fb(), initialize_SSL(), open_client_SSL(), PGRES_POLLING_FAILED, and pgtls_close().

Referenced by pqsecure_open_client().

pgtls_read()

ssize_t pgtls_read	(	PGconn *	conn,
		void *	ptr,
		size_t	len
	)

Definition at line 119 of file fe-secure-openssl.c.

{
    ssize_t     n;
    int         result_errno = 0;
    char        sebuf[PG_STRERROR_R_BUFLEN];
    int         err;
    unsigned long ecode;
 
rloop:
 
    /*
     * Prepare to call SSL_get_error() by clearing thread's OpenSSL error
     * queue.  In general, the current thread's error queue must be empty
     * before the TLS/SSL I/O operation is attempted, or SSL_get_error() will
     * not work reliably.  Since the possibility exists that other OpenSSL
     * clients running in the same thread but not under our control will fail
     * to call ERR_get_error() themselves (after their own I/O operations),
     * pro-actively clear the per-thread error queue now.
     */
    SOCK_ERRNO_SET(0);
    ERR_clear_error();
    n = SSL_read(conn->ssl, ptr, len);
    err = SSL_get_error(conn->ssl, n);
 
    /*
     * Other clients of OpenSSL may fail to call ERR_get_error(), but we
     * always do, so as to not cause problems for OpenSSL clients that don't
     * call ERR_clear_error() defensively.  Be sure that this happens by
     * calling now.  SSL_get_error() relies on the OpenSSL per-thread error
     * queue being intact, so this is the earliest possible point
     * ERR_get_error() may be called.
     */
    ecode = (err != SSL_ERROR_NONE || n < 0) ? ERR_get_error() : 0;
    switch (err)
    {
        case SSL_ERROR_NONE:
            if (n < 0)
            {
                /* Not supposed to happen, so we don't translate the msg */
                appendPQExpBufferStr(&conn->errorMessage,
                                     "SSL_read failed but did not provide error information\n");
                /* assume the connection is broken */
                result_errno = ECONNRESET;
            }
            break;
        case SSL_ERROR_WANT_READ:
            n = 0;
            break;
        case SSL_ERROR_WANT_WRITE:
 
            /*
             * Returning 0 here would cause caller to wait for read-ready,
             * which is not correct since what SSL wants is wait for
             * write-ready.  The former could get us stuck in an infinite
             * wait, so don't risk it; busy-loop instead.
             */
            goto rloop;
        case SSL_ERROR_SYSCALL:
            if (n < 0 && SOCK_ERRNO != 0)
            {
                result_errno = SOCK_ERRNO;
                if (result_errno == EPIPE ||
                    result_errno == ECONNRESET)
                    libpq_append_conn_error(conn, "server closed the connection unexpectedly\n"
                                            "\tThis probably means the server terminated abnormally\n"
                                            "\tbefore or while processing the request.");
                else
                    libpq_append_conn_error(conn, "SSL SYSCALL error: %s",
                                            SOCK_STRERROR(result_errno,
                                                          sebuf, sizeof(sebuf)));
            }
            else
            {
                libpq_append_conn_error(conn, "SSL SYSCALL error: EOF detected");
                /* assume the connection is broken */
                result_errno = ECONNRESET;
                n = -1;
            }
            break;
        case SSL_ERROR_SSL:
            {
                char       *errm = SSLerrmessage(ecode);
 
                libpq_append_conn_error(conn, "SSL error: %s", errm);
                SSLerrfree(errm);
                /* assume the connection is broken */
                result_errno = ECONNRESET;
                n = -1;
                break;
            }
        case SSL_ERROR_ZERO_RETURN:
 
            /*
             * Per OpenSSL documentation, this error code is only returned for
             * a clean connection closure, so we should not report it as a
             * server crash.
             */
            libpq_append_conn_error(conn, "SSL connection has been closed unexpectedly");
            result_errno = ECONNRESET;
            n = -1;
            break;
        default:
            libpq_append_conn_error(conn, "unrecognized SSL error code: %d", err);
            /* assume the connection is broken */
            result_errno = ECONNRESET;
            n = -1;
            break;
    }
 
    /* ensure we return the intended errno to caller */
    SOCK_ERRNO_SET(result_errno);
 
    return n;
}

References appendPQExpBufferStr(), conn, ECONNRESET, err(), pg_conn::errorMessage, fb(), len, libpq_append_conn_error(), PG_STRERROR_R_BUFLEN, SOCK_ERRNO, SOCK_ERRNO_SET, SOCK_STRERROR, SSLerrfree(), and SSLerrmessage().

Referenced by pqsecure_read().

pgtls_verify_peer_name_matches_certificate_guts()

int pgtls_verify_peer_name_matches_certificate_guts	(	PGconn *	conn,
		int *	names_examined,
		char **	first_name
	)

Definition at line 576 of file fe-secure-openssl.c.

{
    STACK_OF(GENERAL_NAME) * peer_san;
    int         i;
    int         rc = 0;
    char       *host = conn->connhost[conn->whichhost].host;
    int         host_type;
    bool        check_cn = true;
 
    Assert(host && host[0]);    /* should be guaranteed by caller */
 
    /*
     * We try to match the NSS behavior here, which is a slight departure from
     * the spec but seems to make more intuitive sense:
     *
     * If connhost contains a DNS name, and the certificate's SANs contain any
     * dNSName entries, then we'll ignore the Subject Common Name entirely;
     * otherwise, we fall back to checking the CN. (This behavior matches the
     * RFC.)
     *
     * If connhost contains an IP address, and the SANs contain iPAddress
     * entries, we again ignore the CN. Otherwise, we allow the CN to match,
     * EVEN IF there is a dNSName in the SANs. (RFC 6125 prohibits this: "A
     * client MUST NOT seek a match for a reference identifier of CN-ID if the
     * presented identifiers include a DNS-ID, SRV-ID, URI-ID, or any
     * application-specific identifier types supported by the client.")
     *
     * NOTE: Prior versions of libpq did not consider iPAddress entries at
     * all, so this new behavior might break a certificate that has different
     * IP addresses in the Subject CN and the SANs.
     */
    if (is_ip_address(host))
        host_type = GEN_IPADD;
    else
        host_type = GEN_DNS;
 
    /*
     * First, get the Subject Alternative Names (SANs) from the certificate,
     * and compare them against the originally given hostname.
     */
    peer_san = (STACK_OF(GENERAL_NAME) *)
        X509_get_ext_d2i(conn->peer, NID_subject_alt_name, NULL, NULL);
 
    if (peer_san)
    {
        int         san_len = sk_GENERAL_NAME_num(peer_san);
 
        for (i = 0; i < san_len; i++)
        {
            const GENERAL_NAME *name = sk_GENERAL_NAME_value(peer_san, i);
            char       *alt_name = NULL;
 
            if (name->type == host_type)
            {
                /*
                 * This SAN is of the same type (IP or DNS) as our host name,
                 * so don't allow a fallback check of the CN.
                 */
                check_cn = false;
            }
 
            if (name->type == GEN_DNS)
            {
                (*names_examined)++;
                rc = openssl_verify_peer_name_matches_certificate_name(conn,
                                                                       name->d.dNSName,
                                                                       &alt_name);
            }
            else if (name->type == GEN_IPADD)
            {
                (*names_examined)++;
                rc = openssl_verify_peer_name_matches_certificate_ip(conn,
                                                                     name->d.iPAddress,
                                                                     &alt_name);
            }
 
            if (alt_name)
            {
                if (!*first_name)
                    *first_name = alt_name;
                else
                    free(alt_name);
            }
 
            if (rc != 0)
            {
                /*
                 * Either we hit an error or a match, and either way we should
                 * not fall back to the CN.
                 */
                check_cn = false;
                break;
            }
        }
        sk_GENERAL_NAME_pop_free(peer_san, GENERAL_NAME_free);
    }
 
    /*
     * If there is no subjectAltName extension of the matching type, check the
     * Common Name.
     *
     * (Per RFC 2818 and RFC 6125, if the subjectAltName extension of type
     * dNSName is present, the CN must be ignored. We break this rule if host
     * is an IP address; see the comment above.)
     */
    if (check_cn)
    {
        const X509_NAME *subject_name;
 
        subject_name = X509_get_subject_name(conn->peer);
        if (subject_name != NULL)
        {
            int         cn_index;
 
            cn_index = X509_NAME_get_index_by_NID(unconstify(X509_NAME *, subject_name),
                                                  NID_commonName, -1);
            if (cn_index >= 0)
            {
                char       *common_name = NULL;
 
                (*names_examined)++;
                rc = openssl_verify_peer_name_matches_certificate_name(conn,
                                                                       X509_NAME_ENTRY_get_data(X509_NAME_get_entry(subject_name, cn_index)),
                                                                       &common_name);
 
                if (common_name)
                {
                    if (!*first_name)
                        *first_name = common_name;
                    else
                        free(common_name);
                }
            }
        }
    }
 
    return rc;
}

References Assert, conn, pg_conn::connhost, fb(), free, pg_conn_host::host, i, is_ip_address(), name, openssl_verify_peer_name_matches_certificate_ip(), openssl_verify_peer_name_matches_certificate_name(), unconstify, and pg_conn::whichhost.

Referenced by pq_verify_peer_name_matches_certificate().

pgtls_write()

ssize_t pgtls_write	(	PGconn *	conn,
		const void *	ptr,
		size_t	len
	)

Definition at line 271 of file fe-secure-openssl.c.

{
    ssize_t     n;
    int         result_errno = 0;
    char        sebuf[PG_STRERROR_R_BUFLEN];
    int         err;
    unsigned long ecode;
 
    SOCK_ERRNO_SET(0);
    ERR_clear_error();
    n = SSL_write(conn->ssl, ptr, len);
    err = SSL_get_error(conn->ssl, n);
    ecode = (err != SSL_ERROR_NONE || n < 0) ? ERR_get_error() : 0;
    switch (err)
    {
        case SSL_ERROR_NONE:
            if (n < 0)
            {
                /* Not supposed to happen, so we don't translate the msg */
                appendPQExpBufferStr(&conn->errorMessage,
                                     "SSL_write failed but did not provide error information\n");
                /* assume the connection is broken */
                result_errno = ECONNRESET;
            }
            break;
        case SSL_ERROR_WANT_READ:
 
            /*
             * Returning 0 here causes caller to wait for write-ready, which
             * is not really the right thing, but it's the best we can do.
             */
            n = 0;
            break;
        case SSL_ERROR_WANT_WRITE:
            n = 0;
            break;
        case SSL_ERROR_SYSCALL:
 
            /*
             * If errno is still zero then assume it's a read EOF situation,
             * and report EOF.  (This seems possible because SSL_write can
             * also do reads.)
             */
            if (n < 0 && SOCK_ERRNO != 0)
            {
                result_errno = SOCK_ERRNO;
                if (result_errno == EPIPE || result_errno == ECONNRESET)
                    libpq_append_conn_error(conn, "server closed the connection unexpectedly\n"
                                            "\tThis probably means the server terminated abnormally\n"
                                            "\tbefore or while processing the request.");
                else
                    libpq_append_conn_error(conn, "SSL SYSCALL error: %s",
                                            SOCK_STRERROR(result_errno,
                                                          sebuf, sizeof(sebuf)));
            }
            else
            {
                libpq_append_conn_error(conn, "SSL SYSCALL error: EOF detected");
                /* assume the connection is broken */
                result_errno = ECONNRESET;
                n = -1;
            }
            break;
        case SSL_ERROR_SSL:
            {
                char       *errm = SSLerrmessage(ecode);
 
                libpq_append_conn_error(conn, "SSL error: %s", errm);
                SSLerrfree(errm);
                /* assume the connection is broken */
                result_errno = ECONNRESET;
                n = -1;
                break;
            }
        case SSL_ERROR_ZERO_RETURN:
 
            /*
             * Per OpenSSL documentation, this error code is only returned for
             * a clean connection closure, so we should not report it as a
             * server crash.
             */
            libpq_append_conn_error(conn, "SSL connection has been closed unexpectedly");
            result_errno = ECONNRESET;
            n = -1;
            break;
        default:
            libpq_append_conn_error(conn, "unrecognized SSL error code: %d", err);
            /* assume the connection is broken */
            result_errno = ECONNRESET;
            n = -1;
            break;
    }
 
    /* ensure we return the intended errno to caller */
    SOCK_ERRNO_SET(result_errno);
 
    return n;
}

References appendPQExpBufferStr(), conn, ECONNRESET, err(), pg_conn::errorMessage, fb(), len, libpq_append_conn_error(), PG_STRERROR_R_BUFLEN, SOCK_ERRNO, SOCK_ERRNO_SET, SOCK_STRERROR, SSLerrfree(), and SSLerrmessage().

Referenced by pqsecure_write().

PQdefaultSSLKeyPassHook_OpenSSL()

int PQdefaultSSLKeyPassHook_OpenSSL	(	char *	buf,
		int	size,
		PGconn *	conn
	)

Definition at line 1936 of file fe-secure-openssl.c.

{
    if (conn && conn->sslpassword)
    {
        if (strlen(conn->sslpassword) + 1 > size)
            fprintf(stderr, libpq_gettext("WARNING: sslpassword truncated\n"));
        strncpy(buf, conn->sslpassword, size);
        buf[size - 1] = '\0';
        return strlen(buf);
    }
    else
    {
        buf[0] = '\0';
        return 0;
    }
}

References buf, conn, fb(), fprintf, libpq_gettext, and pg_conn::sslpassword.

Referenced by PQssl_passwd_cb().

PQgetssl()

void * PQgetssl

(

PGconn *

conn

)

Definition at line 1658 of file fe-secure-openssl.c.

{
    if (!conn)
        return NULL;
    return conn->ssl;
}

References conn, and fb().

PQgetSSLKeyPassHook_OpenSSL()

PQsslKeyPassHook_OpenSSL_type PQgetSSLKeyPassHook_OpenSSL

(

void

)

Definition at line 1954 of file fe-secure-openssl.c.

{
    return PQsslKeyPassHook;
}

References PQsslKeyPassHook.

PQsetSSLKeyPassHook_OpenSSL()

void PQsetSSLKeyPassHook_OpenSSL

(

PQsslKeyPassHook_OpenSSL_type

hook

)

Definition at line 1960 of file fe-secure-openssl.c.

{
    PQsslKeyPassHook = hook;
}

References PQsslKeyPassHook.

PQssl_passwd_cb()

static int PQssl_passwd_cb ( char *  buf, int  size, int  rwflag, void *  userdata  )

static

Definition at line 1971 of file fe-secure-openssl.c.

{
    PGconn     *conn = userdata;
 
    if (PQsslKeyPassHook)
        return PQsslKeyPassHook(buf, size, conn);
    else
        return PQdefaultSSLKeyPassHook_OpenSSL(buf, size, conn);
}

References buf, conn, fb(), PQdefaultSSLKeyPassHook_OpenSSL(), and PQsslKeyPassHook.

Referenced by initialize_SSL().

PQsslAttribute()

const char * PQsslAttribute	(	PGconn *	conn,
		const char *	attribute_name
	)

Definition at line 1703 of file fe-secure-openssl.c.

{
    if (!conn)
    {
        /* PQsslAttribute(NULL, "library") reports the default SSL library */
        if (strcmp(attribute_name, "library") == 0)
            return "OpenSSL";
        return NULL;
    }
 
    /* All attributes read as NULL for a non-encrypted connection */
    if (conn->ssl == NULL)
        return NULL;
 
    if (strcmp(attribute_name, "library") == 0)
        return "OpenSSL";
 
    if (strcmp(attribute_name, "key_bits") == 0)
    {
        static char sslbits_str[12];
        int         sslbits;
 
        SSL_get_cipher_bits(conn->ssl, &sslbits);
        snprintf(sslbits_str, sizeof(sslbits_str), "%d", sslbits);
        return sslbits_str;
    }
 
    if (strcmp(attribute_name, "cipher") == 0)
        return SSL_get_cipher(conn->ssl);
 
    if (strcmp(attribute_name, "compression") == 0)
        return SSL_get_current_compression(conn->ssl) ? "on" : "off";
 
    if (strcmp(attribute_name, "protocol") == 0)
        return SSL_get_version(conn->ssl);
 
    if (strcmp(attribute_name, "alpn") == 0)
    {
        const unsigned char *data;
        unsigned int len;
        static char alpn_str[256];  /* alpn doesn't support longer than 255
                                     * bytes */
 
        SSL_get0_alpn_selected(conn->ssl, &data, &len);
        if (data == NULL || len == 0 || len > sizeof(alpn_str) - 1)
            return "";
        memcpy(alpn_str, data, len);
        alpn_str[len] = 0;
        return alpn_str;
    }
 
    return NULL;                /* unknown attribute */
}

References conn, data, fb(), len, memcpy(), and snprintf.

Referenced by exec_command_conninfo(), print_ssl_library(), and printSSLInfo().

PQsslAttributeNames()

const char *const * PQsslAttributeNames

(

PGconn *

conn

)

Definition at line 1676 of file fe-secure-openssl.c.

{
    static const char *const openssl_attrs[] = {
        "library",
        "key_bits",
        "cipher",
        "compression",
        "protocol",
        "alpn",
        NULL
    };
    static const char *const empty_attrs[] = {NULL};
 
    if (!conn)
    {
        /* Return attributes of default SSL library */
        return openssl_attrs;
    }
 
    /* No attrs for unencrypted connection */
    if (conn->ssl == NULL)
        return empty_attrs;
 
    return openssl_attrs;
}

References conn, and fb().

PQsslStruct()

void * PQsslStruct	(	PGconn *	conn,
		const char *	struct_name
	)

Definition at line 1666 of file fe-secure-openssl.c.

{
    if (!conn)
        return NULL;
    if (strcmp(struct_name, "OpenSSL") == 0)
        return conn->ssl;
    return NULL;
}

References conn, and fb().

ssl_protocol_version_to_openssl()

static int ssl_protocol_version_to_openssl ( const char *  protocol )

static

Definition at line 1992 of file fe-secure-openssl.c.

{
    if (pg_strcasecmp("TLSv1", protocol) == 0)
        return TLS1_VERSION;
 
#ifdef TLS1_1_VERSION
    if (pg_strcasecmp("TLSv1.1", protocol) == 0)
        return TLS1_1_VERSION;
#endif
 
#ifdef TLS1_2_VERSION
    if (pg_strcasecmp("TLSv1.2", protocol) == 0)
        return TLS1_2_VERSION;
#endif
 
#ifdef TLS1_3_VERSION
    if (pg_strcasecmp("TLSv1.3", protocol) == 0)
        return TLS1_3_VERSION;
#endif
 
    return -1;
}

References fb(), and pg_strcasecmp().

Referenced by initialize_SSL().

ssl_set_pgconn_bio()

static int ssl_set_pgconn_bio ( PGconn *  conn )

static

Definition at line 1910 of file fe-secure-openssl.c.

{
    BIO        *bio;
    BIO_METHOD *bio_method;
 
    bio_method = pgconn_bio_method();
    if (bio_method == NULL)
        return 0;
 
    bio = BIO_new(bio_method);
    if (bio == NULL)
        return 0;
 
    BIO_set_data(bio, conn);
    BIO_set_init(bio, 1);
 
    SSL_set_bio(conn->ssl, bio, bio);
    return 1;
}

References conn, fb(), and pgconn_bio_method().

Referenced by initialize_SSL().

SSLerrfree()

static void SSLerrfree ( char *  buf )

static

Definition at line 1644 of file fe-secure-openssl.c.

{
    if (buf != ssl_nomem)
        free(buf);
}

References buf, free, and ssl_nomem.

Referenced by initialize_SSL(), open_client_SSL(), pgtls_read(), and pgtls_write().

SSLerrmessage()

static char * SSLerrmessage ( unsigned long  ecode )

static

Definition at line 1586 of file fe-secure-openssl.c.

{
    const char *errreason;
    char       *errbuf;
 
    errbuf = malloc(SSL_ERR_LEN);
    if (!errbuf)
        return ssl_nomem;
    if (ecode == 0)
    {
        snprintf(errbuf, SSL_ERR_LEN, libpq_gettext("no SSL error reported"));
        return errbuf;
    }
    errreason = ERR_reason_error_string(ecode);
    if (errreason != NULL)
    {
        strlcpy(errbuf, errreason, SSL_ERR_LEN);
        return errbuf;
    }
 
    /*
     * Server aborted the connection with TLS "no_application_protocol" alert.
     * The ERR_reason_error_string() function doesn't give any error string
     * for that for some reason, so do it ourselves.  See
     * https://github.com/openssl/openssl/issues/24300.  This is available in
     * OpenSSL 1.1.0 and later, as well as in LibreSSL 3.4.3 (OpenBSD 7.0) and
     * later.
     */
#ifdef SSL_AD_NO_APPLICATION_PROTOCOL
    if (ERR_GET_LIB(ecode) == ERR_LIB_SSL &&
        ERR_GET_REASON(ecode) == SSL_AD_REASON_OFFSET + SSL_AD_NO_APPLICATION_PROTOCOL)
    {
        snprintf(errbuf, SSL_ERR_LEN, "no application protocol");
        return errbuf;
    }
#endif
 
    /*
     * In OpenSSL 3.0.0 and later, ERR_reason_error_string does not map system
     * errno values anymore.  (See OpenSSL source code for the explanation.)
     * We can cover that shortcoming with this bit of code.  Older OpenSSL
     * versions don't have the ERR_SYSTEM_ERROR macro, but that's okay because
     * they don't have the shortcoming either.
     */
#ifdef ERR_SYSTEM_ERROR
    if (ERR_SYSTEM_ERROR(ecode))
    {
        strerror_r(ERR_GET_REASON(ecode), errbuf, SSL_ERR_LEN);
        return errbuf;
    }
#endif
 
    /* No choice but to report the numeric ecode */
    snprintf(errbuf, SSL_ERR_LEN, libpq_gettext("SSL error code %lu"), ecode);
    return errbuf;
}

References fb(), libpq_gettext, malloc, snprintf, SSL_ERR_LEN, ssl_nomem, strerror_r, and strlcpy().

Referenced by initialize_SSL(), open_client_SSL(), pgtls_read(), and pgtls_write().

verify_cb()

static int verify_cb ( int  ok, X509_STORE_CTX *  ctx  )

static

Definition at line 461 of file fe-secure-openssl.c.

{
    return ok;
}

References fb().

Referenced by initialize_SSL().

Variable Documentation

alpn_protos

unsigned char alpn_protos[] = PG_ALPN_PROTOCOL_VECTOR

static

Definition at line 718 of file fe-secure-openssl.c.

Referenced by initialize_SSL().

pgconn_bio_method_ptr

BIO_METHOD* pgconn_bio_method_ptr

static

Definition at line 1767 of file fe-secure-openssl.c.

Referenced by pgconn_bio_method().

PQsslKeyPassHook

PQsslKeyPassHook_OpenSSL_type PQsslKeyPassHook = NULL

static

Definition at line 89 of file fe-secure-openssl.c.

Referenced by initialize_SSL(), PQgetSSLKeyPassHook_OpenSSL(), PQsetSSLKeyPassHook_OpenSSL(), and PQssl_passwd_cb().

ssl_config_mutex

pthread_mutex_t ssl_config_mutex = PTHREAD_MUTEX_INITIALIZER

static

Definition at line 87 of file fe-secure-openssl.c.

Referenced by pgconn_bio_method().

ssl_nomem

char ssl_nomem[] = "out of memory allocating error description"

static

Definition at line 1581 of file fe-secure-openssl.c.

Referenced by SSLerrfree(), and SSLerrmessage().