1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2019 */
6 /* See the file NOTICE for conditions of use and distribution. */
8 /* Portions Copyright (c) The OpenSSL Project 1999 */
10 /* This module provides the TLS (aka SSL) support for Exim using the OpenSSL
11 library. It is #included into the tls.c file when that library is used. The
12 code herein is based on a patch that was originally contributed by Steve
13 Haslam. It was adapted from stunnel, a GPL program by Michal Trojnara.
15 No cryptographic code is included in Exim. All this module does is to call
16 functions from the OpenSSL library. */
21 #include <openssl/lhash.h>
22 #include <openssl/ssl.h>
23 #include <openssl/err.h>
24 #include <openssl/rand.h>
25 #ifndef OPENSSL_NO_ECDH
26 # include <openssl/ec.h>
29 # include <openssl/ocsp.h>
37 # define EXIM_OCSP_SKEW_SECONDS (300L)
38 # define EXIM_OCSP_MAX_AGE (-1L)
41 #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
42 # define EXIM_HAVE_OPENSSL_TLSEXT
44 #if OPENSSL_VERSION_NUMBER >= 0x00908000L
45 # define EXIM_HAVE_RSA_GENKEY_EX
47 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
48 # define EXIM_HAVE_OCSP_RESP_COUNT
50 # define EXIM_HAVE_EPHEM_RSA_KEX
51 # define EXIM_HAVE_RAND_PSEUDO
53 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
54 # define EXIM_HAVE_SHA256
57 /* X509_check_host provides sane certificate hostname checking, but was added
58 to OpenSSL late, after other projects forked off the code-base. So in
59 addition to guarding against the base version number, beware that LibreSSL
60 does not (at this time) support this function.
62 If LibreSSL gains a different API, perhaps via libtls, then we'll probably
63 opt to disentangle and ask a LibreSSL user to provide glue for a third
64 crypto provider for libtls instead of continuing to tie the OpenSSL glue
65 into even twistier knots. If LibreSSL gains the same API, we can just
66 change this guard and punt the issue for a while longer. */
68 #ifndef LIBRESSL_VERSION_NUMBER
69 # if OPENSSL_VERSION_NUMBER >= 0x010100000L
70 # define EXIM_HAVE_OPENSSL_CHECKHOST
71 # define EXIM_HAVE_OPENSSL_DH_BITS
72 # define EXIM_HAVE_OPENSSL_TLS_METHOD
73 # define EXIM_HAVE_OPENSSL_KEYLOG
74 # define EXIM_HAVE_OPENSSL_CIPHER_GET_ID
75 # define EXIM_HAVE_SESSION_TICKET
76 # define EXIM_HAVE_OPESSL_TRACE
78 # define EXIM_NEED_OPENSSL_INIT
80 # if OPENSSL_VERSION_NUMBER >= 0x010000000L \
81 && (OPENSSL_VERSION_NUMBER & 0x0000ff000L) >= 0x000002000L
82 # define EXIM_HAVE_OPENSSL_CHECKHOST
86 #if !defined(LIBRESSL_VERSION_NUMBER) \
87 || LIBRESSL_VERSION_NUMBER >= 0x20010000L
88 # if !defined(OPENSSL_NO_ECDH)
89 # if OPENSSL_VERSION_NUMBER >= 0x0090800fL
90 # define EXIM_HAVE_ECDH
92 # if OPENSSL_VERSION_NUMBER >= 0x10002000L
93 # define EXIM_HAVE_OPENSSL_EC_NIST2NID
98 #ifndef LIBRESSL_VERSION_NUMBER
99 # if OPENSSL_VERSION_NUMBER >= 0x010101000L
100 # define OPENSSL_HAVE_KEYLOG_CB
101 # define OPENSSL_HAVE_NUM_TICKETS
102 # define EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
106 #if !defined(EXIM_HAVE_OPENSSL_TLSEXT) && !defined(DISABLE_OCSP)
107 # warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
108 # define DISABLE_OCSP
111 #ifdef EXPERIMENTAL_TLS_RESUME
112 # if OPENSSL_VERSION_NUMBER < 0x0101010L
113 # error OpenSSL version too old for session-resumption
117 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
118 # include <openssl/x509v3.h>
121 #ifndef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
122 # ifndef EXIM_HAVE_OPENSSL_CIPHER_GET_ID
123 # define SSL_CIPHER_get_id(c) (c->id)
125 # ifndef MACRO_PREDEF
126 # include "tls-cipher-stdname.c"
130 /*************************************************
131 * OpenSSL option parse *
132 *************************************************/
134 typedef struct exim_openssl_option {
137 } exim_openssl_option;
138 /* We could use a macro to expand, but we need the ifdef and not all the
139 options document which version they were introduced in. Policylet: include
140 all options unless explicitly for DTLS, let the administrator choose which
143 This list is current as of:
145 Plus SSL_OP_SAFARI_ECDHE_ECDSA_BUG from 2013-June patch/discussion on openssl-dev
146 Plus SSL_OP_NO_TLSv1_3 for 1.1.2-dev
148 static exim_openssl_option exim_openssl_options[] = {
149 /* KEEP SORTED ALPHABETICALLY! */
151 { US"all", (long) SSL_OP_ALL },
153 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
154 { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
156 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
157 { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
159 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
160 { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
162 #ifdef SSL_OP_EPHEMERAL_RSA
163 { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
165 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
166 { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
168 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
169 { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
171 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
172 { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
174 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
175 { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
177 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
178 { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
180 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
181 { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
183 #ifdef SSL_OP_NO_COMPRESSION
184 { US"no_compression", SSL_OP_NO_COMPRESSION },
186 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
187 { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
189 #ifdef SSL_OP_NO_SSLv2
190 { US"no_sslv2", SSL_OP_NO_SSLv2 },
192 #ifdef SSL_OP_NO_SSLv3
193 { US"no_sslv3", SSL_OP_NO_SSLv3 },
195 #ifdef SSL_OP_NO_TICKET
196 { US"no_ticket", SSL_OP_NO_TICKET },
198 #ifdef SSL_OP_NO_TLSv1
199 { US"no_tlsv1", SSL_OP_NO_TLSv1 },
201 #ifdef SSL_OP_NO_TLSv1_1
202 #if SSL_OP_NO_TLSv1_1 == 0x00000400L
203 /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
204 #warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
206 { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
209 #ifdef SSL_OP_NO_TLSv1_2
210 { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
212 #ifdef SSL_OP_NO_TLSv1_3
213 { US"no_tlsv1_3", SSL_OP_NO_TLSv1_3 },
215 #ifdef SSL_OP_SAFARI_ECDHE_ECDSA_BUG
216 { US"safari_ecdhe_ecdsa_bug", SSL_OP_SAFARI_ECDHE_ECDSA_BUG },
218 #ifdef SSL_OP_SINGLE_DH_USE
219 { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
221 #ifdef SSL_OP_SINGLE_ECDH_USE
222 { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
224 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
225 { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
227 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
228 { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
230 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
231 { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
233 #ifdef SSL_OP_TLS_D5_BUG
234 { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
236 #ifdef SSL_OP_TLS_ROLLBACK_BUG
237 { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
242 static int exim_openssl_options_size = nelem(exim_openssl_options);
251 for (struct exim_openssl_option * o = exim_openssl_options;
252 o < exim_openssl_options + nelem(exim_openssl_options); o++)
254 /* Trailing X is workaround for problem with _OPT_OPENSSL_NO_TLSV1
255 being a ".ifdef _OPT_OPENSSL_NO_TLSV1_3" match */
257 spf(buf, sizeof(buf), US"_OPT_OPENSSL_%T_X", o->name);
258 builtin_macro_create(buf);
261 # ifdef EXPERIMENTAL_TLS_RESUME
262 builtin_macro_create_var(US"_RESUME_DECODE", RESUME_DECODE_STRING );
264 # ifdef SSL_OP_NO_TLSv1_3
265 builtin_macro_create(US"_HAVE_TLS1_3");
270 /******************************************************************************/
272 /* Structure for collecting random data for seeding. */
274 typedef struct randstuff {
279 /* Local static variables */
281 static BOOL client_verify_callback_called = FALSE;
282 static BOOL server_verify_callback_called = FALSE;
283 static const uschar *sid_ctx = US"exim";
285 /* We have three different contexts to care about.
287 Simple case: client, `client_ctx`
288 As a client, we can be doing a callout or cut-through delivery while receiving
289 a message. So we have a client context, which should have options initialised
290 from the SMTP Transport. We may also concurrently want to make TLS connections
291 to utility daemons, so client-contexts are allocated and passed around in call
292 args rather than using a gobal.
295 There are two cases: with and without ServerNameIndication from the client.
296 Given TLS SNI, we can be using different keys, certs and various other
297 configuration settings, because they're re-expanded with $tls_sni set. This
298 allows vhosting with TLS. This SNI is sent in the handshake.
299 A client might not send SNI, so we need a fallback, and an initial setup too.
300 So as a server, we start out using `server_ctx`.
301 If SNI is sent by the client, then we as server, mid-negotiation, try to clone
302 `server_sni` from `server_ctx` and then initialise settings by re-expanding
310 } exim_openssl_client_tls_ctx;
312 static SSL_CTX *server_ctx = NULL;
313 static SSL *server_ssl = NULL;
315 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
316 static SSL_CTX *server_sni = NULL;
319 static char ssl_errstring[256];
321 static int ssl_session_timeout = 7200; /* Two hours */
322 static BOOL client_verify_optional = FALSE;
323 static BOOL server_verify_optional = FALSE;
325 static BOOL reexpand_tls_files_for_sni = FALSE;
328 typedef struct tls_ext_ctx_cb {
334 STACK_OF(X509) *verify_stack; /* chain for verifying the proof */
338 uschar *file_expanded;
339 OCSP_RESPONSE *response;
342 X509_STORE *verify_store; /* non-null if status requested */
343 BOOL verify_required;
348 /* these are cached from first expand */
349 uschar *server_cipher_list;
350 /* only passed down to tls_error: */
352 const uschar * verify_cert_hostnames;
353 #ifndef DISABLE_EVENT
354 uschar * event_action;
358 /* should figure out a cleanup of API to handle state preserved per
359 implementation, for various reasons, which can be void * in the APIs.
360 For now, we hack around it. */
361 tls_ext_ctx_cb *client_static_cbinfo = NULL; /*XXX should not use static; multiple concurrent clients! */
362 tls_ext_ctx_cb *server_static_cbinfo = NULL;
365 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
366 int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr );
369 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
370 static int tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg);
373 static int tls_server_stapling_cb(SSL *s, void *arg);
378 /* Daemon-called, before every connection, key create/rotate */
379 #ifdef EXPERIMENTAL_TLS_RESUME
380 static void tk_init(void);
381 static int tls_exdata_idx = -1;
385 tls_daemon_init(void)
387 #ifdef EXPERIMENTAL_TLS_RESUME
394 /*************************************************
396 *************************************************/
398 /* Called from lots of places when errors occur before actually starting to do
399 the TLS handshake, that is, while the session is still in clear. Always returns
400 DEFER for a server and FAIL for a client so that most calls can use "return
401 tls_error(...)" to do this processing and then give an appropriate return. A
402 single function is used for both server and client, because it is called from
403 some shared functions.
406 prefix text to include in the logged error
407 host NULL if setting up a server;
408 the connected host if setting up a client
409 msg error message or NULL if we should ask OpenSSL
410 errstr pointer to output error message
412 Returns: OK/DEFER/FAIL
416 tls_error(uschar * prefix, const host_item * host, uschar * msg, uschar ** errstr)
420 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
421 msg = US ssl_errstring;
424 msg = string_sprintf("(%s): %s", prefix, msg);
425 DEBUG(D_tls) debug_printf("TLS error '%s'\n", msg);
426 if (errstr) *errstr = msg;
427 return host ? FAIL : DEFER;
432 /*************************************************
433 * Callback to generate RSA key *
434 *************************************************/
438 s SSL connection (not used)
442 Returns: pointer to generated key
446 rsa_callback(SSL *s, int export, int keylength)
449 #ifdef EXIM_HAVE_RSA_GENKEY_EX
450 BIGNUM *bn = BN_new();
453 export = export; /* Shut picky compilers up */
454 DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
456 #ifdef EXIM_HAVE_RSA_GENKEY_EX
457 if ( !BN_set_word(bn, (unsigned long)RSA_F4)
458 || !(rsa_key = RSA_new())
459 || !RSA_generate_key_ex(rsa_key, keylength, bn, NULL)
462 if (!(rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL)))
466 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
467 log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
479 x509_store_dump_cert_s_names(X509_STORE * store)
481 STACK_OF(X509_OBJECT) * roots= store->objs;
482 static uschar name[256];
484 for (int i= 0; i < sk_X509_OBJECT_num(roots); i++)
486 X509_OBJECT * tmp_obj= sk_X509_OBJECT_value(roots, i);
487 if(tmp_obj->type == X509_LU_X509)
489 X509_NAME * sn = X509_get_subject_name(tmp_obj->data.x509);
490 if (X509_NAME_oneline(sn, CS name, sizeof(name)))
492 name[sizeof(name)-1] = '\0';
493 debug_printf(" %s\n", name);
502 #ifndef DISABLE_EVENT
504 verify_event(tls_support * tlsp, X509 * cert, int depth, const uschar * dn,
505 BOOL *calledp, const BOOL *optionalp, const uschar * what)
511 ev = tlsp == &tls_out ? client_static_cbinfo->event_action : event_action;
514 DEBUG(D_tls) debug_printf("verify_event: %s %d\n", what, depth);
515 old_cert = tlsp->peercert;
516 tlsp->peercert = X509_dup(cert);
517 /* NB we do not bother setting peerdn */
518 if ((yield = event_raise(ev, US"tls:cert", string_sprintf("%d", depth))))
520 log_write(0, LOG_MAIN, "[%s] %s verify denied by event-action: "
521 "depth=%d cert=%s: %s",
522 tlsp == &tls_out ? deliver_host_address : sender_host_address,
523 what, depth, dn, yield);
527 if (old_cert) tlsp->peercert = old_cert; /* restore 1st failing cert */
528 return 1; /* reject (leaving peercert set) */
530 DEBUG(D_tls) debug_printf("Event-action verify failure overridden "
531 "(host in tls_try_verify_hosts)\n");
532 tlsp->verify_override = TRUE;
534 X509_free(tlsp->peercert);
535 tlsp->peercert = old_cert;
541 /*************************************************
542 * Callback for verification *
543 *************************************************/
545 /* The SSL library does certificate verification if set up to do so. This
546 callback has the current yes/no state is in "state". If verification succeeded,
547 we set the certificate-verified flag. If verification failed, what happens
548 depends on whether the client is required to present a verifiable certificate
551 If verification is optional, we change the state to yes, but still log the
552 verification error. For some reason (it really would help to have proper
553 documentation of OpenSSL), this callback function then gets called again, this
554 time with state = 1. We must take care not to set the private verified flag on
555 the second time through.
557 Note: this function is not called if the client fails to present a certificate
558 when asked. We get here only if a certificate has been received. Handling of
559 optional verification for this case is done when requesting SSL to verify, by
560 setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
562 May be called multiple times for different issues with a certificate, even
563 for a given "depth" in the certificate chain.
566 preverify_ok current yes/no state as 1/0
567 x509ctx certificate information.
568 tlsp per-direction (client vs. server) support data
569 calledp has-been-called flag
570 optionalp verification-is-optional flag
572 Returns: 0 if verification should fail, otherwise 1
576 verify_callback(int preverify_ok, X509_STORE_CTX * x509ctx,
577 tls_support * tlsp, BOOL * calledp, BOOL * optionalp)
579 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
580 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
583 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
585 DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
586 log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
587 tlsp == &tls_out ? deliver_host_address : sender_host_address);
590 dn[sizeof(dn)-1] = '\0';
592 tlsp->verify_override = FALSE;
593 if (preverify_ok == 0)
595 uschar * extra = verify_mode ? string_sprintf(" (during %c-verify for [%s])",
596 *verify_mode, sender_host_address)
598 log_write(0, LOG_MAIN, "[%s] SSL verify error%s: depth=%d error=%s cert=%s",
599 tlsp == &tls_out ? deliver_host_address : sender_host_address,
601 X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509ctx)), dn);
606 tlsp->peercert = X509_dup(cert); /* record failing cert */
607 return 0; /* reject */
609 DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
610 "tls_try_verify_hosts)\n");
611 tlsp->verify_override = TRUE;
616 DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d SN=%s\n", depth, dn);
618 if (tlsp == &tls_out && client_static_cbinfo->u_ocsp.client.verify_store)
619 { /* client, wanting stapling */
620 /* Add the server cert's signing chain as the one
621 for the verification of the OCSP stapled information. */
623 if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
626 sk_X509_push(client_static_cbinfo->verify_stack, cert);
629 #ifndef DISABLE_EVENT
630 if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
631 return 0; /* reject, with peercert set */
636 const uschar * verify_cert_hostnames;
638 if ( tlsp == &tls_out
639 && ((verify_cert_hostnames = client_static_cbinfo->verify_cert_hostnames)))
640 /* client, wanting hostname check */
643 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
644 # ifndef X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
645 # define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0
647 # ifndef X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS
648 # define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0
651 const uschar * list = verify_cert_hostnames;
654 while ((name = string_nextinlist(&list, &sep, NULL, 0)))
655 if ((rc = X509_check_host(cert, CCS name, 0,
656 X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
657 | X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS,
662 log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
663 tlsp == &tls_out ? deliver_host_address : sender_host_address);
670 if (!tls_is_name_for_cert(verify_cert_hostnames, cert))
673 uschar * extra = verify_mode
674 ? string_sprintf(" (during %c-verify for [%s])",
675 *verify_mode, sender_host_address)
677 log_write(0, LOG_MAIN,
678 "[%s] SSL verify error%s: certificate name mismatch: DN=\"%s\" H=\"%s\"",
679 tlsp == &tls_out ? deliver_host_address : sender_host_address,
680 extra, dn, verify_cert_hostnames);
685 tlsp->peercert = X509_dup(cert); /* record failing cert */
686 return 0; /* reject */
688 DEBUG(D_tls) debug_printf("SSL verify name failure overridden (host in "
689 "tls_try_verify_hosts)\n");
690 tlsp->verify_override = TRUE;
694 #ifndef DISABLE_EVENT
695 if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
696 return 0; /* reject, with peercert set */
699 DEBUG(D_tls) debug_printf("SSL%s verify ok: depth=0 SN=%s\n",
700 *calledp ? "" : " authenticated", dn);
704 return 1; /* accept, at least for this level */
708 verify_callback_client(int preverify_ok, X509_STORE_CTX *x509ctx)
710 return verify_callback(preverify_ok, x509ctx, &tls_out,
711 &client_verify_callback_called, &client_verify_optional);
715 verify_callback_server(int preverify_ok, X509_STORE_CTX *x509ctx)
717 return verify_callback(preverify_ok, x509ctx, &tls_in,
718 &server_verify_callback_called, &server_verify_optional);
724 /* This gets called *by* the dane library verify callback, which interposes
728 verify_callback_client_dane(int preverify_ok, X509_STORE_CTX * x509ctx)
730 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
732 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
733 #ifndef DISABLE_EVENT
734 BOOL dummy_called, optional = FALSE;
737 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
739 DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
740 log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
741 deliver_host_address);
744 dn[sizeof(dn)-1] = '\0';
746 DEBUG(D_tls) debug_printf("verify_callback_client_dane: %s depth %d %s\n",
747 preverify_ok ? "ok":"BAD", depth, dn);
749 #ifndef DISABLE_EVENT
750 if (verify_event(&tls_out, cert, depth, dn,
751 &dummy_called, &optional, US"DANE"))
752 return 0; /* reject, with peercert set */
755 if (preverify_ok == 1)
757 tls_out.dane_verified = TRUE;
759 if (client_static_cbinfo->u_ocsp.client.verify_store)
760 { /* client, wanting stapling */
761 /* Add the server cert's signing chain as the one
762 for the verification of the OCSP stapled information. */
764 if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
767 sk_X509_push(client_static_cbinfo->verify_stack, cert);
773 int err = X509_STORE_CTX_get_error(x509ctx);
775 debug_printf(" - err %d '%s'\n", err, X509_verify_cert_error_string(err));
776 if (err == X509_V_ERR_APPLICATION_VERIFICATION)
782 #endif /*SUPPORT_DANE*/
785 /*************************************************
786 * Information callback *
787 *************************************************/
789 /* The SSL library functions call this from time to time to indicate what they
790 are doing. We copy the string to the debugging output when TLS debugging has
802 info_callback(SSL *s, int where, int ret)
808 if (where & SSL_ST_CONNECT)
809 str = US"SSL_connect";
810 else if (where & SSL_ST_ACCEPT)
811 str = US"SSL_accept";
813 str = US"SSL info (undefined)";
815 if (where & SSL_CB_LOOP)
816 debug_printf("%s: %s\n", str, SSL_state_string_long(s));
817 else if (where & SSL_CB_ALERT)
818 debug_printf("SSL3 alert %s:%s:%s\n",
819 str = where & SSL_CB_READ ? US"read" : US"write",
820 SSL_alert_type_string_long(ret), SSL_alert_desc_string_long(ret));
821 else if (where & SSL_CB_EXIT)
823 debug_printf("%s: failed in %s\n", str, SSL_state_string_long(s));
825 debug_printf("%s: error in %s\n", str, SSL_state_string_long(s));
826 else if (where & SSL_CB_HANDSHAKE_START)
827 debug_printf("%s: hshake start: %s\n", str, SSL_state_string_long(s));
828 else if (where & SSL_CB_HANDSHAKE_DONE)
829 debug_printf("%s: hshake done: %s\n", str, SSL_state_string_long(s));
833 #ifdef OPENSSL_HAVE_KEYLOG_CB
835 keylog_callback(const SSL *ssl, const char *line)
837 DEBUG(D_tls) debug_printf("%.200s\n", line);
842 #ifdef EXPERIMENTAL_TLS_RESUME
843 /* Manage the keysets used for encrypting the session tickets, on the server. */
845 typedef struct { /* Session ticket encryption key */
848 const EVP_CIPHER * aes_cipher;
849 uschar aes_key[32]; /* size needed depends on cipher. aes_128 implies 128/8 = 16? */
850 const EVP_MD * hmac_hash;
856 static exim_stek exim_tk; /* current key */
857 static exim_stek exim_tk_old; /* previous key */
862 time_t t = time(NULL);
866 if (exim_tk.renew >= t) return;
867 exim_tk_old = exim_tk;
870 if (f.running_in_test_harness) ssl_session_timeout = 6;
872 DEBUG(D_tls) debug_printf("OpenSSL: %s STEK\n", exim_tk.name[0] ? "rotating" : "creating");
873 if (RAND_bytes(exim_tk.aes_key, sizeof(exim_tk.aes_key)) <= 0) return;
874 if (RAND_bytes(exim_tk.hmac_key, sizeof(exim_tk.hmac_key)) <= 0) return;
875 if (RAND_bytes(exim_tk.name+1, sizeof(exim_tk.name)-1) <= 0) return;
877 exim_tk.name[0] = 'E';
878 exim_tk.aes_cipher = EVP_aes_256_cbc();
879 exim_tk.hmac_hash = EVP_sha256();
880 exim_tk.expire = t + ssl_session_timeout;
881 exim_tk.renew = t + ssl_session_timeout/2;
887 if (!exim_tk.name[0]) return NULL;
892 tk_find(const uschar * name)
894 return memcmp(name, exim_tk.name, sizeof(exim_tk.name)) == 0 ? &exim_tk
895 : memcmp(name, exim_tk_old.name, sizeof(exim_tk_old.name)) == 0 ? &exim_tk_old
899 /* Callback for session tickets, on server */
901 ticket_key_callback(SSL * ssl, uschar key_name[16],
902 uschar * iv, EVP_CIPHER_CTX * ctx, HMAC_CTX * hctx, int enc)
904 tls_support * tlsp = server_static_cbinfo->tlsp;
909 DEBUG(D_tls) debug_printf("ticket_key_callback: create new session\n");
910 tlsp->resumption |= RESUME_CLIENT_REQUESTED;
912 if (RAND_bytes(iv, EVP_MAX_IV_LENGTH) <= 0)
913 return -1; /* insufficient random */
915 if (!(key = tk_current())) /* current key doesn't exist or isn't valid */
916 return 0; /* key couldn't be created */
917 memcpy(key_name, key->name, 16);
918 DEBUG(D_tls) debug_printf("STEK expire " TIME_T_FMT "\n", key->expire - time(NULL));
920 /*XXX will want these dependent on the ssl session strength */
921 HMAC_Init_ex(hctx, key->hmac_key, sizeof(key->hmac_key),
922 key->hmac_hash, NULL);
923 EVP_EncryptInit_ex(ctx, key->aes_cipher, NULL, key->aes_key, iv);
925 DEBUG(D_tls) debug_printf("ticket created\n");
930 time_t now = time(NULL);
932 DEBUG(D_tls) debug_printf("ticket_key_callback: retrieve session\n");
933 tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
935 if (!(key = tk_find(key_name)) || key->expire < now)
939 debug_printf("ticket not usable (%s)\n", key ? "expired" : "not found");
940 if (key) debug_printf("STEK expire " TIME_T_FMT "\n", key->expire - now);
945 HMAC_Init_ex(hctx, key->hmac_key, sizeof(key->hmac_key),
946 key->hmac_hash, NULL);
947 EVP_DecryptInit_ex(ctx, key->aes_cipher, NULL, key->aes_key, iv);
949 DEBUG(D_tls) debug_printf("ticket usable, STEK expire " TIME_T_FMT "\n", key->expire - now);
951 /* The ticket lifetime and renewal are the same as the STEK lifetime and
952 renewal, which is overenthusiastic. A factor of, say, 3x longer STEK would
953 be better. To do that we'd have to encode ticket lifetime in the name as
954 we don't yet see the restored session. Could check posthandshake for TLS1.3
955 and trigger a new ticket then, but cannot do that for TLS1.2 */
956 return key->renew < now ? 2 : 1;
963 /*************************************************
964 * Initialize for DH *
965 *************************************************/
967 /* If dhparam is set, expand it, and load up the parameters for DH encryption.
970 sctx The current SSL CTX (inbound or outbound)
971 dhparam DH parameter file or fixed parameter identity string
972 host connected host, if client; NULL if server
973 errstr error string pointer
975 Returns: TRUE if OK (nothing to set up, or setup worked)
979 init_dh(SSL_CTX *sctx, uschar *dhparam, const host_item *host, uschar ** errstr)
987 if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded, errstr))
990 if (!dhexpanded || !*dhexpanded)
991 bio = BIO_new_mem_buf(CS std_dh_prime_default(), -1);
992 else if (dhexpanded[0] == '/')
994 if (!(bio = BIO_new_file(CS dhexpanded, "r")))
996 tls_error(string_sprintf("could not read dhparams file %s", dhexpanded),
997 host, US strerror(errno), errstr);
1003 if (Ustrcmp(dhexpanded, "none") == 0)
1005 DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
1009 if (!(pem = std_dh_prime_named(dhexpanded)))
1011 tls_error(string_sprintf("Unknown standard DH prime \"%s\"", dhexpanded),
1012 host, US strerror(errno), errstr);
1015 bio = BIO_new_mem_buf(CS pem, -1);
1018 if (!(dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL)))
1021 tls_error(string_sprintf("Could not read tls_dhparams \"%s\"", dhexpanded),
1022 host, NULL, errstr);
1026 /* note: our default limit of 2236 is not a multiple of 8; the limit comes from
1027 * an NSS limit, and the GnuTLS APIs handle bit-sizes fine, so we went with
1028 * 2236. But older OpenSSL can only report in bytes (octets), not bits.
1029 * If someone wants to dance at the edge, then they can raise the limit or use
1030 * current libraries. */
1031 #ifdef EXIM_HAVE_OPENSSL_DH_BITS
1032 /* Added in commit 26c79d5641d; `git describe --contains` says OpenSSL_1_1_0-pre1~1022
1033 * This predates OpenSSL_1_1_0 (before a, b, ...) so is in all 1.1.0 */
1034 dh_bitsize = DH_bits(dh);
1036 dh_bitsize = 8 * DH_size(dh);
1039 /* Even if it is larger, we silently return success rather than cause things
1040 * to fail out, so that a too-large DH will not knock out all TLS; it's a
1041 * debatable choice. */
1042 if (dh_bitsize > tls_dh_max_bits)
1045 debug_printf("dhparams file %d bits, is > tls_dh_max_bits limit of %d\n",
1046 dh_bitsize, tls_dh_max_bits);
1050 SSL_CTX_set_tmp_dh(sctx, dh);
1052 debug_printf("Diffie-Hellman initialized from %s with %d-bit prime\n",
1053 dhexpanded ? dhexpanded : US"default", dh_bitsize);
1065 /*************************************************
1066 * Initialize for ECDH *
1067 *************************************************/
1069 /* Load parameters for ECDH encryption.
1071 For now, we stick to NIST P-256 because: it's simple and easy to configure;
1072 it avoids any patent issues that might bite redistributors; despite events in
1073 the news and concerns over curve choices, we're not cryptographers, we're not
1074 pretending to be, and this is "good enough" to be better than no support,
1075 protecting against most adversaries. Given another year or two, there might
1076 be sufficient clarity about a "right" way forward to let us make an informed
1077 decision, instead of a knee-jerk reaction.
1079 Longer-term, we should look at supporting both various named curves and
1080 external files generated with "openssl ecparam", much as we do for init_dh().
1081 We should also support "none" as a value, to explicitly avoid initialisation.
1086 sctx The current SSL CTX (inbound or outbound)
1087 host connected host, if client; NULL if server
1088 errstr error string pointer
1090 Returns: TRUE if OK (nothing to set up, or setup worked)
1094 init_ecdh(SSL_CTX * sctx, host_item * host, uschar ** errstr)
1096 #ifdef OPENSSL_NO_ECDH
1105 if (host) /* No ECDH setup for clients, only for servers */
1108 # ifndef EXIM_HAVE_ECDH
1110 debug_printf("No OpenSSL API to define ECDH parameters, skipping\n");
1114 if (!expand_check(tls_eccurve, US"tls_eccurve", &exp_curve, errstr))
1116 if (!exp_curve || !*exp_curve)
1119 /* "auto" needs to be handled carefully.
1120 * OpenSSL < 1.0.2: we do not select anything, but fallback to prime256v1
1121 * OpenSSL < 1.1.0: we have to call SSL_CTX_set_ecdh_auto
1122 * (openssl/ssl.h defines SSL_CTRL_SET_ECDH_AUTO)
1123 * OpenSSL >= 1.1.0: we do not set anything, the libray does autoselection
1124 * https://github.com/openssl/openssl/commit/fe6ef2472db933f01b59cad82aa925736935984b
1126 if (Ustrcmp(exp_curve, "auto") == 0)
1128 #if OPENSSL_VERSION_NUMBER < 0x10002000L
1129 DEBUG(D_tls) debug_printf(
1130 "ECDH OpenSSL < 1.0.2: temp key parameter settings: overriding \"auto\" with \"prime256v1\"\n");
1131 exp_curve = US"prime256v1";
1133 # if defined SSL_CTRL_SET_ECDH_AUTO
1134 DEBUG(D_tls) debug_printf(
1135 "ECDH OpenSSL 1.0.2+ temp key parameter settings: autoselection\n");
1136 SSL_CTX_set_ecdh_auto(sctx, 1);
1139 DEBUG(D_tls) debug_printf(
1140 "ECDH OpenSSL 1.1.0+ temp key parameter settings: default selection\n");
1146 DEBUG(D_tls) debug_printf("ECDH: curve '%s'\n", exp_curve);
1147 if ( (nid = OBJ_sn2nid (CCS exp_curve)) == NID_undef
1148 # ifdef EXIM_HAVE_OPENSSL_EC_NIST2NID
1149 && (nid = EC_curve_nist2nid(CCS exp_curve)) == NID_undef
1153 tls_error(string_sprintf("Unknown curve name tls_eccurve '%s'", exp_curve),
1154 host, NULL, errstr);
1158 if (!(ecdh = EC_KEY_new_by_curve_name(nid)))
1160 tls_error(US"Unable to create ec curve", host, NULL, errstr);
1164 /* The "tmp" in the name here refers to setting a temporary key
1165 not to the stability of the interface. */
1167 if ((rv = SSL_CTX_set_tmp_ecdh(sctx, ecdh) == 0))
1168 tls_error(string_sprintf("Error enabling '%s' curve", exp_curve), host, NULL, errstr);
1170 DEBUG(D_tls) debug_printf("ECDH: enabled '%s' curve\n", exp_curve);
1175 # endif /*EXIM_HAVE_ECDH*/
1176 #endif /*OPENSSL_NO_ECDH*/
1182 #ifndef DISABLE_OCSP
1183 /*************************************************
1184 * Load OCSP information into state *
1185 *************************************************/
1186 /* Called to load the server OCSP response from the given file into memory, once
1187 caller has determined this is needed. Checks validity. Debugs a message
1190 ASSUMES: single response, for single cert.
1193 sctx the SSL_CTX* to update
1194 cbinfo various parts of session state
1195 expanded the filename putatively holding an OCSP response
1200 ocsp_load_response(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo, const uschar *expanded)
1203 OCSP_RESPONSE * resp;
1204 OCSP_BASICRESP * basic_response;
1205 OCSP_SINGLERESP * single_response;
1206 ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
1207 STACK_OF(X509) * sk;
1208 unsigned long verify_flags;
1209 int status, reason, i;
1211 cbinfo->u_ocsp.server.file_expanded = string_copy(expanded);
1212 if (cbinfo->u_ocsp.server.response)
1214 OCSP_RESPONSE_free(cbinfo->u_ocsp.server.response);
1215 cbinfo->u_ocsp.server.response = NULL;
1218 if (!(bio = BIO_new_file(CS cbinfo->u_ocsp.server.file_expanded, "rb")))
1220 DEBUG(D_tls) debug_printf("Failed to open OCSP response file \"%s\"\n",
1221 cbinfo->u_ocsp.server.file_expanded);
1225 resp = d2i_OCSP_RESPONSE_bio(bio, NULL);
1229 DEBUG(D_tls) debug_printf("Error reading OCSP response.\n");
1233 if ((status = OCSP_response_status(resp)) != OCSP_RESPONSE_STATUS_SUCCESSFUL)
1235 DEBUG(D_tls) debug_printf("OCSP response not valid: %s (%d)\n",
1236 OCSP_response_status_str(status), status);
1240 if (!(basic_response = OCSP_response_get1_basic(resp)))
1243 debug_printf("OCSP response parse error: unable to extract basic response.\n");
1247 sk = cbinfo->verify_stack;
1248 verify_flags = OCSP_NOVERIFY; /* check sigs, but not purpose */
1250 /* May need to expose ability to adjust those flags?
1251 OCSP_NOSIGS OCSP_NOVERIFY OCSP_NOCHAIN OCSP_NOCHECKS OCSP_NOEXPLICIT
1252 OCSP_TRUSTOTHER OCSP_NOINTERN */
1254 /* This does a full verify on the OCSP proof before we load it for serving
1255 up; possibly overkill - just date-checks might be nice enough.
1257 OCSP_basic_verify takes a "store" arg, but does not
1258 use it for the chain verification, which is all we do
1259 when OCSP_NOVERIFY is set. The content from the wire
1260 "basic_response" and a cert-stack "sk" are all that is used.
1262 We have a stack, loaded in setup_certs() if tls_verify_certificates
1263 was a file (not a directory, or "system"). It is unfortunate we
1264 cannot used the connection context store, as that would neatly
1265 handle the "system" case too, but there seems to be no library
1266 function for getting a stack from a store.
1267 [ In OpenSSL 1.1 - ? X509_STORE_CTX_get0_chain(ctx) ? ]
1268 We do not free the stack since it could be needed a second time for
1271 Separately we might try to replace using OCSP_basic_verify() - which seems to not
1272 be a public interface into the OpenSSL library (there's no manual entry) -
1273 But what with? We also use OCSP_basic_verify in the client stapling callback.
1274 And there we NEED it; we must verify that status... unless the
1275 library does it for us anyway? */
1277 if ((i = OCSP_basic_verify(basic_response, sk, NULL, verify_flags)) < 0)
1281 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
1282 debug_printf("OCSP response verify failure: %s\n", US ssl_errstring);
1287 /* Here's the simplifying assumption: there's only one response, for the
1288 one certificate we use, and nothing for anything else in a chain. If this
1289 proves false, we need to extract a cert id from our issued cert
1290 (tls_certificate) and use that for OCSP_resp_find_status() (which finds the
1291 right cert in the stack and then calls OCSP_single_get0_status()).
1293 I'm hoping to avoid reworking a bunch more of how we handle state here. */
1295 if (!(single_response = OCSP_resp_get0(basic_response, 0)))
1298 debug_printf("Unable to get first response from OCSP basic response.\n");
1302 status = OCSP_single_get0_status(single_response, &reason, &rev, &thisupd, &nextupd);
1303 if (status != V_OCSP_CERTSTATUS_GOOD)
1305 DEBUG(D_tls) debug_printf("OCSP response bad cert status: %s (%d) %s (%d)\n",
1306 OCSP_cert_status_str(status), status,
1307 OCSP_crl_reason_str(reason), reason);
1311 if (!OCSP_check_validity(thisupd, nextupd, EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1313 DEBUG(D_tls) debug_printf("OCSP status invalid times.\n");
1318 /*XXX stack? (these tag points are for multiple leaf-cert support for ocsp */
1319 cbinfo->u_ocsp.server.response = resp;
1323 if (f.running_in_test_harness)
1325 extern char ** environ;
1326 if (environ) for (uschar ** p = USS environ; *p; p++)
1327 if (Ustrncmp(*p, "EXIM_TESTHARNESS_DISABLE_OCSPVALIDITYCHECK", 42) == 0)
1329 DEBUG(D_tls) debug_printf("Supplying known bad OCSP response\n");
1330 goto supply_response;
1335 #endif /*!DISABLE_OCSP*/
1340 /* Create and install a selfsigned certificate, for use in server mode */
1343 tls_install_selfsign(SSL_CTX * sctx, uschar ** errstr)
1351 where = US"allocating pkey";
1352 if (!(pkey = EVP_PKEY_new()))
1355 where = US"allocating cert";
1356 if (!(x509 = X509_new()))
1359 where = US"generating pkey";
1360 if (!(rsa = rsa_callback(NULL, 0, 2048)))
1363 where = US"assigning pkey";
1364 if (!EVP_PKEY_assign_RSA(pkey, rsa))
1367 X509_set_version(x509, 2); /* N+1 - version 3 */
1368 ASN1_INTEGER_set(X509_get_serialNumber(x509), 1);
1369 X509_gmtime_adj(X509_get_notBefore(x509), 0);
1370 X509_gmtime_adj(X509_get_notAfter(x509), (long)60 * 60); /* 1 hour */
1371 X509_set_pubkey(x509, pkey);
1373 name = X509_get_subject_name(x509);
1374 X509_NAME_add_entry_by_txt(name, "C",
1375 MBSTRING_ASC, CUS "UK", -1, -1, 0);
1376 X509_NAME_add_entry_by_txt(name, "O",
1377 MBSTRING_ASC, CUS "Exim Developers", -1, -1, 0);
1378 X509_NAME_add_entry_by_txt(name, "CN",
1379 MBSTRING_ASC, CUS smtp_active_hostname, -1, -1, 0);
1380 X509_set_issuer_name(x509, name);
1382 where = US"signing cert";
1383 if (!X509_sign(x509, pkey, EVP_md5()))
1386 where = US"installing selfsign cert";
1387 if (!SSL_CTX_use_certificate(sctx, x509))
1390 where = US"installing selfsign key";
1391 if (!SSL_CTX_use_PrivateKey(sctx, pkey))
1397 (void) tls_error(where, NULL, NULL, errstr);
1398 if (x509) X509_free(x509);
1399 if (pkey) EVP_PKEY_free(pkey);
1407 tls_add_certfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1410 DEBUG(D_tls) debug_printf("tls_certificate file %s\n", file);
1411 if (!SSL_CTX_use_certificate_chain_file(sctx, CS file))
1412 return tls_error(string_sprintf(
1413 "SSL_CTX_use_certificate_chain_file file=%s", file),
1414 cbinfo->host, NULL, errstr);
1419 tls_add_pkeyfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1422 DEBUG(D_tls) debug_printf("tls_privatekey file %s\n", file);
1423 if (!SSL_CTX_use_PrivateKey_file(sctx, CS file, SSL_FILETYPE_PEM))
1424 return tls_error(string_sprintf(
1425 "SSL_CTX_use_PrivateKey_file file=%s", file), cbinfo->host, NULL, errstr);
1430 /*************************************************
1431 * Expand key and cert file specs *
1432 *************************************************/
1434 /* Called once during tls_init and possibly again during TLS setup, for a
1435 new context, if Server Name Indication was used and tls_sni was seen in
1436 the certificate string.
1439 sctx the SSL_CTX* to update
1440 cbinfo various parts of session state
1441 errstr error string pointer
1443 Returns: OK/DEFER/FAIL
1447 tls_expand_session_files(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo,
1452 if (!cbinfo->certificate)
1454 if (!cbinfo->is_server) /* client */
1457 if (tls_install_selfsign(sctx, errstr) != OK)
1464 if (Ustrstr(cbinfo->certificate, US"tls_sni") ||
1465 Ustrstr(cbinfo->certificate, US"tls_in_sni") ||
1466 Ustrstr(cbinfo->certificate, US"tls_out_sni")
1468 reexpand_tls_files_for_sni = TRUE;
1470 if (!expand_check(cbinfo->certificate, US"tls_certificate", &expanded, errstr))
1474 if (cbinfo->is_server)
1476 const uschar * file_list = expanded;
1480 while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1481 if ((err = tls_add_certfile(sctx, cbinfo, file, errstr)))
1484 else /* would there ever be a need for multiple client certs? */
1485 if ((err = tls_add_certfile(sctx, cbinfo, expanded, errstr)))
1488 if ( cbinfo->privatekey
1489 && !expand_check(cbinfo->privatekey, US"tls_privatekey", &expanded, errstr))
1492 /* If expansion was forced to fail, key_expanded will be NULL. If the result
1493 of the expansion is an empty string, ignore it also, and assume the private
1494 key is in the same file as the certificate. */
1496 if (expanded && *expanded)
1497 if (cbinfo->is_server)
1499 const uschar * file_list = expanded;
1503 while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1504 if ((err = tls_add_pkeyfile(sctx, cbinfo, file, errstr)))
1507 else /* would there ever be a need for multiple client certs? */
1508 if ((err = tls_add_pkeyfile(sctx, cbinfo, expanded, errstr)))
1512 #ifndef DISABLE_OCSP
1513 if (cbinfo->is_server && cbinfo->u_ocsp.server.file)
1516 if (!expand_check(cbinfo->u_ocsp.server.file, US"tls_ocsp_file", &expanded, errstr))
1519 if (expanded && *expanded)
1521 DEBUG(D_tls) debug_printf("tls_ocsp_file %s\n", expanded);
1522 if ( cbinfo->u_ocsp.server.file_expanded
1523 && (Ustrcmp(expanded, cbinfo->u_ocsp.server.file_expanded) == 0))
1525 DEBUG(D_tls) debug_printf(" - value unchanged, using existing values\n");
1528 ocsp_load_response(sctx, cbinfo, expanded);
1539 /*************************************************
1540 * Callback to handle SNI *
1541 *************************************************/
1543 /* Called when acting as server during the TLS session setup if a Server Name
1544 Indication extension was sent by the client.
1546 API documentation is OpenSSL s_server.c implementation.
1549 s SSL* of the current session
1550 ad unknown (part of OpenSSL API) (unused)
1551 arg Callback of "our" registered data
1553 Returns: SSL_TLSEXT_ERR_{OK,ALERT_WARNING,ALERT_FATAL,NOACK}
1555 XXX might need to change to using ClientHello callback,
1556 per https://www.openssl.org/docs/manmaster/man3/SSL_client_hello_cb_fn.html
1559 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1561 tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg)
1563 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
1564 tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
1566 int old_pool = store_pool;
1567 uschar * dummy_errstr;
1570 return SSL_TLSEXT_ERR_OK;
1572 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", servername,
1573 reexpand_tls_files_for_sni ? "" : " (unused for certificate selection)");
1575 /* Make the extension value available for expansion */
1576 store_pool = POOL_PERM;
1577 tls_in.sni = string_copy_taint(US servername, TRUE);
1578 store_pool = old_pool;
1580 if (!reexpand_tls_files_for_sni)
1581 return SSL_TLSEXT_ERR_OK;
1583 /* Can't find an SSL_CTX_clone() or equivalent, so we do it manually;
1584 not confident that memcpy wouldn't break some internal reference counting.
1585 Especially since there's a references struct member, which would be off. */
1587 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
1588 if (!(server_sni = SSL_CTX_new(TLS_server_method())))
1590 if (!(server_sni = SSL_CTX_new(SSLv23_server_method())))
1593 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
1594 DEBUG(D_tls) debug_printf("SSL_CTX_new() failed: %s\n", ssl_errstring);
1598 /* Not sure how many of these are actually needed, since SSL object
1599 already exists. Might even need this selfsame callback, for reneg? */
1601 SSL_CTX_set_info_callback(server_sni, SSL_CTX_get_info_callback(server_ctx));
1602 SSL_CTX_set_mode(server_sni, SSL_CTX_get_mode(server_ctx));
1603 SSL_CTX_set_options(server_sni, SSL_CTX_get_options(server_ctx));
1604 SSL_CTX_set_timeout(server_sni, SSL_CTX_get_timeout(server_ctx));
1605 SSL_CTX_set_tlsext_servername_callback(server_sni, tls_servername_cb);
1606 SSL_CTX_set_tlsext_servername_arg(server_sni, cbinfo);
1608 if ( !init_dh(server_sni, cbinfo->dhparam, NULL, &dummy_errstr)
1609 || !init_ecdh(server_sni, NULL, &dummy_errstr)
1613 if ( cbinfo->server_cipher_list
1614 && !SSL_CTX_set_cipher_list(server_sni, CS cbinfo->server_cipher_list))
1617 #ifndef DISABLE_OCSP
1618 if (cbinfo->u_ocsp.server.file)
1620 SSL_CTX_set_tlsext_status_cb(server_sni, tls_server_stapling_cb);
1621 SSL_CTX_set_tlsext_status_arg(server_sni, cbinfo);
1625 if ((rc = setup_certs(server_sni, tls_verify_certificates, tls_crl, NULL, FALSE,
1626 verify_callback_server, &dummy_errstr)) != OK)
1629 /* do this after setup_certs, because this can require the certs for verifying
1630 OCSP information. */
1631 if ((rc = tls_expand_session_files(server_sni, cbinfo, &dummy_errstr)) != OK)
1634 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
1635 SSL_set_SSL_CTX(s, server_sni);
1636 return SSL_TLSEXT_ERR_OK;
1638 bad: return SSL_TLSEXT_ERR_ALERT_FATAL;
1640 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
1645 #ifndef DISABLE_OCSP
1647 /*************************************************
1648 * Callback to handle OCSP Stapling *
1649 *************************************************/
1651 /* Called when acting as server during the TLS session setup if the client
1652 requests OCSP information with a Certificate Status Request.
1654 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
1660 tls_server_stapling_cb(SSL *s, void *arg)
1662 const tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
1663 uschar *response_der; /*XXX blob */
1664 int response_der_len;
1666 /*XXX stack: use SSL_get_certificate() to see which cert; from that work
1667 out which ocsp blob to send. Unfortunately, SSL_get_certificate is known
1668 buggy in current OpenSSL; it returns the last cert loaded always rather than
1669 the one actually presented. So we can't support a stack of OCSP proofs at
1673 debug_printf("Received TLS status request (OCSP stapling); %s response\n",
1674 cbinfo->u_ocsp.server.response ? "have" : "lack");
1676 tls_in.ocsp = OCSP_NOT_RESP;
1677 if (!cbinfo->u_ocsp.server.response)
1678 return SSL_TLSEXT_ERR_NOACK;
1680 response_der = NULL;
1681 response_der_len = i2d_OCSP_RESPONSE(cbinfo->u_ocsp.server.response, /*XXX stack*/
1683 if (response_der_len <= 0)
1684 return SSL_TLSEXT_ERR_NOACK;
1686 SSL_set_tlsext_status_ocsp_resp(server_ssl, response_der, response_der_len);
1687 tls_in.ocsp = OCSP_VFIED;
1688 return SSL_TLSEXT_ERR_OK;
1693 time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
1695 BIO_printf(bp, "\t%s: ", str);
1696 ASN1_GENERALIZEDTIME_print(bp, time);
1701 tls_client_stapling_cb(SSL *s, void *arg)
1703 tls_ext_ctx_cb * cbinfo = arg;
1704 const unsigned char * p;
1706 OCSP_RESPONSE * rsp;
1707 OCSP_BASICRESP * bs;
1710 DEBUG(D_tls) debug_printf("Received TLS status response (OCSP stapling):");
1711 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
1714 /* Expect this when we requested ocsp but got none */
1715 if (cbinfo->u_ocsp.client.verify_required && LOGGING(tls_cipher))
1716 log_write(0, LOG_MAIN, "Received TLS status callback, null content");
1718 DEBUG(D_tls) debug_printf(" null\n");
1719 return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1722 if (!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
1724 tls_out.ocsp = OCSP_FAILED; /*XXX should use tlsp-> to permit concurrent outbound */
1725 if (LOGGING(tls_cipher))
1726 log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
1728 DEBUG(D_tls) debug_printf(" parse error\n");
1732 if (!(bs = OCSP_response_get1_basic(rsp)))
1734 tls_out.ocsp = OCSP_FAILED;
1735 if (LOGGING(tls_cipher))
1736 log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
1738 DEBUG(D_tls) debug_printf(" error parsing response\n");
1739 OCSP_RESPONSE_free(rsp);
1743 /* We'd check the nonce here if we'd put one in the request. */
1744 /* However that would defeat cacheability on the server so we don't. */
1746 /* This section of code reworked from OpenSSL apps source;
1747 The OpenSSL Project retains copyright:
1748 Copyright (c) 1999 The OpenSSL Project. All rights reserved.
1753 ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
1755 DEBUG(D_tls) bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
1757 /*OCSP_RESPONSE_print(bp, rsp, 0); extreme debug: stapling content */
1759 /* Use the chain that verified the server cert to verify the stapled info */
1760 /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
1762 if ((i = OCSP_basic_verify(bs, cbinfo->verify_stack,
1763 cbinfo->u_ocsp.client.verify_store, 0)) <= 0)
1765 tls_out.ocsp = OCSP_FAILED;
1766 if (LOGGING(tls_cipher)) log_write(0, LOG_MAIN,
1767 "Received TLS cert status response, itself unverifiable: %s",
1768 ERR_reason_error_string(ERR_peek_error()));
1769 BIO_printf(bp, "OCSP response verify failure\n");
1770 ERR_print_errors(bp);
1771 OCSP_RESPONSE_print(bp, rsp, 0);
1775 BIO_printf(bp, "OCSP response well-formed and signed OK\n");
1777 /*XXX So we have a good stapled OCSP status. How do we know
1778 it is for the cert of interest? OpenSSL 1.1.0 has a routine
1779 OCSP_resp_find_status() which matches on a cert id, which presumably
1780 we should use. Making an id needs OCSP_cert_id_new(), which takes
1781 issuerName, issuerKey, serialNumber. Are they all in the cert?
1783 For now, carry on blindly accepting the resp. */
1786 OCSP_SINGLERESP * single;
1788 #ifdef EXIM_HAVE_OCSP_RESP_COUNT
1789 if (OCSP_resp_count(bs) != 1)
1791 STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
1792 if (sk_OCSP_SINGLERESP_num(sresp) != 1)
1795 tls_out.ocsp = OCSP_FAILED;
1796 log_write(0, LOG_MAIN, "OCSP stapling "
1797 "with multiple responses not handled");
1800 single = OCSP_resp_get0(bs, 0);
1801 status = OCSP_single_get0_status(single, &reason, &rev,
1802 &thisupd, &nextupd);
1805 DEBUG(D_tls) time_print(bp, "This OCSP Update", thisupd);
1806 DEBUG(D_tls) if(nextupd) time_print(bp, "Next OCSP Update", nextupd);
1807 if (!OCSP_check_validity(thisupd, nextupd,
1808 EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1810 tls_out.ocsp = OCSP_FAILED;
1811 DEBUG(D_tls) ERR_print_errors(bp);
1812 log_write(0, LOG_MAIN, "Server OSCP dates invalid");
1816 DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
1817 OCSP_cert_status_str(status));
1820 case V_OCSP_CERTSTATUS_GOOD:
1821 tls_out.ocsp = OCSP_VFIED;
1824 case V_OCSP_CERTSTATUS_REVOKED:
1825 tls_out.ocsp = OCSP_FAILED;
1826 log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
1827 reason != -1 ? "; reason: " : "",
1828 reason != -1 ? OCSP_crl_reason_str(reason) : "");
1829 DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
1832 tls_out.ocsp = OCSP_FAILED;
1833 log_write(0, LOG_MAIN,
1834 "Server certificate status unknown, in OCSP stapling");
1839 i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1844 OCSP_RESPONSE_free(rsp);
1847 #endif /*!DISABLE_OCSP*/
1850 /*************************************************
1851 * Initialize for TLS *
1852 *************************************************/
1854 /* Called from both server and client code, to do preliminary initialization
1855 of the library. We allocate and return a context structure.
1858 ctxp returned SSL context
1859 host connected host, if client; NULL if server
1860 dhparam DH parameter file
1861 certificate certificate file
1862 privatekey private key
1863 ocsp_file file of stapling info (server); flag for require ocsp (client)
1864 addr address if client; NULL if server (for some randomness)
1865 cbp place to put allocated callback context
1866 errstr error string pointer
1868 Returns: OK/DEFER/FAIL
1872 tls_init(SSL_CTX **ctxp, host_item *host, uschar *dhparam, uschar *certificate,
1874 #ifndef DISABLE_OCSP
1875 uschar *ocsp_file, /*XXX stack, in server*/
1877 address_item *addr, tls_ext_ctx_cb ** cbp,
1884 tls_ext_ctx_cb * cbinfo;
1886 cbinfo = store_malloc(sizeof(tls_ext_ctx_cb));
1887 cbinfo->tlsp = tlsp;
1888 cbinfo->certificate = certificate;
1889 cbinfo->privatekey = privatekey;
1890 cbinfo->is_server = host==NULL;
1891 #ifndef DISABLE_OCSP
1892 cbinfo->verify_stack = NULL;
1895 cbinfo->u_ocsp.server.file = ocsp_file;
1896 cbinfo->u_ocsp.server.file_expanded = NULL;
1897 cbinfo->u_ocsp.server.response = NULL;
1900 cbinfo->u_ocsp.client.verify_store = NULL;
1902 cbinfo->dhparam = dhparam;
1903 cbinfo->server_cipher_list = NULL;
1904 cbinfo->host = host;
1905 #ifndef DISABLE_EVENT
1906 cbinfo->event_action = NULL;
1909 #ifdef EXIM_NEED_OPENSSL_INIT
1910 SSL_load_error_strings(); /* basic set up */
1911 OpenSSL_add_ssl_algorithms();
1914 #ifdef EXIM_HAVE_SHA256
1915 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
1916 list of available digests. */
1917 EVP_add_digest(EVP_sha256());
1920 /* Create a context.
1921 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
1922 negotiation in the different methods; as far as I can tell, the only
1923 *_{server,client}_method which allows negotiation is SSLv23, which exists even
1924 when OpenSSL is built without SSLv2 support.
1925 By disabling with openssl_options, we can let admins re-enable with the
1928 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
1929 if (!(ctx = SSL_CTX_new(host ? TLS_client_method() : TLS_server_method())))
1931 if (!(ctx = SSL_CTX_new(host ? SSLv23_client_method() : SSLv23_server_method())))
1933 return tls_error(US"SSL_CTX_new", host, NULL, errstr);
1935 /* It turns out that we need to seed the random number generator this early in
1936 order to get the full complement of ciphers to work. It took me roughly a day
1937 of work to discover this by experiment.
1939 On systems that have /dev/urandom, SSL may automatically seed itself from
1940 there. Otherwise, we have to make something up as best we can. Double check
1946 gettimeofday(&r.tv, NULL);
1949 RAND_seed(US (&r), sizeof(r));
1950 RAND_seed(US big_buffer, big_buffer_size);
1951 if (addr != NULL) RAND_seed(US addr, sizeof(addr));
1954 return tls_error(US"RAND_status", host,
1955 US"unable to seed random number generator", errstr);
1958 /* Set up the information callback, which outputs if debugging is at a suitable
1963 SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
1964 #if defined(EXIM_HAVE_OPESSL_TRACE) && !defined(OPENSSL_NO_SSL_TRACE)
1965 /* this needs a debug build of OpenSSL */
1966 SSL_CTX_set_msg_callback(ctx, (void (*)())SSL_trace);
1968 #ifdef OPENSSL_HAVE_KEYLOG_CB
1969 SSL_CTX_set_keylog_callback(ctx, (void (*)())keylog_callback);
1973 /* Automatically re-try reads/writes after renegotiation. */
1974 (void) SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
1976 /* Apply administrator-supplied work-arounds.
1977 Historically we applied just one requested option,
1978 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
1979 moved to an administrator-controlled list of options to specify and
1980 grandfathered in the first one as the default value for "openssl_options".
1982 No OpenSSL version number checks: the options we accept depend upon the
1983 availability of the option value macros from OpenSSL. */
1985 if (!tls_openssl_options_parse(openssl_options, &init_options))
1986 return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
1988 #ifdef EXPERIMENTAL_TLS_RESUME
1989 tlsp->resumption = RESUME_SUPPORTED;
1993 #ifdef EXPERIMENTAL_TLS_RESUME
1994 /* Should the server offer session resumption? */
1995 if (!host && verify_check_host(&tls_resumption_hosts) == OK)
1997 DEBUG(D_tls) debug_printf("tls_resumption_hosts overrides openssl_options\n");
1998 init_options &= ~SSL_OP_NO_TICKET;
1999 tlsp->resumption |= RESUME_SERVER_TICKET; /* server will give ticket on request */
2000 tlsp->host_resumable = TRUE;
2004 DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
2005 if (!(SSL_CTX_set_options(ctx, init_options)))
2006 return tls_error(string_sprintf(
2007 "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
2010 DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
2012 /* We'd like to disable session cache unconditionally, but foolish Outlook
2013 Express clients then give up the first TLS connection and make a second one
2014 (which works). Only when there is an IMAP service on the same machine.
2015 Presumably OE is trying to use the cache for A on B. Leave it enabled for
2016 now, until we work out a decent way of presenting control to the config. It
2017 will never be used because we use a new context every time. */
2019 (void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
2022 /* Initialize with DH parameters if supplied */
2023 /* Initialize ECDH temp key parameter selection */
2025 if ( !init_dh(ctx, dhparam, host, errstr)
2026 || !init_ecdh(ctx, host, errstr)
2030 /* Set up certificate and key (and perhaps OCSP info) */
2032 if ((rc = tls_expand_session_files(ctx, cbinfo, errstr)) != OK)
2035 /* If we need to handle SNI or OCSP, do so */
2037 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2038 # ifndef DISABLE_OCSP
2039 if (!(cbinfo->verify_stack = sk_X509_new_null()))
2041 DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
2046 if (!host) /* server */
2048 # ifndef DISABLE_OCSP
2049 /* We check u_ocsp.server.file, not server.response, because we care about if
2050 the option exists, not what the current expansion might be, as SNI might
2051 change the certificate and OCSP file in use between now and the time the
2052 callback is invoked. */
2053 if (cbinfo->u_ocsp.server.file)
2055 SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
2056 SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
2059 /* We always do this, so that $tls_sni is available even if not used in
2061 SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
2062 SSL_CTX_set_tlsext_servername_arg(ctx, cbinfo);
2064 # ifndef DISABLE_OCSP
2066 if(ocsp_file) /* wanting stapling */
2068 if (!(cbinfo->u_ocsp.client.verify_store = X509_STORE_new()))
2070 DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
2073 SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
2074 SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
2079 cbinfo->verify_cert_hostnames = NULL;
2081 #ifdef EXIM_HAVE_EPHEM_RSA_KEX
2082 /* Set up the RSA callback */
2083 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
2086 /* Finally, set the session cache timeout, and we are done.
2087 The period appears to be also used for (server-generated) session tickets */
2089 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
2090 DEBUG(D_tls) debug_printf("Initialized TLS\n");
2101 /*************************************************
2102 * Get name of cipher in use *
2103 *************************************************/
2106 Argument: pointer to an SSL structure for the connection
2107 pointer to number of bits for cipher
2108 Returns: pointer to allocated string in perm-pool
2112 construct_cipher_name(SSL * ssl, int * bits)
2114 int pool = store_pool;
2115 /* With OpenSSL 1.0.0a, 'c' needs to be const but the documentation doesn't
2116 yet reflect that. It should be a safe change anyway, even 0.9.8 versions have
2117 the accessor functions use const in the prototype. */
2119 const uschar * ver = CUS SSL_get_version(ssl);
2120 const SSL_CIPHER * c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
2123 SSL_CIPHER_get_bits(c, bits);
2125 store_pool = POOL_PERM;
2126 s = string_sprintf("%s:%s:%u", ver, SSL_CIPHER_get_name(c), *bits);
2128 DEBUG(D_tls) debug_printf("Cipher: %s\n", s);
2133 /* Get IETF-standard name for ciphersuite.
2134 Argument: pointer to an SSL structure for the connection
2135 Returns: pointer to string
2138 static const uschar *
2139 cipher_stdname_ssl(SSL * ssl)
2141 #ifdef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
2142 return CUS SSL_CIPHER_standard_name(SSL_get_current_cipher(ssl));
2144 ushort id = 0xffff & SSL_CIPHER_get_id(SSL_get_current_cipher(ssl));
2145 return cipher_stdname(id >> 8, id & 0xff);
2151 peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned siz)
2153 /*XXX we might consider a list-of-certs variable for the cert chain.
2154 SSL_get_peer_cert_chain(SSL*). We'd need a new variable type and support
2155 in list-handling functions, also consider the difference between the entire
2156 chain and the elements sent by the peer. */
2158 tlsp->peerdn = NULL;
2160 /* Will have already noted peercert on a verify fail; possibly not the leaf */
2161 if (!tlsp->peercert)
2162 tlsp->peercert = SSL_get_peer_certificate(ssl);
2163 /* Beware anonymous ciphers which lead to server_cert being NULL */
2165 if (!X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, siz))
2166 { DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n"); }
2169 int oldpool = store_pool;
2171 peerdn[siz-1] = '\0'; /* paranoia */
2172 store_pool = POOL_PERM;
2173 tlsp->peerdn = string_copy(peerdn);
2174 store_pool = oldpool;
2176 /* We used to set CV in the cert-verify callbacks (either plain or dane)
2177 but they don't get called on session-resumption. So use the official
2178 interface, which uses the resumed value. Unfortunately this claims verified
2179 when it actually failed but we're in try-verify mode, due to us wanting the
2180 knowlege that it failed so needing to have the callback and forcing a
2181 permissive return. If we don't force it, the TLS startup is failed.
2182 The extra bit of information is set in verify_override in the cb, stashed
2183 for resumption next to the TLS session, and used here. */
2185 if (!tlsp->verify_override)
2186 tlsp->certificate_verified = SSL_get_verify_result(ssl) == X509_V_OK;
2194 /*************************************************
2195 * Set up for verifying certificates *
2196 *************************************************/
2198 #ifndef DISABLE_OCSP
2199 /* Load certs from file, return TRUE on success */
2202 chain_from_pem_file(const uschar * file, STACK_OF(X509) * verify_stack)
2207 while (sk_X509_num(verify_stack) > 0)
2208 X509_free(sk_X509_pop(verify_stack));
2210 if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
2211 while ((x = PEM_read_bio_X509(bp, NULL, 0, NULL)))
2212 sk_X509_push(verify_stack, x);
2220 /* Called by both client and server startup; on the server possibly
2221 repeated after a Server Name Indication.
2224 sctx SSL_CTX* to initialise
2225 certs certs file or NULL
2226 crl CRL file or NULL
2227 host NULL in a server; the remote host in a client
2228 optional TRUE if called from a server for a host in tls_try_verify_hosts;
2229 otherwise passed as FALSE
2230 cert_vfy_cb Callback function for certificate verification
2231 errstr error string pointer
2233 Returns: OK/DEFER/FAIL
2237 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
2238 int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr)
2240 uschar *expcerts, *expcrl;
2242 if (!expand_check(certs, US"tls_verify_certificates", &expcerts, errstr))
2244 DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
2246 if (expcerts && *expcerts)
2248 /* Tell the library to use its compiled-in location for the system default
2249 CA bundle. Then add the ones specified in the config, if any. */
2251 if (!SSL_CTX_set_default_verify_paths(sctx))
2252 return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
2254 if (Ustrcmp(expcerts, "system") != 0)
2256 struct stat statbuf;
2258 if (Ustat(expcerts, &statbuf) < 0)
2260 log_write(0, LOG_MAIN|LOG_PANIC,
2261 "failed to stat %s for certificates", expcerts);
2267 if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
2268 { file = NULL; dir = expcerts; }
2271 file = expcerts; dir = NULL;
2272 #ifndef DISABLE_OCSP
2273 /* In the server if we will be offering an OCSP proof, load chain from
2274 file for verifying the OCSP proof at load time. */
2277 && statbuf.st_size > 0
2278 && server_static_cbinfo->u_ocsp.server.file
2279 && !chain_from_pem_file(file, server_static_cbinfo->verify_stack)
2282 log_write(0, LOG_MAIN|LOG_PANIC,
2283 "failed to load cert chain from %s", file);
2289 /* If a certificate file is empty, the next function fails with an
2290 unhelpful error message. If we skip it, we get the correct behaviour (no
2291 certificates are recognized, but the error message is still misleading (it
2292 says no certificate was supplied). But this is better. */
2294 if ( (!file || statbuf.st_size > 0)
2295 && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
2296 return tls_error(US"SSL_CTX_load_verify_locations", host, NULL, errstr);
2298 /* Load the list of CAs for which we will accept certs, for sending
2299 to the client. This is only for the one-file tls_verify_certificates
2301 If a list isn't loaded into the server, but some verify locations are set,
2302 the server end appears to make a wildcard request for client certs.
2303 Meanwhile, the client library as default behaviour *ignores* the list
2304 we send over the wire - see man SSL_CTX_set_client_cert_cb.
2305 Because of this, and that the dir variant is likely only used for
2306 the public-CA bundle (not for a private CA), not worth fixing. */
2310 STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
2312 SSL_CTX_set_client_CA_list(sctx, names);
2313 DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n",
2314 sk_X509_NAME_num(names));
2319 /* Handle a certificate revocation list. */
2321 #if OPENSSL_VERSION_NUMBER > 0x00907000L
2323 /* This bit of code is now the version supplied by Lars Mainka. (I have
2324 merely reformatted it into the Exim code style.)
2326 "From here I changed the code to add support for multiple crl's
2327 in pem format in one file or to support hashed directory entries in
2328 pem format instead of a file. This method now uses the library function
2329 X509_STORE_load_locations to add the CRL location to the SSL context.
2330 OpenSSL will then handle the verify against CA certs and CRLs by
2331 itself in the verify callback." */
2333 if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
2334 if (expcrl && *expcrl)
2336 struct stat statbufcrl;
2337 if (Ustat(expcrl, &statbufcrl) < 0)
2339 log_write(0, LOG_MAIN|LOG_PANIC,
2340 "failed to stat %s for certificates revocation lists", expcrl);
2345 /* is it a file or directory? */
2347 X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
2348 if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
2352 DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
2358 DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
2360 if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
2361 return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
2363 /* setting the flags to check against the complete crl chain */
2365 X509_STORE_set_flags(cvstore,
2366 X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
2370 #endif /* OPENSSL_VERSION_NUMBER > 0x00907000L */
2372 /* If verification is optional, don't fail if no certificate */
2374 SSL_CTX_set_verify(sctx,
2375 SSL_VERIFY_PEER | (optional ? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
2384 /*************************************************
2385 * Start a TLS session in a server *
2386 *************************************************/
2388 /* This is called when Exim is running as a server, after having received
2389 the STARTTLS command. It must respond to that command, and then negotiate
2393 require_ciphers allowed ciphers
2394 errstr pointer to error message
2396 Returns: OK on success
2397 DEFER for errors before the start of the negotiation
2398 FAIL for errors during the negotiation; the server can't
2403 tls_server_start(const uschar * require_ciphers, uschar ** errstr)
2406 uschar * expciphers;
2407 tls_ext_ctx_cb * cbinfo;
2408 static uschar peerdn[256];
2410 /* Check for previous activation */
2412 if (tls_in.active.sock >= 0)
2414 tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
2415 smtp_printf("554 Already in TLS\r\n", FALSE);
2419 /* Initialize the SSL library. If it fails, it will already have logged
2422 rc = tls_init(&server_ctx, NULL, tls_dhparam, tls_certificate, tls_privatekey,
2423 #ifndef DISABLE_OCSP
2424 tls_ocsp_file, /*XXX stack*/
2426 NULL, &server_static_cbinfo, &tls_in, errstr);
2427 if (rc != OK) return rc;
2428 cbinfo = server_static_cbinfo;
2430 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
2433 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2434 were historically separated by underscores. So that I can use either form in my
2435 tests, and also for general convenience, we turn underscores into hyphens here.
2437 XXX SSL_CTX_set_cipher_list() is replaced by SSL_CTX_set_ciphersuites()
2438 for TLS 1.3 . Since we do not call it at present we get the default list:
2439 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
2444 for (uschar * s = expciphers; *s; s++ ) if (*s == '_') *s = '-';
2445 DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2446 if (!SSL_CTX_set_cipher_list(server_ctx, CS expciphers))
2447 return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL, errstr);
2448 cbinfo->server_cipher_list = expciphers;
2451 /* If this is a host for which certificate verification is mandatory or
2452 optional, set up appropriately. */
2454 tls_in.certificate_verified = FALSE;
2456 tls_in.dane_verified = FALSE;
2458 server_verify_callback_called = FALSE;
2460 if (verify_check_host(&tls_verify_hosts) == OK)
2462 rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2463 FALSE, verify_callback_server, errstr);
2464 if (rc != OK) return rc;
2465 server_verify_optional = FALSE;
2467 else if (verify_check_host(&tls_try_verify_hosts) == OK)
2469 rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2470 TRUE, verify_callback_server, errstr);
2471 if (rc != OK) return rc;
2472 server_verify_optional = TRUE;
2475 #ifdef EXPERIMENTAL_TLS_RESUME
2476 SSL_CTX_set_tlsext_ticket_key_cb(server_ctx, ticket_key_callback);
2477 /* despite working, appears to always return failure, so ignoring */
2479 #ifdef OPENSSL_HAVE_NUM_TICKETS
2480 # ifdef EXPERIMENTAL_TLS_RESUME
2481 SSL_CTX_set_num_tickets(server_ctx, tls_in.host_resumable ? 1 : 0);
2483 SSL_CTX_set_num_tickets(server_ctx, 0); /* send no TLS1.3 stateful-tickets */
2488 /* Prepare for new connection */
2490 if (!(server_ssl = SSL_new(server_ctx)))
2491 return tls_error(US"SSL_new", NULL, NULL, errstr);
2493 /* Warning: we used to SSL_clear(ssl) here, it was removed.
2495 * With the SSL_clear(), we get strange interoperability bugs with
2496 * OpenSSL 1.0.1b and TLS1.1/1.2. It looks as though this may be a bug in
2497 * OpenSSL itself, as a clear should not lead to inability to follow protocols.
2499 * The SSL_clear() call is to let an existing SSL* be reused, typically after
2500 * session shutdown. In this case, we have a brand new object and there's no
2501 * obvious reason to immediately clear it. I'm guessing that this was
2502 * originally added because of incomplete initialisation which the clear fixed,
2503 * in some historic release.
2506 /* Set context and tell client to go ahead, except in the case of TLS startup
2507 on connection, where outputting anything now upsets the clients and tends to
2508 make them disconnect. We need to have an explicit fflush() here, to force out
2509 the response. Other smtp_printf() calls do not need it, because in non-TLS
2510 mode, the fflush() happens when smtp_getc() is called. */
2512 SSL_set_session_id_context(server_ssl, sid_ctx, Ustrlen(sid_ctx));
2513 if (!tls_in.on_connect)
2515 smtp_printf("220 TLS go ahead\r\n", FALSE);
2519 /* Now negotiate the TLS session. We put our own timer on it, since it seems
2520 that the OpenSSL library doesn't. */
2522 SSL_set_wfd(server_ssl, fileno(smtp_out));
2523 SSL_set_rfd(server_ssl, fileno(smtp_in));
2524 SSL_set_accept_state(server_ssl);
2526 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
2528 sigalrm_seen = FALSE;
2529 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
2530 rc = SSL_accept(server_ssl);
2535 (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
2539 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
2540 ERR_clear_error(); /* Even success can leave errors in the stack. Seen with
2541 anon-authentication ciphersuite negotiated. */
2543 #ifdef EXPERIMENTAL_TLS_RESUME
2544 if (SSL_session_reused(server_ssl))
2546 tls_in.resumption |= RESUME_USED;
2547 DEBUG(D_tls) debug_printf("Session reused\n");
2551 /* TLS has been set up. Adjust the input functions to read via TLS,
2552 and initialize things. */
2554 peer_cert(server_ssl, &tls_in, peerdn, sizeof(peerdn));
2556 tls_in.cipher = construct_cipher_name(server_ssl, &tls_in.bits);
2557 tls_in.cipher_stdname = cipher_stdname_ssl(server_ssl);
2562 if (SSL_get_shared_ciphers(server_ssl, CS buf, sizeof(buf)))
2563 debug_printf("Shared ciphers: %s\n", buf);
2565 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
2567 BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
2568 SSL_SESSION_print_keylog(bp, SSL_get_session(server_ssl));
2573 #ifdef EXIM_HAVE_SESSION_TICKET
2575 SSL_SESSION * ss = SSL_get_session(server_ssl);
2576 if (SSL_SESSION_has_ticket(ss)) /* 1.1.0 */
2577 debug_printf("The session has a ticket, life %lu seconds\n",
2578 SSL_SESSION_get_ticket_lifetime_hint(ss));
2583 /* Record the certificate we presented */
2585 X509 * crt = SSL_get_certificate(server_ssl);
2586 tls_in.ourcert = crt ? X509_dup(crt) : NULL;
2589 /* Only used by the server-side tls (tls_in), including tls_getc.
2590 Client-side (tls_out) reads (seem to?) go via
2591 smtp_read_response()/ip_recv().
2592 Hence no need to duplicate for _in and _out.
2594 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
2595 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
2596 ssl_xfer_eof = ssl_xfer_error = FALSE;
2598 receive_getc = tls_getc;
2599 receive_getbuf = tls_getbuf;
2600 receive_get_cache = tls_get_cache;
2601 receive_ungetc = tls_ungetc;
2602 receive_feof = tls_feof;
2603 receive_ferror = tls_ferror;
2604 receive_smtp_buffered = tls_smtp_buffered;
2606 tls_in.active.sock = fileno(smtp_out);
2607 tls_in.active.tls_ctx = NULL; /* not using explicit ctx for server-side */
2615 tls_client_basic_ctx_init(SSL_CTX * ctx,
2616 host_item * host, smtp_transport_options_block * ob, tls_ext_ctx_cb * cbinfo,
2620 /* stick to the old behaviour for compatibility if tls_verify_certificates is
2621 set but both tls_verify_hosts and tls_try_verify_hosts is not set. Check only
2622 the specified host patterns if one of them is defined */
2624 if ( ( !ob->tls_verify_hosts
2625 && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
2627 || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
2629 client_verify_optional = FALSE;
2630 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
2631 client_verify_optional = TRUE;
2635 if ((rc = setup_certs(ctx, ob->tls_verify_certificates,
2636 ob->tls_crl, host, client_verify_optional, verify_callback_client,
2640 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
2642 cbinfo->verify_cert_hostnames =
2644 string_domain_utf8_to_alabel(host->name, NULL);
2648 DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
2649 cbinfo->verify_cert_hostnames);
2657 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
2660 const char * hostnames[2] = { CS host->name, NULL };
2663 if (DANESSL_init(ssl, NULL, hostnames) != 1)
2664 return tls_error(US"hostnames load", host, NULL, errstr);
2666 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
2667 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2668 ) if (rr->type == T_TLSA && rr->size > 3)
2670 const uschar * p = rr->data;
2671 uint8_t usage, selector, mtype;
2672 const char * mdname;
2676 /* Only DANE-TA(2) and DANE-EE(3) are supported */
2677 if (usage != 2 && usage != 3) continue;
2684 default: continue; /* Only match-types 0, 1, 2 are supported */
2685 case 0: mdname = NULL; break;
2686 case 1: mdname = "sha256"; break;
2687 case 2: mdname = "sha512"; break;
2691 switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
2694 return tls_error(US"tlsa load", host, NULL, errstr);
2695 case 0: /* action not taken */
2699 tls_out.tlsa_usage |= 1<<usage;
2705 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
2708 #endif /*SUPPORT_DANE*/
2712 #ifdef EXPERIMENTAL_TLS_RESUME
2713 /* On the client, get any stashed session for the given IP from hints db
2714 and apply it to the ssl-connection for attempted resumption. */
2717 tls_retrieve_session(tls_support * tlsp, SSL * ssl, const uschar * key)
2719 tlsp->resumption |= RESUME_SUPPORTED;
2720 if (tlsp->host_resumable)
2722 dbdata_tls_session * dt;
2724 open_db dbblock, * dbm_file;
2726 tlsp->resumption |= RESUME_CLIENT_REQUESTED;
2727 DEBUG(D_tls) debug_printf("checking for resumable session for %s\n", key);
2728 if ((dbm_file = dbfn_open(US"tls", O_RDONLY, &dbblock, FALSE, FALSE)))
2730 /* key for the db is the IP */
2731 if ((dt = dbfn_read_with_length(dbm_file, key, &len)))
2733 SSL_SESSION * ss = NULL;
2734 const uschar * sess_asn1 = dt->session;
2736 len -= sizeof(dbdata_tls_session);
2737 if (!(d2i_SSL_SESSION(&ss, &sess_asn1, (long)len)))
2741 ERR_error_string_n(ERR_get_error(),
2742 ssl_errstring, sizeof(ssl_errstring));
2743 debug_printf("decoding session: %s\n", ssl_errstring);
2746 #ifdef EXIM_HAVE_SESSION_TICKET
2747 else if ( SSL_SESSION_get_ticket_lifetime_hint(ss) + dt->time_stamp
2750 DEBUG(D_tls) debug_printf("session expired\n");
2751 dbfn_delete(dbm_file, key);
2754 else if (!SSL_set_session(ssl, ss))
2758 ERR_error_string_n(ERR_get_error(),
2759 ssl_errstring, sizeof(ssl_errstring));
2760 debug_printf("applying session to ssl: %s\n", ssl_errstring);
2765 DEBUG(D_tls) debug_printf("good session\n");
2766 tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
2767 tlsp->verify_override = dt->verify_override;
2768 tlsp->ocsp = dt->ocsp;
2772 DEBUG(D_tls) debug_printf("no session record\n");
2773 dbfn_close(dbm_file);
2779 /* On the client, save the session for later resumption */
2782 tls_save_session_cb(SSL * ssl, SSL_SESSION * ss)
2784 tls_ext_ctx_cb * cbinfo = SSL_get_ex_data(ssl, tls_exdata_idx);
2787 DEBUG(D_tls) debug_printf("tls_save_session_cb\n");
2789 if (!cbinfo || !(tlsp = cbinfo->tlsp)->host_resumable) return 0;
2791 # ifdef OPENSSL_HAVE_NUM_TICKETS
2792 if (SSL_SESSION_is_resumable(ss)) /* 1.1.1 */
2795 int len = i2d_SSL_SESSION(ss, NULL);
2796 int dlen = sizeof(dbdata_tls_session) + len;
2797 dbdata_tls_session * dt = store_get(dlen, TRUE);
2798 uschar * s = dt->session;
2799 open_db dbblock, * dbm_file;
2801 DEBUG(D_tls) debug_printf("session is resumable\n");
2802 tlsp->resumption |= RESUME_SERVER_TICKET; /* server gave us a ticket */
2804 dt->verify_override = tlsp->verify_override;
2805 dt->ocsp = tlsp->ocsp;
2806 (void) i2d_SSL_SESSION(ss, &s); /* s gets bumped to end */
2808 if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
2810 const uschar * key = cbinfo->host->address;
2811 dbfn_delete(dbm_file, key);
2812 dbfn_write(dbm_file, key, dt, dlen);
2813 dbfn_close(dbm_file);
2814 DEBUG(D_tls) debug_printf("wrote session (len %u) to db\n",
2823 tls_client_ctx_resume_prehandshake(
2824 exim_openssl_client_tls_ctx * exim_client_ctx, tls_support * tlsp,
2825 smtp_transport_options_block * ob, host_item * host)
2827 /* Should the client request a session resumption ticket? */
2828 if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
2830 tlsp->host_resumable = TRUE;
2832 SSL_CTX_set_session_cache_mode(exim_client_ctx->ctx,
2833 SSL_SESS_CACHE_CLIENT
2834 | SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_NO_AUTO_CLEAR);
2835 SSL_CTX_sess_set_new_cb(exim_client_ctx->ctx, tls_save_session_cb);
2840 tls_client_ssl_resume_prehandshake(SSL * ssl, tls_support * tlsp,
2841 host_item * host, uschar ** errstr)
2843 if (tlsp->host_resumable)
2846 debug_printf("tls_resumption_hosts overrides openssl_options, enabling tickets\n");
2847 SSL_clear_options(ssl, SSL_OP_NO_TICKET);
2849 tls_exdata_idx = SSL_get_ex_new_index(0, 0, 0, 0, 0);
2850 if (!SSL_set_ex_data(ssl, tls_exdata_idx, client_static_cbinfo))
2852 tls_error(US"set ex_data", host, NULL, errstr);
2855 debug_printf("tls_exdata_idx %d cbinfo %p\n", tls_exdata_idx, client_static_cbinfo);
2858 tlsp->resumption = RESUME_SUPPORTED;
2859 /* Pick up a previous session, saved on an old ticket */
2860 tls_retrieve_session(tlsp, ssl, host->address);
2865 tls_client_resume_posthandshake(exim_openssl_client_tls_ctx * exim_client_ctx,
2868 if (SSL_session_reused(exim_client_ctx->ssl))
2870 DEBUG(D_tls) debug_printf("The session was reused\n");
2871 tlsp->resumption |= RESUME_USED;
2874 #endif /* EXPERIMENTAL_TLS_RESUME */
2877 /*************************************************
2878 * Start a TLS session in a client *
2879 *************************************************/
2881 /* Called from the smtp transport after STARTTLS has been accepted.
2884 cctx connection context
2885 conn_args connection details
2886 cookie datum for randomness; can be NULL
2887 tlsp record details of TLS channel configuration here; must be non-NULL
2888 errstr error string pointer
2890 Returns: TRUE for success with TLS session context set in connection context,
2895 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
2896 void * cookie, tls_support * tlsp, uschar ** errstr)
2898 host_item * host = conn_args->host; /* for msgs and option-tests */
2899 transport_instance * tb = conn_args->tblock; /* always smtp or NULL */
2900 smtp_transport_options_block * ob = tb
2901 ? (smtp_transport_options_block *)tb->options_block
2902 : &smtp_transport_option_defaults;
2903 exim_openssl_client_tls_ctx * exim_client_ctx;
2904 uschar * expciphers;
2906 static uschar peerdn[256];
2908 #ifndef DISABLE_OCSP
2909 BOOL request_ocsp = FALSE;
2910 BOOL require_ocsp = FALSE;
2914 store_pool = POOL_PERM;
2915 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx), FALSE);
2916 exim_client_ctx->corked = NULL;
2920 tlsp->tlsa_usage = 0;
2923 #ifndef DISABLE_OCSP
2925 # ifdef SUPPORT_DANE
2926 if ( conn_args->dane
2927 && ob->hosts_request_ocsp[0] == '*'
2928 && ob->hosts_request_ocsp[1] == '\0'
2931 /* Unchanged from default. Use a safer one under DANE */
2932 request_ocsp = TRUE;
2933 ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
2934 " {= {4}{$tls_out_tlsa_usage}} } "
2940 verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK))
2941 request_ocsp = TRUE;
2943 # ifdef SUPPORT_DANE
2947 verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
2951 rc = tls_init(&exim_client_ctx->ctx, host, NULL,
2952 ob->tls_certificate, ob->tls_privatekey,
2953 #ifndef DISABLE_OCSP
2954 (void *)(long)request_ocsp,
2956 cookie, &client_static_cbinfo, tlsp, errstr);
2957 if (rc != OK) return FALSE;
2959 tlsp->certificate_verified = FALSE;
2960 client_verify_callback_called = FALSE;
2964 if (conn_args->dane)
2966 /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
2967 other failures should be treated as problems. */
2968 if (ob->dane_require_tls_ciphers &&
2969 !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
2970 &expciphers, errstr))
2972 if (expciphers && *expciphers == '\0')
2977 !expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
2978 &expciphers, errstr))
2981 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2982 are separated by underscores. So that I can use either form in my tests, and
2983 also for general convenience, we turn underscores into hyphens here. */
2987 uschar *s = expciphers;
2988 while (*s) { if (*s == '_') *s = '-'; s++; }
2989 DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2990 if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
2992 tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
2998 if (conn_args->dane)
3000 SSL_CTX_set_verify(exim_client_ctx->ctx,
3001 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
3002 verify_callback_client_dane);
3004 if (!DANESSL_library_init())
3006 tls_error(US"library init", host, NULL, errstr);
3009 if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
3011 tls_error(US"context init", host, NULL, errstr);
3019 if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
3020 client_static_cbinfo, errstr) != OK)
3023 #ifdef EXPERIMENTAL_TLS_RESUME
3024 tls_client_ctx_resume_prehandshake(exim_client_ctx, tlsp, ob, host);
3028 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
3030 tls_error(US"SSL_new", host, NULL, errstr);
3033 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
3035 SSL_set_fd(exim_client_ctx->ssl, cctx->sock);
3036 SSL_set_connect_state(exim_client_ctx->ssl);
3040 if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
3044 DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
3046 else if (!Ustrlen(tlsp->sni))
3050 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
3051 DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
3052 SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
3054 log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
3061 if (conn_args->dane)
3062 if (dane_tlsa_load(exim_client_ctx->ssl, host, &conn_args->tlsa_dnsa, errstr) != OK)
3066 #ifndef DISABLE_OCSP
3067 /* Request certificate status at connection-time. If the server
3068 does OCSP stapling we will get the callback (set in tls_init()) */
3069 # ifdef SUPPORT_DANE
3073 if ( ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3074 || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3076 { /* Re-eval now $tls_out_tlsa_usage is populated. If
3077 this means we avoid the OCSP request, we wasted the setup
3078 cost in tls_init(). */
3079 require_ocsp = verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
3080 request_ocsp = require_ocsp
3081 || verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3088 SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
3089 client_static_cbinfo->u_ocsp.client.verify_required = require_ocsp;
3090 tlsp->ocsp = OCSP_NOT_RESP;
3094 #ifdef EXPERIMENTAL_TLS_RESUME
3095 if (!tls_client_ssl_resume_prehandshake(exim_client_ctx->ssl, tlsp, host,
3100 #ifndef DISABLE_EVENT
3101 client_static_cbinfo->event_action = tb ? tb->event_action : NULL;
3104 /* There doesn't seem to be a built-in timeout on connection. */
3106 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
3107 sigalrm_seen = FALSE;
3108 ALARM(ob->command_timeout);
3109 rc = SSL_connect(exim_client_ctx->ssl);
3113 if (conn_args->dane)
3114 DANESSL_cleanup(exim_client_ctx->ssl);
3119 tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
3125 debug_printf("SSL_connect succeeded\n");
3126 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3128 BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
3129 SSL_SESSION_print_keylog(bp, SSL_get_session(exim_client_ctx->ssl));
3135 #ifdef EXPERIMENTAL_TLS_RESUME
3136 tls_client_resume_posthandshake(exim_client_ctx, tlsp);
3139 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
3141 tlsp->cipher = construct_cipher_name(exim_client_ctx->ssl, &tlsp->bits);
3142 tlsp->cipher_stdname = cipher_stdname_ssl(exim_client_ctx->ssl);
3144 /* Record the certificate we presented */
3146 X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
3147 tlsp->ourcert = crt ? X509_dup(crt) : NULL;
3150 tlsp->active.sock = cctx->sock;
3151 tlsp->active.tls_ctx = exim_client_ctx;
3152 cctx->tls_ctx = exim_client_ctx;
3161 tls_refill(unsigned lim)
3166 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", server_ssl,
3167 ssl_xfer_buffer, ssl_xfer_buffer_size);
3169 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3170 inbytes = SSL_read(server_ssl, CS ssl_xfer_buffer,
3171 MIN(ssl_xfer_buffer_size, lim));
3172 error = SSL_get_error(server_ssl, inbytes);
3173 if (smtp_receive_timeout > 0) ALARM_CLR(0);
3175 if (had_command_timeout) /* set by signal handler */
3176 smtp_command_timeout_exit(); /* does not return */
3177 if (had_command_sigterm)
3178 smtp_command_sigterm_exit();
3179 if (had_data_timeout)
3180 smtp_data_timeout_exit();
3181 if (had_data_sigint)
3182 smtp_data_sigint_exit();
3184 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
3185 closed down, not that the socket itself has been closed down. Revert to
3186 non-SSL handling. */
3190 case SSL_ERROR_NONE:
3193 case SSL_ERROR_ZERO_RETURN:
3194 DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3196 if (SSL_get_shutdown(server_ssl) == SSL_RECEIVED_SHUTDOWN)
3197 SSL_shutdown(server_ssl);
3199 tls_close(NULL, TLS_NO_SHUTDOWN);
3202 /* Handle genuine errors */
3204 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3205 log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
3206 ssl_xfer_error = TRUE;
3210 DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
3211 DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
3212 debug_printf(" - syscall %s\n", strerror(errno));
3213 ssl_xfer_error = TRUE;
3217 #ifndef DISABLE_DKIM
3218 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
3220 ssl_xfer_buffer_hwm = inbytes;
3221 ssl_xfer_buffer_lwm = 0;
3226 /*************************************************
3227 * TLS version of getc *
3228 *************************************************/
3230 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
3231 it refills the buffer via the SSL reading function.
3233 Arguments: lim Maximum amount to read/buffer
3234 Returns: the next character or EOF
3236 Only used by the server-side TLS.
3240 tls_getc(unsigned lim)
3242 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
3243 if (!tls_refill(lim))
3244 return ssl_xfer_error ? EOF : smtp_getc(lim);
3246 /* Something in the buffer; return next uschar */
3248 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
3252 tls_getbuf(unsigned * len)
3257 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
3258 if (!tls_refill(*len))
3260 if (!ssl_xfer_error) return smtp_getbuf(len);
3265 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
3267 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
3268 ssl_xfer_buffer_lwm += size;
3277 #ifndef DISABLE_DKIM
3278 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
3280 dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
3286 tls_could_read(void)
3288 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm || SSL_pending(server_ssl) > 0;
3292 /*************************************************
3293 * Read bytes from TLS channel *
3294 *************************************************/
3298 ct_ctx client context pointer, or NULL for the one global server context
3302 Returns: the number of bytes read
3303 -1 after a failed read, including EOF
3305 Only used by the client-side TLS.
3309 tls_read(void * ct_ctx, uschar *buff, size_t len)
3311 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
3315 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
3316 buff, (unsigned int)len);
3318 inbytes = SSL_read(ssl, CS buff, len);
3319 error = SSL_get_error(ssl, inbytes);
3321 if (error == SSL_ERROR_ZERO_RETURN)
3323 DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3326 else if (error != SSL_ERROR_NONE)
3336 /*************************************************
3337 * Write bytes down TLS channel *
3338 *************************************************/
3342 ct_ctx client context pointer, or NULL for the one global server context
3345 more further data expected soon
3347 Returns: the number of bytes after a successful write,
3348 -1 after a failed write
3350 Used by both server-side and client-side TLS.
3354 tls_write(void * ct_ctx, const uschar *buff, size_t len, BOOL more)
3357 int outbytes, error;
3359 ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
3360 static gstring * server_corked = NULL;
3361 gstring ** corkedp = ct_ctx
3362 ? &((exim_openssl_client_tls_ctx *)ct_ctx)->corked : &server_corked;
3363 gstring * corked = *corkedp;
3365 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
3366 buff, (unsigned long)len, more ? ", more" : "");
3368 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
3369 "more" is notified. This hack is only ok if small amounts are involved AND only
3370 one stream does it, in one context (i.e. no store reset). Currently it is used
3371 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only.
3372 We support callouts done by the server process by using a separate client
3373 context for the stashed information. */
3374 /* + if PIPE_COMMAND, banner & ehlo-resp for smmtp-on-connect. Suspect there's
3375 a store reset there, so use POOL_PERM. */
3376 /* + if CHUNKING, cmds EHLO,MAIL,RCPT(s),BDAT */
3378 if ((more || corked))
3380 #ifdef SUPPORT_PIPE_CONNECT
3381 int save_pool = store_pool;
3382 store_pool = POOL_PERM;
3385 corked = string_catn(corked, buff, len);
3387 #ifdef SUPPORT_PIPE_CONNECT
3388 store_pool = save_pool;
3396 buff = CUS corked->s;
3401 for (int left = len; left > 0;)
3403 DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
3404 outbytes = SSL_write(ssl, CS buff, left);
3405 error = SSL_get_error(ssl, outbytes);
3406 DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
3410 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3411 log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
3414 case SSL_ERROR_NONE:
3419 case SSL_ERROR_ZERO_RETURN:
3420 log_write(0, LOG_MAIN, "SSL channel closed on write");
3423 case SSL_ERROR_SYSCALL:
3424 log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
3425 sender_fullhost ? sender_fullhost : US"<unknown>",
3430 log_write(0, LOG_MAIN, "SSL_write error %d", error);
3439 /*************************************************
3440 * Close down a TLS session *
3441 *************************************************/
3443 /* This is also called from within a delivery subprocess forked from the
3444 daemon, to shut down the TLS library, without actually doing a shutdown (which
3445 would tamper with the SSL session in the parent process).
3448 ct_ctx client TLS context pointer, or NULL for the one global server context
3449 shutdown 1 if TLS close-alert is to be sent,
3450 2 if also response to be waited for
3454 Used by both server-side and client-side TLS.
3458 tls_close(void * ct_ctx, int shutdown)
3460 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
3461 SSL_CTX **ctxp = o_ctx ? &o_ctx->ctx : &server_ctx;
3462 SSL **sslp = o_ctx ? &o_ctx->ssl : &server_ssl;
3463 int *fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
3465 if (*fdp < 0) return; /* TLS was not active */
3470 DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
3471 shutdown > 1 ? " (with response-wait)" : "");
3473 if ( (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
3477 rc = SSL_shutdown(*sslp); /* wait for response */
3481 if (rc < 0) DEBUG(D_tls)
3483 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3484 debug_printf("SSL_shutdown: %s\n", ssl_errstring);
3488 if (!o_ctx) /* server side */
3490 #ifndef DISABLE_OCSP
3491 sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
3492 server_static_cbinfo->verify_stack = NULL;
3495 receive_getc = smtp_getc;
3496 receive_getbuf = smtp_getbuf;
3497 receive_get_cache = smtp_get_cache;
3498 receive_ungetc = smtp_ungetc;
3499 receive_feof = smtp_feof;
3500 receive_ferror = smtp_ferror;
3501 receive_smtp_buffered = smtp_buffered;
3502 tls_in.active.tls_ctx = NULL;
3504 /* Leave bits, peercert, cipher, peerdn, certificate_verified set, for logging */
3507 SSL_CTX_free(*ctxp);
3517 /*************************************************
3518 * Let tls_require_ciphers be checked at startup *
3519 *************************************************/
3521 /* The tls_require_ciphers option, if set, must be something which the
3524 Returns: NULL on success, or error message
3528 tls_validate_require_cipher(void)
3531 uschar *s, *expciphers, *err;
3533 /* this duplicates from tls_init(), we need a better "init just global
3534 state, for no specific purpose" singleton function of our own */
3536 #ifdef EXIM_NEED_OPENSSL_INIT
3537 SSL_load_error_strings();
3538 OpenSSL_add_ssl_algorithms();
3540 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
3541 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
3542 list of available digests. */
3543 EVP_add_digest(EVP_sha256());
3546 if (!(tls_require_ciphers && *tls_require_ciphers))
3549 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
3551 return US"failed to expand tls_require_ciphers";
3553 if (!(expciphers && *expciphers))
3556 /* normalisation ripped from above */
3558 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
3562 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
3563 if (!(ctx = SSL_CTX_new(TLS_server_method())))
3565 if (!(ctx = SSL_CTX_new(SSLv23_server_method())))
3568 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3569 return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
3573 debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
3575 if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
3577 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3578 err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
3579 expciphers, ssl_errstring);
3590 /*************************************************
3591 * Report the library versions. *
3592 *************************************************/
3594 /* There have historically been some issues with binary compatibility in
3595 OpenSSL libraries; if Exim (like many other applications) is built against
3596 one version of OpenSSL but the run-time linker picks up another version,
3597 it can result in serious failures, including crashing with a SIGSEGV. So
3598 report the version found by the compiler and the run-time version.
3600 Note: some OS vendors backport security fixes without changing the version
3601 number/string, and the version date remains unchanged. The _build_ date
3602 will change, so we can more usefully assist with version diagnosis by also
3603 reporting the build date.
3605 Arguments: a FILE* to print the results to
3610 tls_version_report(FILE *f)
3612 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
3615 OPENSSL_VERSION_TEXT,
3616 SSLeay_version(SSLEAY_VERSION),
3617 SSLeay_version(SSLEAY_BUILT_ON));
3618 /* third line is 38 characters for the %s and the line is 73 chars long;
3619 the OpenSSL output includes a "built on: " prefix already. */
3625 /*************************************************
3626 * Random number generation *
3627 *************************************************/
3629 /* Pseudo-random number generation. The result is not expected to be
3630 cryptographically strong but not so weak that someone will shoot themselves
3631 in the foot using it as a nonce in input in some email header scheme or
3632 whatever weirdness they'll twist this into. The result should handle fork()
3633 and avoid repeating sequences. OpenSSL handles that for us.
3637 Returns a random number in range [0, max-1]
3641 vaguely_random_number(int max)
3645 static pid_t pidlast = 0;
3647 uschar smallbuf[sizeof(r)];
3653 if (pidnow != pidlast)
3655 /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
3656 is unique for each thread", this doesn't apparently apply across processes,
3657 so our own warning from vaguely_random_number_fallback() applies here too.
3658 Fix per PostgreSQL. */
3664 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
3668 gettimeofday(&r.tv, NULL);
3671 RAND_seed(US (&r), sizeof(r));
3673 /* We're after pseudo-random, not random; if we still don't have enough data
3674 in the internal PRNG then our options are limited. We could sleep and hope
3675 for entropy to come along (prayer technique) but if the system is so depleted
3676 in the first place then something is likely to just keep taking it. Instead,
3677 we'll just take whatever little bit of pseudo-random we can still manage to
3680 needed_len = sizeof(r);
3681 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
3682 asked for a number less than 10. */
3683 for (r = max, i = 0; r; ++i)
3689 #ifdef EXIM_HAVE_RAND_PSEUDO
3690 /* We do not care if crypto-strong */
3691 i = RAND_pseudo_bytes(smallbuf, needed_len);
3693 i = RAND_bytes(smallbuf, needed_len);
3699 debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
3700 return vaguely_random_number_fallback(max);
3704 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
3707 /* We don't particularly care about weighted results; if someone wants
3708 smooth distribution and cares enough then they should submit a patch then. */
3715 /*************************************************
3716 * OpenSSL option parse *
3717 *************************************************/
3719 /* Parse one option for tls_openssl_options_parse below
3722 name one option name
3723 value place to store a value for it
3724 Returns success or failure in parsing
3730 tls_openssl_one_option_parse(uschar *name, long *value)
3733 int last = exim_openssl_options_size;
3734 while (last > first)
3736 int middle = (first + last)/2;
3737 int c = Ustrcmp(name, exim_openssl_options[middle].name);
3740 *value = exim_openssl_options[middle].value;
3754 /*************************************************
3755 * OpenSSL option parsing logic *
3756 *************************************************/
3758 /* OpenSSL has a number of compatibility options which an administrator might
3759 reasonably wish to set. Interpret a list similarly to decode_bits(), so that
3760 we look like log_selector.
3763 option_spec the administrator-supplied string of options
3764 results ptr to long storage for the options bitmap
3765 Returns success or failure
3769 tls_openssl_options_parse(uschar *option_spec, long *results)
3774 BOOL adding, item_parsed;
3776 /* Server: send no (<= TLS1.2) session tickets */
3777 result = SSL_OP_NO_TICKET;
3779 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
3780 * from default because it increases BEAST susceptibility. */
3781 #ifdef SSL_OP_NO_SSLv2
3782 result |= SSL_OP_NO_SSLv2;
3784 #ifdef SSL_OP_NO_SSLv3
3785 result |= SSL_OP_NO_SSLv3;
3787 #ifdef SSL_OP_SINGLE_DH_USE
3788 result |= SSL_OP_SINGLE_DH_USE;
3797 for (uschar * s = option_spec; *s; /**/)
3799 while (isspace(*s)) ++s;
3802 if (*s != '+' && *s != '-')
3804 DEBUG(D_tls) debug_printf("malformed openssl option setting: "
3805 "+ or - expected but found \"%s\"\n", s);
3808 adding = *s++ == '+';
3809 for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
3812 item_parsed = tls_openssl_one_option_parse(s, &item);
3816 DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
3819 DEBUG(D_tls) debug_printf("openssl option, %s %8lx: %lx (%s)\n",
3820 adding ? "adding to " : "removing from", result, item, s);
3832 #endif /*!MACRO_PREDEF*/
3835 /* End of tls-openssl.c */