#include "postgres.h"
#include <sys/stat.h>
#include <signal.h>
#include <fcntl.h>
#include <ctype.h>
#include <sys/socket.h>
#include <unistd.h>
#include <netdb.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include "common/hashfn.h"
#include "common/string.h"
#include "libpq/libpq.h"
#include "miscadmin.h"
#include "pgstat.h"
#include "storage/fd.h"
#include "storage/latch.h"
#include "utils/guc.h"
#include "utils/memutils.h"
#include "utils/wait_event.h"
#include "common/openssl.h"
#include <openssl/bn.h>
#include <openssl/conf.h>
#include <openssl/dh.h>
#include <openssl/ec.h>
#include <openssl/x509v3.h>
#include "lib/simplehash.h"

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

Data Structures
struct	HostCacheEntry

struct	hosts

struct	CallbackErr

Macros
#define	SH_PREFIX host_cache

#define	SH_ELEMENT_TYPE HostCacheEntry

#define	SH_KEY_TYPE const char *

#define	SH_KEY hostname

#define	SH_HASH_KEY(tb, key) host_cache_pointer(key)

#define	SH_EQUAL(tb, a, b) (pg_strcasecmp(a, b) == 0)

#define	SH_SCOPE static inline

#define	SH_DECLARE

#define	SH_DEFINE

#define	MAXLEN 71

Functions
static uint32	host_cache_pointer (const char *key)

static void	default_openssl_tls_init (SSL_CTX *context, bool isServerStart)

static int	port_bio_read (BIO h, char buf, int size)

static int	port_bio_write (BIO h, const char buf, int size)

static BIO_METHOD *	port_bio_method (void)

static int	ssl_set_port_bio (Port *port)

static DH *	load_dh_file (char *filename, bool isServerStart)

static DH *	load_dh_buffer (const char *buffer, size_t len)

static int	ssl_external_passwd_cb (char buf, int size, int rwflag, void userdata)

static int	dummy_ssl_passwd_cb (char buf, int size, int rwflag, void userdata)

static int	verify_cb (int ok, X509_STORE_CTX *ctx)

static void	info_cb (const SSL *ssl, int type, int args)

static int	alpn_cb (SSL ssl, const unsigned char out, unsigned char outlen, const unsigned char in, unsigned int inlen, void userdata)

static bool	initialize_dh (SSL_CTX *context, bool isServerStart)

static bool	initialize_ecdh (SSL_CTX *context, bool isServerStart)

static const char *	SSLerrmessageExt (unsigned long ecode, const char *replacement)

static const char *	SSLerrmessage (unsigned long ecode)

static bool	init_host_context (HostsLine *host, bool isServerStart)

static void	host_context_cleanup_cb (void *arg)

static char *	X509_NAME_to_cstring (X509_NAME *name)

static int	ssl_protocol_version_to_openssl (int v)

static const char *	ssl_protocol_version_to_string (int v)

int	be_tls_init (bool isServerStart)

void	be_tls_destroy (void)

int	be_tls_open_server (Port *port)

void	be_tls_close (Port *port)

ssize_t	be_tls_read (Port port, void ptr, size_t len, int *waitfor)

ssize_t	be_tls_write (Port port, const void ptr, size_t len, int *waitfor)

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

static char *	prepare_cert_name (char *name)

int	be_tls_get_cipher_bits (Port *port)

const char *	be_tls_get_version (Port *port)

const char *	be_tls_get_cipher (Port *port)

void	be_tls_get_peer_subject_name (Port port, char ptr, size_t len)

void	be_tls_get_peer_issuer_name (Port port, char ptr, size_t len)

void	be_tls_get_peer_serial (Port port, char ptr, size_t len)

char *	be_tls_get_certificate_hash (Port port, size_t len)

Macro Definition Documentation

◆ MAXLEN

#define MAXLEN 71

◆ SH_DECLARE

#define SH_DECLARE

Definition at line 74 of file be-secure-openssl.c.

◆ SH_DEFINE

#define SH_DEFINE

Definition at line 75 of file be-secure-openssl.c.

◆ SH_ELEMENT_TYPE

#define SH_ELEMENT_TYPE HostCacheEntry

Definition at line 68 of file be-secure-openssl.c.

◆ SH_EQUAL

#define SH_EQUAL	(	tb,
		a,
		b
	)	(pg_strcasecmp(a, b) == 0)

Definition at line 72 of file be-secure-openssl.c.

◆ SH_HASH_KEY

#define SH_HASH_KEY	(	tb,
		key
	)	host_cache_pointer(key)

Definition at line 71 of file be-secure-openssl.c.

◆ SH_KEY

#define SH_KEY hostname

Definition at line 70 of file be-secure-openssl.c.

◆ SH_KEY_TYPE

#define SH_KEY_TYPE const char *

Definition at line 69 of file be-secure-openssl.c.

◆ SH_PREFIX

#define SH_PREFIX host_cache

Definition at line 67 of file be-secure-openssl.c.

◆ SH_SCOPE

#define SH_SCOPE static inline

Definition at line 73 of file be-secure-openssl.c.

Function Documentation

◆ alpn_cb()

static int alpn_cb	(	SSL *	ssl,
		const unsigned char **	out,
		unsigned char *	outlen,
		const unsigned char *	in,
		unsigned int	inlen,
		void *	userdata
	)

static

Definition at line 1778 of file be-secure-openssl.c.

{
    /*
     * Why does OpenSSL provide a helper function that requires a nonconst
     * vector when the callback is declared to take a const vector? What are
     * we to do with that?
     */
    int         retval;
 
    Assert(userdata != NULL);
    Assert(out != NULL);
    Assert(outlen != NULL);
    Assert(in != NULL);
 
    retval = SSL_select_next_proto((unsigned char **) out, outlen,
                                   alpn_protos, sizeof(alpn_protos),
                                   in, inlen);
    if (*out == NULL || *outlen > sizeof(alpn_protos) || *outlen <= 0)
        return SSL_TLSEXT_ERR_NOACK;    /* can't happen */
 
    if (retval == OPENSSL_NPN_NEGOTIATED)
        return SSL_TLSEXT_ERR_OK;
    else
    {
        /*
         * The client doesn't support our protocol.  Reject the connection
         * with TLS "no_application_protocol" alert, per RFC 7301.
         */
        return SSL_TLSEXT_ERR_ALERT_FATAL;
    }
}

References alpn_protos, Assert, and fb().

Referenced by be_tls_open_server().

◆ be_tls_close()

void be_tls_close ( Port * port )

Definition at line 1168 of file be-secure-openssl.c.

{
    if (port->ssl)
    {
        SSL_shutdown(port->ssl);
        SSL_free(port->ssl);
        port->ssl = NULL;
        port->ssl_in_use = false;
    }
 
    if (port->peer)
    {
        X509_free(port->peer);
        port->peer = NULL;
    }
 
    if (port->peer_cn)
    {
        pfree(port->peer_cn);
        port->peer_cn = NULL;
    }
 
    if (port->peer_dn)
    {
        pfree(port->peer_dn);
        port->peer_dn = NULL;
    }
}

References fb(), pfree(), and port.

Referenced by secure_close().

◆ be_tls_destroy()

void be_tls_destroy ( void )

Definition at line 825 of file be-secure-openssl.c.

{
    if (SSL_context)
        SSL_CTX_free(SSL_context);
    SSL_context = NULL;
    ssl_loaded_verify_locations = false;
}

References fb(), and SSL_context.

Referenced by secure_destroy().

◆ be_tls_get_certificate_hash()

char * be_tls_get_certificate_hash	(	Port *	port,
		size_t *	len
	)

Definition at line 2273 of file be-secure-openssl.c.

{
    X509       *server_cert;
    char       *cert_hash;
    const EVP_MD *algo_type = NULL;
    unsigned char hash[EVP_MAX_MD_SIZE];    /* size for SHA-512 */
    unsigned int hash_size;
    int         algo_nid;
 
    *len = 0;
    server_cert = SSL_get_certificate(port->ssl);
    if (server_cert == NULL)
        return NULL;
 
    /*
     * 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(server_cert, &algo_nid, NULL, NULL, NULL))
#else
    if (!OBJ_find_sigid_algs(X509_get_signature_nid(server_cert),
                             &algo_nid, NULL))
#endif
        elog(ERROR, "could not determine server certificate signature algorithm");
 
    /*
     * 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)
                elog(ERROR, "could not find digest for NID %s",
                     OBJ_nid2sn(algo_nid));
            break;
    }
 
    /* generate and save the certificate hash */
    if (!X509_digest(server_cert, algo_type, hash, &hash_size))
        elog(ERROR, "could not generate server certificate hash");
 
    cert_hash = palloc(hash_size);
    memcpy(cert_hash, hash, hash_size);
    *len = hash_size;
 
    return cert_hash;
}

References elog, ERROR, fb(), hash(), len, palloc(), and port.

Referenced by read_client_final_message().

◆ be_tls_get_cipher()

const char * be_tls_get_cipher ( Port * port )

Definition at line 2225 of file be-secure-openssl.c.

{
    if (port->ssl)
        return SSL_get_cipher(port->ssl);
    else
        return NULL;
}

References fb(), and port.

Referenced by PerformAuthentication(), pgstat_bestart_security(), and ssl_cipher().

◆ be_tls_get_cipher_bits()

int be_tls_get_cipher_bits ( Port * port )

Definition at line 2202 of file be-secure-openssl.c.

{
    int         bits;
 
    if (port->ssl)
    {
        SSL_get_cipher_bits(port->ssl, &bits);
        return bits;
    }
    else
        return 0;
}

References fb(), and port.

Referenced by PerformAuthentication(), and pgstat_bestart_security().

◆ be_tls_get_peer_issuer_name()

void be_tls_get_peer_issuer_name	(	Port *	port,
		char *	ptr,
		size_t	len
	)

Definition at line 2243 of file be-secure-openssl.c.

