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
77 # define EXIM_NEED_OPENSSL_INIT
79 # if OPENSSL_VERSION_NUMBER >= 0x010000000L \
80 && (OPENSSL_VERSION_NUMBER & 0x0000ff000L) >= 0x000002000L
81 # define EXIM_HAVE_OPENSSL_CHECKHOST
85 #if !defined(LIBRESSL_VERSION_NUMBER) \
86 || LIBRESSL_VERSION_NUMBER >= 0x20010000L
87 # if !defined(OPENSSL_NO_ECDH)
88 # if OPENSSL_VERSION_NUMBER >= 0x0090800fL
89 # define EXIM_HAVE_ECDH
91 # if OPENSSL_VERSION_NUMBER >= 0x10002000L
92 # define EXIM_HAVE_OPENSSL_EC_NIST2NID
97 #ifndef LIBRESSL_VERSION_NUMBER
98 # if OPENSSL_VERSION_NUMBER >= 0x010101000L
99 # define OPENSSL_HAVE_KEYLOG_CB
100 # define OPENSSL_HAVE_NUM_TICKETS
101 # define EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
105 #if !defined(EXIM_HAVE_OPENSSL_TLSEXT) && !defined(DISABLE_OCSP)
106 # warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
107 # define DISABLE_OCSP
110 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
111 # include <openssl/x509v3.h>
114 #ifndef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
115 # ifndef EXIM_HAVE_OPENSSL_CIPHER_GET_ID
116 # define SSL_CIPHER_get_id(c) (c->id)
118 # ifndef MACRO_PREDEF
119 # include "tls-cipher-stdname.c"
123 /*************************************************
124 * OpenSSL option parse *
125 *************************************************/
127 typedef struct exim_openssl_option {
130 } exim_openssl_option;
131 /* We could use a macro to expand, but we need the ifdef and not all the
132 options document which version they were introduced in. Policylet: include
133 all options unless explicitly for DTLS, let the administrator choose which
136 This list is current as of:
138 Plus SSL_OP_SAFARI_ECDHE_ECDSA_BUG from 2013-June patch/discussion on openssl-dev
139 Plus SSL_OP_NO_TLSv1_3 for 1.1.2-dev
141 static exim_openssl_option exim_openssl_options[] = {
142 /* KEEP SORTED ALPHABETICALLY! */
144 { US"all", SSL_OP_ALL },
146 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
147 { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
149 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
150 { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
152 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
153 { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
155 #ifdef SSL_OP_EPHEMERAL_RSA
156 { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
158 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
159 { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
161 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
162 { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
164 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
165 { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
167 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
168 { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
170 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
171 { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
173 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
174 { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
176 #ifdef SSL_OP_NO_COMPRESSION
177 { US"no_compression", SSL_OP_NO_COMPRESSION },
179 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
180 { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
182 #ifdef SSL_OP_NO_SSLv2
183 { US"no_sslv2", SSL_OP_NO_SSLv2 },
185 #ifdef SSL_OP_NO_SSLv3
186 { US"no_sslv3", SSL_OP_NO_SSLv3 },
188 #ifdef SSL_OP_NO_TICKET
189 { US"no_ticket", SSL_OP_NO_TICKET },
191 #ifdef SSL_OP_NO_TLSv1
192 { US"no_tlsv1", SSL_OP_NO_TLSv1 },
194 #ifdef SSL_OP_NO_TLSv1_1
195 #if SSL_OP_NO_TLSv1_1 == 0x00000400L
196 /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
197 #warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
199 { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
202 #ifdef SSL_OP_NO_TLSv1_2
203 { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
205 #ifdef SSL_OP_NO_TLSv1_3
206 { US"no_tlsv1_3", SSL_OP_NO_TLSv1_3 },
208 #ifdef SSL_OP_SAFARI_ECDHE_ECDSA_BUG
209 { US"safari_ecdhe_ecdsa_bug", SSL_OP_SAFARI_ECDHE_ECDSA_BUG },
211 #ifdef SSL_OP_SINGLE_DH_USE
212 { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
214 #ifdef SSL_OP_SINGLE_ECDH_USE
215 { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
217 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
218 { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
220 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
221 { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
223 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
224 { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
226 #ifdef SSL_OP_TLS_D5_BUG
227 { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
229 #ifdef SSL_OP_TLS_ROLLBACK_BUG
230 { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
235 static int exim_openssl_options_size = nelem(exim_openssl_options);
244 for (struct exim_openssl_option * o = exim_openssl_options;
245 o < exim_openssl_options + nelem(exim_openssl_options); o++)
247 /* Trailing X is workaround for problem with _OPT_OPENSSL_NO_TLSV1
248 being a ".ifdef _OPT_OPENSSL_NO_TLSV1_3" match */
250 spf(buf, sizeof(buf), US"_OPT_OPENSSL_%T_X", o->name);
251 builtin_macro_create(buf);
254 # ifdef EXPERIMENTAL_TLS_RESUME
255 builtin_macro_create_var(US"_RESUME_DECODE", RESUME_DECODE_STRING );
260 /******************************************************************************/
262 /* Structure for collecting random data for seeding. */
264 typedef struct randstuff {
269 /* Local static variables */
271 static BOOL client_verify_callback_called = FALSE;
272 static BOOL server_verify_callback_called = FALSE;
273 static const uschar *sid_ctx = US"exim";
275 /* We have three different contexts to care about.
277 Simple case: client, `client_ctx`
278 As a client, we can be doing a callout or cut-through delivery while receiving
279 a message. So we have a client context, which should have options initialised
280 from the SMTP Transport. We may also concurrently want to make TLS connections
281 to utility daemons, so client-contexts are allocated and passed around in call
282 args rather than using a gobal.
285 There are two cases: with and without ServerNameIndication from the client.
286 Given TLS SNI, we can be using different keys, certs and various other
287 configuration settings, because they're re-expanded with $tls_sni set. This
288 allows vhosting with TLS. This SNI is sent in the handshake.
289 A client might not send SNI, so we need a fallback, and an initial setup too.
290 So as a server, we start out using `server_ctx`.
291 If SNI is sent by the client, then we as server, mid-negotiation, try to clone
292 `server_sni` from `server_ctx` and then initialise settings by re-expanding
300 } exim_openssl_client_tls_ctx;
302 static SSL_CTX *server_ctx = NULL;
303 static SSL *server_ssl = NULL;
305 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
306 static SSL_CTX *server_sni = NULL;
309 static char ssl_errstring[256];
311 static int ssl_session_timeout = 3600;
312 static BOOL client_verify_optional = FALSE;
313 static BOOL server_verify_optional = FALSE;
315 static BOOL reexpand_tls_files_for_sni = FALSE;
318 typedef struct tls_ext_ctx_cb {
324 STACK_OF(X509) *verify_stack; /* chain for verifying the proof */
328 uschar *file_expanded;
329 OCSP_RESPONSE *response;
332 X509_STORE *verify_store; /* non-null if status requested */
333 BOOL verify_required;
338 /* these are cached from first expand */
339 uschar *server_cipher_list;
340 /* only passed down to tls_error: */
342 const uschar * verify_cert_hostnames;
343 #ifndef DISABLE_EVENT
344 uschar * event_action;
348 /* should figure out a cleanup of API to handle state preserved per
349 implementation, for various reasons, which can be void * in the APIs.
350 For now, we hack around it. */
351 tls_ext_ctx_cb *client_static_cbinfo = NULL; /*XXX should not use static; multiple concurrent clients! */
352 tls_ext_ctx_cb *server_static_cbinfo = NULL;
355 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
356 int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr );
359 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
360 static int tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg);
363 static int tls_server_stapling_cb(SSL *s, void *arg);
368 /* Daemon-called key create/rotate */
369 #ifdef EXPERIMENTAL_TLS_RESUME
370 static void tk_init(void);
371 static int tls_exdata_idx = -1;
375 tls_daemon_init(void)
377 #ifdef EXPERIMENTAL_TLS_RESUME
384 /*************************************************
386 *************************************************/
388 /* Called from lots of places when errors occur before actually starting to do
389 the TLS handshake, that is, while the session is still in clear. Always returns
390 DEFER for a server and FAIL for a client so that most calls can use "return
391 tls_error(...)" to do this processing and then give an appropriate return. A
392 single function is used for both server and client, because it is called from
393 some shared functions.
396 prefix text to include in the logged error
397 host NULL if setting up a server;
398 the connected host if setting up a client
399 msg error message or NULL if we should ask OpenSSL
400 errstr pointer to output error message
402 Returns: OK/DEFER/FAIL
406 tls_error(uschar * prefix, const host_item * host, uschar * msg, uschar ** errstr)
410 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
411 msg = US ssl_errstring;
414 msg = string_sprintf("(%s): %s", prefix, msg);
415 DEBUG(D_tls) debug_printf("TLS error '%s'\n", msg);
416 if (errstr) *errstr = msg;
417 return host ? FAIL : DEFER;
422 /*************************************************
423 * Callback to generate RSA key *
424 *************************************************/
428 s SSL connection (not used)
432 Returns: pointer to generated key
436 rsa_callback(SSL *s, int export, int keylength)
439 #ifdef EXIM_HAVE_RSA_GENKEY_EX
440 BIGNUM *bn = BN_new();
443 export = export; /* Shut picky compilers up */
444 DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
446 #ifdef EXIM_HAVE_RSA_GENKEY_EX
447 if ( !BN_set_word(bn, (unsigned long)RSA_F4)
448 || !(rsa_key = RSA_new())
449 || !RSA_generate_key_ex(rsa_key, keylength, bn, NULL)
452 if (!(rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL)))
456 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
457 log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
469 x509_store_dump_cert_s_names(X509_STORE * store)
471 STACK_OF(X509_OBJECT) * roots= store->objs;
472 static uschar name[256];
474 for (int i= 0; i < sk_X509_OBJECT_num(roots); i++)
476 X509_OBJECT * tmp_obj= sk_X509_OBJECT_value(roots, i);
477 if(tmp_obj->type == X509_LU_X509)
479 X509_NAME * sn = X509_get_subject_name(tmp_obj->data.x509);
480 if (X509_NAME_oneline(sn, CS name, sizeof(name)))
482 name[sizeof(name)-1] = '\0';
483 debug_printf(" %s\n", name);
492 #ifndef DISABLE_EVENT
494 verify_event(tls_support * tlsp, X509 * cert, int depth, const uschar * dn,
495 BOOL *calledp, const BOOL *optionalp, const uschar * what)
501 ev = tlsp == &tls_out ? client_static_cbinfo->event_action : event_action;
504 DEBUG(D_tls) debug_printf("verify_event: %s %d\n", what, depth);
505 old_cert = tlsp->peercert;
506 tlsp->peercert = X509_dup(cert);
507 /* NB we do not bother setting peerdn */
508 if ((yield = event_raise(ev, US"tls:cert", string_sprintf("%d", depth))))
510 log_write(0, LOG_MAIN, "[%s] %s verify denied by event-action: "
511 "depth=%d cert=%s: %s",
512 tlsp == &tls_out ? deliver_host_address : sender_host_address,
513 what, depth, dn, yield);
517 if (old_cert) tlsp->peercert = old_cert; /* restore 1st failing cert */
518 return 1; /* reject (leaving peercert set) */
520 DEBUG(D_tls) debug_printf("Event-action verify failure overridden "
521 "(host in tls_try_verify_hosts)\n");
523 X509_free(tlsp->peercert);
524 tlsp->peercert = old_cert;
530 /*************************************************
531 * Callback for verification *
532 *************************************************/
534 /* The SSL library does certificate verification if set up to do so. This
535 callback has the current yes/no state is in "state". If verification succeeded,
536 we set the certificate-verified flag. If verification failed, what happens
537 depends on whether the client is required to present a verifiable certificate
540 If verification is optional, we change the state to yes, but still log the
541 verification error. For some reason (it really would help to have proper
542 documentation of OpenSSL), this callback function then gets called again, this
543 time with state = 1. We must take care not to set the private verified flag on
544 the second time through.
546 Note: this function is not called if the client fails to present a certificate
547 when asked. We get here only if a certificate has been received. Handling of
548 optional verification for this case is done when requesting SSL to verify, by
549 setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
551 May be called multiple times for different issues with a certificate, even
552 for a given "depth" in the certificate chain.
555 preverify_ok current yes/no state as 1/0
556 x509ctx certificate information.
557 tlsp per-direction (client vs. server) support data
558 calledp has-been-called flag
559 optionalp verification-is-optional flag
561 Returns: 0 if verification should fail, otherwise 1
565 verify_callback(int preverify_ok, X509_STORE_CTX * x509ctx,
566 tls_support * tlsp, BOOL * calledp, BOOL * optionalp)
568 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
569 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
572 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
574 DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
575 log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
576 tlsp == &tls_out ? deliver_host_address : sender_host_address);
579 dn[sizeof(dn)-1] = '\0';
581 if (preverify_ok == 0)
583 uschar * extra = verify_mode ? string_sprintf(" (during %c-verify for [%s])",
584 *verify_mode, sender_host_address)
586 log_write(0, LOG_MAIN, "[%s] SSL verify error%s: depth=%d error=%s cert=%s",
587 tlsp == &tls_out ? deliver_host_address : sender_host_address,
589 X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509ctx)), dn);
594 tlsp->peercert = X509_dup(cert); /* record failing cert */
595 return 0; /* reject */
597 DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
598 "tls_try_verify_hosts)\n");
603 DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d SN=%s\n", depth, dn);
605 if (tlsp == &tls_out && client_static_cbinfo->u_ocsp.client.verify_store)
606 { /* client, wanting stapling */
607 /* Add the server cert's signing chain as the one
608 for the verification of the OCSP stapled information. */
610 if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
613 sk_X509_push(client_static_cbinfo->verify_stack, cert);
616 #ifndef DISABLE_EVENT
617 if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
618 return 0; /* reject, with peercert set */
623 const uschar * verify_cert_hostnames;
625 if ( tlsp == &tls_out
626 && ((verify_cert_hostnames = client_static_cbinfo->verify_cert_hostnames)))
627 /* client, wanting hostname check */
630 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
631 # ifndef X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
632 # define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0
634 # ifndef X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS
635 # define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0
638 const uschar * list = verify_cert_hostnames;
641 while ((name = string_nextinlist(&list, &sep, NULL, 0)))
642 if ((rc = X509_check_host(cert, CCS name, 0,
643 X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
644 | X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS,
649 log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
650 tlsp == &tls_out ? deliver_host_address : sender_host_address);
657 if (!tls_is_name_for_cert(verify_cert_hostnames, cert))
660 uschar * extra = verify_mode
661 ? string_sprintf(" (during %c-verify for [%s])",
662 *verify_mode, sender_host_address)
664 log_write(0, LOG_MAIN,
665 "[%s] SSL verify error%s: certificate name mismatch: DN=\"%s\" H=\"%s\"",
666 tlsp == &tls_out ? deliver_host_address : sender_host_address,
667 extra, dn, verify_cert_hostnames);
672 tlsp->peercert = X509_dup(cert); /* record failing cert */
673 return 0; /* reject */
675 DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
676 "tls_try_verify_hosts)\n");
680 #ifndef DISABLE_EVENT
681 if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
682 return 0; /* reject, with peercert set */
685 DEBUG(D_tls) debug_printf("SSL%s verify ok: depth=0 SN=%s\n",
686 *calledp ? "" : " authenticated", dn);
687 if (!*calledp) tlsp->certificate_verified = TRUE;
691 return 1; /* accept, at least for this level */
695 verify_callback_client(int preverify_ok, X509_STORE_CTX *x509ctx)
697 return verify_callback(preverify_ok, x509ctx, &tls_out,
698 &client_verify_callback_called, &client_verify_optional);
702 verify_callback_server(int preverify_ok, X509_STORE_CTX *x509ctx)
704 return verify_callback(preverify_ok, x509ctx, &tls_in,
705 &server_verify_callback_called, &server_verify_optional);
711 /* This gets called *by* the dane library verify callback, which interposes
715 verify_callback_client_dane(int preverify_ok, X509_STORE_CTX * x509ctx)
717 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
719 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
720 #ifndef DISABLE_EVENT
721 BOOL dummy_called, optional = FALSE;
724 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
726 DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
727 log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
728 deliver_host_address);
731 dn[sizeof(dn)-1] = '\0';
733 DEBUG(D_tls) debug_printf("verify_callback_client_dane: %s depth %d %s\n",
734 preverify_ok ? "ok":"BAD", depth, dn);
736 #ifndef DISABLE_EVENT
737 if (verify_event(&tls_out, cert, depth, dn,
738 &dummy_called, &optional, US"DANE"))
739 return 0; /* reject, with peercert set */
742 if (preverify_ok == 1)
744 tls_out.dane_verified = tls_out.certificate_verified = TRUE;
746 if (client_static_cbinfo->u_ocsp.client.verify_store)
747 { /* client, wanting stapling */
748 /* Add the server cert's signing chain as the one
749 for the verification of the OCSP stapled information. */
751 if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
754 sk_X509_push(client_static_cbinfo->verify_stack, cert);
760 int err = X509_STORE_CTX_get_error(x509ctx);
762 debug_printf(" - err %d '%s'\n", err, X509_verify_cert_error_string(err));
763 if (err == X509_V_ERR_APPLICATION_VERIFICATION)
769 #endif /*SUPPORT_DANE*/
772 /*************************************************
773 * Information callback *
774 *************************************************/
776 /* The SSL library functions call this from time to time to indicate what they
777 are doing. We copy the string to the debugging output when TLS debugging has
789 info_callback(SSL *s, int where, int ret)
795 if (where & SSL_ST_CONNECT)
796 str = US"SSL_connect";
797 else if (where & SSL_ST_ACCEPT)
798 str = US"SSL_accept";
800 str = US"SSL info (undefined)";
802 if (where & SSL_CB_LOOP)
803 debug_printf("%s: %s\n", str, SSL_state_string_long(s));
804 else if (where & SSL_CB_ALERT)
805 debug_printf("SSL3 alert %s:%s:%s\n",
806 str = where & SSL_CB_READ ? US"read" : US"write",
807 SSL_alert_type_string_long(ret), SSL_alert_desc_string_long(ret));
808 else if (where & SSL_CB_EXIT)
810 debug_printf("%s: failed in %s\n", str, SSL_state_string_long(s));
812 debug_printf("%s: error in %s\n", str, SSL_state_string_long(s));
813 else if (where & SSL_CB_HANDSHAKE_START)
814 debug_printf("%s: hshake start: %s\n", str, SSL_state_string_long(s));
815 else if (where & SSL_CB_HANDSHAKE_DONE)
816 debug_printf("%s: hshake done: %s\n", str, SSL_state_string_long(s));
820 #ifdef OPENSSL_HAVE_KEYLOG_CB
822 keylog_callback(const SSL *ssl, const char *line)
824 DEBUG(D_tls) debug_printf("%.200s\n", line);
829 #ifdef EXPERIMENTAL_TLS_RESUME
830 /* Manage the keysets used for encrypting the session tickets, on the server. */
832 typedef struct { /* Session ticket encryption key */
835 const EVP_CIPHER * aes_cipher;
836 uschar aes_key[16]; /* size needed depends on cipher. aes_128 implies 128/8 = 16? */
837 const EVP_MD * hmac_hash;
843 /*XXX for now just always create/find the one key.
844 Worry about rotation and overlap later. */
846 static exim_stek exim_tk;
847 static exim_stek exim_tk_old;
854 if (exim_tk.renew >= time(NULL)) return;
855 exim_tk_old = exim_tk;
858 if (f.running_in_test_harness) ssl_session_timeout = 6;
860 DEBUG(D_tls) debug_printf("OpenSSL: %s STEK\n", exim_tk.name[0] ? "rotating" : "creating");
861 if (RAND_bytes(exim_tk.aes_key, sizeof(exim_tk.aes_key)) <= 0) return;
862 if (RAND_bytes(exim_tk.hmac_key, sizeof(exim_tk.hmac_key)) <= 0) return;
863 if (RAND_bytes(exim_tk.name+1, sizeof(exim_tk.name)-1) <= 0) return;
865 exim_tk.name[0] = 'E';
866 exim_tk.aes_cipher = EVP_aes_128_cbc();
867 exim_tk.hmac_hash = EVP_sha256();
868 exim_tk.expire = time(NULL) + ssl_session_timeout;
869 exim_tk.renew = exim_tk.expire - ssl_session_timeout/2;
875 if (!exim_tk.name[0]) return NULL;
880 tk_find(const uschar * name)
882 return memcmp(name, exim_tk.name, sizeof(exim_tk.name)) == 0 ? &exim_tk
883 : memcmp(name, exim_tk_old.name, sizeof(exim_tk_old.name)) == 0 ? &exim_tk_old
887 /* Callback for session tickets, on server */
889 ticket_key_callback(SSL * ssl, uschar key_name[16],
890 uschar * iv, EVP_CIPHER_CTX * ctx, HMAC_CTX * hctx, int enc)
892 tls_support * tlsp = server_static_cbinfo->tlsp;
897 DEBUG(D_tls) debug_printf("ticket_key_callback: create new session\n");
898 tlsp->resumption |= RESUME_CLIENT_REQUESTED;
900 if (RAND_bytes(iv, EVP_MAX_IV_LENGTH) <= 0)
901 return -1; /* insufficient random */
903 if (!(key = tk_current())) /* current key doesn't exist or isn't valid */
904 return 0; /* key couldn't be created */
905 memcpy(key_name, key->name, 16);
906 DEBUG(D_tls) debug_printf("STEK expire %ld\n", key->expire - time(NULL));
908 /*XXX will want these dependent on the ssl session strength */
909 HMAC_Init_ex(hctx, key->hmac_key, sizeof(key->hmac_key),
910 key->hmac_hash, NULL);
911 EVP_EncryptInit_ex(ctx, key->aes_cipher, NULL, key->aes_key, iv);
913 DEBUG(D_tls) debug_printf("ticket created\n");
918 time_t now = time(NULL);
920 DEBUG(D_tls) debug_printf("ticket_key_callback: retrieve session\n");
921 tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
923 if (!(key = tk_find(key_name)) || key->expire < now)
927 debug_printf("ticket not usable (%s)\n", key ? "expired" : "not found");
928 if (key) debug_printf("STEK expire %ld\n", key->expire - now);
933 HMAC_Init_ex(hctx, key->hmac_key, sizeof(key->hmac_key),
934 key->hmac_hash, NULL);
935 EVP_DecryptInit_ex(ctx, key->aes_cipher, NULL, key->aes_key, iv);
937 DEBUG(D_tls) debug_printf("ticket usable, STEK expire %ld\n", key->expire - now);
938 return key->renew < now ? 2 : 1;
945 /*************************************************
946 * Initialize for DH *
947 *************************************************/
949 /* If dhparam is set, expand it, and load up the parameters for DH encryption.
952 sctx The current SSL CTX (inbound or outbound)
953 dhparam DH parameter file or fixed parameter identity string
954 host connected host, if client; NULL if server
955 errstr error string pointer
957 Returns: TRUE if OK (nothing to set up, or setup worked)
961 init_dh(SSL_CTX *sctx, uschar *dhparam, const host_item *host, uschar ** errstr)
969 if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded, errstr))
972 if (!dhexpanded || !*dhexpanded)
973 bio = BIO_new_mem_buf(CS std_dh_prime_default(), -1);
974 else if (dhexpanded[0] == '/')
976 if (!(bio = BIO_new_file(CS dhexpanded, "r")))
978 tls_error(string_sprintf("could not read dhparams file %s", dhexpanded),
979 host, US strerror(errno), errstr);
985 if (Ustrcmp(dhexpanded, "none") == 0)
987 DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
991 if (!(pem = std_dh_prime_named(dhexpanded)))
993 tls_error(string_sprintf("Unknown standard DH prime \"%s\"", dhexpanded),
994 host, US strerror(errno), errstr);
997 bio = BIO_new_mem_buf(CS pem, -1);
1000 if (!(dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL)))
1003 tls_error(string_sprintf("Could not read tls_dhparams \"%s\"", dhexpanded),
1004 host, NULL, errstr);
1008 /* note: our default limit of 2236 is not a multiple of 8; the limit comes from
1009 * an NSS limit, and the GnuTLS APIs handle bit-sizes fine, so we went with
1010 * 2236. But older OpenSSL can only report in bytes (octets), not bits.
1011 * If someone wants to dance at the edge, then they can raise the limit or use
1012 * current libraries. */
1013 #ifdef EXIM_HAVE_OPENSSL_DH_BITS
1014 /* Added in commit 26c79d5641d; `git describe --contains` says OpenSSL_1_1_0-pre1~1022
1015 * This predates OpenSSL_1_1_0 (before a, b, ...) so is in all 1.1.0 */
1016 dh_bitsize = DH_bits(dh);
1018 dh_bitsize = 8 * DH_size(dh);
1021 /* Even if it is larger, we silently return success rather than cause things
1022 * to fail out, so that a too-large DH will not knock out all TLS; it's a
1023 * debatable choice. */
1024 if (dh_bitsize > tls_dh_max_bits)
1027 debug_printf("dhparams file %d bits, is > tls_dh_max_bits limit of %d\n",
1028 dh_bitsize, tls_dh_max_bits);
1032 SSL_CTX_set_tmp_dh(sctx, dh);
1034 debug_printf("Diffie-Hellman initialized from %s with %d-bit prime\n",
1035 dhexpanded ? dhexpanded : US"default", dh_bitsize);
1047 /*************************************************
1048 * Initialize for ECDH *
1049 *************************************************/
1051 /* Load parameters for ECDH encryption.
1053 For now, we stick to NIST P-256 because: it's simple and easy to configure;
1054 it avoids any patent issues that might bite redistributors; despite events in
1055 the news and concerns over curve choices, we're not cryptographers, we're not
1056 pretending to be, and this is "good enough" to be better than no support,
1057 protecting against most adversaries. Given another year or two, there might
1058 be sufficient clarity about a "right" way forward to let us make an informed
1059 decision, instead of a knee-jerk reaction.
1061 Longer-term, we should look at supporting both various named curves and
1062 external files generated with "openssl ecparam", much as we do for init_dh().
1063 We should also support "none" as a value, to explicitly avoid initialisation.
1068 sctx The current SSL CTX (inbound or outbound)
1069 host connected host, if client; NULL if server
1070 errstr error string pointer
1072 Returns: TRUE if OK (nothing to set up, or setup worked)
1076 init_ecdh(SSL_CTX * sctx, host_item * host, uschar ** errstr)
1078 #ifdef OPENSSL_NO_ECDH
1087 if (host) /* No ECDH setup for clients, only for servers */
1090 # ifndef EXIM_HAVE_ECDH
1092 debug_printf("No OpenSSL API to define ECDH parameters, skipping\n");
1096 if (!expand_check(tls_eccurve, US"tls_eccurve", &exp_curve, errstr))
1098 if (!exp_curve || !*exp_curve)
1101 /* "auto" needs to be handled carefully.
1102 * OpenSSL < 1.0.2: we do not select anything, but fallback to prime256v1
1103 * OpenSSL < 1.1.0: we have to call SSL_CTX_set_ecdh_auto
1104 * (openssl/ssl.h defines SSL_CTRL_SET_ECDH_AUTO)
1105 * OpenSSL >= 1.1.0: we do not set anything, the libray does autoselection
1106 * https://github.com/openssl/openssl/commit/fe6ef2472db933f01b59cad82aa925736935984b
1108 if (Ustrcmp(exp_curve, "auto") == 0)
1110 #if OPENSSL_VERSION_NUMBER < 0x10002000L
1111 DEBUG(D_tls) debug_printf(
1112 "ECDH OpenSSL < 1.0.2: temp key parameter settings: overriding \"auto\" with \"prime256v1\"\n");
1113 exp_curve = US"prime256v1";
1115 # if defined SSL_CTRL_SET_ECDH_AUTO
1116 DEBUG(D_tls) debug_printf(
1117 "ECDH OpenSSL 1.0.2+ temp key parameter settings: autoselection\n");
1118 SSL_CTX_set_ecdh_auto(sctx, 1);
1121 DEBUG(D_tls) debug_printf(
1122 "ECDH OpenSSL 1.1.0+ temp key parameter settings: default selection\n");
1128 DEBUG(D_tls) debug_printf("ECDH: curve '%s'\n", exp_curve);
1129 if ( (nid = OBJ_sn2nid (CCS exp_curve)) == NID_undef
1130 # ifdef EXIM_HAVE_OPENSSL_EC_NIST2NID
1131 && (nid = EC_curve_nist2nid(CCS exp_curve)) == NID_undef
1135 tls_error(string_sprintf("Unknown curve name tls_eccurve '%s'", exp_curve),
1136 host, NULL, errstr);
1140 if (!(ecdh = EC_KEY_new_by_curve_name(nid)))
1142 tls_error(US"Unable to create ec curve", host, NULL, errstr);
1146 /* The "tmp" in the name here refers to setting a temporary key
1147 not to the stability of the interface. */
1149 if ((rv = SSL_CTX_set_tmp_ecdh(sctx, ecdh) == 0))
1150 tls_error(string_sprintf("Error enabling '%s' curve", exp_curve), host, NULL, errstr);
1152 DEBUG(D_tls) debug_printf("ECDH: enabled '%s' curve\n", exp_curve);
1157 # endif /*EXIM_HAVE_ECDH*/
1158 #endif /*OPENSSL_NO_ECDH*/
1164 #ifndef DISABLE_OCSP
1165 /*************************************************
1166 * Load OCSP information into state *
1167 *************************************************/
1168 /* Called to load the server OCSP response from the given file into memory, once
1169 caller has determined this is needed. Checks validity. Debugs a message
1172 ASSUMES: single response, for single cert.
1175 sctx the SSL_CTX* to update
1176 cbinfo various parts of session state
1177 expanded the filename putatively holding an OCSP response
1182 ocsp_load_response(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo, const uschar *expanded)
1185 OCSP_RESPONSE * resp;
1186 OCSP_BASICRESP * basic_response;
1187 OCSP_SINGLERESP * single_response;
1188 ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
1189 STACK_OF(X509) * sk;
1190 unsigned long verify_flags;
1191 int status, reason, i;
1193 cbinfo->u_ocsp.server.file_expanded = string_copy(expanded);
1194 if (cbinfo->u_ocsp.server.response)
1196 OCSP_RESPONSE_free(cbinfo->u_ocsp.server.response);
1197 cbinfo->u_ocsp.server.response = NULL;
1200 if (!(bio = BIO_new_file(CS cbinfo->u_ocsp.server.file_expanded, "rb")))
1202 DEBUG(D_tls) debug_printf("Failed to open OCSP response file \"%s\"\n",
1203 cbinfo->u_ocsp.server.file_expanded);
1207 resp = d2i_OCSP_RESPONSE_bio(bio, NULL);
1211 DEBUG(D_tls) debug_printf("Error reading OCSP response.\n");
1215 if ((status = OCSP_response_status(resp)) != OCSP_RESPONSE_STATUS_SUCCESSFUL)
1217 DEBUG(D_tls) debug_printf("OCSP response not valid: %s (%d)\n",
1218 OCSP_response_status_str(status), status);
1222 if (!(basic_response = OCSP_response_get1_basic(resp)))
1225 debug_printf("OCSP response parse error: unable to extract basic response.\n");
1229 sk = cbinfo->verify_stack;
1230 verify_flags = OCSP_NOVERIFY; /* check sigs, but not purpose */
1232 /* May need to expose ability to adjust those flags?
1233 OCSP_NOSIGS OCSP_NOVERIFY OCSP_NOCHAIN OCSP_NOCHECKS OCSP_NOEXPLICIT
1234 OCSP_TRUSTOTHER OCSP_NOINTERN */
1236 /* This does a full verify on the OCSP proof before we load it for serving
1237 up; possibly overkill - just date-checks might be nice enough.
1239 OCSP_basic_verify takes a "store" arg, but does not
1240 use it for the chain verification, which is all we do
1241 when OCSP_NOVERIFY is set. The content from the wire
1242 "basic_response" and a cert-stack "sk" are all that is used.
1244 We have a stack, loaded in setup_certs() if tls_verify_certificates
1245 was a file (not a directory, or "system"). It is unfortunate we
1246 cannot used the connection context store, as that would neatly
1247 handle the "system" case too, but there seems to be no library
1248 function for getting a stack from a store.
1249 [ In OpenSSL 1.1 - ? X509_STORE_CTX_get0_chain(ctx) ? ]
1250 We do not free the stack since it could be needed a second time for
1253 Separately we might try to replace using OCSP_basic_verify() - which seems to not
1254 be a public interface into the OpenSSL library (there's no manual entry) -
1255 But what with? We also use OCSP_basic_verify in the client stapling callback.
1256 And there we NEED it; we must verify that status... unless the
1257 library does it for us anyway? */
1259 if ((i = OCSP_basic_verify(basic_response, sk, NULL, verify_flags)) < 0)
1263 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
1264 debug_printf("OCSP response verify failure: %s\n", US ssl_errstring);
1269 /* Here's the simplifying assumption: there's only one response, for the
1270 one certificate we use, and nothing for anything else in a chain. If this
1271 proves false, we need to extract a cert id from our issued cert
1272 (tls_certificate) and use that for OCSP_resp_find_status() (which finds the
1273 right cert in the stack and then calls OCSP_single_get0_status()).
1275 I'm hoping to avoid reworking a bunch more of how we handle state here. */
1277 if (!(single_response = OCSP_resp_get0(basic_response, 0)))
1280 debug_printf("Unable to get first response from OCSP basic response.\n");
1284 status = OCSP_single_get0_status(single_response, &reason, &rev, &thisupd, &nextupd);
1285 if (status != V_OCSP_CERTSTATUS_GOOD)
1287 DEBUG(D_tls) debug_printf("OCSP response bad cert status: %s (%d) %s (%d)\n",
1288 OCSP_cert_status_str(status), status,
1289 OCSP_crl_reason_str(reason), reason);
1293 if (!OCSP_check_validity(thisupd, nextupd, EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1295 DEBUG(D_tls) debug_printf("OCSP status invalid times.\n");
1300 cbinfo->u_ocsp.server.response = resp; /*XXX stack?*/
1304 if (f.running_in_test_harness)
1306 extern char ** environ;
1307 if (environ) for (uschar ** p = USS environ; *p; p++)
1308 if (Ustrncmp(*p, "EXIM_TESTHARNESS_DISABLE_OCSPVALIDITYCHECK", 42) == 0)
1310 DEBUG(D_tls) debug_printf("Supplying known bad OCSP response\n");
1311 goto supply_response;
1316 #endif /*!DISABLE_OCSP*/
1321 /* Create and install a selfsigned certificate, for use in server mode */
1324 tls_install_selfsign(SSL_CTX * sctx, uschar ** errstr)
1332 where = US"allocating pkey";
1333 if (!(pkey = EVP_PKEY_new()))
1336 where = US"allocating cert";
1337 if (!(x509 = X509_new()))
1340 where = US"generating pkey";
1341 if (!(rsa = rsa_callback(NULL, 0, 2048)))
1344 where = US"assigning pkey";
1345 if (!EVP_PKEY_assign_RSA(pkey, rsa))
1348 X509_set_version(x509, 2); /* N+1 - version 3 */
1349 ASN1_INTEGER_set(X509_get_serialNumber(x509), 1);
1350 X509_gmtime_adj(X509_get_notBefore(x509), 0);
1351 X509_gmtime_adj(X509_get_notAfter(x509), (long)60 * 60); /* 1 hour */
1352 X509_set_pubkey(x509, pkey);
1354 name = X509_get_subject_name(x509);
1355 X509_NAME_add_entry_by_txt(name, "C",
1356 MBSTRING_ASC, CUS "UK", -1, -1, 0);
1357 X509_NAME_add_entry_by_txt(name, "O",
1358 MBSTRING_ASC, CUS "Exim Developers", -1, -1, 0);
1359 X509_NAME_add_entry_by_txt(name, "CN",
1360 MBSTRING_ASC, CUS smtp_active_hostname, -1, -1, 0);
1361 X509_set_issuer_name(x509, name);
1363 where = US"signing cert";
1364 if (!X509_sign(x509, pkey, EVP_md5()))
1367 where = US"installing selfsign cert";
1368 if (!SSL_CTX_use_certificate(sctx, x509))
1371 where = US"installing selfsign key";
1372 if (!SSL_CTX_use_PrivateKey(sctx, pkey))
1378 (void) tls_error(where, NULL, NULL, errstr);
1379 if (x509) X509_free(x509);
1380 if (pkey) EVP_PKEY_free(pkey);
1388 tls_add_certfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1391 DEBUG(D_tls) debug_printf("tls_certificate file %s\n", file);
1392 if (!SSL_CTX_use_certificate_chain_file(sctx, CS file))
1393 return tls_error(string_sprintf(
1394 "SSL_CTX_use_certificate_chain_file file=%s", file),
1395 cbinfo->host, NULL, errstr);
1400 tls_add_pkeyfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1403 DEBUG(D_tls) debug_printf("tls_privatekey file %s\n", file);
1404 if (!SSL_CTX_use_PrivateKey_file(sctx, CS file, SSL_FILETYPE_PEM))
1405 return tls_error(string_sprintf(
1406 "SSL_CTX_use_PrivateKey_file file=%s", file), cbinfo->host, NULL, errstr);
1411 /*************************************************
1412 * Expand key and cert file specs *
1413 *************************************************/
1415 /* Called once during tls_init and possibly again during TLS setup, for a
1416 new context, if Server Name Indication was used and tls_sni was seen in
1417 the certificate string.
1420 sctx the SSL_CTX* to update
1421 cbinfo various parts of session state
1422 errstr error string pointer
1424 Returns: OK/DEFER/FAIL
1428 tls_expand_session_files(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo,
1433 if (!cbinfo->certificate)
1435 if (!cbinfo->is_server) /* client */
1438 if (tls_install_selfsign(sctx, errstr) != OK)
1445 if (Ustrstr(cbinfo->certificate, US"tls_sni") ||
1446 Ustrstr(cbinfo->certificate, US"tls_in_sni") ||
1447 Ustrstr(cbinfo->certificate, US"tls_out_sni")
1449 reexpand_tls_files_for_sni = TRUE;
1451 if (!expand_check(cbinfo->certificate, US"tls_certificate", &expanded, errstr))
1455 if (cbinfo->is_server)
1457 const uschar * file_list = expanded;
1461 while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1462 if ((err = tls_add_certfile(sctx, cbinfo, file, errstr)))
1465 else /* would there ever be a need for multiple client certs? */
1466 if ((err = tls_add_certfile(sctx, cbinfo, expanded, errstr)))
1469 if ( cbinfo->privatekey
1470 && !expand_check(cbinfo->privatekey, US"tls_privatekey", &expanded, errstr))
1473 /* If expansion was forced to fail, key_expanded will be NULL. If the result
1474 of the expansion is an empty string, ignore it also, and assume the private
1475 key is in the same file as the certificate. */
1477 if (expanded && *expanded)
1478 if (cbinfo->is_server)
1480 const uschar * file_list = expanded;
1484 while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1485 if ((err = tls_add_pkeyfile(sctx, cbinfo, file, errstr)))
1488 else /* would there ever be a need for multiple client certs? */
1489 if ((err = tls_add_pkeyfile(sctx, cbinfo, expanded, errstr)))
1493 #ifndef DISABLE_OCSP
1494 if (cbinfo->is_server && cbinfo->u_ocsp.server.file)
1497 if (!expand_check(cbinfo->u_ocsp.server.file, US"tls_ocsp_file", &expanded, errstr))
1500 if (expanded && *expanded)
1502 DEBUG(D_tls) debug_printf("tls_ocsp_file %s\n", expanded);
1503 if ( cbinfo->u_ocsp.server.file_expanded
1504 && (Ustrcmp(expanded, cbinfo->u_ocsp.server.file_expanded) == 0))
1506 DEBUG(D_tls) debug_printf(" - value unchanged, using existing values\n");
1509 ocsp_load_response(sctx, cbinfo, expanded);
1520 /*************************************************
1521 * Callback to handle SNI *
1522 *************************************************/
1524 /* Called when acting as server during the TLS session setup if a Server Name
1525 Indication extension was sent by the client.
1527 API documentation is OpenSSL s_server.c implementation.
1530 s SSL* of the current session
1531 ad unknown (part of OpenSSL API) (unused)
1532 arg Callback of "our" registered data
1534 Returns: SSL_TLSEXT_ERR_{OK,ALERT_WARNING,ALERT_FATAL,NOACK}
1536 XXX might need to change to using ClientHello callback,
1537 per https://www.openssl.org/docs/manmaster/man3/SSL_client_hello_cb_fn.html
1540 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1542 tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg)
1544 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
1545 tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
1547 int old_pool = store_pool;
1548 uschar * dummy_errstr;
1551 return SSL_TLSEXT_ERR_OK;
1553 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", servername,
1554 reexpand_tls_files_for_sni ? "" : " (unused for certificate selection)");
1556 /* Make the extension value available for expansion */
1557 store_pool = POOL_PERM;
1558 tls_in.sni = string_copy(US servername);
1559 store_pool = old_pool;
1561 if (!reexpand_tls_files_for_sni)
1562 return SSL_TLSEXT_ERR_OK;
1564 /* Can't find an SSL_CTX_clone() or equivalent, so we do it manually;
1565 not confident that memcpy wouldn't break some internal reference counting.
1566 Especially since there's a references struct member, which would be off. */
1568 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
1569 if (!(server_sni = SSL_CTX_new(TLS_server_method())))
1571 if (!(server_sni = SSL_CTX_new(SSLv23_server_method())))
1574 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
1575 DEBUG(D_tls) debug_printf("SSL_CTX_new() failed: %s\n", ssl_errstring);
1579 /* Not sure how many of these are actually needed, since SSL object
1580 already exists. Might even need this selfsame callback, for reneg? */
1582 SSL_CTX_set_info_callback(server_sni, SSL_CTX_get_info_callback(server_ctx));
1583 SSL_CTX_set_mode(server_sni, SSL_CTX_get_mode(server_ctx));
1584 SSL_CTX_set_options(server_sni, SSL_CTX_get_options(server_ctx));
1585 SSL_CTX_set_timeout(server_sni, SSL_CTX_get_timeout(server_ctx));
1586 SSL_CTX_set_tlsext_servername_callback(server_sni, tls_servername_cb);
1587 SSL_CTX_set_tlsext_servername_arg(server_sni, cbinfo);
1589 if ( !init_dh(server_sni, cbinfo->dhparam, NULL, &dummy_errstr)
1590 || !init_ecdh(server_sni, NULL, &dummy_errstr)
1594 if ( cbinfo->server_cipher_list
1595 && !SSL_CTX_set_cipher_list(server_sni, CS cbinfo->server_cipher_list))
1598 #ifndef DISABLE_OCSP
1599 if (cbinfo->u_ocsp.server.file)
1601 SSL_CTX_set_tlsext_status_cb(server_sni, tls_server_stapling_cb);
1602 SSL_CTX_set_tlsext_status_arg(server_sni, cbinfo);
1606 if ((rc = setup_certs(server_sni, tls_verify_certificates, tls_crl, NULL, FALSE,
1607 verify_callback_server, &dummy_errstr)) != OK)
1610 /* do this after setup_certs, because this can require the certs for verifying
1611 OCSP information. */
1612 if ((rc = tls_expand_session_files(server_sni, cbinfo, &dummy_errstr)) != OK)
1615 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
1616 SSL_set_SSL_CTX(s, server_sni);
1617 return SSL_TLSEXT_ERR_OK;
1619 bad: return SSL_TLSEXT_ERR_ALERT_FATAL;
1621 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
1626 #ifndef DISABLE_OCSP
1628 /*************************************************
1629 * Callback to handle OCSP Stapling *
1630 *************************************************/
1632 /* Called when acting as server during the TLS session setup if the client
1633 requests OCSP information with a Certificate Status Request.
1635 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
1641 tls_server_stapling_cb(SSL *s, void *arg)
1643 const tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
1644 uschar *response_der; /*XXX blob */
1645 int response_der_len;
1647 /*XXX stack: use SSL_get_certificate() to see which cert; from that work
1648 out which ocsp blob to send. Unfortunately, SSL_get_certificate is known
1649 buggy in current OpenSSL; it returns the last cert loaded always rather than
1650 the one actually presented. So we can't support a stack of OCSP proofs at
1654 debug_printf("Received TLS status request (OCSP stapling); %s response\n",
1655 cbinfo->u_ocsp.server.response ? "have" : "lack");
1657 tls_in.ocsp = OCSP_NOT_RESP;
1658 if (!cbinfo->u_ocsp.server.response)
1659 return SSL_TLSEXT_ERR_NOACK;
1661 response_der = NULL;
1662 response_der_len = i2d_OCSP_RESPONSE(cbinfo->u_ocsp.server.response, /*XXX stack*/
1664 if (response_der_len <= 0)
1665 return SSL_TLSEXT_ERR_NOACK;
1667 SSL_set_tlsext_status_ocsp_resp(server_ssl, response_der, response_der_len);
1668 tls_in.ocsp = OCSP_VFIED;
1669 return SSL_TLSEXT_ERR_OK;
1674 time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
1676 BIO_printf(bp, "\t%s: ", str);
1677 ASN1_GENERALIZEDTIME_print(bp, time);
1682 tls_client_stapling_cb(SSL *s, void *arg)
1684 tls_ext_ctx_cb * cbinfo = arg;
1685 const unsigned char * p;
1687 OCSP_RESPONSE * rsp;
1688 OCSP_BASICRESP * bs;
1691 DEBUG(D_tls) debug_printf("Received TLS status response (OCSP stapling):");
1692 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
1695 /* Expect this when we requested ocsp but got none */
1696 if (cbinfo->u_ocsp.client.verify_required && LOGGING(tls_cipher))
1697 log_write(0, LOG_MAIN, "Received TLS status callback, null content");
1699 DEBUG(D_tls) debug_printf(" null\n");
1700 return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1703 if(!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
1705 tls_out.ocsp = OCSP_FAILED;
1706 if (LOGGING(tls_cipher))
1707 log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
1709 DEBUG(D_tls) debug_printf(" parse error\n");
1713 if(!(bs = OCSP_response_get1_basic(rsp)))
1715 tls_out.ocsp = OCSP_FAILED;
1716 if (LOGGING(tls_cipher))
1717 log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
1719 DEBUG(D_tls) debug_printf(" error parsing response\n");
1720 OCSP_RESPONSE_free(rsp);
1724 /* We'd check the nonce here if we'd put one in the request. */
1725 /* However that would defeat cacheability on the server so we don't. */
1727 /* This section of code reworked from OpenSSL apps source;
1728 The OpenSSL Project retains copyright:
1729 Copyright (c) 1999 The OpenSSL Project. All rights reserved.
1734 ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
1736 DEBUG(D_tls) bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
1738 /*OCSP_RESPONSE_print(bp, rsp, 0); extreme debug: stapling content */
1740 /* Use the chain that verified the server cert to verify the stapled info */
1741 /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
1743 if ((i = OCSP_basic_verify(bs, cbinfo->verify_stack,
1744 cbinfo->u_ocsp.client.verify_store, 0)) <= 0)
1746 tls_out.ocsp = OCSP_FAILED;
1747 if (LOGGING(tls_cipher)) log_write(0, LOG_MAIN,
1748 "Received TLS cert status response, itself unverifiable: %s",
1749 ERR_reason_error_string(ERR_peek_error()));
1750 BIO_printf(bp, "OCSP response verify failure\n");
1751 ERR_print_errors(bp);
1752 OCSP_RESPONSE_print(bp, rsp, 0);
1756 BIO_printf(bp, "OCSP response well-formed and signed OK\n");
1758 /*XXX So we have a good stapled OCSP status. How do we know
1759 it is for the cert of interest? OpenSSL 1.1.0 has a routine
1760 OCSP_resp_find_status() which matches on a cert id, which presumably
1761 we should use. Making an id needs OCSP_cert_id_new(), which takes
1762 issuerName, issuerKey, serialNumber. Are they all in the cert?
1764 For now, carry on blindly accepting the resp. */
1767 OCSP_SINGLERESP * single;
1769 #ifdef EXIM_HAVE_OCSP_RESP_COUNT
1770 if (OCSP_resp_count(bs) != 1)
1772 STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
1773 if (sk_OCSP_SINGLERESP_num(sresp) != 1)
1776 tls_out.ocsp = OCSP_FAILED;
1777 log_write(0, LOG_MAIN, "OCSP stapling "
1778 "with multiple responses not handled");
1781 single = OCSP_resp_get0(bs, 0);
1782 status = OCSP_single_get0_status(single, &reason, &rev,
1783 &thisupd, &nextupd);
1786 DEBUG(D_tls) time_print(bp, "This OCSP Update", thisupd);
1787 DEBUG(D_tls) if(nextupd) time_print(bp, "Next OCSP Update", nextupd);
1788 if (!OCSP_check_validity(thisupd, nextupd,
1789 EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1791 tls_out.ocsp = OCSP_FAILED;
1792 DEBUG(D_tls) ERR_print_errors(bp);
1793 log_write(0, LOG_MAIN, "Server OSCP dates invalid");
1797 DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
1798 OCSP_cert_status_str(status));
1801 case V_OCSP_CERTSTATUS_GOOD:
1802 tls_out.ocsp = OCSP_VFIED;
1805 case V_OCSP_CERTSTATUS_REVOKED:
1806 tls_out.ocsp = OCSP_FAILED;
1807 log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
1808 reason != -1 ? "; reason: " : "",
1809 reason != -1 ? OCSP_crl_reason_str(reason) : "");
1810 DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
1813 tls_out.ocsp = OCSP_FAILED;
1814 log_write(0, LOG_MAIN,
1815 "Server certificate status unknown, in OCSP stapling");
1820 i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1825 OCSP_RESPONSE_free(rsp);
1828 #endif /*!DISABLE_OCSP*/
1831 /*************************************************
1832 * Initialize for TLS *
1833 *************************************************/
1835 /* Called from both server and client code, to do preliminary initialization
1836 of the library. We allocate and return a context structure.
1839 ctxp returned SSL context
1840 host connected host, if client; NULL if server
1841 dhparam DH parameter file
1842 certificate certificate file
1843 privatekey private key
1844 ocsp_file file of stapling info (server); flag for require ocsp (client)
1845 addr address if client; NULL if server (for some randomness)
1846 cbp place to put allocated callback context
1847 errstr error string pointer
1849 Returns: OK/DEFER/FAIL
1853 tls_init(SSL_CTX **ctxp, host_item *host, uschar *dhparam, uschar *certificate,
1855 #ifndef DISABLE_OCSP
1856 uschar *ocsp_file, /*XXX stack, in server*/
1858 address_item *addr, tls_ext_ctx_cb ** cbp,
1865 tls_ext_ctx_cb * cbinfo;
1867 cbinfo = store_malloc(sizeof(tls_ext_ctx_cb));
1868 cbinfo->tlsp = tlsp;
1869 cbinfo->certificate = certificate;
1870 cbinfo->privatekey = privatekey;
1871 cbinfo->is_server = host==NULL;
1872 #ifndef DISABLE_OCSP
1873 cbinfo->verify_stack = NULL;
1876 cbinfo->u_ocsp.server.file = ocsp_file;
1877 cbinfo->u_ocsp.server.file_expanded = NULL;
1878 cbinfo->u_ocsp.server.response = NULL;
1881 cbinfo->u_ocsp.client.verify_store = NULL;
1883 cbinfo->dhparam = dhparam;
1884 cbinfo->server_cipher_list = NULL;
1885 cbinfo->host = host;
1886 #ifndef DISABLE_EVENT
1887 cbinfo->event_action = NULL;
1890 #ifdef EXIM_NEED_OPENSSL_INIT
1891 SSL_load_error_strings(); /* basic set up */
1892 OpenSSL_add_ssl_algorithms();
1895 #ifdef EXIM_HAVE_SHA256
1896 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
1897 list of available digests. */
1898 EVP_add_digest(EVP_sha256());
1901 /* Create a context.
1902 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
1903 negotiation in the different methods; as far as I can tell, the only
1904 *_{server,client}_method which allows negotiation is SSLv23, which exists even
1905 when OpenSSL is built without SSLv2 support.
1906 By disabling with openssl_options, we can let admins re-enable with the
1909 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
1910 if (!(ctx = SSL_CTX_new(host ? TLS_client_method() : TLS_server_method())))
1912 if (!(ctx = SSL_CTX_new(host ? SSLv23_client_method() : SSLv23_server_method())))
1914 return tls_error(US"SSL_CTX_new", host, NULL, errstr);
1916 /* It turns out that we need to seed the random number generator this early in
1917 order to get the full complement of ciphers to work. It took me roughly a day
1918 of work to discover this by experiment.
1920 On systems that have /dev/urandom, SSL may automatically seed itself from
1921 there. Otherwise, we have to make something up as best we can. Double check
1927 gettimeofday(&r.tv, NULL);
1930 RAND_seed(US (&r), sizeof(r));
1931 RAND_seed(US big_buffer, big_buffer_size);
1932 if (addr != NULL) RAND_seed(US addr, sizeof(addr));
1935 return tls_error(US"RAND_status", host,
1936 US"unable to seed random number generator", errstr);
1939 /* Set up the information callback, which outputs if debugging is at a suitable
1944 SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
1945 #ifndef OPENSSL_NO_SSL_TRACE /* this needs a debug build of OpenSSL */
1946 SSL_CTX_set_msg_callback(ctx, (void (*)())SSL_trace);
1948 #ifdef OPENSSL_HAVE_KEYLOG_CB
1949 SSL_CTX_set_keylog_callback(ctx, (void (*)())keylog_callback);
1953 /* Automatically re-try reads/writes after renegotiation. */
1954 (void) SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
1956 /* Apply administrator-supplied work-arounds.
1957 Historically we applied just one requested option,
1958 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
1959 moved to an administrator-controlled list of options to specify and
1960 grandfathered in the first one as the default value for "openssl_options".
1962 No OpenSSL version number checks: the options we accept depend upon the
1963 availability of the option value macros from OpenSSL. */
1965 if (!tls_openssl_options_parse(openssl_options, &init_options))
1966 return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
1968 #ifdef EXPERIMENTAL_TLS_RESUME
1969 tlsp->resumption = RESUME_SUPPORTED;
1973 #ifdef EXPERIMENTAL_TLS_RESUME
1974 /* Should the server offer session resumption? */
1975 if (!host && verify_check_host(&tls_resumption_hosts) == OK)
1977 DEBUG(D_tls) debug_printf("tls_resumption_hosts overrides openssl_options\n");
1978 init_options &= ~SSL_OP_NO_TICKET;
1979 tlsp->resumption |= RESUME_SERVER_TICKET; /* server will give ticket on request */
1980 tlsp->host_resumable = TRUE;
1984 DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
1985 if (!(SSL_CTX_set_options(ctx, init_options)))
1986 return tls_error(string_sprintf(
1987 "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
1990 DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
1992 /* We'd like to disable session cache unconditionally, but foolish Outlook
1993 Express clients then give up the first TLS connection and make a second one
1994 (which works). Only when there is an IMAP service on the same machine.
1995 Presumably OE is trying to use the cache for A on B. Leave it enabled for
1996 now, until we work out a decent way of presenting control to the config. It
1997 will never be used because we use a new context every time. */
1999 (void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
2002 /* Initialize with DH parameters if supplied */
2003 /* Initialize ECDH temp key parameter selection */
2005 if ( !init_dh(ctx, dhparam, host, errstr)
2006 || !init_ecdh(ctx, host, errstr)
2010 /* Set up certificate and key (and perhaps OCSP info) */
2012 if ((rc = tls_expand_session_files(ctx, cbinfo, errstr)) != OK)
2015 /* If we need to handle SNI or OCSP, do so */
2017 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2018 # ifndef DISABLE_OCSP
2019 if (!(cbinfo->verify_stack = sk_X509_new_null()))
2021 DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
2026 if (!host) /* server */
2028 # ifndef DISABLE_OCSP
2029 /* We check u_ocsp.server.file, not server.response, because we care about if
2030 the option exists, not what the current expansion might be, as SNI might
2031 change the certificate and OCSP file in use between now and the time the
2032 callback is invoked. */
2033 if (cbinfo->u_ocsp.server.file)
2035 SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
2036 SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
2039 /* We always do this, so that $tls_sni is available even if not used in
2041 SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
2042 SSL_CTX_set_tlsext_servername_arg(ctx, cbinfo);
2044 # ifndef DISABLE_OCSP
2046 if(ocsp_file) /* wanting stapling */
2048 if (!(cbinfo->u_ocsp.client.verify_store = X509_STORE_new()))
2050 DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
2053 SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
2054 SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
2059 cbinfo->verify_cert_hostnames = NULL;
2061 #ifdef EXIM_HAVE_EPHEM_RSA_KEX
2062 /* Set up the RSA callback */
2063 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
2066 /* Finally, set the session cache timeout, and we are done.
2067 The period appears to be also used for (server-generated) session tickets */
2069 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
2070 DEBUG(D_tls) debug_printf("Initialized TLS\n");
2081 /*************************************************
2082 * Get name of cipher in use *
2083 *************************************************/
2086 Argument: pointer to an SSL structure for the connection
2087 pointer to number of bits for cipher
2088 Returns: pointer to allocated string in perm-pool
2092 construct_cipher_name(SSL * ssl, int * bits)
2094 int pool = store_pool;
2095 /* With OpenSSL 1.0.0a, 'c' needs to be const but the documentation doesn't
2096 yet reflect that. It should be a safe change anyway, even 0.9.8 versions have
2097 the accessor functions use const in the prototype. */
2099 const uschar * ver = CUS SSL_get_version(ssl);
2100 const SSL_CIPHER * c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
2103 SSL_CIPHER_get_bits(c, bits);
2105 store_pool = POOL_PERM;
2106 s = string_sprintf("%s:%s:%u", ver, SSL_CIPHER_get_name(c), *bits);
2108 DEBUG(D_tls) debug_printf("Cipher: %s\n", s);
2113 /* Get IETF-standard name for ciphersuite.
2114 Argument: pointer to an SSL structure for the connection
2115 Returns: pointer to string
2118 static const uschar *
2119 cipher_stdname_ssl(SSL * ssl)
2121 #ifdef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
2122 return CUS SSL_CIPHER_standard_name(SSL_get_current_cipher(ssl));
2124 ushort id = 0xffff & SSL_CIPHER_get_id(SSL_get_current_cipher(ssl));
2125 return cipher_stdname(id >> 8, id & 0xff);
2131 peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned siz)
2133 /*XXX we might consider a list-of-certs variable for the cert chain.
2134 SSL_get_peer_cert_chain(SSL*). We'd need a new variable type and support
2135 in list-handling functions, also consider the difference between the entire
2136 chain and the elements sent by the peer. */
2138 tlsp->peerdn = NULL;
2140 /* Will have already noted peercert on a verify fail; possibly not the leaf */
2141 if (!tlsp->peercert)
2142 tlsp->peercert = SSL_get_peer_certificate(ssl);
2143 /* Beware anonymous ciphers which lead to server_cert being NULL */
2145 if (!X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, siz))
2146 { DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n"); }
2149 peerdn[siz-1] = '\0';
2150 tlsp->peerdn = peerdn; /*XXX a static buffer... */
2158 /*************************************************
2159 * Set up for verifying certificates *
2160 *************************************************/
2162 #ifndef DISABLE_OCSP
2163 /* Load certs from file, return TRUE on success */
2166 chain_from_pem_file(const uschar * file, STACK_OF(X509) * verify_stack)
2171 while (sk_X509_num(verify_stack) > 0)
2172 X509_free(sk_X509_pop(verify_stack));
2174 if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
2175 while ((x = PEM_read_bio_X509(bp, NULL, 0, NULL)))
2176 sk_X509_push(verify_stack, x);
2184 /* Called by both client and server startup; on the server possibly
2185 repeated after a Server Name Indication.
2188 sctx SSL_CTX* to initialise
2189 certs certs file or NULL
2190 crl CRL file or NULL
2191 host NULL in a server; the remote host in a client
2192 optional TRUE if called from a server for a host in tls_try_verify_hosts;
2193 otherwise passed as FALSE
2194 cert_vfy_cb Callback function for certificate verification
2195 errstr error string pointer
2197 Returns: OK/DEFER/FAIL
2201 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
2202 int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr)
2204 uschar *expcerts, *expcrl;
2206 if (!expand_check(certs, US"tls_verify_certificates", &expcerts, errstr))
2208 DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
2210 if (expcerts && *expcerts)
2212 /* Tell the library to use its compiled-in location for the system default
2213 CA bundle. Then add the ones specified in the config, if any. */
2215 if (!SSL_CTX_set_default_verify_paths(sctx))
2216 return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
2218 if (Ustrcmp(expcerts, "system") != 0)
2220 struct stat statbuf;
2222 if (Ustat(expcerts, &statbuf) < 0)
2224 log_write(0, LOG_MAIN|LOG_PANIC,
2225 "failed to stat %s for certificates", expcerts);
2231 if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
2232 { file = NULL; dir = expcerts; }
2235 file = expcerts; dir = NULL;
2236 #ifndef DISABLE_OCSP
2237 /* In the server if we will be offering an OCSP proof, load chain from
2238 file for verifying the OCSP proof at load time. */
2241 && statbuf.st_size > 0
2242 && server_static_cbinfo->u_ocsp.server.file
2243 && !chain_from_pem_file(file, server_static_cbinfo->verify_stack)
2246 log_write(0, LOG_MAIN|LOG_PANIC,
2247 "failed to load cert chain from %s", file);
2253 /* If a certificate file is empty, the next function fails with an
2254 unhelpful error message. If we skip it, we get the correct behaviour (no
2255 certificates are recognized, but the error message is still misleading (it
2256 says no certificate was supplied). But this is better. */
2258 if ( (!file || statbuf.st_size > 0)
2259 && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
2260 return tls_error(US"SSL_CTX_load_verify_locations", host, NULL, errstr);
2262 /* Load the list of CAs for which we will accept certs, for sending
2263 to the client. This is only for the one-file tls_verify_certificates
2265 If a list isn't loaded into the server, but some verify locations are set,
2266 the server end appears to make a wildcard request for client certs.
2267 Meanwhile, the client library as default behaviour *ignores* the list
2268 we send over the wire - see man SSL_CTX_set_client_cert_cb.
2269 Because of this, and that the dir variant is likely only used for
2270 the public-CA bundle (not for a private CA), not worth fixing. */
2274 STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
2276 SSL_CTX_set_client_CA_list(sctx, names);
2277 DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n",
2278 sk_X509_NAME_num(names));
2283 /* Handle a certificate revocation list. */
2285 #if OPENSSL_VERSION_NUMBER > 0x00907000L
2287 /* This bit of code is now the version supplied by Lars Mainka. (I have
2288 merely reformatted it into the Exim code style.)
2290 "From here I changed the code to add support for multiple crl's
2291 in pem format in one file or to support hashed directory entries in
2292 pem format instead of a file. This method now uses the library function
2293 X509_STORE_load_locations to add the CRL location to the SSL context.
2294 OpenSSL will then handle the verify against CA certs and CRLs by
2295 itself in the verify callback." */
2297 if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
2298 if (expcrl && *expcrl)
2300 struct stat statbufcrl;
2301 if (Ustat(expcrl, &statbufcrl) < 0)
2303 log_write(0, LOG_MAIN|LOG_PANIC,
2304 "failed to stat %s for certificates revocation lists", expcrl);
2309 /* is it a file or directory? */
2311 X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
2312 if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
2316 DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
2322 DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
2324 if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
2325 return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
2327 /* setting the flags to check against the complete crl chain */
2329 X509_STORE_set_flags(cvstore,
2330 X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
2334 #endif /* OPENSSL_VERSION_NUMBER > 0x00907000L */
2336 /* If verification is optional, don't fail if no certificate */
2338 SSL_CTX_set_verify(sctx,
2339 SSL_VERIFY_PEER | (optional ? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
2348 /*************************************************
2349 * Start a TLS session in a server *
2350 *************************************************/
2352 /* This is called when Exim is running as a server, after having received
2353 the STARTTLS command. It must respond to that command, and then negotiate
2357 require_ciphers allowed ciphers
2358 errstr pointer to error message
2360 Returns: OK on success
2361 DEFER for errors before the start of the negotiation
2362 FAIL for errors during the negotiation; the server can't
2367 tls_server_start(const uschar * require_ciphers, uschar ** errstr)
2370 uschar * expciphers;
2371 tls_ext_ctx_cb * cbinfo;
2372 static uschar peerdn[256];
2374 /* Check for previous activation */
2376 if (tls_in.active.sock >= 0)
2378 tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
2379 smtp_printf("554 Already in TLS\r\n", FALSE);
2383 /* Initialize the SSL library. If it fails, it will already have logged
2386 rc = tls_init(&server_ctx, NULL, tls_dhparam, tls_certificate, tls_privatekey,
2387 #ifndef DISABLE_OCSP
2388 tls_ocsp_file, /*XXX stack*/
2390 NULL, &server_static_cbinfo, &tls_in, errstr);
2391 if (rc != OK) return rc;
2392 cbinfo = server_static_cbinfo;
2394 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
2397 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2398 were historically separated by underscores. So that I can use either form in my
2399 tests, and also for general convenience, we turn underscores into hyphens here.
2401 XXX SSL_CTX_set_cipher_list() is replaced by SSL_CTX_set_ciphersuites()
2402 for TLS 1.3 . Since we do not call it at present we get the default list:
2403 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
2408 for (uschar * s = expciphers; *s; s++ ) if (*s == '_') *s = '-';
2409 DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2410 if (!SSL_CTX_set_cipher_list(server_ctx, CS expciphers))
2411 return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL, errstr);
2412 cbinfo->server_cipher_list = expciphers;
2415 /* If this is a host for which certificate verification is mandatory or
2416 optional, set up appropriately. */
2418 tls_in.certificate_verified = FALSE;
2420 tls_in.dane_verified = FALSE;
2422 server_verify_callback_called = FALSE;
2424 if (verify_check_host(&tls_verify_hosts) == OK)
2426 rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2427 FALSE, verify_callback_server, errstr);
2428 if (rc != OK) return rc;
2429 server_verify_optional = FALSE;
2431 else if (verify_check_host(&tls_try_verify_hosts) == OK)
2433 rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2434 TRUE, verify_callback_server, errstr);
2435 if (rc != OK) return rc;
2436 server_verify_optional = TRUE;
2439 #ifdef EXPERIMENTAL_TLS_RESUME
2440 SSL_CTX_set_tlsext_ticket_key_cb(server_ctx, ticket_key_callback);
2441 /* despite working, appears to always return failure, so ignoring */
2443 #ifdef OPENSSL_HAVE_NUM_TICKETS
2444 # ifdef EXPERIMENTAL_TLS_RESUME
2445 SSL_CTX_set_num_tickets(server_ctx, tls_in.host_resumable ? 1 : 0);
2447 SSL_CTX_set_num_tickets(server_ctx, 0); /* send no TLS1.3 stateful-tickets */
2452 /* Prepare for new connection */
2454 if (!(server_ssl = SSL_new(server_ctx)))
2455 return tls_error(US"SSL_new", NULL, NULL, errstr);
2457 /* Warning: we used to SSL_clear(ssl) here, it was removed.
2459 * With the SSL_clear(), we get strange interoperability bugs with
2460 * OpenSSL 1.0.1b and TLS1.1/1.2. It looks as though this may be a bug in
2461 * OpenSSL itself, as a clear should not lead to inability to follow protocols.
2463 * The SSL_clear() call is to let an existing SSL* be reused, typically after
2464 * session shutdown. In this case, we have a brand new object and there's no
2465 * obvious reason to immediately clear it. I'm guessing that this was
2466 * originally added because of incomplete initialisation which the clear fixed,
2467 * in some historic release.
2470 /* Set context and tell client to go ahead, except in the case of TLS startup
2471 on connection, where outputting anything now upsets the clients and tends to
2472 make them disconnect. We need to have an explicit fflush() here, to force out
2473 the response. Other smtp_printf() calls do not need it, because in non-TLS
2474 mode, the fflush() happens when smtp_getc() is called. */
2476 SSL_set_session_id_context(server_ssl, sid_ctx, Ustrlen(sid_ctx));
2477 if (!tls_in.on_connect)
2479 smtp_printf("220 TLS go ahead\r\n", FALSE);
2483 /* Now negotiate the TLS session. We put our own timer on it, since it seems
2484 that the OpenSSL library doesn't. */
2486 SSL_set_wfd(server_ssl, fileno(smtp_out));
2487 SSL_set_rfd(server_ssl, fileno(smtp_in));
2488 SSL_set_accept_state(server_ssl);
2490 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
2492 sigalrm_seen = FALSE;
2493 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
2494 rc = SSL_accept(server_ssl);
2499 (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
2503 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
2504 ERR_clear_error(); /* Even success can leave errors in the stack. Seen with
2505 anon-authentication ciphersuite negotiated. */
2507 #ifdef EXPERIMENTAL_TLS_RESUME
2508 if (SSL_session_reused(server_ssl))
2510 tls_in.resumption |= RESUME_USED;
2511 DEBUG(D_tls) debug_printf("Session reused\n");
2515 /* TLS has been set up. Adjust the input functions to read via TLS,
2516 and initialize things. */
2518 peer_cert(server_ssl, &tls_in, peerdn, sizeof(peerdn));
2520 tls_in.cipher = construct_cipher_name(server_ssl, &tls_in.bits);
2521 tls_in.cipher_stdname = cipher_stdname_ssl(server_ssl);
2526 if (SSL_get_shared_ciphers(server_ssl, CS buf, sizeof(buf)))
2527 debug_printf("Shared ciphers: %s\n", buf);
2529 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
2531 BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
2532 SSL_SESSION_print_keylog(bp, SSL_get_session(server_ssl));
2537 #ifdef EXIM_HAVE_SESSION_TICKET
2539 SSL_SESSION * ss = SSL_get_session(server_ssl);
2540 if (SSL_SESSION_has_ticket(ss))
2541 debug_printf("The session has a ticket, life %lu seconds\n",
2542 SSL_SESSION_get_ticket_lifetime_hint(ss));
2547 /* Record the certificate we presented */
2549 X509 * crt = SSL_get_certificate(server_ssl);
2550 tls_in.ourcert = crt ? X509_dup(crt) : NULL;
2553 /* Only used by the server-side tls (tls_in), including tls_getc.
2554 Client-side (tls_out) reads (seem to?) go via
2555 smtp_read_response()/ip_recv().
2556 Hence no need to duplicate for _in and _out.
2558 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
2559 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
2560 ssl_xfer_eof = ssl_xfer_error = FALSE;
2562 receive_getc = tls_getc;
2563 receive_getbuf = tls_getbuf;
2564 receive_get_cache = tls_get_cache;
2565 receive_ungetc = tls_ungetc;
2566 receive_feof = tls_feof;
2567 receive_ferror = tls_ferror;
2568 receive_smtp_buffered = tls_smtp_buffered;
2570 tls_in.active.sock = fileno(smtp_out);
2571 tls_in.active.tls_ctx = NULL; /* not using explicit ctx for server-side */
2579 tls_client_basic_ctx_init(SSL_CTX * ctx,
2580 host_item * host, smtp_transport_options_block * ob, tls_ext_ctx_cb * cbinfo,
2584 /* stick to the old behaviour for compatibility if tls_verify_certificates is
2585 set but both tls_verify_hosts and tls_try_verify_hosts is not set. Check only
2586 the specified host patterns if one of them is defined */
2588 if ( ( !ob->tls_verify_hosts
2589 && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
2591 || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
2593 client_verify_optional = FALSE;
2594 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
2595 client_verify_optional = TRUE;
2599 if ((rc = setup_certs(ctx, ob->tls_verify_certificates,
2600 ob->tls_crl, host, client_verify_optional, verify_callback_client,
2604 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
2606 cbinfo->verify_cert_hostnames =
2608 string_domain_utf8_to_alabel(host->name, NULL);
2612 DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
2613 cbinfo->verify_cert_hostnames);
2621 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
2624 const char * hostnames[2] = { CS host->name, NULL };
2627 if (DANESSL_init(ssl, NULL, hostnames) != 1)
2628 return tls_error(US"hostnames load", host, NULL, errstr);
2630 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
2631 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2632 ) if (rr->type == T_TLSA && rr->size > 3)
2634 const uschar * p = rr->data;
2635 uint8_t usage, selector, mtype;
2636 const char * mdname;
2640 /* Only DANE-TA(2) and DANE-EE(3) are supported */
2641 if (usage != 2 && usage != 3) continue;
2648 default: continue; /* Only match-types 0, 1, 2 are supported */
2649 case 0: mdname = NULL; break;
2650 case 1: mdname = "sha256"; break;
2651 case 2: mdname = "sha512"; break;
2655 switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
2658 return tls_error(US"tlsa load", host, NULL, errstr);
2659 case 0: /* action not taken */
2663 tls_out.tlsa_usage |= 1<<usage;
2669 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
2672 #endif /*SUPPORT_DANE*/
2676 #ifdef EXPERIMENTAL_TLS_RESUME
2677 /* On the client, get any stashed session for the given IP from hints db
2678 and apply it to the ssl-connection for attempted resumption. */
2681 tls_retrieve_session(tls_support * tlsp, SSL * ssl, const uschar * key)
2683 tlsp->resumption |= RESUME_SUPPORTED;
2684 if (tlsp->host_resumable)
2686 dbdata_tls_session * dt;
2688 open_db dbblock, * dbm_file;
2690 tlsp->resumption |= RESUME_CLIENT_REQUESTED;
2691 DEBUG(D_tls) debug_printf("checking for resumable session for %s\n", key);
2692 if ((dbm_file = dbfn_open(US"tls", O_RDONLY, &dbblock, FALSE, FALSE)))
2694 /* key for the db is the IP */
2695 if ((dt = dbfn_read_with_length(dbm_file, key, &len)))
2697 SSL_SESSION * ss = NULL;
2698 const uschar * sess_asn1 = dt->session;
2700 len -= sizeof(dbdata_tls_session);
2701 if (!(d2i_SSL_SESSION(&ss, &sess_asn1, (long)len)))
2705 ERR_error_string_n(ERR_get_error(),
2706 ssl_errstring, sizeof(ssl_errstring));
2707 debug_printf("decoding session: %s\n", ssl_errstring);
2710 else if (!SSL_set_session(ssl, ss))
2714 ERR_error_string_n(ERR_get_error(),
2715 ssl_errstring, sizeof(ssl_errstring));
2716 debug_printf("applying session to ssl: %s\n", ssl_errstring);
2721 DEBUG(D_tls) debug_printf("good session\n");
2722 tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
2726 DEBUG(D_tls) debug_printf("no session record\n");
2727 dbfn_close(dbm_file);
2733 /* On the client, save the session for later resumption */
2736 tls_save_session_cb(SSL * ssl, SSL_SESSION * ss)
2738 tls_ext_ctx_cb * cbinfo = SSL_get_ex_data(ssl, tls_exdata_idx);
2741 DEBUG(D_tls) debug_printf("tls_save_session_cb\n");
2743 if (!cbinfo || !(tlsp = cbinfo->tlsp)->host_resumable) return 0;
2745 # ifdef EXIM_HAVE_SESSION_TICKET
2747 if (SSL_SESSION_is_resumable(ss))
2749 int len = i2d_SSL_SESSION(ss, NULL);
2750 int dlen = sizeof(dbdata_tls_session) + len;
2751 dbdata_tls_session * dt = store_get(dlen);
2752 uschar * s = dt->session;
2753 open_db dbblock, * dbm_file;
2755 DEBUG(D_tls) debug_printf("session is resumable\n");
2756 tlsp->resumption |= RESUME_SERVER_TICKET; /* server gave us a ticket */
2758 len = i2d_SSL_SESSION(ss, &s); /* s gets bumped to end */
2760 if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
2762 const uschar * key = cbinfo->host->address;
2763 dbfn_delete(dbm_file, key);
2764 dbfn_write(dbm_file, key, dt, dlen);
2765 dbfn_close(dbm_file);
2766 DEBUG(D_tls) debug_printf("wrote session (len %u) to db\n",
2776 tls_client_ctx_resume_prehandshake(
2777 exim_openssl_client_tls_ctx * exim_client_ctx, tls_support * tlsp,
2778 smtp_transport_options_block * ob, host_item * host)
2780 /* Should the client request a session resumption ticket? */
2781 if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
2783 tlsp->host_resumable = TRUE;
2785 SSL_CTX_set_session_cache_mode(exim_client_ctx->ctx,
2786 SSL_SESS_CACHE_CLIENT
2787 | SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_NO_AUTO_CLEAR);
2788 SSL_CTX_sess_set_new_cb(exim_client_ctx->ctx, tls_save_session_cb);
2793 tls_client_ssl_resume_prehandshake(SSL * ssl, tls_support * tlsp,
2794 host_item * host, uschar ** errstr)
2796 if (tlsp->host_resumable)
2799 debug_printf("tls_resumption_hosts overrides openssl_options, enabling tickets\n");
2800 SSL_clear_options(ssl, SSL_OP_NO_TICKET);
2802 tls_exdata_idx = SSL_get_ex_new_index(0, 0, 0, 0, 0);
2803 if (!SSL_set_ex_data(ssl, tls_exdata_idx, client_static_cbinfo))
2805 tls_error(US"set ex_data", host, NULL, errstr);
2808 debug_printf("tls_exdata_idx %d cbinfo %p\n", tls_exdata_idx, client_static_cbinfo);
2811 tlsp->resumption = RESUME_SUPPORTED;
2812 /* Pick up a previous session, saved on an old ticket */
2813 tls_retrieve_session(tlsp, ssl, host->address);
2818 tls_client_resume_posthandshake(exim_openssl_client_tls_ctx * exim_client_ctx,
2821 if (SSL_session_reused(exim_client_ctx->ssl))
2823 DEBUG(D_tls) debug_printf("The session was reused\n");
2824 tlsp->resumption |= RESUME_USED;
2827 #endif /* EXPERIMENTAL_TLS_RESUME */
2830 /*************************************************
2831 * Start a TLS session in a client *
2832 *************************************************/
2834 /* Called from the smtp transport after STARTTLS has been accepted.
2837 cctx connection context
2838 conn_args connection details
2839 cookie datum for randomness; can be NULL
2840 tlsp record details of TLS channel configuration here; must be non-NULL
2841 errstr error string pointer
2843 Returns: TRUE for success with TLS session context set in connection context,
2848 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
2849 void * cookie, tls_support * tlsp, uschar ** errstr)
2851 host_item * host = conn_args->host; /* for msgs and option-tests */
2852 transport_instance * tb = conn_args->tblock; /* always smtp or NULL */
2853 smtp_transport_options_block * ob = tb
2854 ? (smtp_transport_options_block *)tb->options_block
2855 : &smtp_transport_option_defaults;
2856 exim_openssl_client_tls_ctx * exim_client_ctx;
2857 uschar * expciphers;
2859 static uschar peerdn[256];
2861 #ifndef DISABLE_OCSP
2862 BOOL request_ocsp = FALSE;
2863 BOOL require_ocsp = FALSE;
2867 store_pool = POOL_PERM;
2868 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx));
2869 exim_client_ctx->corked = NULL;
2873 tlsp->tlsa_usage = 0;
2876 #ifndef DISABLE_OCSP
2878 # ifdef SUPPORT_DANE
2879 if ( conn_args->dane
2880 && ob->hosts_request_ocsp[0] == '*'
2881 && ob->hosts_request_ocsp[1] == '\0'
2884 /* Unchanged from default. Use a safer one under DANE */
2885 request_ocsp = TRUE;
2886 ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
2887 " {= {4}{$tls_out_tlsa_usage}} } "
2893 verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK))
2894 request_ocsp = TRUE;
2896 # ifdef SUPPORT_DANE
2900 verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
2904 rc = tls_init(&exim_client_ctx->ctx, host, NULL,
2905 ob->tls_certificate, ob->tls_privatekey,
2906 #ifndef DISABLE_OCSP
2907 (void *)(long)request_ocsp,
2909 cookie, &client_static_cbinfo, tlsp, errstr);
2910 if (rc != OK) return FALSE;
2912 tlsp->certificate_verified = FALSE;
2913 client_verify_callback_called = FALSE;
2917 if (conn_args->dane)
2919 /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
2920 other failures should be treated as problems. */
2921 if (ob->dane_require_tls_ciphers &&
2922 !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
2923 &expciphers, errstr))
2925 if (expciphers && *expciphers == '\0')
2930 !expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
2931 &expciphers, errstr))
2934 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2935 are separated by underscores. So that I can use either form in my tests, and
2936 also for general convenience, we turn underscores into hyphens here. */
2940 uschar *s = expciphers;
2941 while (*s) { if (*s == '_') *s = '-'; s++; }
2942 DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2943 if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
2945 tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
2951 if (conn_args->dane)
2953 SSL_CTX_set_verify(exim_client_ctx->ctx,
2954 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2955 verify_callback_client_dane);
2957 if (!DANESSL_library_init())
2959 tls_error(US"library init", host, NULL, errstr);
2962 if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
2964 tls_error(US"context init", host, NULL, errstr);
2972 if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
2973 client_static_cbinfo, errstr) != OK)
2976 #ifdef EXPERIMENTAL_TLS_RESUME
2977 tls_client_ctx_resume_prehandshake(exim_client_ctx, tlsp, ob, host);
2981 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
2983 tls_error(US"SSL_new", host, NULL, errstr);
2986 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
2988 #ifdef EXPERIMENTAL_TLS_RESUME
2989 if (!tls_client_ssl_resume_prehandshake(exim_client_ctx->ssl, tlsp, host,
2994 SSL_set_fd(exim_client_ctx->ssl, cctx->sock);
2995 SSL_set_connect_state(exim_client_ctx->ssl);
2999 if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
3003 DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
3005 else if (!Ustrlen(tlsp->sni))
3009 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
3010 DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
3011 SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
3013 log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
3020 if (conn_args->dane)
3021 if (dane_tlsa_load(exim_client_ctx->ssl, host, &conn_args->tlsa_dnsa, errstr) != OK)
3025 #ifndef DISABLE_OCSP
3026 /* Request certificate status at connection-time. If the server
3027 does OCSP stapling we will get the callback (set in tls_init()) */
3028 # ifdef SUPPORT_DANE
3032 if ( ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3033 || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3035 { /* Re-eval now $tls_out_tlsa_usage is populated. If
3036 this means we avoid the OCSP request, we wasted the setup
3037 cost in tls_init(). */
3038 require_ocsp = verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
3039 request_ocsp = require_ocsp
3040 || verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3047 SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
3048 client_static_cbinfo->u_ocsp.client.verify_required = require_ocsp;
3049 tlsp->ocsp = OCSP_NOT_RESP;
3053 #ifndef DISABLE_EVENT
3054 client_static_cbinfo->event_action = tb ? tb->event_action : NULL;
3057 /* There doesn't seem to be a built-in timeout on connection. */
3059 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
3060 sigalrm_seen = FALSE;
3061 ALARM(ob->command_timeout);
3062 rc = SSL_connect(exim_client_ctx->ssl);
3066 if (conn_args->dane)
3067 DANESSL_cleanup(exim_client_ctx->ssl);
3072 tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
3078 debug_printf("SSL_connect succeeded\n");
3079 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3081 BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
3082 SSL_SESSION_print_keylog(bp, SSL_get_session(exim_client_ctx->ssl));
3088 #ifdef EXPERIMENTAL_TLS_RESUME
3089 tls_client_resume_posthandshake(exim_client_ctx, tlsp);
3092 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
3094 tlsp->cipher = construct_cipher_name(exim_client_ctx->ssl, &tlsp->bits);
3095 tlsp->cipher_stdname = cipher_stdname_ssl(exim_client_ctx->ssl);
3097 /* Record the certificate we presented */
3099 X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
3100 tlsp->ourcert = crt ? X509_dup(crt) : NULL;
3103 tlsp->active.sock = cctx->sock;
3104 tlsp->active.tls_ctx = exim_client_ctx;
3105 cctx->tls_ctx = exim_client_ctx;
3114 tls_refill(unsigned lim)
3119 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", server_ssl,
3120 ssl_xfer_buffer, ssl_xfer_buffer_size);
3122 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3123 inbytes = SSL_read(server_ssl, CS ssl_xfer_buffer,
3124 MIN(ssl_xfer_buffer_size, lim));
3125 error = SSL_get_error(server_ssl, inbytes);
3126 if (smtp_receive_timeout > 0) ALARM_CLR(0);
3128 if (had_command_timeout) /* set by signal handler */
3129 smtp_command_timeout_exit(); /* does not return */
3130 if (had_command_sigterm)
3131 smtp_command_sigterm_exit();
3132 if (had_data_timeout)
3133 smtp_data_timeout_exit();
3134 if (had_data_sigint)
3135 smtp_data_sigint_exit();
3137 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
3138 closed down, not that the socket itself has been closed down. Revert to
3139 non-SSL handling. */
3143 case SSL_ERROR_NONE:
3146 case SSL_ERROR_ZERO_RETURN:
3147 DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3149 receive_getc = smtp_getc;
3150 receive_getbuf = smtp_getbuf;
3151 receive_get_cache = smtp_get_cache;
3152 receive_ungetc = smtp_ungetc;
3153 receive_feof = smtp_feof;
3154 receive_ferror = smtp_ferror;
3155 receive_smtp_buffered = smtp_buffered;
3157 if (SSL_get_shutdown(server_ssl) == SSL_RECEIVED_SHUTDOWN)
3158 SSL_shutdown(server_ssl);
3160 #ifndef DISABLE_OCSP
3161 sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
3162 server_static_cbinfo->verify_stack = NULL;
3164 SSL_free(server_ssl);
3165 SSL_CTX_free(server_ctx);
3168 tls_in.active.sock = -1;
3169 tls_in.active.tls_ctx = NULL;
3171 tls_in.cipher = NULL;
3172 tls_in.peerdn = NULL;
3177 /* Handle genuine errors */
3179 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3180 log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
3181 ssl_xfer_error = TRUE;
3185 DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
3186 DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
3187 debug_printf(" - syscall %s\n", strerror(errno));
3188 ssl_xfer_error = TRUE;
3192 #ifndef DISABLE_DKIM
3193 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
3195 ssl_xfer_buffer_hwm = inbytes;
3196 ssl_xfer_buffer_lwm = 0;
3201 /*************************************************
3202 * TLS version of getc *
3203 *************************************************/
3205 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
3206 it refills the buffer via the SSL reading function.
3208 Arguments: lim Maximum amount to read/buffer
3209 Returns: the next character or EOF
3211 Only used by the server-side TLS.
3215 tls_getc(unsigned lim)
3217 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
3218 if (!tls_refill(lim))
3219 return ssl_xfer_error ? EOF : smtp_getc(lim);
3221 /* Something in the buffer; return next uschar */
3223 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
3227 tls_getbuf(unsigned * len)
3232 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
3233 if (!tls_refill(*len))
3235 if (!ssl_xfer_error) return smtp_getbuf(len);
3240 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
3242 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
3243 ssl_xfer_buffer_lwm += size;
3252 #ifndef DISABLE_DKIM
3253 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
3255 dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
3261 tls_could_read(void)
3263 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm || SSL_pending(server_ssl) > 0;
3267 /*************************************************
3268 * Read bytes from TLS channel *
3269 *************************************************/
3273 ct_ctx client context pointer, or NULL for the one global server context
3277 Returns: the number of bytes read
3278 -1 after a failed read, including EOF
3280 Only used by the client-side TLS.
3284 tls_read(void * ct_ctx, uschar *buff, size_t len)
3286 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
3290 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
3291 buff, (unsigned int)len);
3293 inbytes = SSL_read(ssl, CS buff, len);
3294 error = SSL_get_error(ssl, inbytes);
3296 if (error == SSL_ERROR_ZERO_RETURN)
3298 DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3301 else if (error != SSL_ERROR_NONE)
3311 /*************************************************
3312 * Write bytes down TLS channel *
3313 *************************************************/
3317 ct_ctx client context pointer, or NULL for the one global server context
3320 more further data expected soon
3322 Returns: the number of bytes after a successful write,
3323 -1 after a failed write
3325 Used by both server-side and client-side TLS.
3329 tls_write(void * ct_ctx, const uschar *buff, size_t len, BOOL more)
3332 int outbytes, error;
3334 ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
3335 static gstring * server_corked = NULL;
3336 gstring ** corkedp = ct_ctx
3337 ? &((exim_openssl_client_tls_ctx *)ct_ctx)->corked : &server_corked;
3338 gstring * corked = *corkedp;
3340 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
3341 buff, (unsigned long)len, more ? ", more" : "");
3343 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
3344 "more" is notified. This hack is only ok if small amounts are involved AND only
3345 one stream does it, in one context (i.e. no store reset). Currently it is used
3346 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only.
3347 We support callouts done by the server process by using a separate client
3348 context for the stashed information. */
3349 /* + if PIPE_COMMAND, banner & ehlo-resp for smmtp-on-connect. Suspect there's
3350 a store reset there, so use POOL_PERM. */
3351 /* + if CHUNKING, cmds EHLO,MAIL,RCPT(s),BDAT */
3353 if ((more || corked))
3355 #ifdef EXPERIMENTAL_PIPE_CONNECT
3356 int save_pool = store_pool;
3357 store_pool = POOL_PERM;
3360 corked = string_catn(corked, buff, len);
3362 #ifdef EXPERIMENTAL_PIPE_CONNECT
3363 store_pool = save_pool;
3371 buff = CUS corked->s;
3376 for (int left = len; left > 0;)
3378 DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
3379 outbytes = SSL_write(ssl, CS buff, left);
3380 error = SSL_get_error(ssl, outbytes);
3381 DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
3385 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3386 log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
3389 case SSL_ERROR_NONE:
3394 case SSL_ERROR_ZERO_RETURN:
3395 log_write(0, LOG_MAIN, "SSL channel closed on write");
3398 case SSL_ERROR_SYSCALL:
3399 log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
3400 sender_fullhost ? sender_fullhost : US"<unknown>",
3405 log_write(0, LOG_MAIN, "SSL_write error %d", error);
3414 /*************************************************
3415 * Close down a TLS session *
3416 *************************************************/
3418 /* This is also called from within a delivery subprocess forked from the
3419 daemon, to shut down the TLS library, without actually doing a shutdown (which
3420 would tamper with the SSL session in the parent process).
3423 ct_ctx client TLS context pointer, or NULL for the one global server context
3424 shutdown 1 if TLS close-alert is to be sent,
3425 2 if also response to be waited for
3429 Used by both server-side and client-side TLS.
3433 tls_close(void * ct_ctx, int shutdown)
3435 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
3436 SSL_CTX **ctxp = o_ctx ? &o_ctx->ctx : &server_ctx;
3437 SSL **sslp = o_ctx ? &o_ctx->ssl : &server_ssl;
3438 int *fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
3440 if (*fdp < 0) return; /* TLS was not active */
3445 DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
3446 shutdown > 1 ? " (with response-wait)" : "");
3448 if ( (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
3452 rc = SSL_shutdown(*sslp); /* wait for response */
3456 if (rc < 0) DEBUG(D_tls)
3458 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3459 debug_printf("SSL_shutdown: %s\n", ssl_errstring);
3463 #ifndef DISABLE_OCSP
3464 if (!o_ctx) /* server side */
3466 sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
3467 server_static_cbinfo->verify_stack = NULL;
3471 SSL_CTX_free(*ctxp);
3481 /*************************************************
3482 * Let tls_require_ciphers be checked at startup *
3483 *************************************************/
3485 /* The tls_require_ciphers option, if set, must be something which the
3488 Returns: NULL on success, or error message
3492 tls_validate_require_cipher(void)
3495 uschar *s, *expciphers, *err;
3497 /* this duplicates from tls_init(), we need a better "init just global
3498 state, for no specific purpose" singleton function of our own */
3500 #ifdef EXIM_NEED_OPENSSL_INIT
3501 SSL_load_error_strings();
3502 OpenSSL_add_ssl_algorithms();
3504 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
3505 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
3506 list of available digests. */
3507 EVP_add_digest(EVP_sha256());
3510 if (!(tls_require_ciphers && *tls_require_ciphers))
3513 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
3515 return US"failed to expand tls_require_ciphers";
3517 if (!(expciphers && *expciphers))
3520 /* normalisation ripped from above */
3522 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
3526 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
3527 if (!(ctx = SSL_CTX_new(TLS_server_method())))
3529 if (!(ctx = SSL_CTX_new(SSLv23_server_method())))
3532 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3533 return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
3537 debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
3539 if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
3541 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3542 err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
3543 expciphers, ssl_errstring);
3554 /*************************************************
3555 * Report the library versions. *
3556 *************************************************/
3558 /* There have historically been some issues with binary compatibility in
3559 OpenSSL libraries; if Exim (like many other applications) is built against
3560 one version of OpenSSL but the run-time linker picks up another version,
3561 it can result in serious failures, including crashing with a SIGSEGV. So
3562 report the version found by the compiler and the run-time version.
3564 Note: some OS vendors backport security fixes without changing the version
3565 number/string, and the version date remains unchanged. The _build_ date
3566 will change, so we can more usefully assist with version diagnosis by also
3567 reporting the build date.
3569 Arguments: a FILE* to print the results to
3574 tls_version_report(FILE *f)
3576 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
3579 OPENSSL_VERSION_TEXT,
3580 SSLeay_version(SSLEAY_VERSION),
3581 SSLeay_version(SSLEAY_BUILT_ON));
3582 /* third line is 38 characters for the %s and the line is 73 chars long;
3583 the OpenSSL output includes a "built on: " prefix already. */
3589 /*************************************************
3590 * Random number generation *
3591 *************************************************/
3593 /* Pseudo-random number generation. The result is not expected to be
3594 cryptographically strong but not so weak that someone will shoot themselves
3595 in the foot using it as a nonce in input in some email header scheme or
3596 whatever weirdness they'll twist this into. The result should handle fork()
3597 and avoid repeating sequences. OpenSSL handles that for us.
3601 Returns a random number in range [0, max-1]
3605 vaguely_random_number(int max)
3609 static pid_t pidlast = 0;
3611 uschar smallbuf[sizeof(r)];
3617 if (pidnow != pidlast)
3619 /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
3620 is unique for each thread", this doesn't apparently apply across processes,
3621 so our own warning from vaguely_random_number_fallback() applies here too.
3622 Fix per PostgreSQL. */
3628 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
3632 gettimeofday(&r.tv, NULL);
3635 RAND_seed(US (&r), sizeof(r));
3637 /* We're after pseudo-random, not random; if we still don't have enough data
3638 in the internal PRNG then our options are limited. We could sleep and hope
3639 for entropy to come along (prayer technique) but if the system is so depleted
3640 in the first place then something is likely to just keep taking it. Instead,
3641 we'll just take whatever little bit of pseudo-random we can still manage to
3644 needed_len = sizeof(r);
3645 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
3646 asked for a number less than 10. */
3647 for (r = max, i = 0; r; ++i)
3653 #ifdef EXIM_HAVE_RAND_PSEUDO
3654 /* We do not care if crypto-strong */
3655 i = RAND_pseudo_bytes(smallbuf, needed_len);
3657 i = RAND_bytes(smallbuf, needed_len);
3663 debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
3664 return vaguely_random_number_fallback(max);
3668 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
3671 /* We don't particularly care about weighted results; if someone wants
3672 smooth distribution and cares enough then they should submit a patch then. */
3679 /*************************************************
3680 * OpenSSL option parse *
3681 *************************************************/
3683 /* Parse one option for tls_openssl_options_parse below
3686 name one option name
3687 value place to store a value for it
3688 Returns success or failure in parsing
3694 tls_openssl_one_option_parse(uschar *name, long *value)
3697 int last = exim_openssl_options_size;
3698 while (last > first)
3700 int middle = (first + last)/2;
3701 int c = Ustrcmp(name, exim_openssl_options[middle].name);
3704 *value = exim_openssl_options[middle].value;
3718 /*************************************************
3719 * OpenSSL option parsing logic *
3720 *************************************************/
3722 /* OpenSSL has a number of compatibility options which an administrator might
3723 reasonably wish to set. Interpret a list similarly to decode_bits(), so that
3724 we look like log_selector.
3727 option_spec the administrator-supplied string of options
3728 results ptr to long storage for the options bitmap
3729 Returns success or failure
3733 tls_openssl_options_parse(uschar *option_spec, long *results)
3738 BOOL adding, item_parsed;
3740 /* Server: send no (<= TLS1.2) session tickets */
3741 result = SSL_OP_NO_TICKET;
3743 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
3744 * from default because it increases BEAST susceptibility. */
3745 #ifdef SSL_OP_NO_SSLv2
3746 result |= SSL_OP_NO_SSLv2;
3748 #ifdef SSL_OP_NO_SSLv3
3749 result |= SSL_OP_NO_SSLv3;
3751 #ifdef SSL_OP_SINGLE_DH_USE
3752 result |= SSL_OP_SINGLE_DH_USE;
3761 for (uschar * s = option_spec; *s; /**/)
3763 while (isspace(*s)) ++s;
3766 if (*s != '+' && *s != '-')
3768 DEBUG(D_tls) debug_printf("malformed openssl option setting: "
3769 "+ or - expected but found \"%s\"\n", s);
3772 adding = *s++ == '+';
3773 for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
3776 item_parsed = tls_openssl_one_option_parse(s, &item);
3780 DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
3783 DEBUG(D_tls) debug_printf("openssl option, %s %8lx: %lx (%s)\n",
3784 adding ? "adding to " : "removing from", result, item, s);
3796 #endif /*!MACRO_PREDEF*/
3799 /* End of tls-openssl.c */