Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * fe-secure-openssl.c
4 : : * OpenSSL support
5 : : *
6 : : *
7 : : * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
8 : : * Portions Copyright (c) 1994, Regents of the University of California
9 : : *
10 : : *
11 : : * IDENTIFICATION
12 : : * src/interfaces/libpq/fe-secure-openssl.c
13 : : *
14 : : * NOTES
15 : : *
16 : : * We don't provide informational callbacks here (like
17 : : * info_cb() in be-secure-openssl.c), since there's no good mechanism to
18 : : * display such information to the user.
19 : : *
20 : : *-------------------------------------------------------------------------
21 : : */
22 : :
23 : : #include "postgres_fe.h"
24 : :
25 : : #include <signal.h>
26 : : #include <fcntl.h>
27 : : #include <ctype.h>
28 : :
29 : : #include "libpq-fe.h"
30 : : #include "fe-auth.h"
31 : : #include "fe-secure-common.h"
32 : : #include "libpq-int.h"
33 : :
34 : : #ifdef WIN32
35 : : #include "win32.h"
36 : : #else
37 : : #include <sys/socket.h>
38 : : #include <unistd.h>
39 : : #include <netdb.h>
40 : : #include <netinet/in.h>
41 : : #include <netinet/tcp.h>
42 : : #include <arpa/inet.h>
43 : : #endif
44 : :
45 : : #include <sys/stat.h>
46 : :
47 : : #ifdef WIN32
48 : : #include "pthread-win32.h"
49 : : #else
50 : : #include <pthread.h>
51 : : #endif
52 : :
53 : : /*
54 : : * These SSL-related #includes must come after all system-provided headers.
55 : : * This ensures that OpenSSL can take care of conflicts with Windows'
56 : : * <wincrypt.h> by #undef'ing the conflicting macros. (We don't directly
57 : : * include <wincrypt.h>, but some other Windows headers do.)
58 : : */
59 : : #include "common/openssl.h"
60 : : #include <openssl/conf.h>
61 : : #ifdef USE_SSL_ENGINE
62 : : #include <openssl/engine.h>
63 : : #endif
64 : : #include <openssl/x509v3.h>
65 : :
66 : :
67 : : static int verify_cb(int ok, X509_STORE_CTX *ctx);
68 : : static int openssl_verify_peer_name_matches_certificate_name(PGconn *conn,
69 : : ASN1_STRING *name_entry,
70 : : char **store_name);
71 : : static int openssl_verify_peer_name_matches_certificate_ip(PGconn *conn,
72 : : ASN1_OCTET_STRING *addr_entry,
73 : : char **store_name);
74 : : static void destroy_ssl_system(void);
75 : : static int initialize_SSL(PGconn *conn);
76 : : static PostgresPollingStatusType open_client_SSL(PGconn *conn);
77 : : static char *SSLerrmessage(unsigned long ecode);
78 : : static void SSLerrfree(char *buf);
79 : : static int PQssl_passwd_cb(char *buf, int size, int rwflag, void *userdata);
80 : :
81 : : static int my_sock_read(BIO *h, char *buf, int size);
82 : : static int my_sock_write(BIO *h, const char *buf, int size);
83 : : static BIO_METHOD *my_BIO_s_socket(void);
84 : : static int my_SSL_set_fd(PGconn *conn, int fd);
85 : :
86 : :
87 : : static bool pq_init_ssl_lib = true;
88 : : static bool pq_init_crypto_lib = true;
89 : :
90 : : static bool ssl_lib_initialized = false;
91 : :
92 : : static long crypto_open_connections = 0;
93 : :
94 : : static pthread_mutex_t ssl_config_mutex = PTHREAD_MUTEX_INITIALIZER;
95 : :
96 : : static PQsslKeyPassHook_OpenSSL_type PQsslKeyPassHook = NULL;
97 : : static int ssl_protocol_version_to_openssl(const char *protocol);
98 : :
99 : : /* ------------------------------------------------------------ */
100 : : /* Procedures common to all secure sessions */
101 : : /* ------------------------------------------------------------ */
102 : :
103 : : void
3534 heikki.linnakangas@i 104 :UBC 0 : pgtls_init_library(bool do_ssl, int do_crypto)
105 : : {
106 : : /*
107 : : * Disallow changing the flags while we have open connections, else we'd
108 : : * get completely confused.
109 : : */
1130 michael@paquier.xyz 110 [ # # ]: 0 : if (crypto_open_connections != 0)
3534 heikki.linnakangas@i 111 : 0 : return;
112 : :
113 : 0 : pq_init_ssl_lib = do_ssl;
114 : 0 : pq_init_crypto_lib = do_crypto;
115 : : }
116 : :
117 : : PostgresPollingStatusType
3534 heikki.linnakangas@i 118 :CBC 598 : pgtls_open_client(PGconn *conn)
119 : : {
120 : : /* First time through? */
121 [ + + ]: 598 : if (conn->ssl == NULL)
122 : : {
123 : : /*
124 : : * Create a connection-specific SSL object, and load client
125 : : * certificate, private key, and trusted CA certs.
126 : : */
127 [ + + ]: 214 : if (initialize_SSL(conn) != 0)
128 : : {
129 : : /* initialize_SSL already put a message in conn->errorMessage */
130 : 4 : pgtls_close(conn);
131 : 4 : return PGRES_POLLING_FAILED;
132 : : }
133 : : }
134 : :
135 : : /* Begin or continue the actual handshake */
136 : 594 : return open_client_SSL(conn);
137 : : }
138 : :
139 : : ssize_t
140 : 584 : pgtls_read(PGconn *conn, void *ptr, size_t len)
141 : : {
142 : : ssize_t n;
143 : 584 : int result_errno = 0;
144 : : char sebuf[PG_STRERROR_R_BUFLEN];
145 : : int err;
146 : : unsigned long ecode;
147 : :
148 : 584 : rloop:
149 : :
150 : : /*
151 : : * Prepare to call SSL_get_error() by clearing thread's OpenSSL error
152 : : * queue. In general, the current thread's error queue must be empty
153 : : * before the TLS/SSL I/O operation is attempted, or SSL_get_error() will
154 : : * not work reliably. Since the possibility exists that other OpenSSL
155 : : * clients running in the same thread but not under our control will fail
156 : : * to call ERR_get_error() themselves (after their own I/O operations),
157 : : * pro-actively clear the per-thread error queue now.
158 : : */
159 : 584 : SOCK_ERRNO_SET(0);
2928 peter_e@gmx.net 160 : 584 : ERR_clear_error();
3534 heikki.linnakangas@i 161 : 584 : n = SSL_read(conn->ssl, ptr, len);
162 : 584 : err = SSL_get_error(conn->ssl, n);
163 : :
164 : : /*
165 : : * Other clients of OpenSSL may fail to call ERR_get_error(), but we
166 : : * always do, so as to not cause problems for OpenSSL clients that don't
167 : : * call ERR_clear_error() defensively. Be sure that this happens by
168 : : * calling now. SSL_get_error() relies on the OpenSSL per-thread error
169 : : * queue being intact, so this is the earliest possible point
170 : : * ERR_get_error() may be called.
171 : : */
2928 peter_e@gmx.net 172 [ + + - + ]: 584 : ecode = (err != SSL_ERROR_NONE || n < 0) ? ERR_get_error() : 0;
3534 heikki.linnakangas@i 173 [ + + - - : 584 : switch (err)
+ - - ]
174 : : {
175 : 298 : case SSL_ERROR_NONE:
176 [ - + ]: 298 : if (n < 0)
177 : : {
178 : : /* Not supposed to happen, so we don't translate the msg */
1189 tgl@sss.pgh.pa.us 179 :UBC 0 : appendPQExpBufferStr(&conn->errorMessage,
180 : : "SSL_read failed but did not provide error information\n");
181 : : /* assume the connection is broken */
3534 heikki.linnakangas@i 182 : 0 : result_errno = ECONNRESET;
183 : : }
3534 heikki.linnakangas@i 184 :CBC 298 : break;
185 : 280 : case SSL_ERROR_WANT_READ:
186 : 280 : n = 0;
187 : 280 : break;
3534 heikki.linnakangas@i 188 :UBC 0 : case SSL_ERROR_WANT_WRITE:
189 : :
190 : : /*
191 : : * Returning 0 here would cause caller to wait for read-ready,
192 : : * which is not correct since what SSL wants is wait for
193 : : * write-ready. The former could get us stuck in an infinite
194 : : * wait, so don't risk it; busy-loop instead.
195 : : */
196 : 0 : goto rloop;
197 : 0 : case SSL_ERROR_SYSCALL:
125 tgl@sss.pgh.pa.us 198 [ # # # # ]: 0 : if (n < 0 && SOCK_ERRNO != 0)
199 : : {
3534 heikki.linnakangas@i 200 : 0 : result_errno = SOCK_ERRNO;
201 [ # # # # ]: 0 : if (result_errno == EPIPE ||
202 : : result_errno == ECONNRESET)
516 peter@eisentraut.org 203 : 0 : libpq_append_conn_error(conn, "server closed the connection unexpectedly\n"
204 : : "\tThis probably means the server terminated abnormally\n"
205 : : "\tbefore or while processing the request.");
206 : : else
207 : 0 : libpq_append_conn_error(conn, "SSL SYSCALL error: %s",
208 : : SOCK_STRERROR(result_errno,
209 : : sebuf, sizeof(sebuf)));
210 : : }
211 : : else
212 : : {
213 : 0 : libpq_append_conn_error(conn, "SSL SYSCALL error: EOF detected");
214 : : /* assume the connection is broken */
3534 heikki.linnakangas@i 215 : 0 : result_errno = ECONNRESET;
216 : 0 : n = -1;
217 : : }
218 : 0 : break;
3534 heikki.linnakangas@i 219 :CBC 6 : case SSL_ERROR_SSL:
220 : : {
2928 peter_e@gmx.net 221 : 6 : char *errm = SSLerrmessage(ecode);
222 : :
516 peter@eisentraut.org 223 : 6 : libpq_append_conn_error(conn, "SSL error: %s", errm);
3534 heikki.linnakangas@i 224 : 6 : SSLerrfree(errm);
225 : : /* assume the connection is broken */
226 : 6 : result_errno = ECONNRESET;
227 : 6 : n = -1;
228 : 6 : break;
229 : : }
3534 heikki.linnakangas@i 230 :UBC 0 : case SSL_ERROR_ZERO_RETURN:
231 : :
232 : : /*
233 : : * Per OpenSSL documentation, this error code is only returned for
234 : : * a clean connection closure, so we should not report it as a
235 : : * server crash.
236 : : */
516 peter@eisentraut.org 237 : 0 : libpq_append_conn_error(conn, "SSL connection has been closed unexpectedly");
3534 heikki.linnakangas@i 238 : 0 : result_errno = ECONNRESET;
239 : 0 : n = -1;
240 : 0 : break;
241 : 0 : default:
516 peter@eisentraut.org 242 : 0 : libpq_append_conn_error(conn, "unrecognized SSL error code: %d", err);
243 : : /* assume the connection is broken */
3534 heikki.linnakangas@i 244 : 0 : result_errno = ECONNRESET;
245 : 0 : n = -1;
246 : 0 : break;
247 : : }
248 : :
249 : : /* ensure we return the intended errno to caller */
3534 heikki.linnakangas@i 250 :CBC 584 : SOCK_ERRNO_SET(result_errno);
251 : :
252 : 584 : return n;
253 : : }
254 : :
255 : : bool
2278 peter_e@gmx.net 256 : 841 : pgtls_read_pending(PGconn *conn)
257 : : {
1798 tgl@sss.pgh.pa.us 258 : 841 : return SSL_pending(conn->ssl) > 0;
259 : : }
260 : :
261 : : ssize_t
3534 heikki.linnakangas@i 262 : 430 : pgtls_write(PGconn *conn, const void *ptr, size_t len)
263 : : {
264 : : ssize_t n;
265 : 430 : int result_errno = 0;
266 : : char sebuf[PG_STRERROR_R_BUFLEN];
267 : : int err;
268 : : unsigned long ecode;
269 : :
270 : 430 : SOCK_ERRNO_SET(0);
2928 peter_e@gmx.net 271 : 430 : ERR_clear_error();
3534 heikki.linnakangas@i 272 : 430 : n = SSL_write(conn->ssl, ptr, len);
273 : 430 : err = SSL_get_error(conn->ssl, n);
2928 peter_e@gmx.net 274 [ + - - + ]: 430 : ecode = (err != SSL_ERROR_NONE || n < 0) ? ERR_get_error() : 0;
3534 heikki.linnakangas@i 275 [ + - - - : 430 : switch (err)
- - - ]
276 : : {
277 : 430 : case SSL_ERROR_NONE:
278 [ - + ]: 430 : if (n < 0)
279 : : {
280 : : /* Not supposed to happen, so we don't translate the msg */
1189 tgl@sss.pgh.pa.us 281 :UBC 0 : appendPQExpBufferStr(&conn->errorMessage,
282 : : "SSL_write failed but did not provide error information\n");
283 : : /* assume the connection is broken */
3534 heikki.linnakangas@i 284 : 0 : result_errno = ECONNRESET;
285 : : }
3534 heikki.linnakangas@i 286 :CBC 430 : break;
3534 heikki.linnakangas@i 287 :UBC 0 : case SSL_ERROR_WANT_READ:
288 : :
289 : : /*
290 : : * Returning 0 here causes caller to wait for write-ready, which
291 : : * is not really the right thing, but it's the best we can do.
292 : : */
293 : 0 : n = 0;
294 : 0 : break;
295 : 0 : case SSL_ERROR_WANT_WRITE:
296 : 0 : n = 0;
297 : 0 : break;
298 : 0 : case SSL_ERROR_SYSCALL:
299 : :
300 : : /*
301 : : * If errno is still zero then assume it's a read EOF situation,
302 : : * and report EOF. (This seems possible because SSL_write can
303 : : * also do reads.)
304 : : */
125 tgl@sss.pgh.pa.us 305 [ # # # # ]: 0 : if (n < 0 && SOCK_ERRNO != 0)
306 : : {
3534 heikki.linnakangas@i 307 : 0 : result_errno = SOCK_ERRNO;
308 [ # # # # ]: 0 : if (result_errno == EPIPE || result_errno == ECONNRESET)
516 peter@eisentraut.org 309 : 0 : libpq_append_conn_error(conn, "server closed the connection unexpectedly\n"
310 : : "\tThis probably means the server terminated abnormally\n"
311 : : "\tbefore or while processing the request.");
312 : : else
313 : 0 : libpq_append_conn_error(conn, "SSL SYSCALL error: %s",
314 : : SOCK_STRERROR(result_errno,
315 : : sebuf, sizeof(sebuf)));
316 : : }
317 : : else
318 : : {
319 : 0 : libpq_append_conn_error(conn, "SSL SYSCALL error: EOF detected");
320 : : /* assume the connection is broken */
3534 heikki.linnakangas@i 321 : 0 : result_errno = ECONNRESET;
322 : 0 : n = -1;
323 : : }
324 : 0 : break;
325 : 0 : case SSL_ERROR_SSL:
326 : : {
2928 peter_e@gmx.net 327 : 0 : char *errm = SSLerrmessage(ecode);
328 : :
516 peter@eisentraut.org 329 : 0 : libpq_append_conn_error(conn, "SSL error: %s", errm);
3534 heikki.linnakangas@i 330 : 0 : SSLerrfree(errm);
331 : : /* assume the connection is broken */
332 : 0 : result_errno = ECONNRESET;
333 : 0 : n = -1;
334 : 0 : break;
335 : : }
336 : 0 : case SSL_ERROR_ZERO_RETURN:
337 : :
338 : : /*
339 : : * Per OpenSSL documentation, this error code is only returned for
340 : : * a clean connection closure, so we should not report it as a
341 : : * server crash.
342 : : */
516 peter@eisentraut.org 343 : 0 : libpq_append_conn_error(conn, "SSL connection has been closed unexpectedly");
3534 heikki.linnakangas@i 344 : 0 : result_errno = ECONNRESET;
345 : 0 : n = -1;
346 : 0 : break;
347 : 0 : default:
516 peter@eisentraut.org 348 : 0 : libpq_append_conn_error(conn, "unrecognized SSL error code: %d", err);
349 : : /* assume the connection is broken */
3534 heikki.linnakangas@i 350 : 0 : result_errno = ECONNRESET;
351 : 0 : n = -1;
352 : 0 : break;
353 : : }
354 : :
355 : : /* ensure we return the intended errno to caller */
3534 heikki.linnakangas@i 356 :CBC 430 : SOCK_ERRNO_SET(result_errno);
357 : :
358 : 430 : return n;
359 : : }
360 : :
361 : : char *
2292 peter_e@gmx.net 362 : 5 : pgtls_get_peer_certificate_hash(PGconn *conn, size_t *len)
363 : : {
364 : : X509 *peer_cert;
365 : : const EVP_MD *algo_type;
366 : : unsigned char hash[EVP_MAX_MD_SIZE]; /* size for SHA-512 */
367 : : unsigned int hash_size;
368 : : int algo_nid;
369 : : char *cert_hash;
370 : :
371 : 5 : *len = 0;
372 : :
373 [ - + ]: 5 : if (!conn->peer)
2292 peter_e@gmx.net 374 :UBC 0 : return NULL;
375 : :
2292 peter_e@gmx.net 376 :CBC 5 : peer_cert = conn->peer;
377 : :
378 : : /*
379 : : * Get the signature algorithm of the certificate to determine the hash
380 : : * algorithm to use for the result. Prefer X509_get_signature_info(),
381 : : * introduced in OpenSSL 1.1.1, which can handle RSA-PSS signatures.
382 : : */
383 : : #if HAVE_X509_GET_SIGNATURE_INFO
424 michael@paquier.xyz 384 [ - + ]: 5 : if (!X509_get_signature_info(peer_cert, &algo_nid, NULL, NULL, NULL))
385 : : #else
386 : : if (!OBJ_find_sigid_algs(X509_get_signature_nid(peer_cert),
387 : : &algo_nid, NULL))
388 : : #endif
389 : : {
516 peter@eisentraut.org 390 :UBC 0 : libpq_append_conn_error(conn, "could not determine server certificate signature algorithm");
2292 peter_e@gmx.net 391 : 0 : return NULL;
392 : : }
393 : :
394 : : /*
395 : : * The TLS server's certificate bytes need to be hashed with SHA-256 if
396 : : * its signature algorithm is MD5 or SHA-1 as per RFC 5929
397 : : * (https://tools.ietf.org/html/rfc5929#section-4.1). If something else
398 : : * is used, the same hash as the signature algorithm is used.
399 : : */
2292 peter_e@gmx.net 400 [ - + ]:CBC 5 : switch (algo_nid)
401 : : {
2292 peter_e@gmx.net 402 :UBC 0 : case NID_md5:
403 : : case NID_sha1:
404 : 0 : algo_type = EVP_sha256();
405 : 0 : break;
2292 peter_e@gmx.net 406 :CBC 5 : default:
407 : 5 : algo_type = EVP_get_digestbynid(algo_nid);
408 [ - + ]: 5 : if (algo_type == NULL)
409 : : {
516 peter@eisentraut.org 410 :UBC 0 : libpq_append_conn_error(conn, "could not find digest for NID %s",
411 : : OBJ_nid2sn(algo_nid));
2292 peter_e@gmx.net 412 : 0 : return NULL;
413 : : }
2292 peter_e@gmx.net 414 :CBC 5 : break;
415 : : }
416 : :
417 [ - + ]: 5 : if (!X509_digest(peer_cert, algo_type, hash, &hash_size))
418 : : {
516 peter@eisentraut.org 419 :UBC 0 : libpq_append_conn_error(conn, "could not generate peer certificate hash");
2292 peter_e@gmx.net 420 : 0 : return NULL;
421 : : }
422 : :
423 : : /* save result */
2292 peter_e@gmx.net 424 :CBC 5 : cert_hash = malloc(hash_size);
425 [ - + ]: 5 : if (cert_hash == NULL)
426 : : {
516 peter@eisentraut.org 427 :UBC 0 : libpq_append_conn_error(conn, "out of memory");
2292 peter_e@gmx.net 428 : 0 : return NULL;
429 : : }
2292 peter_e@gmx.net 430 :CBC 5 : memcpy(cert_hash, hash, hash_size);
431 : 5 : *len = hash_size;
432 : :
433 : 5 : return cert_hash;
434 : : }
435 : :
436 : : /* ------------------------------------------------------------ */
437 : : /* OpenSSL specific code */
438 : : /* ------------------------------------------------------------ */
439 : :
440 : : /*
441 : : * Certificate verification callback
442 : : *
443 : : * This callback allows us to log intermediate problems during
444 : : * verification, but there doesn't seem to be a clean way to get
445 : : * our PGconn * structure. So we can't log anything!
446 : : *
447 : : * This callback also allows us to override the default acceptance
448 : : * criteria (e.g., accepting self-signed or expired certs), but
449 : : * for now we accept the default checks.
450 : : */
451 : : static int
3534 heikki.linnakangas@i 452 : 282 : verify_cb(int ok, X509_STORE_CTX *ctx)
453 : : {
454 : 282 : return ok;
455 : : }
456 : :
457 : : #ifdef HAVE_SSL_CTX_SET_CERT_CB
458 : : /*
459 : : * Certificate selection callback
460 : : *
461 : : * This callback lets us choose the client certificate we send to the server
462 : : * after seeing its CertificateRequest. We only support sending a single
463 : : * hard-coded certificate via sslcert, so we don't actually set any certificates
464 : : * here; we just use it to record whether or not the server has actually asked
465 : : * for one and whether we have one to send.
466 : : */
467 : : static int
387 michael@paquier.xyz 468 : 103 : cert_cb(SSL *ssl, void *arg)
469 : : {
470 : 103 : PGconn *conn = arg;
471 : :
472 : 103 : conn->ssl_cert_requested = true;
473 : :
474 : : /* Do we have a certificate loaded to send back? */
475 [ + + ]: 103 : if (SSL_get_certificate(ssl))
476 : 36 : conn->ssl_cert_sent = true;
477 : :
478 : : /*
479 : : * Tell OpenSSL that the callback succeeded; we're not required to
480 : : * actually make any changes to the SSL handle.
481 : : */
482 : 103 : return 1;
483 : : }
484 : : #endif
485 : :
486 : : /*
487 : : * OpenSSL-specific wrapper around
488 : : * pq_verify_peer_name_matches_certificate_name(), converting the ASN1_STRING
489 : : * into a plain C string.
490 : : */
491 : : static int
2269 peter_e@gmx.net 492 : 34 : openssl_verify_peer_name_matches_certificate_name(PGconn *conn, ASN1_STRING *name_entry,
493 : : char **store_name)
494 : : {
495 : : int len;
496 : : const unsigned char *namedata;
497 : :
498 : : /* Should not happen... */
3502 heikki.linnakangas@i 499 [ - + ]: 34 : if (name_entry == NULL)
500 : : {
516 peter@eisentraut.org 501 :UBC 0 : libpq_append_conn_error(conn, "SSL certificate's name entry is missing");
3502 heikki.linnakangas@i 502 : 0 : return -1;
503 : : }
504 : :
505 : : /*
506 : : * GEN_DNS can be only IA5String, equivalent to US ASCII.
507 : : */
508 : : #ifdef HAVE_ASN1_STRING_GET0_DATA
2768 heikki.linnakangas@i 509 :CBC 34 : namedata = ASN1_STRING_get0_data(name_entry);
510 : : #else
511 : : namedata = ASN1_STRING_data(name_entry);
512 : : #endif
3502 513 : 34 : len = ASN1_STRING_length(name_entry);
514 : :
515 : : /* OK to cast from unsigned to plain char, since it's all ASCII. */
2269 peter_e@gmx.net 516 : 34 : return pq_verify_peer_name_matches_certificate_name(conn, (const char *) namedata, len, store_name);
517 : : }
518 : :
519 : : /*
520 : : * OpenSSL-specific wrapper around
521 : : * pq_verify_peer_name_matches_certificate_ip(), converting the
522 : : * ASN1_OCTET_STRING into a plain C string.
523 : : */
524 : : static int
744 peter@eisentraut.org 525 : 24 : openssl_verify_peer_name_matches_certificate_ip(PGconn *conn,
526 : : ASN1_OCTET_STRING *addr_entry,
527 : : char **store_name)
528 : : {
529 : : int len;
530 : : const unsigned char *addrdata;
531 : :
532 : : /* Should not happen... */
533 [ - + ]: 24 : if (addr_entry == NULL)
534 : : {
516 peter@eisentraut.org 535 :UBC 0 : libpq_append_conn_error(conn, "SSL certificate's address entry is missing");
744 536 : 0 : return -1;
537 : : }
538 : :
539 : : /*
540 : : * GEN_IPADD is an OCTET STRING containing an IP address in network byte
541 : : * order.
542 : : */
543 : : #ifdef HAVE_ASN1_STRING_GET0_DATA
744 peter@eisentraut.org 544 :CBC 24 : addrdata = ASN1_STRING_get0_data(addr_entry);
545 : : #else
546 : : addrdata = ASN1_STRING_data(addr_entry);
547 : : #endif
548 : 24 : len = ASN1_STRING_length(addr_entry);
549 : :
550 : 24 : return pq_verify_peer_name_matches_certificate_ip(conn, addrdata, len, store_name);
551 : : }
552 : :
553 : : static bool
554 : 36 : is_ip_address(const char *host)
555 : : {
556 : : struct in_addr dummy4;
557 : : #ifdef HAVE_INET_PTON
558 : : struct in6_addr dummy6;
559 : : #endif
560 : :
561 : 36 : return inet_aton(host, &dummy4)
562 : : #ifdef HAVE_INET_PTON
563 [ + + + + ]: 36 : || (inet_pton(AF_INET6, host, &dummy6) == 1)
564 : : #endif
565 : : ;
566 : : }
567 : :
568 : : /*
569 : : * Verify that the server certificate matches the hostname we connected to.
570 : : *
571 : : * The certificate's Common Name and Subject Alternative Names are considered.
572 : : */
573 : : int
2269 peter_e@gmx.net 574 : 36 : pgtls_verify_peer_name_matches_certificate_guts(PGconn *conn,
575 : : int *names_examined,
576 : : char **first_name)
577 : : {
578 : : STACK_OF(GENERAL_NAME) * peer_san;
579 : : int i;
580 : 36 : int rc = 0;
744 peter@eisentraut.org 581 : 36 : char *host = conn->connhost[conn->whichhost].host;
582 : : int host_type;
583 : 36 : bool check_cn = true;
584 : :
585 [ + - + - ]: 36 : Assert(host && host[0]); /* should be guaranteed by caller */
586 : :
587 : : /*
588 : : * We try to match the NSS behavior here, which is a slight departure from
589 : : * the spec but seems to make more intuitive sense:
590 : : *
591 : : * If connhost contains a DNS name, and the certificate's SANs contain any
592 : : * dNSName entries, then we'll ignore the Subject Common Name entirely;
593 : : * otherwise, we fall back to checking the CN. (This behavior matches the
594 : : * RFC.)
595 : : *
596 : : * If connhost contains an IP address, and the SANs contain iPAddress
597 : : * entries, we again ignore the CN. Otherwise, we allow the CN to match,
598 : : * EVEN IF there is a dNSName in the SANs. (RFC 6125 prohibits this: "A
599 : : * client MUST NOT seek a match for a reference identifier of CN-ID if the
600 : : * presented identifiers include a DNS-ID, SRV-ID, URI-ID, or any
601 : : * application-specific identifier types supported by the client.")
602 : : *
603 : : * NOTE: Prior versions of libpq did not consider iPAddress entries at
604 : : * all, so this new behavior might break a certificate that has different
605 : : * IP addresses in the Subject CN and the SANs.
606 : : */
607 [ + + ]: 36 : if (is_ip_address(host))
608 : 16 : host_type = GEN_IPADD;
609 : : else
610 : 20 : host_type = GEN_DNS;
611 : :
612 : : /*
613 : : * First, get the Subject Alternative Names (SANs) from the certificate,
614 : : * and compare them against the originally given hostname.
615 : : */
616 : : peer_san = (STACK_OF(GENERAL_NAME) *)
3502 heikki.linnakangas@i 617 : 36 : X509_get_ext_d2i(conn->peer, NID_subject_alt_name, NULL, NULL);
618 : :
619 [ + + ]: 36 : if (peer_san)
620 : : {
621 : 29 : int san_len = sk_GENERAL_NAME_num(peer_san);
622 : :
623 [ + + ]: 61 : for (i = 0; i < san_len; i++)
624 : : {
625 : 50 : const GENERAL_NAME *name = sk_GENERAL_NAME_value(peer_san, i);
744 peter@eisentraut.org 626 : 50 : char *alt_name = NULL;
627 : :
628 [ + + ]: 50 : if (name->type == host_type)
629 : : {
630 : : /*
631 : : * This SAN is of the same type (IP or DNS) as our host name,
632 : : * so don't allow a fallback check of the CN.
633 : : */
634 : 43 : check_cn = false;
635 : : }
636 : :
637 [ + + ]: 50 : if (name->type == GEN_DNS)
638 : : {
2269 peter_e@gmx.net 639 : 26 : (*names_examined)++;
640 : 26 : rc = openssl_verify_peer_name_matches_certificate_name(conn,
2180 tgl@sss.pgh.pa.us 641 : 26 : name->d.dNSName,
642 : : &alt_name);
643 : : }
744 peter@eisentraut.org 644 [ + - ]: 24 : else if (name->type == GEN_IPADD)
645 : : {
646 : 24 : (*names_examined)++;
647 : 24 : rc = openssl_verify_peer_name_matches_certificate_ip(conn,
648 : 24 : name->d.iPAddress,
649 : : &alt_name);
650 : : }
651 : :
652 [ + - ]: 50 : if (alt_name)
653 : : {
654 [ + + ]: 50 : if (!*first_name)
655 : 29 : *first_name = alt_name;
656 : : else
657 : 21 : free(alt_name);
658 : : }
659 : :
2269 peter_e@gmx.net 660 [ + + ]: 50 : if (rc != 0)
661 : : {
662 : : /*
663 : : * Either we hit an error or a match, and either way we should
664 : : * not fall back to the CN.
665 : : */
744 peter@eisentraut.org 666 : 18 : check_cn = false;
3502 heikki.linnakangas@i 667 : 18 : break;
668 : : }
669 : : }
1453 michael@paquier.xyz 670 : 29 : sk_GENERAL_NAME_pop_free(peer_san, GENERAL_NAME_free);
671 : : }
672 : :
673 : : /*
674 : : * If there is no subjectAltName extension of the matching type, check the
675 : : * Common Name.
676 : : *
677 : : * (Per RFC 2818 and RFC 6125, if the subjectAltName extension of type
678 : : * dNSName is present, the CN must be ignored. We break this rule if host
679 : : * is an IP address; see the comment above.)
680 : : */
744 peter@eisentraut.org 681 [ + + ]: 36 : if (check_cn)
682 : : {
683 : : X509_NAME *subject_name;
684 : :
3502 heikki.linnakangas@i 685 : 10 : subject_name = X509_get_subject_name(conn->peer);
686 [ + - ]: 10 : if (subject_name != NULL)
687 : : {
688 : : int cn_index;
689 : :
690 : 10 : cn_index = X509_NAME_get_index_by_NID(subject_name,
691 : : NID_commonName, -1);
692 [ + + ]: 10 : if (cn_index >= 0)
693 : : {
744 peter@eisentraut.org 694 : 8 : char *common_name = NULL;
695 : :
2269 peter_e@gmx.net 696 : 8 : (*names_examined)++;
1536 alvherre@alvh.no-ip. 697 : 8 : rc = openssl_verify_peer_name_matches_certificate_name(conn,
698 : 8 : X509_NAME_ENTRY_get_data(X509_NAME_get_entry(subject_name, cn_index)),
699 : : &common_name);
700 : :
744 peter@eisentraut.org 701 [ + - ]: 8 : if (common_name)
702 : : {
703 [ + + ]: 8 : if (!*first_name)
704 : 6 : *first_name = common_name;
705 : : else
706 : 2 : free(common_name);
707 : : }
708 : : }
709 : : }
710 : : }
711 : :
2269 peter_e@gmx.net 712 : 36 : return rc;
713 : : }
714 : :
715 : : #if defined(HAVE_CRYPTO_LOCK)
716 : : /*
717 : : * Callback functions for OpenSSL internal locking. (OpenSSL 1.1.0
718 : : * does its own locking, and doesn't need these anymore. The
719 : : * CRYPTO_lock() function was removed in 1.1.0, when the callbacks
720 : : * were made obsolete, so we assume that if CRYPTO_lock() exists,
721 : : * the callbacks are still required.)
722 : : */
723 : :
724 : : static unsigned long
725 : : pq_threadidcallback(void)
726 : : {
727 : : /*
728 : : * This is not standards-compliant. pthread_self() returns pthread_t, and
729 : : * shouldn't be cast to unsigned long, but CRYPTO_set_id_callback requires
730 : : * it, so we have to do it.
731 : : */
732 : : return (unsigned long) pthread_self();
733 : : }
734 : :
735 : : static pthread_mutex_t *pq_lockarray;
736 : :
737 : : static void
738 : : pq_lockingcallback(int mode, int n, const char *file, int line)
739 : : {
740 : : /*
741 : : * There's no way to report a mutex-primitive failure, so we just Assert
742 : : * in development builds, and ignore any errors otherwise. Fortunately
743 : : * this is all obsolete in modern OpenSSL.
744 : : */
745 : : if (mode & CRYPTO_LOCK)
746 : : {
747 : : if (pthread_mutex_lock(&pq_lockarray[n]))
748 : : Assert(false);
749 : : }
750 : : else
751 : : {
752 : : if (pthread_mutex_unlock(&pq_lockarray[n]))
753 : : Assert(false);
754 : : }
755 : : }
756 : : #endif /* HAVE_CRYPTO_LOCK */
757 : :
758 : : /*
759 : : * Initialize SSL library.
760 : : *
761 : : * In threadsafe mode, this includes setting up libcrypto callback functions
762 : : * to do thread locking.
763 : : *
764 : : * If the caller has told us (through PQinitOpenSSL) that he's taking care
765 : : * of libcrypto, we expect that callbacks are already set, and won't try to
766 : : * override it.
767 : : */
768 : : int
1130 michael@paquier.xyz 769 : 12682 : pgtls_init(PGconn *conn, bool do_ssl, bool do_crypto)
770 : : {
3534 heikki.linnakangas@i 771 [ - + ]: 12682 : if (pthread_mutex_lock(&ssl_config_mutex))
3534 heikki.linnakangas@i 772 :UBC 0 : return -1;
773 : :
774 : : #ifdef HAVE_CRYPTO_LOCK
775 : : if (pq_init_crypto_lib)
776 : : {
777 : : /*
778 : : * If necessary, set up an array to hold locks for libcrypto.
779 : : * libcrypto will tell us how big to make this array.
780 : : */
781 : : if (pq_lockarray == NULL)
782 : : {
783 : : int i;
784 : :
785 : : pq_lockarray = malloc(sizeof(pthread_mutex_t) * CRYPTO_num_locks());
786 : : if (!pq_lockarray)
787 : : {
788 : : pthread_mutex_unlock(&ssl_config_mutex);
789 : : return -1;
790 : : }
791 : : for (i = 0; i < CRYPTO_num_locks(); i++)
792 : : {
793 : : if (pthread_mutex_init(&pq_lockarray[i], NULL))
794 : : {
795 : : free(pq_lockarray);
796 : : pq_lockarray = NULL;
797 : : pthread_mutex_unlock(&ssl_config_mutex);
798 : : return -1;
799 : : }
800 : : }
801 : : }
802 : :
803 : : if (do_crypto && !conn->crypto_loaded)
804 : : {
805 : : if (crypto_open_connections++ == 0)
806 : : {
807 : : /*
808 : : * These are only required for threaded libcrypto
809 : : * applications, but make sure we don't stomp on them if
810 : : * they're already set.
811 : : */
812 : : if (CRYPTO_get_id_callback() == NULL)
813 : : CRYPTO_set_id_callback(pq_threadidcallback);
814 : : if (CRYPTO_get_locking_callback() == NULL)
815 : : CRYPTO_set_locking_callback(pq_lockingcallback);
816 : : }
817 : :
818 : : conn->crypto_loaded = true;
819 : : }
820 : : }
821 : : #endif /* HAVE_CRYPTO_LOCK */
822 : :
1130 michael@paquier.xyz 823 [ + + + + ]:CBC 12682 : if (!ssl_lib_initialized && do_ssl)
824 : : {
3534 heikki.linnakangas@i 825 [ + - ]: 214 : if (pq_init_ssl_lib)
826 : : {
827 : : #ifdef HAVE_OPENSSL_INIT_SSL
2768 828 : 214 : OPENSSL_init_ssl(OPENSSL_INIT_LOAD_CONFIG, NULL);
829 : : #else
830 : : OPENSSL_config(NULL);
831 : : SSL_library_init();
832 : : SSL_load_error_strings();
833 : : #endif
834 : : }
2746 835 : 214 : ssl_lib_initialized = true;
836 : : }
837 : :
3534 838 : 12682 : pthread_mutex_unlock(&ssl_config_mutex);
839 : 12682 : return 0;
840 : : }
841 : :
842 : : /*
843 : : * This function is needed because if the libpq library is unloaded
844 : : * from the application, the callback functions will no longer exist when
845 : : * libcrypto is used by other parts of the system. For this reason,
846 : : * we unregister the callback functions when the last libpq
847 : : * connection is closed. (The same would apply for OpenSSL callbacks
848 : : * if we had any.)
849 : : *
850 : : * Callbacks are only set when we're compiled in threadsafe mode, so
851 : : * we only need to remove them in this case. They are also not needed
852 : : * with OpenSSL 1.1.0 anymore.
853 : : */
854 : : static void
855 : 212 : destroy_ssl_system(void)
856 : : {
857 : : #if defined(HAVE_CRYPTO_LOCK)
858 : : if (pthread_mutex_lock(&ssl_config_mutex))
859 : : return;
860 : :
861 : : if (pq_init_crypto_lib && crypto_open_connections > 0)
862 : : --crypto_open_connections;
863 : :
864 : : if (pq_init_crypto_lib && crypto_open_connections == 0)
865 : : {
866 : : /*
867 : : * No connections left, unregister libcrypto callbacks, if no one
868 : : * registered different ones in the meantime.
869 : : */
870 : : if (CRYPTO_get_locking_callback() == pq_lockingcallback)
871 : : CRYPTO_set_locking_callback(NULL);
872 : : if (CRYPTO_get_id_callback() == pq_threadidcallback)
873 : : CRYPTO_set_id_callback(NULL);
874 : :
875 : : /*
876 : : * We don't free the lock array. If we get another connection in this
877 : : * process, we will just re-use them with the existing mutexes.
878 : : *
879 : : * This means we leak a little memory on repeated load/unload of the
880 : : * library.
881 : : */
882 : : }
883 : :
884 : : pthread_mutex_unlock(&ssl_config_mutex);
885 : : #endif
886 : 212 : }
887 : :
888 : : /* See pqcomm.h comments on OpenSSL implementation of ALPN (RFC 7301) */
889 : : static unsigned char alpn_protos[] = PG_ALPN_PROTOCOL_VECTOR;
890 : :
891 : : /*
892 : : * Create per-connection SSL object, and load the client certificate,
893 : : * private key, and trusted CA certs.
894 : : *
895 : : * Returns 0 if OK, -1 on failure (with a message in conn->errorMessage).
896 : : */
897 : : static int
898 : 214 : initialize_SSL(PGconn *conn)
899 : : {
900 : : SSL_CTX *SSL_context;
901 : : struct stat buf;
902 : : char homedir[MAXPGPATH];
903 : : char fnbuf[MAXPGPATH];
904 : : char sebuf[PG_STRERROR_R_BUFLEN];
905 : : bool have_homedir;
906 : : bool have_cert;
907 : : bool have_rootcert;
908 : :
909 : : /*
910 : : * We'll need the home directory if any of the relevant parameters are
911 : : * defaulted. If pqGetHomeDirectory fails, act as though none of the
912 : : * files could be found.
913 : : */
914 [ + + + - ]: 214 : if (!(conn->sslcert && strlen(conn->sslcert) > 0) ||
915 [ + + + - ]: 116 : !(conn->sslkey && strlen(conn->sslkey) > 0) ||
916 [ + - + - ]: 108 : !(conn->sslrootcert && strlen(conn->sslrootcert) > 0) ||
1151 peter@eisentraut.org 917 [ + + + + ]: 108 : !((conn->sslcrl && strlen(conn->sslcrl) > 0) ||
918 [ + + - + ]: 4 : (conn->sslcrldir && strlen(conn->sslcrldir) > 0)))
3534 heikki.linnakangas@i 919 : 108 : have_homedir = pqGetHomeDirectory(homedir, sizeof(homedir));
920 : : else /* won't need it */
921 : 106 : have_homedir = false;
922 : :
923 : : /*
924 : : * Create a new SSL_CTX object.
925 : : *
926 : : * We used to share a single SSL_CTX between all connections, but it was
927 : : * complicated if connections used different certificates. So now we
928 : : * create a separate context for each connection, and accept the overhead.
929 : : */
2746 930 : 214 : SSL_context = SSL_CTX_new(SSLv23_method());
931 [ - + ]: 214 : if (!SSL_context)
932 : : {
2746 heikki.linnakangas@i 933 :UBC 0 : char *err = SSLerrmessage(ERR_get_error());
934 : :
516 peter@eisentraut.org 935 : 0 : libpq_append_conn_error(conn, "could not create SSL context: %s", err);
2746 heikki.linnakangas@i 936 : 0 : SSLerrfree(err);
937 : 0 : return -1;
938 : : }
939 : :
940 : : /*
941 : : * Delegate the client cert password prompt to the libpq wrapper callback
942 : : * if any is defined.
943 : : *
944 : : * If the application hasn't installed its own and the sslpassword
945 : : * parameter is non-null, we install ours now to make sure we supply
946 : : * PGconn->sslpassword to OpenSSL instead of letting it prompt on stdin.
947 : : *
948 : : * This will replace OpenSSL's default PEM_def_callback (which prompts on
949 : : * stdin), but we're only setting it for this SSL context so it's
950 : : * harmless.
951 : : */
1597 andrew@dunslane.net 952 [ + - ]:CBC 214 : if (PQsslKeyPassHook
953 [ + + + - ]: 214 : || (conn->sslpassword && strlen(conn->sslpassword) > 0))
954 : : {
955 : 3 : SSL_CTX_set_default_passwd_cb(SSL_context, PQssl_passwd_cb);
956 : 3 : SSL_CTX_set_default_passwd_cb_userdata(SSL_context, conn);
957 : : }
958 : :
959 : : #ifdef HAVE_SSL_CTX_SET_CERT_CB
960 : : /* Set up a certificate selection callback. */
387 michael@paquier.xyz 961 : 214 : SSL_CTX_set_cert_cb(SSL_context, cert_cb, conn);
962 : : #endif
963 : :
964 : : /* Disable old protocol versions */
2746 heikki.linnakangas@i 965 : 214 : SSL_CTX_set_options(SSL_context, SSL_OP_NO_SSLv2 | SSL_OP_NO_SSLv3);
966 : :
967 : : /* Set the minimum and maximum protocol versions if necessary */
1445 michael@paquier.xyz 968 [ + - ]: 214 : if (conn->ssl_min_protocol_version &&
969 [ + - ]: 214 : strlen(conn->ssl_min_protocol_version) != 0)
970 : : {
971 : : int ssl_min_ver;
972 : :
973 : 214 : ssl_min_ver = ssl_protocol_version_to_openssl(conn->ssl_min_protocol_version);
974 : :
1538 975 [ - + ]: 214 : if (ssl_min_ver == -1)
976 : : {
516 peter@eisentraut.org 977 :UBC 0 : libpq_append_conn_error(conn, "invalid value \"%s\" for minimum SSL protocol version",
978 : : conn->ssl_min_protocol_version);
1533 tgl@sss.pgh.pa.us 979 : 0 : SSL_CTX_free(SSL_context);
1538 michael@paquier.xyz 980 : 0 : return -1;
981 : : }
982 : :
1538 michael@paquier.xyz 983 [ - + ]:CBC 214 : if (!SSL_CTX_set_min_proto_version(SSL_context, ssl_min_ver))
984 : : {
1538 michael@paquier.xyz 985 :UBC 0 : char *err = SSLerrmessage(ERR_get_error());
986 : :
516 peter@eisentraut.org 987 : 0 : libpq_append_conn_error(conn, "could not set minimum SSL protocol version: %s", err);
1533 tgl@sss.pgh.pa.us 988 : 0 : SSLerrfree(err);
989 : 0 : SSL_CTX_free(SSL_context);
1538 michael@paquier.xyz 990 : 0 : return -1;
991 : : }
992 : : }
993 : :
1445 michael@paquier.xyz 994 [ + + ]:CBC 214 : if (conn->ssl_max_protocol_version &&
995 [ + - ]: 2 : strlen(conn->ssl_max_protocol_version) != 0)
996 : : {
997 : : int ssl_max_ver;
998 : :
999 : 2 : ssl_max_ver = ssl_protocol_version_to_openssl(conn->ssl_max_protocol_version);
1000 : :
1538 1001 [ - + ]: 2 : if (ssl_max_ver == -1)
1002 : : {
516 peter@eisentraut.org 1003 :UBC 0 : libpq_append_conn_error(conn, "invalid value \"%s\" for maximum SSL protocol version",
1004 : : conn->ssl_max_protocol_version);
1533 tgl@sss.pgh.pa.us 1005 : 0 : SSL_CTX_free(SSL_context);
1538 michael@paquier.xyz 1006 : 0 : return -1;
1007 : : }
1008 : :
1538 michael@paquier.xyz 1009 [ - + ]:CBC 2 : if (!SSL_CTX_set_max_proto_version(SSL_context, ssl_max_ver))
1010 : : {
1538 michael@paquier.xyz 1011 :UBC 0 : char *err = SSLerrmessage(ERR_get_error());
1012 : :
516 peter@eisentraut.org 1013 : 0 : libpq_append_conn_error(conn, "could not set maximum SSL protocol version: %s", err);
1533 tgl@sss.pgh.pa.us 1014 : 0 : SSLerrfree(err);
1015 : 0 : SSL_CTX_free(SSL_context);
1538 michael@paquier.xyz 1016 : 0 : return -1;
1017 : : }
1018 : : }
1019 : :
1020 : : /*
1021 : : * Disable OpenSSL's moving-write-buffer sanity check, because it causes
1022 : : * unnecessary failures in nonblocking send cases.
1023 : : */
2746 heikki.linnakangas@i 1024 :CBC 214 : SSL_CTX_set_mode(SSL_context, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
1025 : :
1026 : : /*
1027 : : * If the root cert file exists, load it so we can perform certificate
1028 : : * verification. If sslmode is "verify-full" we will also do further
1029 : : * verification after the connection has been completed.
1030 : : */
1031 [ + + + - ]: 214 : if (conn->sslrootcert && strlen(conn->sslrootcert) > 0)
1032 : 116 : strlcpy(fnbuf, conn->sslrootcert, sizeof(fnbuf));
2746 heikki.linnakangas@i 1033 [ + - ]:GBC 98 : else if (have_homedir)
1034 : 98 : snprintf(fnbuf, sizeof(fnbuf), "%s/%s", homedir, ROOT_CERT_FILE);
1035 : : else
2746 heikki.linnakangas@i 1036 :UBC 0 : fnbuf[0] = '\0';
1037 : :
375 dgustafsson@postgres 1038 [ + + ]:CBC 214 : if (strcmp(fnbuf, "system") == 0)
1039 : : {
1040 : : /*
1041 : : * The "system" sentinel value indicates that we should load whatever
1042 : : * root certificates are installed for use by OpenSSL; these locations
1043 : : * differ by platform. Note that the default system locations may be
1044 : : * further overridden by the SSL_CERT_DIR and SSL_CERT_FILE
1045 : : * environment variables.
1046 : : */
1047 [ - + ]: 3 : if (SSL_CTX_set_default_verify_paths(SSL_context) != 1)
1048 : : {
375 dgustafsson@postgres 1049 :UBC 0 : char *err = SSLerrmessage(ERR_get_error());
1050 : :
1051 : 0 : libpq_append_conn_error(conn, "could not load system root certificate paths: %s",
1052 : : err);
1053 : 0 : SSLerrfree(err);
1054 : 0 : SSL_CTX_free(SSL_context);
1055 : 0 : return -1;
1056 : : }
375 dgustafsson@postgres 1057 :CBC 3 : have_rootcert = true;
1058 : : }
1059 [ + - + + ]: 422 : else if (fnbuf[0] != '\0' &&
1060 : 211 : stat(fnbuf, &buf) == 0)
2746 heikki.linnakangas@i 1061 : 99 : {
1062 : : X509_STORE *cvstore;
1063 : :
1064 [ - + ]: 99 : if (SSL_CTX_load_verify_locations(SSL_context, fnbuf, NULL) != 1)
1065 : : {
2746 heikki.linnakangas@i 1066 :UBC 0 : char *err = SSLerrmessage(ERR_get_error());
1067 : :
516 peter@eisentraut.org 1068 : 0 : libpq_append_conn_error(conn, "could not read root certificate file \"%s\": %s",
1069 : : fnbuf, err);
2746 heikki.linnakangas@i 1070 : 0 : SSLerrfree(err);
1071 : 0 : SSL_CTX_free(SSL_context);
1072 : 0 : return -1;
1073 : : }
1074 : :
2746 heikki.linnakangas@i 1075 [ + - ]:CBC 99 : if ((cvstore = SSL_CTX_get_cert_store(SSL_context)) != NULL)
1076 : : {
1068 tgl@sss.pgh.pa.us 1077 : 99 : char *fname = NULL;
1078 : 99 : char *dname = NULL;
1079 : :
2746 heikki.linnakangas@i 1080 [ + - + + ]: 99 : if (conn->sslcrl && strlen(conn->sslcrl) > 0)
1151 peter@eisentraut.org 1081 : 97 : fname = conn->sslcrl;
1082 [ + - + - ]: 99 : if (conn->sslcrldir && strlen(conn->sslcrldir) > 0)
1083 : 99 : dname = conn->sslcrldir;
1084 : :
1085 : : /* defaults to use the default CRL file */
1086 [ + + - + : 99 : if (!fname && !dname && have_homedir)
- - ]
1087 : : {
2746 heikki.linnakangas@i 1088 :UBC 0 : snprintf(fnbuf, sizeof(fnbuf), "%s/%s", homedir, ROOT_CRL_FILE);
1151 peter@eisentraut.org 1089 : 0 : fname = fnbuf;
1090 : : }
1091 : :
1092 : : /* Set the flags to check against the complete CRL chain */
1151 peter@eisentraut.org 1093 [ + + + - :CBC 198 : if ((fname || dname) &&
+ + ]
1094 : 99 : X509_STORE_load_locations(cvstore, fname, dname) == 1)
1095 : : {
2746 heikki.linnakangas@i 1096 : 5 : X509_STORE_set_flags(cvstore,
1097 : : X509_V_FLAG_CRL_CHECK | X509_V_FLAG_CRL_CHECK_ALL);
1098 : : }
1099 : :
1100 : : /* if not found, silently ignore; we do not require CRL */
1101 : 99 : ERR_clear_error();
1102 : : }
1103 : 99 : have_rootcert = true;
1104 : : }
1105 : : else
1106 : : {
1107 : : /*
1108 : : * stat() failed; assume root file doesn't exist. If sslmode is
1109 : : * verify-ca or verify-full, this is an error. Otherwise, continue
1110 : : * without performing any server cert verification.
1111 : : */
1112 [ + + ]: 112 : if (conn->sslmode[0] == 'v') /* "verify-ca" or "verify-full" */
1113 : : {
1114 : : /*
1115 : : * The only way to reach here with an empty filename is if
1116 : : * pqGetHomeDirectory failed. That's a sufficiently unusual case
1117 : : * that it seems worth having a specialized error message for it.
1118 : : */
1119 [ - + ]: 2 : if (fnbuf[0] == '\0')
516 peter@eisentraut.org 1120 :UBC 0 : libpq_append_conn_error(conn, "could not get home directory to locate root certificate file\n"
1121 : : "Either provide the file, use the system's trusted roots with sslrootcert=system, or change sslmode to disable server certificate verification.");
1122 : : else
516 peter@eisentraut.org 1123 :CBC 2 : libpq_append_conn_error(conn, "root certificate file \"%s\" does not exist\n"
1124 : : "Either provide the file, use the system's trusted roots with sslrootcert=system, or change sslmode to disable server certificate verification.", fnbuf);
2746 heikki.linnakangas@i 1125 : 2 : SSL_CTX_free(SSL_context);
1126 : 2 : return -1;
1127 : : }
1128 : 110 : have_rootcert = false;
1129 : : }
1130 : :
1131 : : /* Read the client certificate file */
3534 1132 [ + + + - ]: 212 : if (conn->sslcert && strlen(conn->sslcert) > 0)
3368 tgl@sss.pgh.pa.us 1133 : 114 : strlcpy(fnbuf, conn->sslcert, sizeof(fnbuf));
3534 heikki.linnakangas@i 1134 [ + - ]:GBC 98 : else if (have_homedir)
1135 : 98 : snprintf(fnbuf, sizeof(fnbuf), "%s/%s", homedir, USER_CERT_FILE);
1136 : : else
3534 heikki.linnakangas@i 1137 :UBC 0 : fnbuf[0] = '\0';
1138 : :
331 tgl@sss.pgh.pa.us 1139 [ + + ]:CBC 212 : if (conn->sslcertmode[0] == 'd') /* disable */
1140 : : {
1141 : : /* don't send a client cert even if we have one */
387 michael@paquier.xyz 1142 : 3 : have_cert = false;
1143 : : }
1144 [ - + ]: 209 : else if (fnbuf[0] == '\0')
1145 : : {
1146 : : /* no home directory, proceed without a client cert */
3534 heikki.linnakangas@i 1147 :UBC 0 : have_cert = false;
1148 : : }
3534 heikki.linnakangas@i 1149 [ + + ]:CBC 209 : else if (stat(fnbuf, &buf) != 0)
1150 : : {
1151 : : /*
1152 : : * If file is not present, just go on without a client cert; server
1153 : : * might or might not accept the connection. Any other error,
1154 : : * however, is grounds for complaint.
1155 : : */
1156 [ - + - - ]: 171 : if (errno != ENOENT && errno != ENOTDIR)
1157 : : {
516 peter@eisentraut.org 1158 :UBC 0 : libpq_append_conn_error(conn, "could not open certificate file \"%s\": %s",
331 tgl@sss.pgh.pa.us 1159 : 0 : fnbuf, strerror_r(errno, sebuf, sizeof(sebuf)));
2746 heikki.linnakangas@i 1160 : 0 : SSL_CTX_free(SSL_context);
3534 1161 : 0 : return -1;
1162 : : }
3534 heikki.linnakangas@i 1163 :CBC 171 : have_cert = false;
1164 : : }
1165 : : else
1166 : : {
1167 : : /*
1168 : : * Cert file exists, so load it. Since OpenSSL doesn't provide the
1169 : : * equivalent of "SSL_use_certificate_chain_file", we have to load it
1170 : : * into the SSL context, rather than the SSL object.
1171 : : */
1172 [ - + ]: 38 : if (SSL_CTX_use_certificate_chain_file(SSL_context, fnbuf) != 1)
1173 : : {
2928 peter_e@gmx.net 1174 :UBC 0 : char *err = SSLerrmessage(ERR_get_error());
1175 : :
516 peter@eisentraut.org 1176 : 0 : libpq_append_conn_error(conn, "could not read certificate file \"%s\": %s",
1177 : : fnbuf, err);
3534 heikki.linnakangas@i 1178 : 0 : SSLerrfree(err);
2746 1179 : 0 : SSL_CTX_free(SSL_context);
3534 1180 : 0 : return -1;
1181 : : }
1182 : :
1183 : : /* need to load the associated private key, too */
3534 heikki.linnakangas@i 1184 :CBC 38 : have_cert = true;
1185 : : }
1186 : :
1187 : : /*
1188 : : * The SSL context is now loaded with the correct root and client
1189 : : * certificates. Create a connection-specific SSL object. The private key
1190 : : * is loaded directly into the SSL object. (We could load the private key
1191 : : * into the context, too, but we have done it this way historically, and
1192 : : * it doesn't really matter.)
1193 : : */
2746 1194 [ + - + - ]: 424 : if (!(conn->ssl = SSL_new(SSL_context)) ||
1195 [ - + ]: 424 : !SSL_set_app_data(conn->ssl, conn) ||
1196 : 212 : !my_SSL_set_fd(conn, conn->sock))
1197 : : {
2746 heikki.linnakangas@i 1198 :UBC 0 : char *err = SSLerrmessage(ERR_get_error());
1199 : :
516 peter@eisentraut.org 1200 : 0 : libpq_append_conn_error(conn, "could not establish SSL connection: %s", err);
2746 heikki.linnakangas@i 1201 : 0 : SSLerrfree(err);
1202 : 0 : SSL_CTX_free(SSL_context);
1203 : 0 : return -1;
1204 : : }
2746 heikki.linnakangas@i 1205 :CBC 212 : conn->ssl_in_use = true;
1206 : :
1207 : : /*
1208 : : * SSL contexts are reference counted by OpenSSL. We can free it as soon
1209 : : * as we have created the SSL object, and it will stick around for as long
1210 : : * as it's actually needed.
1211 : : */
1212 : 212 : SSL_CTX_free(SSL_context);
1213 : 212 : SSL_context = NULL;
1214 : :
1215 : : /*
1216 : : * Set Server Name Indication (SNI), if enabled by connection parameters.
1217 : : * Per RFC 6066, do not set it if the host is a literal IP address (IPv4
1218 : : * or IPv6).
1219 : : */
975 dgustafsson@postgres 1220 [ + - + - ]: 212 : if (conn->sslsni && conn->sslsni[0] == '1')
1221 : : {
1041 peter@eisentraut.org 1222 : 212 : const char *host = conn->connhost[conn->whichhost].host;
1223 : :
1224 [ + - + - ]: 212 : if (host && host[0] &&
1225 [ + + ]: 212 : !(strspn(host, "0123456789.") == strlen(host) ||
1226 [ + + ]: 202 : strchr(host, ':')))
1227 : : {
1228 [ - + ]: 195 : if (SSL_set_tlsext_host_name(conn->ssl, host) != 1)
1229 : : {
1041 peter@eisentraut.org 1230 :UBC 0 : char *err = SSLerrmessage(ERR_get_error());
1231 : :
516 1232 : 0 : libpq_append_conn_error(conn, "could not set SSL Server Name Indication (SNI): %s", err);
1041 1233 : 0 : SSLerrfree(err);
1234 : 0 : return -1;
1235 : : }
1236 : : }
1237 : : }
1238 : :
1239 : : /* Set ALPN */
1240 : : {
1241 : : int retval;
1242 : :
6 heikki.linnakangas@i 1243 :GNC 212 : retval = SSL_set_alpn_protos(conn->ssl, alpn_protos, sizeof(alpn_protos));
1244 : :
1245 [ - + ]: 212 : if (retval != 0)
1246 : : {
6 heikki.linnakangas@i 1247 :UNC 0 : char *err = SSLerrmessage(ERR_get_error());
1248 : :
5 1249 : 0 : libpq_append_conn_error(conn, "could not set SSL ALPN extension: %s", err);
6 1250 : 0 : SSLerrfree(err);
1251 : 0 : return -1;
1252 : : }
1253 : : }
1254 : :
1255 : : /*
1256 : : * Read the SSL key. If a key is specified, treat it as an engine:key
1257 : : * combination if there is colon present - we don't support files with
1258 : : * colon in the name. The exception is if the second character is a colon,
1259 : : * in which case it can be a Windows filename with drive specification.
1260 : : */
3534 heikki.linnakangas@i 1261 [ + + + - :CBC 212 : if (have_cert && conn->sslkey && strlen(conn->sslkey) > 0)
+ - ]
1262 : : {
1263 : : #ifdef USE_SSL_ENGINE
1264 [ - + ]: 76 : if (strchr(conn->sslkey, ':')
1265 : : #ifdef WIN32
1266 : : && conn->sslkey[1] != ':'
1267 : : #endif
1268 : : )
1269 : : {
1270 : : /* Colon, but not in second character, treat as engine:key */
3534 heikki.linnakangas@i 1271 :UBC 0 : char *engine_str = strdup(conn->sslkey);
1272 : : char *engine_colon;
1273 : : EVP_PKEY *pkey;
1274 : :
1275 [ # # ]: 0 : if (engine_str == NULL)
1276 : : {
516 peter@eisentraut.org 1277 : 0 : libpq_append_conn_error(conn, "out of memory");
3534 heikki.linnakangas@i 1278 : 0 : return -1;
1279 : : }
1280 : :
1281 : : /* cannot return NULL because we already checked before strdup */
1282 : 0 : engine_colon = strchr(engine_str, ':');
1283 : :
2489 tgl@sss.pgh.pa.us 1284 : 0 : *engine_colon = '\0'; /* engine_str now has engine name */
3534 heikki.linnakangas@i 1285 : 0 : engine_colon++; /* engine_colon now has key name */
1286 : :
1287 : 0 : conn->engine = ENGINE_by_id(engine_str);
1288 [ # # ]: 0 : if (conn->engine == NULL)
1289 : : {
2928 peter_e@gmx.net 1290 : 0 : char *err = SSLerrmessage(ERR_get_error());
1291 : :
516 peter@eisentraut.org 1292 : 0 : libpq_append_conn_error(conn, "could not load SSL engine \"%s\": %s",
1293 : : engine_str, err);
3534 heikki.linnakangas@i 1294 : 0 : SSLerrfree(err);
1295 : 0 : free(engine_str);
1296 : 0 : return -1;
1297 : : }
1298 : :
1299 [ # # ]: 0 : if (ENGINE_init(conn->engine) == 0)
1300 : : {
2928 peter_e@gmx.net 1301 : 0 : char *err = SSLerrmessage(ERR_get_error());
1302 : :
516 peter@eisentraut.org 1303 : 0 : libpq_append_conn_error(conn, "could not initialize SSL engine \"%s\": %s",
1304 : : engine_str, err);
3534 heikki.linnakangas@i 1305 : 0 : SSLerrfree(err);
1306 : 0 : ENGINE_free(conn->engine);
1307 : 0 : conn->engine = NULL;
1308 : 0 : free(engine_str);
1309 : 0 : return -1;
1310 : : }
1311 : :
1312 : 0 : pkey = ENGINE_load_private_key(conn->engine, engine_colon,
1313 : : NULL, NULL);
1314 [ # # ]: 0 : if (pkey == NULL)
1315 : : {
2928 peter_e@gmx.net 1316 : 0 : char *err = SSLerrmessage(ERR_get_error());
1317 : :
516 peter@eisentraut.org 1318 : 0 : libpq_append_conn_error(conn, "could not read private SSL key \"%s\" from engine \"%s\": %s",
1319 : : engine_colon, engine_str, err);
3534 heikki.linnakangas@i 1320 : 0 : SSLerrfree(err);
1321 : 0 : ENGINE_finish(conn->engine);
1322 : 0 : ENGINE_free(conn->engine);
1323 : 0 : conn->engine = NULL;
1324 : 0 : free(engine_str);
1325 : 0 : return -1;
1326 : : }
1327 [ # # ]: 0 : if (SSL_use_PrivateKey(conn->ssl, pkey) != 1)
1328 : : {
2928 peter_e@gmx.net 1329 : 0 : char *err = SSLerrmessage(ERR_get_error());
1330 : :
516 peter@eisentraut.org 1331 : 0 : libpq_append_conn_error(conn, "could not load private SSL key \"%s\" from engine \"%s\": %s",
1332 : : engine_colon, engine_str, err);
3534 heikki.linnakangas@i 1333 : 0 : SSLerrfree(err);
1334 : 0 : ENGINE_finish(conn->engine);
1335 : 0 : ENGINE_free(conn->engine);
1336 : 0 : conn->engine = NULL;
1337 : 0 : free(engine_str);
1338 : 0 : return -1;
1339 : : }
1340 : :
1341 : 0 : free(engine_str);
1342 : :
1343 : 0 : fnbuf[0] = '\0'; /* indicate we're not going to load from a
1344 : : * file */
1345 : : }
1346 : : else
1347 : : #endif /* USE_SSL_ENGINE */
1348 : : {
1349 : : /* PGSSLKEY is not an engine, treat it as a filename */
3368 tgl@sss.pgh.pa.us 1350 :CBC 38 : strlcpy(fnbuf, conn->sslkey, sizeof(fnbuf));
1351 : : }
1352 : : }
3534 heikki.linnakangas@i 1353 [ + + ]: 174 : else if (have_homedir)
1354 : : {
1355 : : /* No PGSSLKEY specified, load default file */
1356 : 106 : snprintf(fnbuf, sizeof(fnbuf), "%s/%s", homedir, USER_KEY_FILE);
1357 : : }
1358 : : else
1359 : 68 : fnbuf[0] = '\0';
1360 : :
1361 [ + + + - ]: 212 : if (have_cert && fnbuf[0] != '\0')
1362 : : {
1363 : : /* read the client key from file */
1364 : :
1365 [ - + ]: 38 : if (stat(fnbuf, &buf) != 0)
1366 : : {
866 dgustafsson@postgres 1367 [ # # ]:UBC 0 : if (errno == ENOENT)
516 peter@eisentraut.org 1368 : 0 : libpq_append_conn_error(conn, "certificate present, but not private key file \"%s\"",
1369 : : fnbuf);
1370 : : else
1371 : 0 : libpq_append_conn_error(conn, "could not stat private key file \"%s\": %m",
1372 : : fnbuf);
3534 heikki.linnakangas@i 1373 : 0 : return -1;
1374 : : }
1375 : :
1376 : : /* Key file must be a regular file */
776 tgl@sss.pgh.pa.us 1377 [ - + ]:CBC 38 : if (!S_ISREG(buf.st_mode))
1378 : : {
516 peter@eisentraut.org 1379 :UBC 0 : libpq_append_conn_error(conn, "private key file \"%s\" is not a regular file",
1380 : : fnbuf);
776 tgl@sss.pgh.pa.us 1381 : 0 : return -1;
1382 : : }
1383 : :
1384 : : /*
1385 : : * Refuse to load world-readable key files. We accept root-owned
1386 : : * files with mode 0640 or less, so that we can access system-wide
1387 : : * certificates if we have a supplementary group membership that
1388 : : * allows us to read 'em. For files with non-root ownership, require
1389 : : * mode 0600 or less. We need not check the file's ownership exactly;
1390 : : * if we're able to read it despite it having such restrictive
1391 : : * permissions, it must have the right ownership.
1392 : : *
1393 : : * Note: be very careful about tightening these rules. Some people
1394 : : * expect, for example, that a client process running as root should
1395 : : * be able to use a non-root-owned key file.
1396 : : *
1397 : : * Note that roughly similar checks are performed in
1398 : : * src/backend/libpq/be-secure-common.c so any changes here may need
1399 : : * to be made there as well. However, this code caters for the case
1400 : : * of current user == root, while that code does not.
1401 : : *
1402 : : * Ideally we would do similar permissions checks on Windows, but it
1403 : : * is not clear how that would work since Unix-style permissions may
1404 : : * not be available.
1405 : : */
1406 : : #if !defined(WIN32) && !defined(__CYGWIN__)
689 tgl@sss.pgh.pa.us 1407 [ - + + + ]:CBC 76 : if (buf.st_uid == 0 ?
689 tgl@sss.pgh.pa.us 1408 :UBC 0 : buf.st_mode & (S_IWGRP | S_IXGRP | S_IRWXO) :
689 tgl@sss.pgh.pa.us 1409 :CBC 38 : buf.st_mode & (S_IRWXG | S_IRWXO))
1410 : : {
516 peter@eisentraut.org 1411 : 1 : libpq_append_conn_error(conn,
1412 : : "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",
1413 : : fnbuf);
3534 heikki.linnakangas@i 1414 : 1 : return -1;
1415 : : }
1416 : : #endif
1417 : :
1418 [ + + ]: 37 : if (SSL_use_PrivateKey_file(conn->ssl, fnbuf, SSL_FILETYPE_PEM) != 1)
1419 : : {
2928 peter_e@gmx.net 1420 : 3 : char *err = SSLerrmessage(ERR_get_error());
1421 : :
1422 : : /*
1423 : : * We'll try to load the file in DER (binary ASN.1) format, and if
1424 : : * that fails too, report the original error. This could mask
1425 : : * issues where there's something wrong with a DER-format cert,
1426 : : * but we'd have to duplicate openssl's format detection to be
1427 : : * smarter than this. We can't just probe for a leading -----BEGIN
1428 : : * because PEM can have leading non-matching lines and blanks.
1429 : : * OpenSSL doesn't expose its get_name(...) and its PEM routines
1430 : : * don't differentiate between failure modes in enough detail to
1431 : : * let us tell the difference between "not PEM, try DER" and
1432 : : * "wrong password".
1433 : : */
1597 andrew@dunslane.net 1434 [ + + ]: 3 : if (SSL_use_PrivateKey_file(conn->ssl, fnbuf, SSL_FILETYPE_ASN1) != 1)
1435 : : {
516 peter@eisentraut.org 1436 : 1 : libpq_append_conn_error(conn, "could not load private key file \"%s\": %s",
1437 : : fnbuf, err);
1597 andrew@dunslane.net 1438 : 1 : SSLerrfree(err);
1439 : 1 : return -1;
1440 : : }
1441 : :
3534 heikki.linnakangas@i 1442 : 2 : SSLerrfree(err);
1443 : : }
1444 : : }
1445 : :
1446 : : /* verify that the cert and key go together */
1447 [ + + - + ]: 246 : if (have_cert &&
1448 : 36 : SSL_check_private_key(conn->ssl) != 1)
1449 : : {
2928 peter_e@gmx.net 1450 :UBC 0 : char *err = SSLerrmessage(ERR_get_error());
1451 : :
516 peter@eisentraut.org 1452 : 0 : libpq_append_conn_error(conn, "certificate does not match private key file \"%s\": %s",
1453 : : fnbuf, err);
3534 heikki.linnakangas@i 1454 : 0 : SSLerrfree(err);
1455 : 0 : return -1;
1456 : : }
1457 : :
1458 : : /*
1459 : : * If a root cert was loaded, also set our certificate verification
1460 : : * callback.
1461 : : */
2746 heikki.linnakangas@i 1462 [ + + ]:CBC 210 : if (have_rootcert)
3534 1463 : 100 : SSL_set_verify(conn->ssl, SSL_VERIFY_PEER, verify_cb);
1464 : :
1465 : : /*
1466 : : * Set compression option if necessary.
1467 : : */
1131 michael@paquier.xyz 1468 [ + - + - ]: 210 : if (conn->sslcompression && conn->sslcompression[0] == '0')
1469 : 210 : SSL_set_options(conn->ssl, SSL_OP_NO_COMPRESSION);
1470 : : else
1131 michael@paquier.xyz 1471 :UBC 0 : SSL_clear_options(conn->ssl, SSL_OP_NO_COMPRESSION);
1472 : :
3534 heikki.linnakangas@i 1473 :CBC 210 : return 0;
1474 : : }
1475 : :
1476 : : /*
1477 : : * Attempt to negotiate SSL connection.
1478 : : */
1479 : : static PostgresPollingStatusType
1480 : 594 : open_client_SSL(PGconn *conn)
1481 : : {
1482 : : int r;
1483 : :
361 dgustafsson@postgres 1484 : 594 : SOCK_ERRNO_SET(0);
2928 peter_e@gmx.net 1485 : 594 : ERR_clear_error();
3534 heikki.linnakangas@i 1486 : 594 : r = SSL_connect(conn->ssl);
1487 [ + + ]: 594 : if (r <= 0)
1488 : : {
361 dgustafsson@postgres 1489 : 419 : int save_errno = SOCK_ERRNO;
3534 heikki.linnakangas@i 1490 : 419 : int err = SSL_get_error(conn->ssl, r);
1491 : : unsigned long ecode;
1492 : :
2928 peter_e@gmx.net 1493 : 419 : ecode = ERR_get_error();
3534 heikki.linnakangas@i 1494 [ + - + + : 419 : switch (err)
- ]
1495 : : {
1496 : 384 : case SSL_ERROR_WANT_READ:
1497 : 384 : return PGRES_POLLING_READING;
1498 : :
3534 heikki.linnakangas@i 1499 :UBC 0 : case SSL_ERROR_WANT_WRITE:
1500 : 0 : return PGRES_POLLING_WRITING;
1501 : :
3534 heikki.linnakangas@i 1502 :GBC 26 : case SSL_ERROR_SYSCALL:
1503 : : {
1504 : : char sebuf[PG_STRERROR_R_BUFLEN];
1505 : : unsigned long vcode;
1506 : :
361 dgustafsson@postgres 1507 : 26 : vcode = SSL_get_verify_result(conn->ssl);
1508 : :
1509 : : /*
1510 : : * If we get an X509 error here for failing to load the
1511 : : * local issuer cert, without an error in the socket layer
1512 : : * it means that verification failed due to a missing
1513 : : * system CA pool without it being a protocol error. We
1514 : : * inspect the sslrootcert setting to ensure that the user
1515 : : * was using the system CA pool. For other errors, log
1516 : : * them using the normal SYSCALL logging.
1517 : : */
125 tgl@sss.pgh.pa.us 1518 [ + - - + ]: 26 : if (save_errno == 0 &&
125 tgl@sss.pgh.pa.us 1519 :UBC 0 : vcode == X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY &&
361 dgustafsson@postgres 1520 [ # # ]: 0 : strcmp(conn->sslrootcert, "system") == 0)
1521 : 0 : libpq_append_conn_error(conn, "SSL error: certificate verify failed: %s",
1522 : : X509_verify_cert_error_string(vcode));
125 tgl@sss.pgh.pa.us 1523 [ + - - + ]:GBC 26 : else if (r == -1 && save_errno != 0)
516 peter@eisentraut.org 1524 :UBC 0 : libpq_append_conn_error(conn, "SSL SYSCALL error: %s",
1525 : : SOCK_STRERROR(save_errno, sebuf, sizeof(sebuf)));
1526 : : else
516 peter@eisentraut.org 1527 :GBC 26 : libpq_append_conn_error(conn, "SSL SYSCALL error: EOF detected");
3534 heikki.linnakangas@i 1528 : 26 : pgtls_close(conn);
1529 : 26 : return PGRES_POLLING_FAILED;
1530 : : }
3534 heikki.linnakangas@i 1531 :CBC 9 : case SSL_ERROR_SSL:
1532 : : {
2928 peter_e@gmx.net 1533 : 9 : char *err = SSLerrmessage(ecode);
1534 : :
516 peter@eisentraut.org 1535 : 9 : libpq_append_conn_error(conn, "SSL error: %s", err);
3534 heikki.linnakangas@i 1536 : 9 : SSLerrfree(err);
1387 tgl@sss.pgh.pa.us 1537 : 9 : switch (ERR_GET_REASON(ecode))
1538 : : {
1539 : : /*
1540 : : * UNSUPPORTED_PROTOCOL, WRONG_VERSION_NUMBER, and
1541 : : * TLSV1_ALERT_PROTOCOL_VERSION have been observed
1542 : : * when trying to communicate with an old OpenSSL
1543 : : * library, or when the client and server specify
1544 : : * disjoint protocol ranges.
1545 : : * NO_PROTOCOLS_AVAILABLE occurs if there's a
1546 : : * local misconfiguration (which can happen
1547 : : * despite our checks, if openssl.cnf injects a
1548 : : * limit we didn't account for). It's not very
1549 : : * clear what would make OpenSSL return the other
1550 : : * codes listed here, but a hint about protocol
1551 : : * versions seems like it's appropriate for all.
1552 : : */
1387 tgl@sss.pgh.pa.us 1553 :UBC 0 : case SSL_R_NO_PROTOCOLS_AVAILABLE:
1554 : : case SSL_R_UNSUPPORTED_PROTOCOL:
1555 : : case SSL_R_BAD_PROTOCOL_VERSION_NUMBER:
1556 : : case SSL_R_UNKNOWN_PROTOCOL:
1557 : : case SSL_R_UNKNOWN_SSL_VERSION:
1558 : : case SSL_R_UNSUPPORTED_SSL_VERSION:
1559 : : case SSL_R_WRONG_SSL_VERSION:
1560 : : case SSL_R_WRONG_VERSION_NUMBER:
1561 : : case SSL_R_TLSV1_ALERT_PROTOCOL_VERSION:
1562 : : #ifdef SSL_R_VERSION_TOO_HIGH
1563 : : case SSL_R_VERSION_TOO_HIGH:
1564 : : case SSL_R_VERSION_TOO_LOW:
1565 : : #endif
516 peter@eisentraut.org 1566 : 0 : libpq_append_conn_error(conn, "This may indicate that the server does not support any SSL protocol version between %s and %s.",
331 tgl@sss.pgh.pa.us 1567 [ # # ]: 0 : conn->ssl_min_protocol_version ?
1568 : : conn->ssl_min_protocol_version :
1569 : : MIN_OPENSSL_TLS_VERSION,
1570 [ # # ]: 0 : conn->ssl_max_protocol_version ?
1571 : : conn->ssl_max_protocol_version :
1572 : : MAX_OPENSSL_TLS_VERSION);
1387 1573 : 0 : break;
1387 tgl@sss.pgh.pa.us 1574 :CBC 9 : default:
1575 : 9 : break;
1576 : : }
3534 heikki.linnakangas@i 1577 : 9 : pgtls_close(conn);
1578 : 9 : return PGRES_POLLING_FAILED;
1579 : : }
1580 : :
3534 heikki.linnakangas@i 1581 :UBC 0 : default:
516 peter@eisentraut.org 1582 : 0 : libpq_append_conn_error(conn, "unrecognized SSL error code: %d", err);
3534 heikki.linnakangas@i 1583 : 0 : pgtls_close(conn);
1584 : 0 : return PGRES_POLLING_FAILED;
1585 : : }
1586 : : }
1587 : :
1588 : : /*
1589 : : * We already checked the server certificate in initialize_SSL() using
1590 : : * SSL_CTX_set_verify(), if root.crt exists.
1591 : : */
1592 : :
1593 : : /* get server certificate */
3534 heikki.linnakangas@i 1594 :CBC 175 : conn->peer = SSL_get_peer_certificate(conn->ssl);
1595 [ - + ]: 175 : if (conn->peer == NULL)
1596 : : {
1533 tgl@sss.pgh.pa.us 1597 :UBC 0 : char *err = SSLerrmessage(ERR_get_error());
1598 : :
516 peter@eisentraut.org 1599 : 0 : libpq_append_conn_error(conn, "certificate could not be obtained: %s", err);
3534 heikki.linnakangas@i 1600 : 0 : SSLerrfree(err);
1601 : 0 : pgtls_close(conn);
1602 : 0 : return PGRES_POLLING_FAILED;
1603 : : }
1604 : :
2269 peter_e@gmx.net 1605 [ + + ]:CBC 175 : if (!pq_verify_peer_name_matches_certificate(conn))
1606 : : {
3534 heikki.linnakangas@i 1607 : 13 : pgtls_close(conn);
1608 : 13 : return PGRES_POLLING_FAILED;
1609 : : }
1610 : :
1611 : : /* SSL handshake is complete */
1612 : 162 : return PGRES_POLLING_OK;
1613 : : }
1614 : :
1615 : : void
1616 : 24934 : pgtls_close(PGconn *conn)
1617 : : {
1618 : 24934 : bool destroy_needed = false;
1619 : :
1130 michael@paquier.xyz 1620 [ + + ]: 24934 : if (conn->ssl_in_use)
1621 : : {
1622 [ + - ]: 212 : if (conn->ssl)
1623 : : {
1624 : : /*
1625 : : * We can't destroy everything SSL-related here due to the
1626 : : * possible later calls to OpenSSL routines which may need our
1627 : : * thread callbacks, so set a flag here and check at the end.
1628 : : */
1629 : :
1630 : 212 : SSL_shutdown(conn->ssl);
1631 : 212 : SSL_free(conn->ssl);
1632 : 212 : conn->ssl = NULL;
1633 : 212 : conn->ssl_in_use = false;
6 heikki.linnakangas@i 1634 :GNC 212 : conn->ssl_handshake_started = false;
1635 : :
1130 michael@paquier.xyz 1636 :CBC 212 : destroy_needed = true;
1637 : : }
1638 : :
1639 [ + + ]: 212 : if (conn->peer)
1640 : : {
1641 : 175 : X509_free(conn->peer);
1642 : 175 : conn->peer = NULL;
1643 : : }
1644 : :
1645 : : #ifdef USE_SSL_ENGINE
1646 [ - + ]: 212 : if (conn->engine)
1647 : : {
1130 michael@paquier.xyz 1648 :UBC 0 : ENGINE_finish(conn->engine);
1649 : 0 : ENGINE_free(conn->engine);
1650 : 0 : conn->engine = NULL;
1651 : : }
1652 : : #endif
1653 : : }
1654 : : else
1655 : : {
1656 : : /*
1657 : : * In the non-SSL case, just remove the crypto callbacks if the
1658 : : * connection has then loaded. This code path has no dependency on
1659 : : * any pending SSL calls.
1660 : : */
1130 michael@paquier.xyz 1661 [ - + ]:CBC 24722 : if (conn->crypto_loaded)
1130 michael@paquier.xyz 1662 :UBC 0 : destroy_needed = true;
1663 : : }
1664 : :
1665 : : /*
1666 : : * This will remove our crypto locking hooks if this is the last
1667 : : * connection using libcrypto which means we must wait to call it until
1668 : : * after all the potential SSL calls have been made, otherwise we can end
1669 : : * up with a race condition and possible deadlocks.
1670 : : *
1671 : : * See comments above destroy_ssl_system().
1672 : : */
3534 heikki.linnakangas@i 1673 [ + + ]:CBC 24934 : if (destroy_needed)
1674 : : {
1675 : 212 : destroy_ssl_system();
1130 michael@paquier.xyz 1676 : 212 : conn->crypto_loaded = false;
1677 : : }
3534 heikki.linnakangas@i 1678 : 24934 : }
1679 : :
1680 : :
1681 : : /*
1682 : : * Obtain reason string for passed SSL errcode
1683 : : *
1684 : : * ERR_get_error() is used by caller to get errcode to pass here.
1685 : : * The result must be freed after use, using SSLerrfree.
1686 : : *
1687 : : * Some caution is needed here since ERR_reason_error_string will return NULL
1688 : : * if it doesn't recognize the error code, or (in OpenSSL >= 3) if the code
1689 : : * represents a system errno value. We don't want to return NULL ever.
1690 : : */
1691 : : static char ssl_nomem[] = "out of memory allocating error description";
1692 : :
1693 : : #define SSL_ERR_LEN 128
1694 : :
1695 : : static char *
2928 peter_e@gmx.net 1696 : 18 : SSLerrmessage(unsigned long ecode)
1697 : : {
1698 : : const char *errreason;
1699 : : char *errbuf;
1700 : :
3534 heikki.linnakangas@i 1701 : 18 : errbuf = malloc(SSL_ERR_LEN);
1702 [ - + ]: 18 : if (!errbuf)
3534 heikki.linnakangas@i 1703 :UBC 0 : return ssl_nomem;
2928 peter_e@gmx.net 1704 [ - + ]:CBC 18 : if (ecode == 0)
1705 : : {
3534 heikki.linnakangas@i 1706 :UBC 0 : snprintf(errbuf, SSL_ERR_LEN, libpq_gettext("no SSL error reported"));
1707 : 0 : return errbuf;
1708 : : }
2928 peter_e@gmx.net 1709 :CBC 18 : errreason = ERR_reason_error_string(ecode);
3534 heikki.linnakangas@i 1710 [ + - ]: 18 : if (errreason != NULL)
1711 : : {
1712 : 18 : strlcpy(errbuf, errreason, SSL_ERR_LEN);
1713 : 18 : return errbuf;
1714 : : }
1715 : :
1716 : : /*
1717 : : * In OpenSSL 3.0.0 and later, ERR_reason_error_string randomly refuses to
1718 : : * map system errno values. We can cover that shortcoming with this bit
1719 : : * of code. Older OpenSSL versions don't have the ERR_SYSTEM_ERROR macro,
1720 : : * but that's okay because they don't have the shortcoming either.
1721 : : */
1722 : : #ifdef ERR_SYSTEM_ERROR
38 tgl@sss.pgh.pa.us 1723 [ # # ]:UBC 0 : if (ERR_SYSTEM_ERROR(ecode))
1724 : : {
1725 : 0 : strlcpy(errbuf, strerror(ERR_GET_REASON(ecode)), SSL_ERR_LEN);
1726 : 0 : return errbuf;
1727 : : }
1728 : : #endif
1729 : :
1730 : : /* No choice but to report the numeric ecode */
2928 peter_e@gmx.net 1731 : 0 : snprintf(errbuf, SSL_ERR_LEN, libpq_gettext("SSL error code %lu"), ecode);
3534 heikki.linnakangas@i 1732 : 0 : return errbuf;
1733 : : }
1734 : :
1735 : : static void
3534 heikki.linnakangas@i 1736 :CBC 18 : SSLerrfree(char *buf)
1737 : : {
1738 [ + - ]: 18 : if (buf != ssl_nomem)
1739 : 18 : free(buf);
1740 : 18 : }
1741 : :
1742 : : /* ------------------------------------------------------------ */
1743 : : /* SSL information functions */
1744 : : /* ------------------------------------------------------------ */
1745 : :
1746 : : /*
1747 : : * Return pointer to OpenSSL object.
1748 : : */
1749 : : void *
3534 heikki.linnakangas@i 1750 :UBC 0 : PQgetssl(PGconn *conn)
1751 : : {
1752 [ # # ]: 0 : if (!conn)
1753 : 0 : return NULL;
1754 : 0 : return conn->ssl;
1755 : : }
1756 : :
1757 : : void *
3358 1758 : 0 : PQsslStruct(PGconn *conn, const char *struct_name)
1759 : : {
1760 [ # # ]: 0 : if (!conn)
1761 : 0 : return NULL;
1762 [ # # ]: 0 : if (strcmp(struct_name, "OpenSSL") == 0)
1763 : 0 : return conn->ssl;
1764 : 0 : return NULL;
1765 : : }
1766 : :
1767 : : const char *const *
3081 tgl@sss.pgh.pa.us 1768 : 0 : PQsslAttributeNames(PGconn *conn)
1769 : : {
1770 : : static const char *const openssl_attrs[] = {
1771 : : "library",
1772 : : "key_bits",
1773 : : "cipher",
1774 : : "compression",
1775 : : "protocol",
1776 : : "alpn",
1777 : : NULL
1778 : : };
1779 : : static const char *const empty_attrs[] = {NULL};
1780 : :
562 1781 [ # # ]: 0 : if (!conn)
1782 : : {
1783 : : /* Return attributes of default SSL library */
1784 : 0 : return openssl_attrs;
1785 : : }
1786 : :
1787 : : /* No attrs for unencrypted connection */
1788 [ # # ]: 0 : if (conn->ssl == NULL)
1789 : 0 : return empty_attrs;
1790 : :
1791 : 0 : return openssl_attrs;
1792 : : }
1793 : :
1794 : : const char *
3358 heikki.linnakangas@i 1795 :CBC 1 : PQsslAttribute(PGconn *conn, const char *attribute_name)
1796 : : {
1797 [ + - ]: 1 : if (!conn)
1798 : : {
1799 : : /* PQsslAttribute(NULL, "library") reports the default SSL library */
563 tgl@sss.pgh.pa.us 1800 [ + - ]: 1 : if (strcmp(attribute_name, "library") == 0)
1801 : 1 : return "OpenSSL";
3358 heikki.linnakangas@i 1802 :UBC 0 : return NULL;
1803 : : }
1804 : :
1805 : : /* All attributes read as NULL for a non-encrypted connection */
1806 [ # # ]: 0 : if (conn->ssl == NULL)
1807 : 0 : return NULL;
1808 : :
563 tgl@sss.pgh.pa.us 1809 [ # # ]: 0 : if (strcmp(attribute_name, "library") == 0)
1810 : 0 : return "OpenSSL";
1811 : :
3358 heikki.linnakangas@i 1812 [ # # ]: 0 : if (strcmp(attribute_name, "key_bits") == 0)
1813 : : {
1814 : : static char sslbits_str[12];
1815 : : int sslbits;
1816 : :
1817 : 0 : SSL_get_cipher_bits(conn->ssl, &sslbits);
1818 : 0 : snprintf(sslbits_str, sizeof(sslbits_str), "%d", sslbits);
1819 : 0 : return sslbits_str;
1820 : : }
1821 : :
1822 [ # # ]: 0 : if (strcmp(attribute_name, "cipher") == 0)
1823 : 0 : return SSL_get_cipher(conn->ssl);
1824 : :
1825 [ # # ]: 0 : if (strcmp(attribute_name, "compression") == 0)
1131 michael@paquier.xyz 1826 [ # # ]: 0 : return SSL_get_current_compression(conn->ssl) ? "on" : "off";
1827 : :
3358 heikki.linnakangas@i 1828 [ # # ]: 0 : if (strcmp(attribute_name, "protocol") == 0)
1829 : 0 : return SSL_get_version(conn->ssl);
1830 : :
6 heikki.linnakangas@i 1831 [ # # ]:UNC 0 : if (strcmp(attribute_name, "alpn") == 0)
1832 : : {
1833 : : const unsigned char *data;
1834 : : unsigned int len;
1835 : : static char alpn_str[256]; /* alpn doesn't support longer than 255
1836 : : * bytes */
1837 : :
1838 : 0 : SSL_get0_alpn_selected(conn->ssl, &data, &len);
1839 [ # # # # : 0 : if (data == NULL || len == 0 || len > sizeof(alpn_str) - 1)
# # ]
1840 : 0 : return NULL;
1841 : 0 : memcpy(alpn_str, data, len);
1842 : 0 : alpn_str[len] = 0;
1843 : 0 : return alpn_str;
1844 : : }
1845 : :
3249 bruce@momjian.us 1846 :UBC 0 : return NULL; /* unknown attribute */
1847 : : }
1848 : :
1849 : : /*
1850 : : * Private substitute BIO: this does the sending and receiving using
1851 : : * pqsecure_raw_write() and pqsecure_raw_read() instead, to allow those
1852 : : * functions to disable SIGPIPE and give better error messages on I/O errors.
1853 : : *
1854 : : * These functions are closely modelled on the standard socket BIO in OpenSSL;
1855 : : * see sock_read() and sock_write() in OpenSSL's crypto/bio/bss_sock.c.
1856 : : */
1857 : :
1858 : : /* protected by ssl_config_mutex */
1859 : : static BIO_METHOD *my_bio_methods;
1860 : :
1861 : : static int
3534 heikki.linnakangas@i 1862 :CBC 4674 : my_sock_read(BIO *h, char *buf, int size)
1863 : : {
6 heikki.linnakangas@i 1864 :GNC 4674 : PGconn *conn = (PGconn *) BIO_get_app_data(h);
1865 : : int res;
1866 : :
1867 : 4674 : res = pqsecure_raw_read(conn, buf, size);
3534 heikki.linnakangas@i 1868 :CBC 4674 : BIO_clear_retry_flags(h);
1869 [ + + ]: 4674 : if (res < 0)
1870 : : {
1871 : : /* If we were interrupted, tell caller to retry */
3121 tgl@sss.pgh.pa.us 1872 [ + - ]: 664 : switch (SOCK_ERRNO)
1873 : : {
1874 : : #ifdef EAGAIN
3534 heikki.linnakangas@i 1875 : 664 : case EAGAIN:
1876 : : #endif
1877 : : #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
1878 : : case EWOULDBLOCK:
1879 : : #endif
1880 : : case EINTR:
1881 : 664 : BIO_set_retry_read(h);
1882 : 664 : break;
1883 : :
3534 heikki.linnakangas@i 1884 :UBC 0 : default:
1885 : 0 : break;
1886 : : }
1887 : : }
1888 : :
6 heikki.linnakangas@i 1889 [ + + ]:GNC 4674 : if (res > 0)
1890 : 3984 : conn->ssl_handshake_started = true;
1891 : :
3534 heikki.linnakangas@i 1892 :CBC 4674 : return res;
1893 : : }
1894 : :
1895 : : static int
1896 : 1175 : my_sock_write(BIO *h, const char *buf, int size)
1897 : : {
1898 : : int res;
1899 : :
138 tgl@sss.pgh.pa.us 1900 : 1175 : res = pqsecure_raw_write((PGconn *) BIO_get_app_data(h), buf, size);
3534 heikki.linnakangas@i 1901 : 1175 : BIO_clear_retry_flags(h);
792 tgl@sss.pgh.pa.us 1902 [ - + ]: 1175 : if (res < 0)
1903 : : {
1904 : : /* If we were interrupted, tell caller to retry */
3121 tgl@sss.pgh.pa.us 1905 [ # # ]:UBC 0 : switch (SOCK_ERRNO)
1906 : : {
1907 : : #ifdef EAGAIN
1908 : 0 : case EAGAIN:
1909 : : #endif
1910 : : #if defined(EWOULDBLOCK) && (!defined(EAGAIN) || (EWOULDBLOCK != EAGAIN))
1911 : : case EWOULDBLOCK:
1912 : : #endif
1913 : : case EINTR:
1914 : 0 : BIO_set_retry_write(h);
1915 : 0 : break;
1916 : :
1917 : 0 : default:
1918 : 0 : break;
1919 : : }
1920 : : }
1921 : :
3534 heikki.linnakangas@i 1922 :CBC 1175 : return res;
1923 : : }
1924 : :
1925 : : static BIO_METHOD *
1926 : 212 : my_BIO_s_socket(void)
1927 : : {
1928 : : BIO_METHOD *res;
1929 : :
139 michael@paquier.xyz 1930 [ - + ]: 212 : if (pthread_mutex_lock(&ssl_config_mutex))
139 michael@paquier.xyz 1931 :UBC 0 : return NULL;
1932 : :
139 michael@paquier.xyz 1933 :CBC 212 : res = my_bio_methods;
1934 : :
2768 heikki.linnakangas@i 1935 [ + - ]: 212 : if (!my_bio_methods)
1936 : : {
1937 : 212 : BIO_METHOD *biom = (BIO_METHOD *) BIO_s_socket();
1938 : : #ifdef HAVE_BIO_METH_NEW
1939 : : int my_bio_index;
1940 : :
1941 : 212 : my_bio_index = BIO_get_new_index();
1942 [ - + ]: 212 : if (my_bio_index == -1)
139 michael@paquier.xyz 1943 :UBC 0 : goto err;
971 dgustafsson@postgres 1944 :CBC 212 : my_bio_index |= (BIO_TYPE_DESCRIPTOR | BIO_TYPE_SOURCE_SINK);
139 michael@paquier.xyz 1945 : 212 : res = BIO_meth_new(my_bio_index, "libpq socket");
1946 [ - + ]: 212 : if (!res)
139 michael@paquier.xyz 1947 :UBC 0 : goto err;
1948 : :
1949 : : /*
1950 : : * As of this writing, these functions never fail. But check anyway,
1951 : : * like OpenSSL's own examples do.
1952 : : */
139 michael@paquier.xyz 1953 [ + - + - ]:CBC 424 : if (!BIO_meth_set_write(res, my_sock_write) ||
1954 [ + - ]: 424 : !BIO_meth_set_read(res, my_sock_read) ||
1955 [ + - ]: 424 : !BIO_meth_set_gets(res, BIO_meth_get_gets(biom)) ||
1956 [ + - ]: 424 : !BIO_meth_set_puts(res, BIO_meth_get_puts(biom)) ||
1957 [ + - ]: 424 : !BIO_meth_set_ctrl(res, BIO_meth_get_ctrl(biom)) ||
1958 [ + - ]: 424 : !BIO_meth_set_create(res, BIO_meth_get_create(biom)) ||
1959 [ - + ]: 424 : !BIO_meth_set_destroy(res, BIO_meth_get_destroy(biom)) ||
1960 : 212 : !BIO_meth_set_callback_ctrl(res, BIO_meth_get_callback_ctrl(biom)))
1961 : : {
139 michael@paquier.xyz 1962 :UBC 0 : goto err;
1963 : : }
1964 : : #else
1965 : : res = malloc(sizeof(BIO_METHOD));
1966 : : if (!res)
1967 : : goto err;
1968 : : memcpy(res, biom, sizeof(BIO_METHOD));
1969 : : res->bread = my_sock_read;
1970 : : res->bwrite = my_sock_write;
1971 : : #endif
1972 : : }
1973 : :
139 michael@paquier.xyz 1974 :CBC 212 : my_bio_methods = res;
1975 : 212 : pthread_mutex_unlock(&ssl_config_mutex);
1976 : 212 : return res;
1977 : :
139 michael@paquier.xyz 1978 :UBC 0 : err:
1979 : : #ifdef HAVE_BIO_METH_NEW
1980 [ # # ]: 0 : if (res)
1981 : 0 : BIO_meth_free(res);
1982 : : #else
1983 : : if (res)
1984 : : free(res);
1985 : : #endif
1986 : 0 : pthread_mutex_unlock(&ssl_config_mutex);
1987 : 0 : return NULL;
1988 : : }
1989 : :
1990 : : /* This should exactly match OpenSSL's SSL_set_fd except for using my BIO */
1991 : : static int
3534 heikki.linnakangas@i 1992 :CBC 212 : my_SSL_set_fd(PGconn *conn, int fd)
1993 : : {
1994 : 212 : int ret = 0;
1995 : : BIO *bio;
1996 : : BIO_METHOD *bio_method;
1997 : :
2768 1998 : 212 : bio_method = my_BIO_s_socket();
1999 [ - + ]: 212 : if (bio_method == NULL)
2000 : : {
2768 heikki.linnakangas@i 2001 :UBC 0 : SSLerr(SSL_F_SSL_SET_FD, ERR_R_BUF_LIB);
2002 : 0 : goto err;
2003 : : }
2768 heikki.linnakangas@i 2004 :CBC 212 : bio = BIO_new(bio_method);
3534 2005 [ - + ]: 212 : if (bio == NULL)
2006 : : {
3534 heikki.linnakangas@i 2007 :UBC 0 : SSLerr(SSL_F_SSL_SET_FD, ERR_R_BUF_LIB);
2008 : 0 : goto err;
2009 : : }
138 tgl@sss.pgh.pa.us 2010 :CBC 212 : BIO_set_app_data(bio, conn);
2011 : :
3534 heikki.linnakangas@i 2012 : 212 : SSL_set_bio(conn->ssl, bio, bio);
2013 : 212 : BIO_set_fd(bio, fd, BIO_NOCLOSE);
2014 : 212 : ret = 1;
2015 : 212 : err:
2016 : 212 : return ret;
2017 : : }
2018 : :
2019 : : /*
2020 : : * This is the default handler to return a client cert password from
2021 : : * conn->sslpassword. Apps may install it explicitly if they want to
2022 : : * prevent openssl from ever prompting on stdin.
2023 : : */
2024 : : int
1429 andrew@dunslane.net 2025 : 2 : PQdefaultSSLKeyPassHook_OpenSSL(char *buf, int size, PGconn *conn)
2026 : : {
608 tgl@sss.pgh.pa.us 2027 [ + - + - ]: 2 : if (conn && conn->sslpassword)
2028 : : {
1597 andrew@dunslane.net 2029 [ - + ]: 2 : if (strlen(conn->sslpassword) + 1 > size)
1442 peter@eisentraut.org 2030 :UBC 0 : fprintf(stderr, libpq_gettext("WARNING: sslpassword truncated\n"));
1597 andrew@dunslane.net 2031 :CBC 2 : strncpy(buf, conn->sslpassword, size);
1431 tgl@sss.pgh.pa.us 2032 : 2 : buf[size - 1] = '\0';
1597 andrew@dunslane.net 2033 : 2 : return strlen(buf);
2034 : : }
2035 : : else
2036 : : {
1597 andrew@dunslane.net 2037 :UBC 0 : buf[0] = '\0';
2038 : 0 : return 0;
2039 : : }
2040 : : }
2041 : :
2042 : : PQsslKeyPassHook_OpenSSL_type
1429 tgl@sss.pgh.pa.us 2043 : 0 : PQgetSSLKeyPassHook_OpenSSL(void)
2044 : : {
1597 andrew@dunslane.net 2045 : 0 : return PQsslKeyPassHook;
2046 : : }
2047 : :
2048 : : void
1429 2049 : 0 : PQsetSSLKeyPassHook_OpenSSL(PQsslKeyPassHook_OpenSSL_type hook)
2050 : : {
1597 2051 : 0 : PQsslKeyPassHook = hook;
2052 : 0 : }
2053 : :
2054 : : /*
2055 : : * Supply a password to decrypt a client certificate.
2056 : : *
2057 : : * This must match OpenSSL type pem_password_cb.
2058 : : */
2059 : : static int
1597 andrew@dunslane.net 2060 :CBC 2 : PQssl_passwd_cb(char *buf, int size, int rwflag, void *userdata)
2061 : : {
1431 tgl@sss.pgh.pa.us 2062 : 2 : PGconn *conn = userdata;
2063 : :
1597 andrew@dunslane.net 2064 [ - + ]: 2 : if (PQsslKeyPassHook)
1597 andrew@dunslane.net 2065 :UBC 0 : return PQsslKeyPassHook(buf, size, conn);
2066 : : else
1429 andrew@dunslane.net 2067 :CBC 2 : return PQdefaultSSLKeyPassHook_OpenSSL(buf, size, conn);
2068 : : }
2069 : :
2070 : : /*
2071 : : * Convert TLS protocol version string to OpenSSL values
2072 : : *
2073 : : * If a version is passed that is not supported by the current OpenSSL version,
2074 : : * then we return -1. If a non-negative value is returned, subsequent code can
2075 : : * assume it is working with a supported version.
2076 : : *
2077 : : * Note: this is rather similar to the backend routine in be-secure-openssl.c,
2078 : : * so make sure to update both routines if changing this one.
2079 : : */
2080 : : static int
1538 michael@paquier.xyz 2081 : 216 : ssl_protocol_version_to_openssl(const char *protocol)
2082 : : {
2083 [ - + ]: 216 : if (pg_strcasecmp("TLSv1", protocol) == 0)
1538 michael@paquier.xyz 2084 :UBC 0 : return TLS1_VERSION;
2085 : :
2086 : : #ifdef TLS1_1_VERSION
1538 michael@paquier.xyz 2087 [ - + ]:CBC 216 : if (pg_strcasecmp("TLSv1.1", protocol) == 0)
1538 michael@paquier.xyz 2088 :UBC 0 : return TLS1_1_VERSION;
2089 : : #endif
2090 : :
2091 : : #ifdef TLS1_2_VERSION
1538 michael@paquier.xyz 2092 [ + - ]:CBC 216 : if (pg_strcasecmp("TLSv1.2", protocol) == 0)
2093 : 216 : return TLS1_2_VERSION;
2094 : : #endif
2095 : :
2096 : : #ifdef TLS1_3_VERSION
1538 michael@paquier.xyz 2097 [ # # ]:UBC 0 : if (pg_strcasecmp("TLSv1.3", protocol) == 0)
2098 : 0 : return TLS1_3_VERSION;
2099 : : #endif
2100 : :
2101 : 0 : return -1;
2102 : : }
|