{
    if (port->peer)
        strlcpy(ptr, X509_NAME_to_cstring(X509_get_issuer_name(port->peer)), len);
    else
        ptr[0] = '\0';
}

References fb(), len, port, strlcpy(), and X509_NAME_to_cstring().

Referenced by pgstat_bestart_security(), and ssl_issuer_dn().

◆ be_tls_get_peer_serial()

void be_tls_get_peer_serial	(	Port *	port,
		char *	ptr,
		size_t	len
	)

Definition at line 2252 of file be-secure-openssl.c.

{
    if (port->peer)
    {
        ASN1_INTEGER *serial;
        BIGNUM     *b;
        char       *decimal;
 
        serial = X509_get_serialNumber(port->peer);
        b = ASN1_INTEGER_to_BN(serial, NULL);
        decimal = BN_bn2dec(b);
 
        BN_free(b);
        strlcpy(ptr, decimal, len);
        OPENSSL_free(decimal);
    }
    else
        ptr[0] = '\0';
}

References b, fb(), len, port, and strlcpy().

Referenced by pgstat_bestart_security(), and ssl_client_serial().

◆ be_tls_get_peer_subject_name()

void be_tls_get_peer_subject_name	(	Port *	port,
		char *	ptr,
		size_t	len
	)

Definition at line 2234 of file be-secure-openssl.c.

{
    if (port->peer)
        strlcpy(ptr, X509_NAME_to_cstring(X509_get_subject_name(port->peer)), len);
    else
        ptr[0] = '\0';
}

References fb(), len, port, strlcpy(), and X509_NAME_to_cstring().

Referenced by pgstat_bestart_security(), and ssl_client_dn().

◆ be_tls_get_version()

const char * be_tls_get_version ( Port * port )

Definition at line 2216 of file be-secure-openssl.c.

{
    if (port->ssl)
        return SSL_get_version(port->ssl);
    else
        return NULL;
}

References fb(), and port.

Referenced by PerformAuthentication(), pgstat_bestart_security(), and ssl_version().

◆ be_tls_init()

int be_tls_init ( bool isServerStart )

Definition at line 151 of file be-secure-openssl.c.

{
    List       *pg_hosts = NIL;
    ListCell   *line;
    MemoryContext oldcxt;
    MemoryContext host_memcxt = NULL;
    MemoryContextCallback *host_memcxt_cb;
    char       *err_msg = NULL;
    int         res;
    struct hosts *new_hosts;
    SSL_CTX    *context = NULL;
    int         ssl_ver_min = -1;
    int         ssl_ver_max = -1;
    host_cache_hash *host_cache = NULL;
 
    /*
     * Since we don't know which host we're using until the ClientHello is
     * sent, ssl_loaded_verify_locations *always* starts out as false. The
     * only place it's set to true is in sni_clienthello_cb().
     */
    ssl_loaded_verify_locations = false;
 
    host_memcxt = AllocSetContextCreate(CurrentMemoryContext,
                                        "hosts file parser context",
                                        ALLOCSET_SMALL_SIZES);
    oldcxt = MemoryContextSwitchTo(host_memcxt);
 
    /* Allocate a tentative replacement for SSL_hosts. */
    new_hosts = palloc0_object(struct hosts);
 
    /*
     * Register a reset callback for the memory context which is responsible
     * for freeing OpenSSL managed allocations upon context deletion.  The
     * callback is allocated here to make sure it gets cleaned up along with
     * the memory context it's registered for.
     */
    host_memcxt_cb = palloc0_object(MemoryContextCallback);
    host_memcxt_cb->func = host_context_cleanup_cb;
    host_memcxt_cb->arg = new_hosts;
    MemoryContextRegisterResetCallback(host_memcxt, host_memcxt_cb);
 
    /*
     * If ssl_sni is enabled, attempt to load and parse TLS configuration from
     * the pg_hosts.conf file with the set of hosts returned as a list.  If
     * there are hosts configured they take precedence over the configuration
     * in postgresql.conf.  Make sure to allocate the parsed rows in their own
     * memory context so that we can delete them easily in case parsing fails.
     * If ssl_sni is disabled then set the state accordingly to make sure we
     * instead parse the config from postgresql.conf.
     *
     * The reason for not doing everything in this if-else conditional is that
     * we want to use the same processing of postgresql.conf for when ssl_sni
     * is off as well as when it's on but the hostsfile is missing etc.  Thus
     * we set res to the state and continue with a new conditional instead of
     * duplicating logic and risk it diverging over time.
     */
    if (ssl_sni)
    {
        /*
         * The GUC check hook should have already blocked this but to be on
         * the safe side we doublecheck here.
         */
#ifndef HAVE_SSL_CTX_SET_CLIENT_HELLO_CB
        ereport(isServerStart ? FATAL : LOG,
                errcode(ERRCODE_CONFIG_FILE_ERROR),
                errmsg("ssl_sni is not supported with LibreSSL"));
        goto error;
#endif
 
        /* Attempt to load configuration from pg_hosts.conf */
        res = load_hosts(&pg_hosts, &err_msg);
 
        /*
         * pg_hosts.conf is not required to contain configuration, but if it
         * does we error out in case it fails to load rather than continue to
         * try the postgresql.conf configuration to avoid silently falling
         * back on an undesired configuration.
         */
        if (res == HOSTSFILE_LOAD_FAILED)
        {
            ereport(isServerStart ? FATAL : LOG,
                    errcode(ERRCODE_CONFIG_FILE_ERROR),
                    errmsg("could not load \"%s\": %s", "pg_hosts.conf",
                           err_msg ? err_msg : "unknown error"));
            goto error;
        }
    }
    else
        res = HOSTSFILE_DISABLED;
 
    /*
     * Loading and parsing the hosts file was successful, create configs for
     * each host entry and add to the list of hosts to be checked during
     * login.
     */
    if (res == HOSTSFILE_LOAD_OK)
    {
        Assert(ssl_sni);
 
        foreach(line, pg_hosts)
        {
            HostsLine  *host = lfirst(line);
 
            if (!init_host_context(host, isServerStart))
                goto error;
 
            /*
             * The hostname in the config will be set to NULL for the default
             * host as well as in configs used for non-SNI connections.  Lists
             * of hostnames in pg_hosts.conf are not allowed to contain the
             * default '*' entry or a '/no_sni/' entry and this is checked
             * during parsing.  Thus we can inspect the head of the hostnames
             * list for these since they will never be anywhere else.
             */
            if (strcmp(linitial(host->hostnames), "*") == 0)
            {
                if (new_hosts->default_host)
                {
                    ereport(isServerStart ? FATAL : LOG,
                            errcode(ERRCODE_CONFIG_FILE_ERROR),
                            errmsg("multiple default hosts specified"),
                            errcontext("line %d of configuration file \"%s\"",
                                       host->linenumber, host->sourcefile));
                    goto error;
                }
 
                new_hosts->default_host = host;
            }
            else if (strcmp(linitial(host->hostnames), "/no_sni/") == 0)
            {
                if (new_hosts->no_sni)
                {
                    ereport(isServerStart ? FATAL : LOG,
                            errcode(ERRCODE_CONFIG_FILE_ERROR),
                            errmsg("multiple no_sni hosts specified"),
                            errcontext("line %d of configuration file \"%s\"",
                                       host->linenumber, host->sourcefile));
                    goto error;
                }
 
                new_hosts->no_sni = host;
            }
            else
            {
                /* Check the hostnames for duplicates */
                if (!host_cache)
                    host_cache = host_cache_create(host_memcxt, 32, NULL);
 
                foreach_ptr(char, hostname, host->hostnames)
                {
                    HostCacheEntry *entry;
                    bool        found;
 
                    entry = host_cache_insert(host_cache, hostname, &found);
                    if (found)
                    {
                        ereport(isServerStart ? FATAL : LOG,
                                errcode(ERRCODE_CONFIG_FILE_ERROR),
                                errmsg("multiple entries for host \"%s\" specified",
                                       hostname),
                                errcontext("line %d of configuration file \"%s\"",
                                           host->linenumber, host->sourcefile));
                        goto error;
                    }
                    else
                        entry->hostname = pstrdup(hostname);
                }
 
                /*
                 * At this point we know we have a configuration with a list
                 * of distinct 1..n hostnames for literal string matching with
                 * the SNI extension from the user.
                 */
                new_hosts->sni = lappend(new_hosts->sni, host);
            }
        }
    }
 
    /*
     * If SNI is disabled, then we load configuration from postgresql.conf. If
     * SNI is enabled but the pg_hosts.conf file doesn't exist, or is empty,
     * then we also load the config from postgresql.conf.
     */
    else if (res == HOSTSFILE_DISABLED || res == HOSTSFILE_EMPTY || res == HOSTSFILE_MISSING)
    {
        HostsLine  *pgconf = palloc0(sizeof(HostsLine));
 
#ifdef USE_ASSERT_CHECKING
        if (res == HOSTSFILE_DISABLED)
            Assert(ssl_sni == false);
#endif
 
        pgconf->ssl_cert = ssl_cert_file;
        pgconf->ssl_key = ssl_key_file;
        pgconf->ssl_ca = ssl_ca_file;
        pgconf->ssl_passphrase_cmd = ssl_passphrase_command;
        pgconf->ssl_passphrase_reload = ssl_passphrase_command_supports_reload;
 
        if (!init_host_context(pgconf, isServerStart))
            goto error;
 
        /*
         * If postgresql.conf is used to configure SSL then by definition it
         * will be the default context as we don't have per-host config.
         */
        new_hosts->default_host = pgconf;
    }
 
    /*
     * Make sure we have at least one configuration loaded to use, without
     * that we cannot drive a connection so exit.
     */
    if (new_hosts->sni == NIL && !new_hosts->default_host && !new_hosts->no_sni)
    {
        ereport(isServerStart ? FATAL : LOG,
                errcode(ERRCODE_CONFIG_FILE_ERROR),
                errmsg("no SSL configurations loaded"),
        /*- translator: The two %s contain filenames */
                errhint("If ssl_sni is enabled then add configuration to \"%s\", else \"%s\"",
                        "pg_hosts.conf", "postgresql.conf"));
        goto error;
    }
 
#ifdef HAVE_SSL_CTX_SET_CLIENT_HELLO_CB
 
    /*
     * Create a new SSL context into which we'll load all the configuration
     * settings.  If we fail partway through, we can avoid memory leakage by
     * freeing this context; we don't install it as active until the end.
     *
     * We use SSLv23_method() because it can negotiate use of the highest
     * mutually supported protocol version, while alternatives like
     * TLSv1_2_method() permit only one specific version.  Note that we don't
     * actually allow SSL v2 or v3, only TLS protocols (see below).
     */
    context = SSL_CTX_new(SSLv23_method());
    if (!context)
    {
        ereport(isServerStart ? FATAL : LOG,
                (errmsg("could not create SSL context: %s",
                        SSLerrmessage(ERR_get_error()))));
        goto error;
    }
#else
 
    /*
     * If the client hello callback isn't supported we want to use the default
     * context as the one to drive the handshake so avoid creating a new one
     * and use the already existing default one instead.
     */
    context = new_hosts->default_host->ssl_ctx;
 
    /*
     * Since we don't allocate a new SSL_CTX here like we do when SNI has been
     * enabled we need to bump the reference count on context to avoid double
     * free of the context when using the same cleanup logic across the cases.
     */
    SSL_CTX_up_ref(context);
#endif
 
    /*
     * Disable OpenSSL's moving-write-buffer sanity check, because it causes
     * unnecessary failures in nonblocking send cases.
     */
    SSL_CTX_set_mode(context, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
 
    if (ssl_min_protocol_version)
    {
        ssl_ver_min = ssl_protocol_version_to_openssl(ssl_min_protocol_version);
 
        if (ssl_ver_min == -1)
        {
            ereport(isServerStart ? FATAL : LOG,
            /*- translator: first %s is a GUC option name, second %s is its value */
                    (errmsg("\"%s\" setting \"%s\" not supported by this build",
                            "ssl_min_protocol_version",
                            GetConfigOption("ssl_min_protocol_version",
                                            false, false))));
            goto error;
        }
 
        if (!SSL_CTX_set_min_proto_version(context, ssl_ver_min))
        {
            ereport(isServerStart ? FATAL : LOG,
                    (errmsg("could not set minimum SSL protocol version")));
            goto error;
        }
    }
 
    if (ssl_max_protocol_version)
    {
        ssl_ver_max = ssl_protocol_version_to_openssl(ssl_max_protocol_version);
 
        if (ssl_ver_max == -1)
        {
            ereport(isServerStart ? FATAL : LOG,
            /*- translator: first %s is a GUC option name, second %s is its value */
                    (errmsg("\"%s\" setting \"%s\" not supported by this build",
                            "ssl_max_protocol_version",
                            GetConfigOption("ssl_max_protocol_version",
                                            false, false))));
            goto error;
        }
 
        if (!SSL_CTX_set_max_proto_version(context, ssl_ver_max))
        {
            ereport(isServerStart ? FATAL : LOG,
                    (errmsg("could not set maximum SSL protocol version")));
            goto error;
        }
    }
 
    /* Check compatibility of min/max protocols */
    if (ssl_min_protocol_version &&
        ssl_max_protocol_version)
    {
        /*
         * No need to check for invalid values (-1) for each protocol number
         * as the code above would have already generated an error.
         */
        if (ssl_ver_min > ssl_ver_max)
        {
            ereport(isServerStart ? FATAL : LOG,
                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                     errmsg("could not set SSL protocol version range"),
                     errdetail("\"%s\" cannot be higher than \"%s\"",
                               "ssl_min_protocol_version",
                               "ssl_max_protocol_version")));
            goto error;
        }
    }
 
    /*
     * Disallow SSL session tickets. OpenSSL use both stateful and stateless
     * tickets for TLSv1.3, and stateless ticket for TLSv1.2. SSL_OP_NO_TICKET
     * is available since 0.9.8f but only turns off stateless tickets. In
     * order to turn off stateful tickets we need SSL_CTX_set_num_tickets,
     * which is available since OpenSSL 1.1.1.  LibreSSL 3.5.4 (from OpenBSD
     * 7.1) introduced this API for compatibility, but doesn't support session
     * tickets at all so it's a no-op there.
     */
#ifdef HAVE_SSL_CTX_SET_NUM_TICKETS
    SSL_CTX_set_num_tickets(context, 0);
#endif
    SSL_CTX_set_options(context, SSL_OP_NO_TICKET);
 
    /* disallow SSL session caching, too */
    SSL_CTX_set_session_cache_mode(context, SSL_SESS_CACHE_OFF);
 
    /* disallow SSL compression */
    SSL_CTX_set_options(context, SSL_OP_NO_COMPRESSION);
 
    /*
     * Disallow SSL renegotiation.  This concerns only TLSv1.2 and older
     * protocol versions, as TLSv1.3 has no support for renegotiation.
     * SSL_OP_NO_RENEGOTIATION is available in OpenSSL since 1.1.0h (via a
     * backport from 1.1.1). SSL_OP_NO_CLIENT_RENEGOTIATION is available in
     * LibreSSL since 2.5.1 disallowing all client-initiated renegotiation
     * (this is usually on by default).
     */
#ifdef SSL_OP_NO_RENEGOTIATION
    SSL_CTX_set_options(context, SSL_OP_NO_RENEGOTIATION);
#endif
#ifdef SSL_OP_NO_CLIENT_RENEGOTIATION
    SSL_CTX_set_options(context, SSL_OP_NO_CLIENT_RENEGOTIATION);
#endif
 
    /* set up ephemeral DH and ECDH keys */
    if (!initialize_dh(context, isServerStart))
        goto error;
    if (!initialize_ecdh(context, isServerStart))
        goto error;
 
    /* set up the allowed cipher list for TLSv1.2 and below */
    if (SSL_CTX_set_cipher_list(context, SSLCipherList) != 1)
    {
        ereport(isServerStart ? FATAL : LOG,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("could not set the TLSv1.2 cipher list (no valid ciphers available)")));
        goto error;
    }
 
    /*
     * Set up the allowed cipher suites for TLSv1.3. If the GUC is an empty
     * string we leave the allowed suites to be the OpenSSL default value.
     */
    if (SSLCipherSuites[0])
    {
        /* set up the allowed cipher suites */
        if (SSL_CTX_set_ciphersuites(context, SSLCipherSuites) != 1)
        {
            ereport(isServerStart ? FATAL : LOG,
                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                     errmsg("could not set the TLSv1.3 cipher suites (no valid ciphers available)")));
            goto error;
        }
    }
 
    /* Let server choose order */
    if (SSLPreferServerCiphers)
        SSL_CTX_set_options(context, SSL_OP_CIPHER_SERVER_PREFERENCE);
 
    /*
     * Success!  Replace any existing SSL_context and host configurations.
     */
    if (SSL_context)
    {
        SSL_CTX_free(SSL_context);
        SSL_context = NULL;
    }
 
    MemoryContextSwitchTo(oldcxt);
 
    if (SSL_hosts_memcxt)
        MemoryContextDelete(SSL_hosts_memcxt);
 
    SSL_hosts_memcxt = host_memcxt;
    SSL_hosts = new_hosts;
    SSL_context = context;
 
    return 0;
 
    /*
     * Clean up by releasing working SSL contexts as well as allocations
     * performed during parsing.  Since all our allocations are done in a
     * local memory context all we need to do is delete it.
     */
error:
    if (context)
        SSL_CTX_free(context);
 
    MemoryContextSwitchTo(oldcxt);
    MemoryContextDelete(host_memcxt);
    return -1;
}

References ALLOCSET_SMALL_SIZES, AllocSetContextCreate, Assert, CurrentMemoryContext, ereport, errcode(), errcontext, errdetail(), errhint(), errmsg, error(), FATAL, fb(), foreach_ptr, GetConfigOption(), host_context_cleanup_cb(), HostCacheEntry::hostname, hostname, HostsLine::hostnames, HOSTSFILE_DISABLED, HOSTSFILE_EMPTY, HOSTSFILE_LOAD_FAILED, HOSTSFILE_LOAD_OK, HOSTSFILE_MISSING, init_host_context(), initialize_dh(), initialize_ecdh(), lappend(), lfirst, HostsLine::linenumber, linitial, load_hosts(), LOG, MemoryContextDelete(), MemoryContextRegisterResetCallback(), MemoryContextSwitchTo(), NIL, palloc0(), palloc0_object, pstrdup(), HostsLine::sourcefile, ssl_ca_file, ssl_cert_file, SSL_context, SSL_hosts, SSL_hosts_memcxt, ssl_key_file, ssl_max_protocol_version, ssl_min_protocol_version, ssl_passphrase_command, ssl_passphrase_command_supports_reload, ssl_protocol_version_to_openssl(), ssl_sni, SSLCipherList, SSLCipherSuites, SSLerrmessage(), and SSLPreferServerCiphers.

Referenced by secure_initialize().

◆ be_tls_open_server()

int be_tls_open_server ( Port * port )

Definition at line 834 of file be-secure-openssl.c.

{
    int         r;
    int         err;
    int         waitfor;
    unsigned long ecode;
    bool        give_proto_hint;
    static struct CallbackErr err_context;
 
    Assert(!port->ssl);
    Assert(!port->peer);
 
    if (!SSL_context)
    {
        ereport(COMMERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("could not initialize SSL connection: SSL context not set up")));
        return -1;
    }
 
    /* set up debugging/info callback */
    SSL_CTX_set_info_callback(SSL_context, info_cb);
 
    /* enable ALPN */
    SSL_CTX_set_alpn_select_cb(SSL_context, alpn_cb, port);
 
    if (!(port->ssl = SSL_new(SSL_context)))
    {
        ereport(COMMERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("could not initialize SSL connection: %s",
                        SSLerrmessage(ERR_get_error()))));
        return -1;
    }
    if (!ssl_set_port_bio(port))
    {
        ereport(COMMERROR,
                (errcode(ERRCODE_PROTOCOL_VIOLATION),
                 errmsg("could not set SSL socket: %s",
                        SSLerrmessage(ERR_get_error()))));
        return -1;
    }
 
    /*
     * If the underlying TLS library supports the client hello callback we use
     * that in order to support host based configuration using the SNI TLS
     * extension.  If the user has disabled SNI via the ssl_sni GUC we still
     * make use of the callback in order to have consistent handling of
     * OpenSSL contexts, except in that case the callback will install the
     * default configuration regardless of the hostname sent by the user in
     * the handshake.
     *
     * In case the TLS library does not support the client hello callback, as
     * of this writing LibreSSL does not, we need to install the client cert
     * verification callback here (if the user configured a CA) since we
     * cannot use the OpenSSL context update functionality.
     */
#ifdef HAVE_SSL_CTX_SET_CLIENT_HELLO_CB
    SSL_CTX_set_client_hello_cb(SSL_context, sni_clienthello_cb, NULL);
#else
    if (SSL_hosts->default_host->ssl_ca && SSL_hosts->default_host->ssl_ca[0])
    {
        /*
         * Always ask for SSL client cert, but don't fail if it's not
         * presented.  We might fail such connections later, depending on what
         * we find in pg_hba.conf.
         */
        SSL_set_verify(port->ssl,
                       (SSL_VERIFY_PEER | SSL_VERIFY_CLIENT_ONCE),
                       verify_cb);
 
        ssl_loaded_verify_locations = true;
    }
#endif
 
    err_context.cert_errdetail = NULL;
    SSL_set_ex_data(port->ssl, 0, &err_context);
 
    port->ssl_in_use = true;
 
aloop:
 
    /*
     * 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.  An extension may have failed to clear the
     * per-thread error queue following another call to an OpenSSL I/O
     * routine.
     */
    errno = 0;
    ERR_clear_error();
    r = SSL_accept(port->ssl);
    if (r <= 0)
    {
        err = SSL_get_error(port->ssl, r);
 
        /*
         * Other clients of OpenSSL in the backend 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_get_error();
        switch (err)
        {
            case SSL_ERROR_WANT_READ:
            case SSL_ERROR_WANT_WRITE:
                /* not allowed during connection establishment */
                Assert(!port->noblock);
 
                /*
                 * No need to care about timeouts/interrupts here. At this
                 * point authentication_timeout still employs
                 * StartupPacketTimeoutHandler() which directly exits.
                 */
                if (err == SSL_ERROR_WANT_READ)
                    waitfor = WL_SOCKET_READABLE | WL_EXIT_ON_PM_DEATH;
                else
                    waitfor = WL_SOCKET_WRITEABLE | WL_EXIT_ON_PM_DEATH;
 
                (void) WaitLatchOrSocket(NULL, waitfor, port->sock, 0,
                                         WAIT_EVENT_SSL_OPEN_SERVER);
                goto aloop;
            case SSL_ERROR_SYSCALL:
                if (r < 0 && errno != 0)
                    ereport(COMMERROR,
                            (errcode_for_socket_access(),
                             errmsg("could not accept SSL connection: %m")));
                else
                    ereport(COMMERROR,
                            (errcode(ERRCODE_PROTOCOL_VIOLATION),
                             errmsg("could not accept SSL connection: EOF detected")));
                break;
            case SSL_ERROR_SSL:
                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:
#endif
#ifdef SSL_R_VERSION_TOO_LOW
                    case SSL_R_VERSION_TOO_LOW:
#endif
                        give_proto_hint = true;
                        break;
                    default:
                        give_proto_hint = false;
                        break;
                }
                ereport(COMMERROR,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("could not accept SSL connection: %s",
                                SSLerrmessage(ecode)),
                         err_context.cert_errdetail ? errdetail_internal("%s", err_context.cert_errdetail) : 0,
                         give_proto_hint ?
                         errhint("This may indicate that the client does not support any SSL protocol version between %s and %s.",
                                 ssl_min_protocol_version ?
                                 ssl_protocol_version_to_string(ssl_min_protocol_version) :
                                 MIN_OPENSSL_TLS_VERSION,
                                 ssl_max_protocol_version ?
                                 ssl_protocol_version_to_string(ssl_max_protocol_version) :
                                 MAX_OPENSSL_TLS_VERSION) : 0));
                if (err_context.cert_errdetail)
                    pfree(err_context.cert_errdetail);
                break;
            case SSL_ERROR_ZERO_RETURN:
                ereport(COMMERROR,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("could not accept SSL connection: EOF detected")));
                break;
            default:
                ereport(COMMERROR,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("unrecognized SSL error code: %d",
                                err)));
                break;
        }
        return -1;
    }
 
    /* Get the protocol selected by ALPN */
    port->alpn_used = false;
    {
        const unsigned char *selected;
        unsigned int len;
 
        SSL_get0_alpn_selected(port->ssl, &selected, &len);
 
        /* If ALPN is used, check that we negotiated the expected protocol */
        if (selected != NULL)
        {
            if (len == strlen(PG_ALPN_PROTOCOL) &&
                memcmp(selected, PG_ALPN_PROTOCOL, strlen(PG_ALPN_PROTOCOL)) == 0)
            {
                port->alpn_used = true;
            }
            else
            {
                /* shouldn't happen */
                ereport(COMMERROR,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("received SSL connection request with unexpected ALPN protocol")));
            }
        }
    }
 
    /* Get client certificate, if available. */
    port->peer = SSL_get_peer_certificate(port->ssl);
 
    /* and extract the Common Name and Distinguished Name from it. */
    port->peer_cn = NULL;
    port->peer_dn = NULL;
    port->peer_cert_valid = false;
    if (port->peer != NULL)
    {
        int         len;
        X509_NAME  *x509name = X509_get_subject_name(port->peer);
        char       *peer_dn;
        BIO        *bio = NULL;
        BUF_MEM    *bio_buf = NULL;
 
        len = X509_NAME_get_text_by_NID(x509name, NID_commonName, NULL, 0);
        if (len != -1)
        {
            char       *peer_cn;
 
            peer_cn = MemoryContextAlloc(TopMemoryContext, len + 1);
            r = X509_NAME_get_text_by_NID(x509name, NID_commonName, peer_cn,
                                          len + 1);
            peer_cn[len] = '\0';
            if (r != len)
            {
                /* shouldn't happen */
                pfree(peer_cn);
                return -1;
            }
 
            /*
             * Reject embedded NULLs in certificate common name to prevent
             * attacks like CVE-2009-4034.
             */
            if (len != strlen(peer_cn))
            {
                ereport(COMMERROR,
                        (errcode(ERRCODE_PROTOCOL_VIOLATION),
                         errmsg("SSL certificate's common name contains embedded null")));
                pfree(peer_cn);
                return -1;
            }
 
            port->peer_cn = peer_cn;
        }
 
        bio = BIO_new(BIO_s_mem());
        if (!bio)
        {
            if (port->peer_cn != NULL)
            {
                pfree(port->peer_cn);
                port->peer_cn = NULL;
            }
            return -1;
        }
 
        /*
         * RFC2253 is the closest thing to an accepted standard format for
         * DNs. We have documented how to produce this format from a
         * certificate. It uses commas instead of slashes for delimiters,
         * which make regular expression matching a bit easier. Also note that
         * it prints the Subject fields in reverse order.
         */
        if (X509_NAME_print_ex(bio, x509name, 0, XN_FLAG_RFC2253) == -1 ||
            BIO_get_mem_ptr(bio, &bio_buf) <= 0)
        {
            BIO_free(bio);
            if (port->peer_cn != NULL)
            {
                pfree(port->peer_cn);
                port->peer_cn = NULL;
            }
            return -1;
        }
        peer_dn = MemoryContextAlloc(TopMemoryContext, bio_buf->length + 1);
        memcpy(peer_dn, bio_buf->data, bio_buf->length);
        len = bio_buf->length;
        BIO_free(bio);
        peer_dn[len] = '\0';
        if (len != strlen(peer_dn))
        {
            ereport(COMMERROR,
                    (errcode(ERRCODE_PROTOCOL_VIOLATION),
                     errmsg("SSL certificate's distinguished name contains embedded null")));
            pfree(peer_dn);
            if (port->peer_cn != NULL)
            {
                pfree(port->peer_cn);
                port->peer_cn = NULL;
            }
            return -1;
        }
 
        port->peer_dn = peer_dn;
 
        port->peer_cert_valid = true;
    }
 
    return 0;
}

References alpn_cb(), Assert, COMMERROR, hosts::default_host, ereport, err(), errcode(), errcode_for_socket_access(), ERRCODE_PROTOCOL_VIOLATION, errdetail_internal(), errhint(), errmsg, fb(), info_cb(), len, MemoryContextAlloc(), pfree(), PG_ALPN_PROTOCOL, port, HostsLine::ssl_ca, SSL_context, SSL_hosts, ssl_max_protocol_version, ssl_min_protocol_version, ssl_protocol_version_to_string(), ssl_set_port_bio(), SSLerrmessage(), TopMemoryContext, verify_cb(), WaitLatchOrSocket(), WL_EXIT_ON_PM_DEATH, WL_SOCKET_READABLE, and WL_SOCKET_WRITEABLE.

Referenced by secure_open_server().

◆ be_tls_read()

ssize_t be_tls_read	(	Port *	port,
		void *	ptr,
		size_t	len,
		int *	waitfor
	)

Definition at line 1198 of file be-secure-openssl.c.

{
    ssize_t     n;
    int         err;
    unsigned long ecode;
 
    errno = 0;
    ERR_clear_error();
    n = SSL_read(port->ssl, ptr, len);
    err = SSL_get_error(port->ssl, n);
    ecode = (err != SSL_ERROR_NONE || n < 0) ? ERR_get_error() : 0;
    switch (err)
    {
        case SSL_ERROR_NONE:
            /* a-ok */
            break;
        case SSL_ERROR_WANT_READ:
            *waitfor = WL_SOCKET_READABLE;
            errno = EWOULDBLOCK;
            n = -1;
            break;
        case SSL_ERROR_WANT_WRITE:
            *waitfor = WL_SOCKET_WRITEABLE;
            errno = EWOULDBLOCK;
            n = -1;
            break;
        case SSL_ERROR_SYSCALL:
            /* leave it to caller to ereport the value of errno */
            if (n != -1 || errno == 0)
            {
                errno = ECONNRESET;
                n = -1;
            }
            break;
        case SSL_ERROR_SSL:
            ereport(COMMERROR,
                    (errcode(ERRCODE_PROTOCOL_VIOLATION),
                     errmsg("SSL error: %s", SSLerrmessage(ecode))));
            errno = ECONNRESET;
            n = -1;
            break;
        case SSL_ERROR_ZERO_RETURN:
            /* connection was cleanly shut down by peer */
            n = 0;
            break;
        default:
            ereport(COMMERROR,
                    (errcode(ERRCODE_PROTOCOL_VIOLATION),
                     errmsg("unrecognized SSL error code: %d",
                            err)));
            errno = ECONNRESET;
            n = -1;
            break;
    }
 
    return n;
}

References COMMERROR, ECONNRESET, ereport, err(), errcode(), ERRCODE_PROTOCOL_VIOLATION, errmsg, EWOULDBLOCK, fb(), len, port, SSLerrmessage(), WL_SOCKET_READABLE, and WL_SOCKET_WRITEABLE.

Referenced by secure_read().

◆ be_tls_write()

ssize_t be_tls_write	(	Port *	port,
		const void *	ptr,
		size_t	len,
		int *	waitfor
	)

Definition at line 1257 of file be-secure-openssl.c.

{
    ssize_t     n;
    int         err;
    unsigned long ecode;
 
    errno = 0;
    ERR_clear_error();
    n = SSL_write(port->ssl, ptr, len);
    err = SSL_get_error(port->ssl, n);
    ecode = (err != SSL_ERROR_NONE || n < 0) ? ERR_get_error() : 0;
    switch (err)
    {
        case SSL_ERROR_NONE:
            /* a-ok */
            break;
        case SSL_ERROR_WANT_READ:
            *waitfor = WL_SOCKET_READABLE;
            errno = EWOULDBLOCK;
            n = -1;
            break;
        case SSL_ERROR_WANT_WRITE:
            *waitfor = WL_SOCKET_WRITEABLE;
            errno = EWOULDBLOCK;
            n = -1;
            break;
        case SSL_ERROR_SYSCALL:
 
            /*
             * Leave it to caller to ereport the value of errno.  However, if
             * errno is still zero then assume it's a read EOF situation, and
             * report ECONNRESET.  (This seems possible because SSL_write can
             * also do reads.)
             */
            if (n != -1 || errno == 0)
            {
                errno = ECONNRESET;
                n = -1;
            }
            break;
        case SSL_ERROR_SSL:
            ereport(COMMERROR,
                    (errcode(ERRCODE_PROTOCOL_VIOLATION),
                     errmsg("SSL error: %s", SSLerrmessage(ecode))));
            errno = ECONNRESET;
            n = -1;
            break;
        case SSL_ERROR_ZERO_RETURN:
 
            /*
             * the SSL connection was closed, leave it to the caller to
             * ereport it
             */
            errno = ECONNRESET;
            n = -1;
            break;
        default:
            ereport(COMMERROR,
                    (errcode(ERRCODE_PROTOCOL_VIOLATION),
                     errmsg("unrecognized SSL error code: %d",
                            err)));
            errno = ECONNRESET;
            n = -1;
            break;
    }
 
    return n;
}

References COMMERROR, ECONNRESET, ereport, err(), errcode(), ERRCODE_PROTOCOL_VIOLATION, errmsg, EWOULDBLOCK, fb(), len, port, SSLerrmessage(), WL_SOCKET_READABLE, and WL_SOCKET_WRITEABLE.

Referenced by secure_write().

◆ default_openssl_tls_init()

static void default_openssl_tls_init	(	SSL_CTX *	context,
		bool	isServerStart
	)

static

Definition at line 2479 of file be-secure-openssl.c.

{
    if (isServerStart)
    {
        if (ssl_passphrase_command[0])
        {
            SSL_CTX_set_default_passwd_cb(context, ssl_external_passwd_cb);
            SSL_CTX_set_default_passwd_cb_userdata(context, ssl_passphrase_command);
        }
    }
    else
    {
        if (ssl_passphrase_command[0] && ssl_passphrase_command_supports_reload)
        {
            SSL_CTX_set_default_passwd_cb(context, ssl_external_passwd_cb);
            SSL_CTX_set_default_passwd_cb_userdata(context, ssl_passphrase_command);
        }
        else
 
            /*
             * If reloading and no external command is configured, override
             * OpenSSL's default handling of passphrase-protected files,
             * because we don't want to prompt for a passphrase in an
             * already-running server.
             */
            SSL_CTX_set_default_passwd_cb(context, dummy_ssl_passwd_cb);
    }
}

References dummy_ssl_passwd_cb(), fb(), ssl_external_passwd_cb(), ssl_passphrase_command, and ssl_passphrase_command_supports_reload.

Referenced by init_host_context().

◆ dummy_ssl_passwd_cb()

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

static

Definition at line 1582 of file be-secure-openssl.c.

{
    /* Set flag to change the error message we'll report */
    dummy_ssl_passwd_cb_called = true;
    /* And return empty string */
    Assert(size > 0);
    buf[0] = '\0';
    return 0;
}

References Assert, buf, and dummy_ssl_passwd_cb_called.

Referenced by default_openssl_tls_init(), and init_host_context().

◆ host_cache_pointer()

static uint32 host_cache_pointer ( const char * key )

static

Definition at line 2464 of file be-secure-openssl.c.

{
    uint32      hash;
    char       *lkey = pstrdup(key);
    int         len = strlen(key);
 
    for (int i = 0; i < len; i++)
        lkey[i] = pg_tolower(lkey[i]);
 
    hash = string_hash((const void *) lkey, len);
    pfree(lkey);
    return hash;
}

References fb(), hash(), i, len, pfree(), pg_tolower(), pstrdup(), and string_hash().

◆ host_context_cleanup_cb()

static void host_context_cleanup_cb ( void * arg )

static

Definition at line 596 of file be-secure-openssl.c.

{
    struct hosts *hosts = arg;
 
    foreach_ptr(HostsLine, host, hosts->sni)
    {
        if (host->ssl_ctx != NULL)
            SSL_CTX_free(host->ssl_ctx);
    }
 
    if (hosts->no_sni && hosts->no_sni->ssl_ctx)
        SSL_CTX_free(hosts->no_sni->ssl_ctx);
 
    if (hosts->default_host && hosts->default_host->ssl_ctx)
        SSL_CTX_free(hosts->default_host->ssl_ctx);
}

References arg, hosts::default_host, fb(), foreach_ptr, hosts::no_sni, hosts::sni, and HostsLine::ssl_ctx.

Referenced by be_tls_init().

◆ info_cb()

static void info_cb	(	const SSL *	ssl,
		int	type,
		int	args
	)

static

Definition at line 1727 of file be-secure-openssl.c.

{
    const char *desc;
 
    desc = SSL_state_string_long(ssl);
 
    switch (type)
    {
        case SSL_CB_HANDSHAKE_START:
            ereport(DEBUG4,
                    (errmsg_internal("SSL: handshake start: \"%s\"", desc)));
            break;
        case SSL_CB_HANDSHAKE_DONE:
            ereport(DEBUG4,
                    (errmsg_internal("SSL: handshake done: \"%s\"", desc)));
            break;
        case SSL_CB_ACCEPT_LOOP:
            ereport(DEBUG4,
                    (errmsg_internal("SSL: accept loop: \"%s\"", desc)));
            break;
        case SSL_CB_ACCEPT_EXIT:
            ereport(DEBUG4,
                    (errmsg_internal("SSL: accept exit (%d): \"%s\"", args, desc)));
            break;
        case SSL_CB_CONNECT_LOOP:
            ereport(DEBUG4,
                    (errmsg_internal("SSL: connect loop: \"%s\"", desc)));
            break;
        case SSL_CB_CONNECT_EXIT:
            ereport(DEBUG4,
                    (errmsg_internal("SSL: connect exit (%d): \"%s\"", args, desc)));
            break;
        case SSL_CB_READ_ALERT:
            ereport(DEBUG4,
                    (errmsg_internal("SSL: read alert (0x%04x): \"%s\"", args, desc)));
            break;
        case SSL_CB_WRITE_ALERT:
            ereport(DEBUG4,
                    (errmsg_internal("SSL: write alert (0x%04x): \"%s\"", args, desc)));
            break;
    }
}

References DEBUG4, ereport, errmsg_internal(), fb(), and type.

Referenced by be_tls_open_server().

◆ init_host_context()

static bool init_host_context	(	HostsLine *	host,
		bool	isServerStart
	)

static

Definition at line 614 of file be-secure-openssl.c.

{
    SSL_CTX    *ctx = SSL_CTX_new(SSLv23_method());
    static bool init_warned = false;
 
    if (!ctx)
    {
        ereport(isServerStart ? FATAL : LOG,
                (errmsg("could not create SSL context: %s",
                        SSLerrmessage(ERR_get_error()))));
        goto error;
    }
 
    /*
     * Call init hook (usually to set password callback) in case SNI hasn't
     * been enabled. If SNI is enabled the hook won't operate on the actual
     * TLS context used so it cannot function properly; we warn if one has
     * been installed.
     *
     * If SNI is enabled, we set password callback based what was configured.
     */
    if (!ssl_sni)
        (*openssl_tls_init_hook) (ctx, isServerStart);
    else
    {
        if (openssl_tls_init_hook != default_openssl_tls_init && !init_warned)
        {
            ereport(WARNING,
                    errcode(ERRCODE_CONFIG_FILE_ERROR),
                    errmsg("SNI is enabled; installed TLS init hook will be ignored"),
            /*- translator: first %s is a GUC, second %s contains a filename */
                    errhint("TLS init hooks are incompatible with SNI. "
                            "Set \"%s\" to \"off\" to make use of the hook "
                            "that is currently installed, or remove the hook "
                            "and use per-host passphrase commands in \"%s\".",
                            "ssl_sni", "pg_hosts.conf"));
            init_warned = true;
        }
 
        /*
         * Set up the password callback, if configured.
         */
        if (isServerStart)
        {
            if (host->ssl_passphrase_cmd && host->ssl_passphrase_cmd[0])
            {
                SSL_CTX_set_default_passwd_cb(ctx, ssl_external_passwd_cb);
                SSL_CTX_set_default_passwd_cb_userdata(ctx, host->ssl_passphrase_cmd);
            }
        }
        else
        {
            /*
             * If ssl_passphrase_reload is true then ssl_passphrase_cmd cannot
             * be NULL due to their parsing order, but just in case and to
             * self-document the code we replicate the nullness checks.
             */
            if (host->ssl_passphrase_reload &&
                (host->ssl_passphrase_cmd && host->ssl_passphrase_cmd[0]))
            {
                SSL_CTX_set_default_passwd_cb(ctx, ssl_external_passwd_cb);
                SSL_CTX_set_default_passwd_cb_userdata(ctx, host->ssl_passphrase_cmd);
            }
            else
            {
                /*
                 * If reloading and no external command is configured,
                 * override OpenSSL's default handling of passphrase-protected
                 * files, because we don't want to prompt for a passphrase in
                 * an already-running server.
                 */
                SSL_CTX_set_default_passwd_cb(ctx, dummy_ssl_passwd_cb);
            }
        }
    }
 
    /*
     * Load and verify server's certificate and private key
     */
    if (SSL_CTX_use_certificate_chain_file(ctx, host->ssl_cert) != 1)
    {
        ereport(isServerStart ? FATAL : LOG,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("could not load server certificate file \"%s\": %s",
                        host->ssl_cert, SSLerrmessage(ERR_get_error()))));
        goto error;
    }
 
    if (!check_ssl_key_file_permissions(host->ssl_key, isServerStart))
        goto error;
 
 
    /* used by the callback */
    ssl_is_server_start = isServerStart;
 
    /*
     * OK, try to load the private key file.
     */
    dummy_ssl_passwd_cb_called = false;
 
    if (SSL_CTX_use_PrivateKey_file(ctx,
                                    host->ssl_key,
                                    SSL_FILETYPE_PEM) != 1)
    {
        if (dummy_ssl_passwd_cb_called)
            ereport(isServerStart ? FATAL : LOG,
                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                     errmsg("private key file \"%s\" cannot be reloaded because it requires a passphrase",
                            host->ssl_key)));
        else
            ereport(isServerStart ? FATAL : LOG,
                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                     errmsg("could not load private key file \"%s\": %s",
                            host->ssl_key, SSLerrmessage(ERR_get_error()))));
        goto error;
    }
 
    if (SSL_CTX_check_private_key(ctx) != 1)
    {
        ereport(isServerStart ? FATAL : LOG,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("check of private key failed: %s",
                        SSLerrmessage(ERR_get_error()))));
        goto error;
    }
 
    /*
     * Load CA store, so we can verify client certificates if needed.
     */
    if (host->ssl_ca && host->ssl_ca[0])
    {
        STACK_OF(X509_NAME) * root_cert_list;
 
        if (SSL_CTX_load_verify_locations(ctx, host->ssl_ca, NULL) != 1 ||
            (root_cert_list = SSL_load_client_CA_file(host->ssl_ca)) == NULL)
        {
            ereport(isServerStart ? FATAL : LOG,
                    (errcode(ERRCODE_CONFIG_FILE_ERROR),
                     errmsg("could not load root certificate file \"%s\": %s",
                            host->ssl_ca, SSLerrmessage(ERR_get_error()))));
            goto error;
        }
 
        /*
         * Tell OpenSSL to send the list of root certs we trust to clients in
         * CertificateRequests.  This lets a client with a keystore select the
         * appropriate client certificate to send to us.  Also, this ensures
         * that the SSL context will "own" the root_cert_list and remember to
         * free it when no longer needed.
         */
        SSL_CTX_set_client_CA_list(ctx, root_cert_list);
    }
 
    /*----------
     * Load the Certificate Revocation List (CRL).
     * http://searchsecurity.techtarget.com/sDefinition/0,,sid14_gci803160,00.html
     *----------
     */
    if (ssl_crl_file[0] || ssl_crl_dir[0])
    {
        X509_STORE *cvstore = SSL_CTX_get_cert_store(ctx);
 
        if (cvstore)
        {
            /* Set the flags to check against the complete CRL chain */
            if (X509_STORE_load_locations(cvstore,
                                          ssl_crl_file[0] ? ssl_crl_file : NULL,
                                          ssl_crl_dir[0] ? ssl_crl_dir : NULL)
                == 1)
            {
                X509_STORE_set_flags(cvstore,
                                     X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
            }
            else if (ssl_crl_dir[0] == 0)
            {
                ereport(isServerStart ? FATAL : LOG,
                        (errcode(ERRCODE_CONFIG_FILE_ERROR),
                         errmsg("could not load SSL certificate revocation list file \"%s\": %s",
                                ssl_crl_file, SSLerrmessage(ERR_get_error()))));
                goto error;
            }
            else if (ssl_crl_file[0] == 0)
            {
                ereport(isServerStart ? FATAL : LOG,
                        (errcode(ERRCODE_CONFIG_FILE_ERROR),
                         errmsg("could not load SSL certificate revocation list directory \"%s\": %s",
                                ssl_crl_dir, SSLerrmessage(ERR_get_error()))));
                goto error;
            }
            else
            {
                ereport(isServerStart ? FATAL : LOG,
                        (errcode(ERRCODE_CONFIG_FILE_ERROR),
                         errmsg("could not load SSL certificate revocation list file \"%s\" or directory \"%s\": %s",
                                ssl_crl_file, ssl_crl_dir,
                                SSLerrmessage(ERR_get_error()))));
                goto error;
            }
        }
    }
 
    host->ssl_ctx = ctx;
    return true;
 
error:
    if (ctx)
        SSL_CTX_free(ctx);
    return false;
}

References check_ssl_key_file_permissions(), default_openssl_tls_init(), dummy_ssl_passwd_cb(), dummy_ssl_passwd_cb_called, ereport, errcode(), errhint(), errmsg, error(), FATAL, fb(), LOG, openssl_tls_init_hook, HostsLine::ssl_ca, HostsLine::ssl_cert, ssl_crl_dir, ssl_crl_file, HostsLine::ssl_ctx, ssl_external_passwd_cb(), ssl_is_server_start, HostsLine::ssl_key, HostsLine::ssl_passphrase_cmd, HostsLine::ssl_passphrase_reload, ssl_sni, SSLerrmessage(), and WARNING.

Referenced by be_tls_init().

◆ initialize_dh()

static bool initialize_dh	(	SSL_CTX *	context,
		bool	isServerStart
	)

static

Definition at line 2078 of file be-secure-openssl.c.

{
    DH         *dh = NULL;
 
    SSL_CTX_set_options(context, SSL_OP_SINGLE_DH_USE);
 
    if (ssl_dh_params_file[0])
        dh = load_dh_file(ssl_dh_params_file, isServerStart);
    if (!dh)
        dh = load_dh_buffer(FILE_DH2048, sizeof(FILE_DH2048));
    if (!dh)
    {
        ereport(isServerStart ? FATAL : LOG,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("DH: could not load DH parameters")));
        return false;
    }
 
    if (SSL_CTX_set_tmp_dh(context, dh) != 1)
    {
        ereport(isServerStart ? FATAL : LOG,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("DH: could not set DH parameters: %s",
                        SSLerrmessage(ERR_get_error()))));
        DH_free(dh);
        return false;
    }
 
    DH_free(dh);
    return true;
}

References ereport, errcode(), errmsg, FATAL, fb(), load_dh_buffer(), load_dh_file(), LOG, ssl_dh_params_file, and SSLerrmessage().

Referenced by be_tls_init().

◆ initialize_ecdh()

static bool initialize_ecdh	(	SSL_CTX *	context,
		bool	isServerStart
	)

static

Definition at line 2116 of file be-secure-openssl.c.

{
#ifndef OPENSSL_NO_ECDH
    if (SSL_CTX_set1_groups_list(context, SSLECDHCurve) != 1)
    {
        /*
         * OpenSSL 3.3.0 introduced proper error messages for group parsing
         * errors, earlier versions returns "no SSL error reported" which is
         * far from helpful. For older versions, we replace with a better
         * error message. Injecting the error into the OpenSSL error queue
         * need APIs from OpenSSL 3.0.
         */
        ereport(isServerStart ? FATAL : LOG,
                errcode(ERRCODE_CONFIG_FILE_ERROR),
                errmsg("could not set group names specified in ssl_groups: %s",
                       SSLerrmessageExt(ERR_get_error(),
                                        _("No valid groups found"))),
                errhint("Ensure that each group name is spelled correctly and supported by the installed version of OpenSSL."));
        return false;
    }
#endif
 
    return true;
}

References _, ereport, errcode(), errhint(), errmsg, FATAL, fb(), LOG, SSLECDHCurve, and SSLerrmessageExt().

Referenced by be_tls_init().

◆ load_dh_buffer()

static DH * load_dh_buffer	(	const char *	buffer,
		size_t	len
	)

static

Definition at line 1539 of file be-secure-openssl.c.

{
    BIO        *bio;
    DH         *dh = NULL;
 
    bio = BIO_new_mem_buf(buffer, len);
    if (bio == NULL)
        return NULL;
    dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
    if (dh == NULL)
        ereport(DEBUG2,
                (errmsg_internal("DH load buffer: %s",
                                 SSLerrmessage(ERR_get_error()))));
    BIO_free(bio);
 
    return dh;
}

References DEBUG2, ereport, errmsg_internal(), fb(), len, and SSLerrmessage().

Referenced by initialize_dh().

◆ load_dh_file()

static DH * load_dh_file	(	char *	filename,
		bool	isServerStart
	)

static

Definition at line 1472 of file be-secure-openssl.c.

{
    FILE       *fp;
    DH         *dh = NULL;
    int         codes;
 
    /* attempt to open file.  It's not an error if it doesn't exist. */
    if ((fp = AllocateFile(filename, "r")) == NULL)
    {
        ereport(isServerStart ? FATAL : LOG,
                (errcode_for_file_access(),
                 errmsg("could not open DH parameters file \"%s\": %m",
                        filename)));
        return NULL;
    }
 
    dh = PEM_read_DHparams(fp, NULL, NULL, NULL);
    FreeFile(fp);
 
    if (dh == NULL)
    {
        ereport(isServerStart ? FATAL : LOG,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("could not load DH parameters file: %s",
                        SSLerrmessage(ERR_get_error()))));
        return NULL;
    }
 
    /* make sure the DH parameters are usable */
    if (DH_check(dh, &codes) == 0)
    {
        ereport(isServerStart ? FATAL : LOG,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("invalid DH parameters: %s",
                        SSLerrmessage(ERR_get_error()))));
        DH_free(dh);
        return NULL;
    }
    if (codes & DH_CHECK_P_NOT_PRIME)
    {
        ereport(isServerStart ? FATAL : LOG,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("invalid DH parameters: p is not prime")));
        DH_free(dh);
        return NULL;
    }
    if ((codes & DH_NOT_SUITABLE_GENERATOR) &&
        (codes & DH_CHECK_P_NOT_SAFE_PRIME))
    {
        ereport(isServerStart ? FATAL : LOG,
                (errcode(ERRCODE_CONFIG_FILE_ERROR),
                 errmsg("invalid DH parameters: neither suitable generator or safe prime")));
        DH_free(dh);
        return NULL;
    }
 
    return dh;
}

References AllocateFile(), ereport, errcode(), errcode_for_file_access(), errmsg, FATAL, fb(), filename, FreeFile(), LOG, and SSLerrmessage().

Referenced by initialize_dh().

◆ port_bio_ctrl()

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

static

Definition at line 1388 of file be-secure-openssl.c.

{
    long        res;
    Port       *port = (Port *) BIO_get_data(h);
 
    switch (cmd)
    {
        case BIO_CTRL_EOF:
 
            /*
             * This should not be needed. port_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 = port->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 fb(), Port::last_read_was_eof, and port.

Referenced by port_bio_method().

◆ port_bio_method()

static BIO_METHOD * port_bio_method ( void )

static

Definition at line 1418 of file be-secure-openssl.c.

{
    if (!port_bio_method_ptr)
    {
        int         my_bio_index;
 
        my_bio_index = BIO_get_new_index();
        if (my_bio_index == -1)
            return NULL;
        my_bio_index |= BIO_TYPE_SOURCE_SINK;
        port_bio_method_ptr = BIO_meth_new(my_bio_index, "PostgreSQL backend socket");
        if (!port_bio_method_ptr)
            return NULL;
        if (!BIO_meth_set_write(port_bio_method_ptr, port_bio_write) ||
            !BIO_meth_set_read(port_bio_method_ptr, port_bio_read) ||
            !BIO_meth_set_ctrl(port_bio_method_ptr, port_bio_ctrl))
        {
            BIO_meth_free(port_bio_method_ptr);
            port_bio_method_ptr = NULL;
            return NULL;
        }
    }
    return port_bio_method_ptr;
}

References fb(), port_bio_ctrl(), port_bio_method_ptr, port_bio_read(), and port_bio_write().

Referenced by ssl_set_port_bio().

◆ port_bio_read()

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

static

Definition at line 1345 of file be-secure-openssl.c.

{
    int         res = 0;
    Port       *port = (Port *) BIO_get_data(h);
 
    if (buf != NULL)
    {
        res = secure_raw_read(port, buf, size);
        BIO_clear_retry_flags(h);
        port->last_read_was_eof = res == 0;
        if (res <= 0)
        {
            /* If we were interrupted, tell caller to retry */
            if (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)
            {
                BIO_set_retry_read(h);
            }
        }
    }
 
    return res;
}

References buf, EAGAIN, EINTR, EWOULDBLOCK, fb(), port, and secure_raw_read().

Referenced by port_bio_method().

◆ port_bio_write()

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

static

Definition at line 1369 of file be-secure-openssl.c.

{
    int         res = 0;
 
    res = secure_raw_write(((Port *) BIO_get_data(h)), buf, size);
    BIO_clear_retry_flags(h);
    if (res <= 0)
    {
        /* If we were interrupted, tell caller to retry */
        if (errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN)
        {
            BIO_set_retry_write(h);
        }
    }
 
    return res;
}

References buf, EAGAIN, EINTR, EWOULDBLOCK, fb(), and secure_raw_write().

Referenced by port_bio_method().

◆ prepare_cert_name()

static char * prepare_cert_name ( char * name )

static

Definition at line 1599 of file be-secure-openssl.c.

{
    size_t      namelen = strlen(name);
    char       *truncated = name;
 
    /*
     * Common Names are 64 chars max, so for a common case where the CN is the
     * last field, we can still print the longest possible CN with a
     * 7-character prefix (".../CN=[64 chars]"), for a reasonable limit of 71
     * characters.
     */
#define MAXLEN 71
 
    if (namelen > MAXLEN)
    {
        /*
         * Keep the end of the name, not the beginning, since the most
         * specific field is likely to give users the most information.
         */
        truncated = name + namelen - MAXLEN;
        truncated[0] = truncated[1] = truncated[2] = '.';
        namelen = MAXLEN;
    }
 
#undef MAXLEN
 
    return pg_clean_ascii(truncated, 0);
}

References fb(), MAXLEN, name, and pg_clean_ascii().

Referenced by verify_cb().

◆ ssl_external_passwd_cb()

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

static

Definition at line 1561 of file be-secure-openssl.c.

{
    /* same prompt as OpenSSL uses internally */
    const char *prompt = "Enter PEM pass phrase:";
    const char *cmd = userdata;
 
    Assert(rwflag == 0);
 
    return run_ssl_passphrase_command(cmd, prompt, ssl_is_server_start, buf, size);
}

References Assert, buf, fb(), run_ssl_passphrase_command(), and ssl_is_server_start.

Referenced by default_openssl_tls_init(), and init_host_context().

◆ ssl_protocol_version_to_openssl()

static int ssl_protocol_version_to_openssl ( int v )

static

Definition at line 2409 of file be-secure-openssl.c.

{
    switch (v)
    {
        case PG_TLS_ANY:
            return 0;
        case PG_TLS1_VERSION:
            return TLS1_VERSION;
        case PG_TLS1_1_VERSION:
#ifdef TLS1_1_VERSION
            return TLS1_1_VERSION;
#else
            break;
#endif
        case PG_TLS1_2_VERSION:
#ifdef TLS1_2_VERSION
            return TLS1_2_VERSION;
#else
            break;
#endif
        case PG_TLS1_3_VERSION:
#ifdef TLS1_3_VERSION
            return TLS1_3_VERSION;
#else
            break;
#endif
    }
 
    return -1;
}

References fb(), PG_TLS1_1_VERSION, PG_TLS1_2_VERSION, PG_TLS1_3_VERSION, PG_TLS1_VERSION, and PG_TLS_ANY.

Referenced by be_tls_init().

◆ ssl_protocol_version_to_string()

static const char * ssl_protocol_version_to_string ( int v )

static

Definition at line 2444 of file be-secure-openssl.c.

{
    switch (v)
    {
        case PG_TLS_ANY:
            return "any";
        case PG_TLS1_VERSION:
            return "TLSv1";
        case PG_TLS1_1_VERSION:
            return "TLSv1.1";
        case PG_TLS1_2_VERSION:
            return "TLSv1.2";
        case PG_TLS1_3_VERSION:
            return "TLSv1.3";
    }
 
    return "(unrecognized)";
}

References PG_TLS1_1_VERSION, PG_TLS1_2_VERSION, PG_TLS1_3_VERSION, PG_TLS1_VERSION, and PG_TLS_ANY.

Referenced by be_tls_open_server().

◆ ssl_set_port_bio()

static int ssl_set_port_bio ( Port * port )

static

Definition at line 1444 of file be-secure-openssl.c.

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

References fb(), port, and port_bio_method().

Referenced by be_tls_open_server().

◆ SSLerrmessage()

static const char * SSLerrmessage ( unsigned long ecode )

static

Definition at line 2173 of file be-secure-openssl.c.

{
    const char *errreason;
    static char errbuf[36];
 
    if (ecode == 0)
        return _("no SSL error reported");
    errreason = ERR_reason_error_string(ecode);
    if (errreason != NULL)
        return errreason;
 
    /*
     * 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))
        return strerror(ERR_GET_REASON(ecode));
#endif
 
    /* No choice but to report the numeric ecode */
    snprintf(errbuf, sizeof(errbuf), _("SSL error code %lu"), ecode);
    return errbuf;
}

References _, fb(), snprintf, and strerror.

Referenced by be_tls_init(), be_tls_open_server(), be_tls_read(), be_tls_write(), init_host_context(), initialize_dh(), load_dh_buffer(), load_dh_file(), and SSLerrmessageExt().

◆ SSLerrmessageExt()

static const char * SSLerrmessageExt	(	unsigned long	ecode,
		const char *	replacement
	)

static

Definition at line 2155 of file be-secure-openssl.c.

{
    if (ecode == 0)
        return replacement;
    else
        return SSLerrmessage(ecode);
}

References fb(), and SSLerrmessage().

Referenced by initialize_ecdh().

◆ verify_cb()

static int verify_cb	(	int	ok,
		X509_STORE_CTX *	ctx
	)

static

Definition at line 1639 of file be-secure-openssl.c.

{
    int         depth;
    int         errcode;
    const char *errstring;
    StringInfoData str;
    X509       *cert;
    SSL        *ssl;
    struct CallbackErr *cb_err;
 
    if (ok)
    {
        /* Nothing to do for the successful case. */
        return ok;
    }
 
    /* Pull all the information we have on the verification failure. */
    depth = X509_STORE_CTX_get_error_depth(ctx);
    errcode = X509_STORE_CTX_get_error(ctx);
    errstring = X509_verify_cert_error_string(errcode);
 
    /*
     * Extract the current SSL and CallbackErr object to use for passing error
     * detail back from the callback.
     */
    ssl = X509_STORE_CTX_get_ex_data(ctx, SSL_get_ex_data_X509_STORE_CTX_idx());
    cb_err = (struct CallbackErr *) SSL_get_ex_data(ssl, 0);
 
    initStringInfo(&str);
    appendStringInfo(&str,
                     _("Client certificate verification failed at depth %d: %s."),
                     depth, errstring);
 
    cert = X509_STORE_CTX_get_current_cert(ctx);
    if (cert)
    {
        char       *subject,
                   *issuer;
        char       *sub_prepared,
                   *iss_prepared;
        char       *serialno;
        ASN1_INTEGER *sn;
        BIGNUM     *b;
 
        /*
         * Get the Subject and Issuer for logging, but don't let maliciously
         * huge certs flood the logs, and don't reflect non-ASCII bytes into
         * it either.
         */
        subject = X509_NAME_to_cstring(X509_get_subject_name(cert));
        sub_prepared = prepare_cert_name(subject);
        pfree(subject);
 
        issuer = X509_NAME_to_cstring(X509_get_issuer_name(cert));
        iss_prepared = prepare_cert_name(issuer);
        pfree(issuer);
 
        /*
         * Pull the serial number, too, in case a Subject is still ambiguous.
         * This mirrors be_tls_get_peer_serial().
         */
        sn = X509_get_serialNumber(cert);
        b = ASN1_INTEGER_to_BN(sn, NULL);
        serialno = BN_bn2dec(b);
 
        appendStringInfoChar(&str, '\n');
        appendStringInfo(&str,
                         _("Failed certificate data (unverified): subject \"%s\", serial number %s, issuer \"%s\"."),
                         sub_prepared, serialno ? serialno : _("unknown"),
                         iss_prepared);
 
        BN_free(b);
        OPENSSL_free(serialno);
        pfree(iss_prepared);
        pfree(sub_prepared);
    }
 
    /* Store our detail message to be logged later. */
    cb_err->cert_errdetail = str.data;
 
    return ok;
}

References _, appendStringInfo(), appendStringInfoChar(), b, errcode(), fb(), initStringInfo(), pfree(), prepare_cert_name(), str, and X509_NAME_to_cstring().

Referenced by be_tls_open_server().

◆ X509_NAME_to_cstring()

static char * X509_NAME_to_cstring ( X509_NAME * name )

static

Definition at line 2336 of file be-secure-openssl.c.

{
    BIO        *membuf = BIO_new(BIO_s_mem());
    int         i,
                nid,
                count = X509_NAME_entry_count(name);
    X509_NAME_ENTRY *e;
    ASN1_STRING *v;
    const char *field_name;
    size_t      size;
    char        nullterm;
    char       *sp;
    char       *dp;
    char       *result;
 
    if (membuf == NULL)
        ereport(ERROR,
                (errcode(ERRCODE_OUT_OF_MEMORY),
                 errmsg("could not create BIO")));
 
    (void) BIO_set_close(membuf, BIO_CLOSE);
    for (i = 0; i < count; i++)
    {
        e = X509_NAME_get_entry(name, i);
        nid = OBJ_obj2nid(X509_NAME_ENTRY_get_object(e));
        if (nid == NID_undef)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("could not get NID for ASN1_OBJECT object")));
        v = X509_NAME_ENTRY_get_data(e);
        field_name = OBJ_nid2sn(nid);
        if (field_name == NULL)
            field_name = OBJ_nid2ln(nid);
        if (field_name == NULL)
            ereport(ERROR,
                    (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
                     errmsg("could not convert NID %d to an ASN1_OBJECT structure", nid)));
        BIO_printf(membuf, "/%s=", field_name);
        ASN1_STRING_print_ex(membuf, v,
                             ((ASN1_STRFLGS_RFC2253 & ~ASN1_STRFLGS_ESC_MSB)
                              | ASN1_STRFLGS_UTF8_CONVERT));
    }
 
    /* ensure null termination of the BIO's content */
    nullterm = '\0';
    BIO_write(membuf, &nullterm, 1);
    size = BIO_get_mem_data(membuf, &sp);
    dp = pg_any_to_server(sp, size - 1, PG_UTF8);
 
    result = pstrdup(dp);
    if (dp != sp)
        pfree(dp);
    if (BIO_free(membuf) != 1)
        elog(ERROR, "could not free OpenSSL BIO structure");
 
    return result;
}

References elog, ereport, errcode(), errmsg, ERROR, fb(), i, name, pfree(), pg_any_to_server(), PG_UTF8, and pstrdup().

Referenced by be_tls_get_peer_issuer_name(), be_tls_get_peer_subject_name(), and verify_cb().

Variable Documentation

◆ alpn_protos

const unsigned char alpn_protos[] = PG_ALPN_PROTOCOL_VECTOR

static

Definition at line 1771 of file be-secure-openssl.c.

Referenced by alpn_cb().

◆ dummy_ssl_passwd_cb_called

bool dummy_ssl_passwd_cb_called = false

static

Definition at line 131 of file be-secure-openssl.c.

Referenced by dummy_ssl_passwd_cb(), and init_host_context().

◆ openssl_tls_init_hook

openssl_tls_init_hook_typ openssl_tls_init_hook = default_openssl_tls_init

Definition at line 80 of file be-secure-openssl.c.

Referenced by _PG_init(), and init_host_context().

◆ port_bio_method_ptr

BIO_METHOD* port_bio_method_ptr = NULL

static

Definition at line 1342 of file be-secure-openssl.c.

Referenced by port_bio_method().

◆ SSL_context

SSL_CTX* SSL_context = NULL

static

Definition at line 111 of file be-secure-openssl.c.

Referenced by be_tls_destroy(), be_tls_init(), be_tls_open_server(), and initialize_SSL().

◆ SSL_hosts

struct hosts * SSL_hosts

static

Referenced by be_tls_init(), and be_tls_open_server().

◆ SSL_hosts_memcxt

MemoryContext SSL_hosts_memcxt = NULL

static

Definition at line 112 of file be-secure-openssl.c.

Referenced by be_tls_init().

◆ ssl_is_server_start

bool ssl_is_server_start

static

Definition at line 132 of file be-secure-openssl.c.

Referenced by init_host_context(), and ssl_external_passwd_cb().

Variables
openssl_tls_init_hook_typ	openssl_tls_init_hook = default_openssl_tls_init

static SSL_CTX *	SSL_context = NULL

static MemoryContext	SSL_hosts_memcxt = NULL

static struct hosts *	SSL_hosts

static bool	dummy_ssl_passwd_cb_called = false

static bool	ssl_is_server_start

static BIO_METHOD *	port_bio_method_ptr = NULL

static const unsigned char	alpn_protos [] = PG_ALPN_PROTOCOL_VECTOR

Data Structures

Macros

Functions

Variables

Macro Definition Documentation

◆ MAXLEN

◆ SH_DECLARE

◆ SH_DEFINE

◆ SH_ELEMENT_TYPE

◆ SH_EQUAL

◆ SH_HASH_KEY

◆ SH_KEY

◆ SH_KEY_TYPE

◆ SH_PREFIX

◆ SH_SCOPE

Function Documentation

◆ alpn_cb()

◆ be_tls_close()

◆ be_tls_destroy()

◆ be_tls_get_certificate_hash()

◆ be_tls_get_cipher()

◆ be_tls_get_cipher_bits()

◆ be_tls_get_peer_issuer_name()

◆ be_tls_get_peer_serial()

◆ be_tls_get_peer_subject_name()

◆ be_tls_get_version()

◆ be_tls_init()

◆ be_tls_open_server()

◆ be_tls_read()

◆ be_tls_write()

◆ default_openssl_tls_init()

◆ dummy_ssl_passwd_cb()

◆ host_cache_pointer()

◆ host_context_cleanup_cb()

◆ info_cb()

◆ init_host_context()

◆ initialize_dh()

◆ initialize_ecdh()

◆ load_dh_buffer()

◆ load_dh_file()

◆ port_bio_ctrl()

◆ port_bio_method()

◆ port_bio_read()

◆ port_bio_write()

◆ prepare_cert_name()

◆ ssl_external_passwd_cb()

◆ ssl_protocol_version_to_openssl()

◆ ssl_protocol_version_to_string()

◆ ssl_set_port_bio()

◆ SSLerrmessage()

◆ SSLerrmessageExt()

◆ verify_cb()

◆ X509_NAME_to_cstring()

Variable Documentation

◆ alpn_protos

◆ dummy_ssl_passwd_cb_called

◆ openssl_tls_init_hook

◆ port_bio_method_ptr

◆ SSL_context

◆ SSL_hosts

◆ SSL_hosts_memcxt

◆ ssl_is_server_start