1 /*************************************************
2 * Exim - an Internet mail transport agent *
3 *************************************************/
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
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
58 * X509_check_host provides sane certificate hostname checking, but was added
59 * to OpenSSL late, after other projects forked off the code-base. So in
60 * addition to guarding against the base version number, beware that LibreSSL
61 * does not (at this time) support this function.
63 * If LibreSSL gains a different API, perhaps via libtls, then we'll probably
64 * opt to disentangle and ask a LibreSSL user to provide glue for a third
65 * crypto provider for libtls instead of continuing to tie the OpenSSL glue
66 * into even twistier knots. If LibreSSL gains the same API, we can just
67 * change this guard and punt the issue for a while longer.
69 #ifndef LIBRESSL_VERSION_NUMBER
70 # if OPENSSL_VERSION_NUMBER >= 0x010100000L
71 # define EXIM_HAVE_OPENSSL_CHECKHOST
72 # define EXIM_HAVE_OPENSSL_DH_BITS
73 # define EXIM_HAVE_OPENSSL_TLS_METHOD
75 # define EXIM_NEED_OPENSSL_INIT
77 # if OPENSSL_VERSION_NUMBER >= 0x010000000L \
78 && (OPENSSL_VERSION_NUMBER & 0x0000ff000L) >= 0x000002000L
79 # define EXIM_HAVE_OPENSSL_CHECKHOST
83 #if !defined(LIBRESSL_VERSION_NUMBER) \
84 || LIBRESSL_VERSION_NUMBER >= 0x20010000L
85 # if !defined(OPENSSL_NO_ECDH)
86 # if OPENSSL_VERSION_NUMBER >= 0x0090800fL
87 # define EXIM_HAVE_ECDH
89 # if OPENSSL_VERSION_NUMBER >= 0x10002000L
90 # define EXIM_HAVE_OPENSSL_EC_NIST2NID
95 #if !defined(EXIM_HAVE_OPENSSL_TLSEXT) && !defined(DISABLE_OCSP)
96 # warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
100 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
101 # include <openssl/x509v3.h>
104 /*************************************************
105 * OpenSSL option parse *
106 *************************************************/
108 typedef struct exim_openssl_option {
111 } exim_openssl_option;
112 /* We could use a macro to expand, but we need the ifdef and not all the
113 options document which version they were introduced in. Policylet: include
114 all options unless explicitly for DTLS, let the administrator choose which
117 This list is current as of:
119 Plus SSL_OP_SAFARI_ECDHE_ECDSA_BUG from 2013-June patch/discussion on openssl-dev
120 Plus SSL_OP_NO_TLSv1_3 for 1.1.2-dev
122 static exim_openssl_option exim_openssl_options[] = {
123 /* KEEP SORTED ALPHABETICALLY! */
125 { US"all", SSL_OP_ALL },
127 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
128 { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
130 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
131 { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
133 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
134 { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
136 #ifdef SSL_OP_EPHEMERAL_RSA
137 { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
139 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
140 { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
142 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
143 { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
145 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
146 { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
148 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
149 { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
151 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
152 { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
154 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
155 { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
157 #ifdef SSL_OP_NO_COMPRESSION
158 { US"no_compression", SSL_OP_NO_COMPRESSION },
160 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
161 { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
163 #ifdef SSL_OP_NO_SSLv2
164 { US"no_sslv2", SSL_OP_NO_SSLv2 },
166 #ifdef SSL_OP_NO_SSLv3
167 { US"no_sslv3", SSL_OP_NO_SSLv3 },
169 #ifdef SSL_OP_NO_TICKET
170 { US"no_ticket", SSL_OP_NO_TICKET },
172 #ifdef SSL_OP_NO_TLSv1
173 { US"no_tlsv1", SSL_OP_NO_TLSv1 },
175 #ifdef SSL_OP_NO_TLSv1_1
176 #if SSL_OP_NO_TLSv1_1 == 0x00000400L
177 /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
178 #warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
180 { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
183 #ifdef SSL_OP_NO_TLSv1_2
184 { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
186 #ifdef SSL_OP_NO_TLSv1_3
187 { US"no_tlsv1_3", SSL_OP_NO_TLSv1_3 },
189 #ifdef SSL_OP_SAFARI_ECDHE_ECDSA_BUG
190 { US"safari_ecdhe_ecdsa_bug", SSL_OP_SAFARI_ECDHE_ECDSA_BUG },
192 #ifdef SSL_OP_SINGLE_DH_USE
193 { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
195 #ifdef SSL_OP_SINGLE_ECDH_USE
196 { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
198 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
199 { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
201 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
202 { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
204 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
205 { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
207 #ifdef SSL_OP_TLS_D5_BUG
208 { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
210 #ifdef SSL_OP_TLS_ROLLBACK_BUG
211 { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
216 static int exim_openssl_options_size = nelem(exim_openssl_options);
223 struct exim_openssl_option * o;
226 for (o = exim_openssl_options;
227 o < exim_openssl_options + nelem(exim_openssl_options); o++)
229 /* Trailing X is workaround for problem with _OPT_OPENSSL_NO_TLSV1
230 being a ".ifdef _OPT_OPENSSL_NO_TLSV1_3" match */
232 spf(buf, sizeof(buf), US"_OPT_OPENSSL_%T_X", o->name);
233 builtin_macro_create(buf);
238 /******************************************************************************/
240 /* Structure for collecting random data for seeding. */
242 typedef struct randstuff {
247 /* Local static variables */
249 static BOOL client_verify_callback_called = FALSE;
250 static BOOL server_verify_callback_called = FALSE;
251 static const uschar *sid_ctx = US"exim";
253 /* We have three different contexts to care about.
255 Simple case: client, `client_ctx`
256 As a client, we can be doing a callout or cut-through delivery while receiving
257 a message. So we have a client context, which should have options initialised
258 from the SMTP Transport. We may also concurrently want to make TLS connections
259 to utility daemons, so client-contexts are allocated and passed around in call
260 args rather than using a gobal.
263 There are two cases: with and without ServerNameIndication from the client.
264 Given TLS SNI, we can be using different keys, certs and various other
265 configuration settings, because they're re-expanded with $tls_sni set. This
266 allows vhosting with TLS. This SNI is sent in the handshake.
267 A client might not send SNI, so we need a fallback, and an initial setup too.
268 So as a server, we start out using `server_ctx`.
269 If SNI is sent by the client, then we as server, mid-negotiation, try to clone
270 `server_sni` from `server_ctx` and then initialise settings by re-expanding
277 } exim_openssl_client_tls_ctx;
279 static SSL_CTX *server_ctx = NULL;
280 static SSL *server_ssl = NULL;
282 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
283 static SSL_CTX *server_sni = NULL;
286 static char ssl_errstring[256];
288 static int ssl_session_timeout = 200;
289 static BOOL client_verify_optional = FALSE;
290 static BOOL server_verify_optional = FALSE;
292 static BOOL reexpand_tls_files_for_sni = FALSE;
295 typedef struct tls_ext_ctx_cb {
300 STACK_OF(X509) *verify_stack; /* chain for verifying the proof */
304 uschar *file_expanded;
305 OCSP_RESPONSE *response;
308 X509_STORE *verify_store; /* non-null if status requested */
309 BOOL verify_required;
314 /* these are cached from first expand */
315 uschar *server_cipher_list;
316 /* only passed down to tls_error: */
318 const uschar * verify_cert_hostnames;
319 #ifndef DISABLE_EVENT
320 uschar * event_action;
324 /* should figure out a cleanup of API to handle state preserved per
325 implementation, for various reasons, which can be void * in the APIs.
326 For now, we hack around it. */
327 tls_ext_ctx_cb *client_static_cbinfo = NULL;
328 tls_ext_ctx_cb *server_static_cbinfo = NULL;
331 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
332 int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr );
335 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
336 static int tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg);
339 static int tls_server_stapling_cb(SSL *s, void *arg);
343 /*************************************************
345 *************************************************/
347 /* Called from lots of places when errors occur before actually starting to do
348 the TLS handshake, that is, while the session is still in clear. Always returns
349 DEFER for a server and FAIL for a client so that most calls can use "return
350 tls_error(...)" to do this processing and then give an appropriate return. A
351 single function is used for both server and client, because it is called from
352 some shared functions.
355 prefix text to include in the logged error
356 host NULL if setting up a server;
357 the connected host if setting up a client
358 msg error message or NULL if we should ask OpenSSL
359 errstr pointer to output error message
361 Returns: OK/DEFER/FAIL
365 tls_error(uschar * prefix, const host_item * host, uschar * msg, uschar ** errstr)
369 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
370 msg = US ssl_errstring;
373 if (errstr) *errstr = string_sprintf("(%s): %s", prefix, msg);
374 return host ? FAIL : DEFER;
379 /*************************************************
380 * Callback to generate RSA key *
381 *************************************************/
385 s SSL connection (not used)
389 Returns: pointer to generated key
393 rsa_callback(SSL *s, int export, int keylength)
396 #ifdef EXIM_HAVE_RSA_GENKEY_EX
397 BIGNUM *bn = BN_new();
400 export = export; /* Shut picky compilers up */
401 DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
403 #ifdef EXIM_HAVE_RSA_GENKEY_EX
404 if ( !BN_set_word(bn, (unsigned long)RSA_F4)
405 || !(rsa_key = RSA_new())
406 || !RSA_generate_key_ex(rsa_key, keylength, bn, NULL)
409 if (!(rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL)))
413 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
414 log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
426 x509_store_dump_cert_s_names(X509_STORE * store)
428 STACK_OF(X509_OBJECT) * roots= store->objs;
430 static uschar name[256];
432 for(i= 0; i<sk_X509_OBJECT_num(roots); i++)
434 X509_OBJECT * tmp_obj= sk_X509_OBJECT_value(roots, i);
435 if(tmp_obj->type == X509_LU_X509)
437 X509_NAME * sn = X509_get_subject_name(tmp_obj->data.x509);
438 if (X509_NAME_oneline(sn, CS name, sizeof(name)))
440 name[sizeof(name)-1] = '\0';
441 debug_printf(" %s\n", name);
450 #ifndef DISABLE_EVENT
452 verify_event(tls_support * tlsp, X509 * cert, int depth, const uschar * dn,
453 BOOL *calledp, const BOOL *optionalp, const uschar * what)
459 ev = tlsp == &tls_out ? client_static_cbinfo->event_action : event_action;
462 DEBUG(D_tls) debug_printf("verify_event: %s %d\n", what, depth);
463 old_cert = tlsp->peercert;
464 tlsp->peercert = X509_dup(cert);
465 /* NB we do not bother setting peerdn */
466 if ((yield = event_raise(ev, US"tls:cert", string_sprintf("%d", depth))))
468 log_write(0, LOG_MAIN, "[%s] %s verify denied by event-action: "
469 "depth=%d cert=%s: %s",
470 tlsp == &tls_out ? deliver_host_address : sender_host_address,
471 what, depth, dn, yield);
475 if (old_cert) tlsp->peercert = old_cert; /* restore 1st failing cert */
476 return 1; /* reject (leaving peercert set) */
478 DEBUG(D_tls) debug_printf("Event-action verify failure overridden "
479 "(host in tls_try_verify_hosts)\n");
481 X509_free(tlsp->peercert);
482 tlsp->peercert = old_cert;
488 /*************************************************
489 * Callback for verification *
490 *************************************************/
492 /* The SSL library does certificate verification if set up to do so. This
493 callback has the current yes/no state is in "state". If verification succeeded,
494 we set the certificate-verified flag. If verification failed, what happens
495 depends on whether the client is required to present a verifiable certificate
498 If verification is optional, we change the state to yes, but still log the
499 verification error. For some reason (it really would help to have proper
500 documentation of OpenSSL), this callback function then gets called again, this
501 time with state = 1. We must take care not to set the private verified flag on
502 the second time through.
504 Note: this function is not called if the client fails to present a certificate
505 when asked. We get here only if a certificate has been received. Handling of
506 optional verification for this case is done when requesting SSL to verify, by
507 setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
509 May be called multiple times for different issues with a certificate, even
510 for a given "depth" in the certificate chain.
513 preverify_ok current yes/no state as 1/0
514 x509ctx certificate information.
515 tlsp per-direction (client vs. server) support data
516 calledp has-been-called flag
517 optionalp verification-is-optional flag
519 Returns: 0 if verification should fail, otherwise 1
523 verify_callback(int preverify_ok, X509_STORE_CTX * x509ctx,
524 tls_support * tlsp, BOOL * calledp, BOOL * optionalp)
526 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
527 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
530 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
532 DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
533 log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
534 tlsp == &tls_out ? deliver_host_address : sender_host_address);
537 dn[sizeof(dn)-1] = '\0';
539 if (preverify_ok == 0)
541 uschar * extra = verify_mode ? string_sprintf(" (during %c-verify for [%s])",
542 *verify_mode, sender_host_address)
544 log_write(0, LOG_MAIN, "[%s] SSL verify error%s: depth=%d error=%s cert=%s",
545 tlsp == &tls_out ? deliver_host_address : sender_host_address,
547 X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509ctx)), dn);
552 tlsp->peercert = X509_dup(cert); /* record failing cert */
553 return 0; /* reject */
555 DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
556 "tls_try_verify_hosts)\n");
561 DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d SN=%s\n", depth, dn);
563 if (tlsp == &tls_out && client_static_cbinfo->u_ocsp.client.verify_store)
564 { /* client, wanting stapling */
565 /* Add the server cert's signing chain as the one
566 for the verification of the OCSP stapled information. */
568 if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
571 sk_X509_push(client_static_cbinfo->verify_stack, cert);
574 #ifndef DISABLE_EVENT
575 if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
576 return 0; /* reject, with peercert set */
581 const uschar * verify_cert_hostnames;
583 if ( tlsp == &tls_out
584 && ((verify_cert_hostnames = client_static_cbinfo->verify_cert_hostnames)))
585 /* client, wanting hostname check */
588 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
589 # ifndef X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
590 # define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0
592 # ifndef X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS
593 # define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0
596 const uschar * list = verify_cert_hostnames;
599 while ((name = string_nextinlist(&list, &sep, NULL, 0)))
600 if ((rc = X509_check_host(cert, CCS name, 0,
601 X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
602 | X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS,
607 log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
608 tlsp == &tls_out ? deliver_host_address : sender_host_address);
615 if (!tls_is_name_for_cert(verify_cert_hostnames, cert))
618 uschar * extra = verify_mode
619 ? string_sprintf(" (during %c-verify for [%s])",
620 *verify_mode, sender_host_address)
622 log_write(0, LOG_MAIN,
623 "[%s] SSL verify error%s: certificate name mismatch: DN=\"%s\" H=\"%s\"",
624 tlsp == &tls_out ? deliver_host_address : sender_host_address,
625 extra, dn, verify_cert_hostnames);
630 tlsp->peercert = X509_dup(cert); /* record failing cert */
631 return 0; /* reject */
633 DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
634 "tls_try_verify_hosts)\n");
638 #ifndef DISABLE_EVENT
639 if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
640 return 0; /* reject, with peercert set */
643 DEBUG(D_tls) debug_printf("SSL%s verify ok: depth=0 SN=%s\n",
644 *calledp ? "" : " authenticated", dn);
645 if (!*calledp) tlsp->certificate_verified = TRUE;
649 return 1; /* accept, at least for this level */
653 verify_callback_client(int preverify_ok, X509_STORE_CTX *x509ctx)
655 return verify_callback(preverify_ok, x509ctx, &tls_out,
656 &client_verify_callback_called, &client_verify_optional);
660 verify_callback_server(int preverify_ok, X509_STORE_CTX *x509ctx)
662 return verify_callback(preverify_ok, x509ctx, &tls_in,
663 &server_verify_callback_called, &server_verify_optional);
669 /* This gets called *by* the dane library verify callback, which interposes
673 verify_callback_client_dane(int preverify_ok, X509_STORE_CTX * x509ctx)
675 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
677 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
678 #ifndef DISABLE_EVENT
679 BOOL dummy_called, optional = FALSE;
682 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
684 DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
685 log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
686 deliver_host_address);
689 dn[sizeof(dn)-1] = '\0';
691 DEBUG(D_tls) debug_printf("verify_callback_client_dane: %s depth %d %s\n",
692 preverify_ok ? "ok":"BAD", depth, dn);
694 #ifndef DISABLE_EVENT
695 if (verify_event(&tls_out, cert, depth, dn,
696 &dummy_called, &optional, US"DANE"))
697 return 0; /* reject, with peercert set */
700 if (preverify_ok == 1)
702 tls_out.dane_verified = tls_out.certificate_verified = TRUE;
704 if (client_static_cbinfo->u_ocsp.client.verify_store)
705 { /* client, wanting stapling */
706 /* Add the server cert's signing chain as the one
707 for the verification of the OCSP stapled information. */
709 if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
712 sk_X509_push(client_static_cbinfo->verify_stack, cert);
718 int err = X509_STORE_CTX_get_error(x509ctx);
720 debug_printf(" - err %d '%s'\n", err, X509_verify_cert_error_string(err));
721 if (err == X509_V_ERR_APPLICATION_VERIFICATION)
727 #endif /*SUPPORT_DANE*/
730 /*************************************************
731 * Information callback *
732 *************************************************/
734 /* The SSL library functions call this from time to time to indicate what they
735 are doing. We copy the string to the debugging output when TLS debugging has
747 info_callback(SSL *s, int where, int ret)
753 if (where & SSL_ST_CONNECT)
754 str = US"SSL_connect";
755 else if (where & SSL_ST_ACCEPT)
756 str = US"SSL_accept";
758 str = US"SSL info (undefined)";
760 if (where & SSL_CB_LOOP)
761 debug_printf("%s: %s\n", str, SSL_state_string_long(s));
762 else if (where & SSL_CB_ALERT)
763 debug_printf("SSL3 alert %s:%s:%s\n",
764 str = where & SSL_CB_READ ? US"read" : US"write",
765 SSL_alert_type_string_long(ret), SSL_alert_desc_string_long(ret));
766 else if (where & SSL_CB_EXIT)
768 debug_printf("%s: failed in %s\n", str, SSL_state_string_long(s));
770 debug_printf("%s: error in %s\n", str, SSL_state_string_long(s));
771 else if (where & SSL_CB_HANDSHAKE_START)
772 debug_printf("%s: hshake start: %s\n", str, SSL_state_string_long(s));
773 else if (where & SSL_CB_HANDSHAKE_DONE)
774 debug_printf("%s: hshake done: %s\n", str, SSL_state_string_long(s));
780 /*************************************************
781 * Initialize for DH *
782 *************************************************/
784 /* If dhparam is set, expand it, and load up the parameters for DH encryption.
787 sctx The current SSL CTX (inbound or outbound)
788 dhparam DH parameter file or fixed parameter identity string
789 host connected host, if client; NULL if server
790 errstr error string pointer
792 Returns: TRUE if OK (nothing to set up, or setup worked)
796 init_dh(SSL_CTX *sctx, uschar *dhparam, const host_item *host, uschar ** errstr)
804 if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded, errstr))
807 if (!dhexpanded || !*dhexpanded)
808 bio = BIO_new_mem_buf(CS std_dh_prime_default(), -1);
809 else if (dhexpanded[0] == '/')
811 if (!(bio = BIO_new_file(CS dhexpanded, "r")))
813 tls_error(string_sprintf("could not read dhparams file %s", dhexpanded),
814 host, US strerror(errno), errstr);
820 if (Ustrcmp(dhexpanded, "none") == 0)
822 DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
826 if (!(pem = std_dh_prime_named(dhexpanded)))
828 tls_error(string_sprintf("Unknown standard DH prime \"%s\"", dhexpanded),
829 host, US strerror(errno), errstr);
832 bio = BIO_new_mem_buf(CS pem, -1);
835 if (!(dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL)))
838 tls_error(string_sprintf("Could not read tls_dhparams \"%s\"", dhexpanded),
843 /* note: our default limit of 2236 is not a multiple of 8; the limit comes from
844 * an NSS limit, and the GnuTLS APIs handle bit-sizes fine, so we went with
845 * 2236. But older OpenSSL can only report in bytes (octets), not bits.
846 * If someone wants to dance at the edge, then they can raise the limit or use
847 * current libraries. */
848 #ifdef EXIM_HAVE_OPENSSL_DH_BITS
849 /* Added in commit 26c79d5641d; `git describe --contains` says OpenSSL_1_1_0-pre1~1022
850 * This predates OpenSSL_1_1_0 (before a, b, ...) so is in all 1.1.0 */
851 dh_bitsize = DH_bits(dh);
853 dh_bitsize = 8 * DH_size(dh);
856 /* Even if it is larger, we silently return success rather than cause things
857 * to fail out, so that a too-large DH will not knock out all TLS; it's a
858 * debatable choice. */
859 if (dh_bitsize > tls_dh_max_bits)
862 debug_printf("dhparams file %d bits, is > tls_dh_max_bits limit of %d\n",
863 dh_bitsize, tls_dh_max_bits);
867 SSL_CTX_set_tmp_dh(sctx, dh);
869 debug_printf("Diffie-Hellman initialized from %s with %d-bit prime\n",
870 dhexpanded ? dhexpanded : US"default", dh_bitsize);
882 /*************************************************
883 * Initialize for ECDH *
884 *************************************************/
886 /* Load parameters for ECDH encryption.
888 For now, we stick to NIST P-256 because: it's simple and easy to configure;
889 it avoids any patent issues that might bite redistributors; despite events in
890 the news and concerns over curve choices, we're not cryptographers, we're not
891 pretending to be, and this is "good enough" to be better than no support,
892 protecting against most adversaries. Given another year or two, there might
893 be sufficient clarity about a "right" way forward to let us make an informed
894 decision, instead of a knee-jerk reaction.
896 Longer-term, we should look at supporting both various named curves and
897 external files generated with "openssl ecparam", much as we do for init_dh().
898 We should also support "none" as a value, to explicitly avoid initialisation.
903 sctx The current SSL CTX (inbound or outbound)
904 host connected host, if client; NULL if server
905 errstr error string pointer
907 Returns: TRUE if OK (nothing to set up, or setup worked)
911 init_ecdh(SSL_CTX * sctx, host_item * host, uschar ** errstr)
913 #ifdef OPENSSL_NO_ECDH
922 if (host) /* No ECDH setup for clients, only for servers */
925 # ifndef EXIM_HAVE_ECDH
927 debug_printf("No OpenSSL API to define ECDH parameters, skipping\n");
931 if (!expand_check(tls_eccurve, US"tls_eccurve", &exp_curve, errstr))
933 if (!exp_curve || !*exp_curve)
936 /* "auto" needs to be handled carefully.
937 * OpenSSL < 1.0.2: we do not select anything, but fallback to prime256v1
938 * OpenSSL < 1.1.0: we have to call SSL_CTX_set_ecdh_auto
939 * (openssl/ssl.h defines SSL_CTRL_SET_ECDH_AUTO)
940 * OpenSSL >= 1.1.0: we do not set anything, the libray does autoselection
941 * https://github.com/openssl/openssl/commit/fe6ef2472db933f01b59cad82aa925736935984b
943 if (Ustrcmp(exp_curve, "auto") == 0)
945 #if OPENSSL_VERSION_NUMBER < 0x10002000L
946 DEBUG(D_tls) debug_printf(
947 "ECDH OpenSSL < 1.0.2: temp key parameter settings: overriding \"auto\" with \"prime256v1\"\n");
948 exp_curve = US"prime256v1";
950 # if defined SSL_CTRL_SET_ECDH_AUTO
951 DEBUG(D_tls) debug_printf(
952 "ECDH OpenSSL 1.0.2+ temp key parameter settings: autoselection\n");
953 SSL_CTX_set_ecdh_auto(sctx, 1);
956 DEBUG(D_tls) debug_printf(
957 "ECDH OpenSSL 1.1.0+ temp key parameter settings: default selection\n");
963 DEBUG(D_tls) debug_printf("ECDH: curve '%s'\n", exp_curve);
964 if ( (nid = OBJ_sn2nid (CCS exp_curve)) == NID_undef
965 # ifdef EXIM_HAVE_OPENSSL_EC_NIST2NID
966 && (nid = EC_curve_nist2nid(CCS exp_curve)) == NID_undef
970 tls_error(string_sprintf("Unknown curve name tls_eccurve '%s'", exp_curve),
975 if (!(ecdh = EC_KEY_new_by_curve_name(nid)))
977 tls_error(US"Unable to create ec curve", host, NULL, errstr);
981 /* The "tmp" in the name here refers to setting a temporary key
982 not to the stability of the interface. */
984 if ((rv = SSL_CTX_set_tmp_ecdh(sctx, ecdh) == 0))
985 tls_error(string_sprintf("Error enabling '%s' curve", exp_curve), host, NULL, errstr);
987 DEBUG(D_tls) debug_printf("ECDH: enabled '%s' curve\n", exp_curve);
992 # endif /*EXIM_HAVE_ECDH*/
993 #endif /*OPENSSL_NO_ECDH*/
1000 /*************************************************
1001 * Load OCSP information into state *
1002 *************************************************/
1003 /* Called to load the server OCSP response from the given file into memory, once
1004 caller has determined this is needed. Checks validity. Debugs a message
1007 ASSUMES: single response, for single cert.
1010 sctx the SSL_CTX* to update
1011 cbinfo various parts of session state
1012 expanded the filename putatively holding an OCSP response
1017 ocsp_load_response(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo, const uschar *expanded)
1020 OCSP_RESPONSE * resp;
1021 OCSP_BASICRESP * basic_response;
1022 OCSP_SINGLERESP * single_response;
1023 ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
1024 STACK_OF(X509) * sk;
1025 unsigned long verify_flags;
1026 int status, reason, i;
1028 cbinfo->u_ocsp.server.file_expanded = string_copy(expanded);
1029 if (cbinfo->u_ocsp.server.response)
1031 OCSP_RESPONSE_free(cbinfo->u_ocsp.server.response);
1032 cbinfo->u_ocsp.server.response = NULL;
1035 if (!(bio = BIO_new_file(CS cbinfo->u_ocsp.server.file_expanded, "rb")))
1037 DEBUG(D_tls) debug_printf("Failed to open OCSP response file \"%s\"\n",
1038 cbinfo->u_ocsp.server.file_expanded);
1042 resp = d2i_OCSP_RESPONSE_bio(bio, NULL);
1046 DEBUG(D_tls) debug_printf("Error reading OCSP response.\n");
1050 if ((status = OCSP_response_status(resp)) != OCSP_RESPONSE_STATUS_SUCCESSFUL)
1052 DEBUG(D_tls) debug_printf("OCSP response not valid: %s (%d)\n",
1053 OCSP_response_status_str(status), status);
1057 if (!(basic_response = OCSP_response_get1_basic(resp)))
1060 debug_printf("OCSP response parse error: unable to extract basic response.\n");
1064 sk = cbinfo->verify_stack;
1065 verify_flags = OCSP_NOVERIFY; /* check sigs, but not purpose */
1067 /* May need to expose ability to adjust those flags?
1068 OCSP_NOSIGS OCSP_NOVERIFY OCSP_NOCHAIN OCSP_NOCHECKS OCSP_NOEXPLICIT
1069 OCSP_TRUSTOTHER OCSP_NOINTERN */
1071 /* This does a full verify on the OCSP proof before we load it for serving
1072 up; possibly overkill - just date-checks might be nice enough.
1074 OCSP_basic_verify takes a "store" arg, but does not
1075 use it for the chain verification, which is all we do
1076 when OCSP_NOVERIFY is set. The content from the wire
1077 "basic_response" and a cert-stack "sk" are all that is used.
1079 We have a stack, loaded in setup_certs() if tls_verify_certificates
1080 was a file (not a directory, or "system"). It is unfortunate we
1081 cannot used the connection context store, as that would neatly
1082 handle the "system" case too, but there seems to be no library
1083 function for getting a stack from a store.
1084 [ In OpenSSL 1.1 - ? X509_STORE_CTX_get0_chain(ctx) ? ]
1085 We do not free the stack since it could be needed a second time for
1088 Separately we might try to replace using OCSP_basic_verify() - which seems to not
1089 be a public interface into the OpenSSL library (there's no manual entry) -
1090 But what with? We also use OCSP_basic_verify in the client stapling callback.
1091 And there we NEED it; we must verify that status... unless the
1092 library does it for us anyway? */
1094 if ((i = OCSP_basic_verify(basic_response, sk, NULL, verify_flags)) < 0)
1098 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
1099 debug_printf("OCSP response verify failure: %s\n", US ssl_errstring);
1104 /* Here's the simplifying assumption: there's only one response, for the
1105 one certificate we use, and nothing for anything else in a chain. If this
1106 proves false, we need to extract a cert id from our issued cert
1107 (tls_certificate) and use that for OCSP_resp_find_status() (which finds the
1108 right cert in the stack and then calls OCSP_single_get0_status()).
1110 I'm hoping to avoid reworking a bunch more of how we handle state here. */
1112 if (!(single_response = OCSP_resp_get0(basic_response, 0)))
1115 debug_printf("Unable to get first response from OCSP basic response.\n");
1119 status = OCSP_single_get0_status(single_response, &reason, &rev, &thisupd, &nextupd);
1120 if (status != V_OCSP_CERTSTATUS_GOOD)
1122 DEBUG(D_tls) debug_printf("OCSP response bad cert status: %s (%d) %s (%d)\n",
1123 OCSP_cert_status_str(status), status,
1124 OCSP_crl_reason_str(reason), reason);
1128 if (!OCSP_check_validity(thisupd, nextupd, EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1130 DEBUG(D_tls) debug_printf("OCSP status invalid times.\n");
1135 cbinfo->u_ocsp.server.response = resp; /*XXX stack?*/
1139 if (f.running_in_test_harness)
1141 extern char ** environ;
1143 if (environ) for (p = USS environ; *p; p++)
1144 if (Ustrncmp(*p, "EXIM_TESTHARNESS_DISABLE_OCSPVALIDITYCHECK", 42) == 0)
1146 DEBUG(D_tls) debug_printf("Supplying known bad OCSP response\n");
1147 goto supply_response;
1152 #endif /*!DISABLE_OCSP*/
1157 /* Create and install a selfsigned certificate, for use in server mode */
1160 tls_install_selfsign(SSL_CTX * sctx, uschar ** errstr)
1168 where = US"allocating pkey";
1169 if (!(pkey = EVP_PKEY_new()))
1172 where = US"allocating cert";
1173 if (!(x509 = X509_new()))
1176 where = US"generating pkey";
1177 if (!(rsa = rsa_callback(NULL, 0, 1024)))
1180 where = US"assigning pkey";
1181 if (!EVP_PKEY_assign_RSA(pkey, rsa))
1184 X509_set_version(x509, 2); /* N+1 - version 3 */
1185 ASN1_INTEGER_set(X509_get_serialNumber(x509), 1);
1186 X509_gmtime_adj(X509_get_notBefore(x509), 0);
1187 X509_gmtime_adj(X509_get_notAfter(x509), (long)60 * 60); /* 1 hour */
1188 X509_set_pubkey(x509, pkey);
1190 name = X509_get_subject_name(x509);
1191 X509_NAME_add_entry_by_txt(name, "C",
1192 MBSTRING_ASC, CUS "UK", -1, -1, 0);
1193 X509_NAME_add_entry_by_txt(name, "O",
1194 MBSTRING_ASC, CUS "Exim Developers", -1, -1, 0);
1195 X509_NAME_add_entry_by_txt(name, "CN",
1196 MBSTRING_ASC, CUS smtp_active_hostname, -1, -1, 0);
1197 X509_set_issuer_name(x509, name);
1199 where = US"signing cert";
1200 if (!X509_sign(x509, pkey, EVP_md5()))
1203 where = US"installing selfsign cert";
1204 if (!SSL_CTX_use_certificate(sctx, x509))
1207 where = US"installing selfsign key";
1208 if (!SSL_CTX_use_PrivateKey(sctx, pkey))
1214 (void) tls_error(where, NULL, NULL, errstr);
1215 if (x509) X509_free(x509);
1216 if (pkey) EVP_PKEY_free(pkey);
1224 tls_add_certfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1227 DEBUG(D_tls) debug_printf("tls_certificate file %s\n", file);
1228 if (!SSL_CTX_use_certificate_chain_file(sctx, CS file))
1229 return tls_error(string_sprintf(
1230 "SSL_CTX_use_certificate_chain_file file=%s", file),
1231 cbinfo->host, NULL, errstr);
1236 tls_add_pkeyfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1239 DEBUG(D_tls) debug_printf("tls_privatekey file %s\n", file);
1240 if (!SSL_CTX_use_PrivateKey_file(sctx, CS file, SSL_FILETYPE_PEM))
1241 return tls_error(string_sprintf(
1242 "SSL_CTX_use_PrivateKey_file file=%s", file), cbinfo->host, NULL, errstr);
1247 /*************************************************
1248 * Expand key and cert file specs *
1249 *************************************************/
1251 /* Called once during tls_init and possibly again during TLS setup, for a
1252 new context, if Server Name Indication was used and tls_sni was seen in
1253 the certificate string.
1256 sctx the SSL_CTX* to update
1257 cbinfo various parts of session state
1258 errstr error string pointer
1260 Returns: OK/DEFER/FAIL
1264 tls_expand_session_files(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo,
1269 if (!cbinfo->certificate)
1271 if (!cbinfo->is_server) /* client */
1274 if (tls_install_selfsign(sctx, errstr) != OK)
1281 if (Ustrstr(cbinfo->certificate, US"tls_sni") ||
1282 Ustrstr(cbinfo->certificate, US"tls_in_sni") ||
1283 Ustrstr(cbinfo->certificate, US"tls_out_sni")
1285 reexpand_tls_files_for_sni = TRUE;
1287 if (!expand_check(cbinfo->certificate, US"tls_certificate", &expanded, errstr))
1291 if (cbinfo->is_server)
1293 const uschar * file_list = expanded;
1297 while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1298 if ((err = tls_add_certfile(sctx, cbinfo, file, errstr)))
1301 else /* would there ever be a need for multiple client certs? */
1302 if ((err = tls_add_certfile(sctx, cbinfo, expanded, errstr)))
1305 if (cbinfo->privatekey != NULL &&
1306 !expand_check(cbinfo->privatekey, US"tls_privatekey", &expanded, errstr))
1309 /* If expansion was forced to fail, key_expanded will be NULL. If the result
1310 of the expansion is an empty string, ignore it also, and assume the private
1311 key is in the same file as the certificate. */
1313 if (expanded && *expanded)
1314 if (cbinfo->is_server)
1316 const uschar * file_list = expanded;
1320 while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1321 if ((err = tls_add_pkeyfile(sctx, cbinfo, file, errstr)))
1324 else /* would there ever be a need for multiple client certs? */
1325 if ((err = tls_add_pkeyfile(sctx, cbinfo, expanded, errstr)))
1329 #ifndef DISABLE_OCSP
1330 if (cbinfo->is_server && cbinfo->u_ocsp.server.file)
1333 if (!expand_check(cbinfo->u_ocsp.server.file, US"tls_ocsp_file", &expanded, errstr))
1336 if (expanded && *expanded)
1338 DEBUG(D_tls) debug_printf("tls_ocsp_file %s\n", expanded);
1339 if ( cbinfo->u_ocsp.server.file_expanded
1340 && (Ustrcmp(expanded, cbinfo->u_ocsp.server.file_expanded) == 0))
1342 DEBUG(D_tls) debug_printf(" - value unchanged, using existing values\n");
1345 ocsp_load_response(sctx, cbinfo, expanded);
1356 /*************************************************
1357 * Callback to handle SNI *
1358 *************************************************/
1360 /* Called when acting as server during the TLS session setup if a Server Name
1361 Indication extension was sent by the client.
1363 API documentation is OpenSSL s_server.c implementation.
1366 s SSL* of the current session
1367 ad unknown (part of OpenSSL API) (unused)
1368 arg Callback of "our" registered data
1370 Returns: SSL_TLSEXT_ERR_{OK,ALERT_WARNING,ALERT_FATAL,NOACK}
1373 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1375 tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg)
1377 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
1378 tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
1380 int old_pool = store_pool;
1381 uschar * dummy_errstr;
1384 return SSL_TLSEXT_ERR_OK;
1386 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", servername,
1387 reexpand_tls_files_for_sni ? "" : " (unused for certificate selection)");
1389 /* Make the extension value available for expansion */
1390 store_pool = POOL_PERM;
1391 tls_in.sni = string_copy(US servername);
1392 store_pool = old_pool;
1394 if (!reexpand_tls_files_for_sni)
1395 return SSL_TLSEXT_ERR_OK;
1397 /* Can't find an SSL_CTX_clone() or equivalent, so we do it manually;
1398 not confident that memcpy wouldn't break some internal reference counting.
1399 Especially since there's a references struct member, which would be off. */
1401 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
1402 if (!(server_sni = SSL_CTX_new(TLS_server_method())))
1404 if (!(server_sni = SSL_CTX_new(SSLv23_server_method())))
1407 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
1408 DEBUG(D_tls) debug_printf("SSL_CTX_new() failed: %s\n", ssl_errstring);
1409 return SSL_TLSEXT_ERR_NOACK;
1412 /* Not sure how many of these are actually needed, since SSL object
1413 already exists. Might even need this selfsame callback, for reneg? */
1415 SSL_CTX_set_info_callback(server_sni, SSL_CTX_get_info_callback(server_ctx));
1416 SSL_CTX_set_mode(server_sni, SSL_CTX_get_mode(server_ctx));
1417 SSL_CTX_set_options(server_sni, SSL_CTX_get_options(server_ctx));
1418 SSL_CTX_set_timeout(server_sni, SSL_CTX_get_timeout(server_ctx));
1419 SSL_CTX_set_tlsext_servername_callback(server_sni, tls_servername_cb);
1420 SSL_CTX_set_tlsext_servername_arg(server_sni, cbinfo);
1422 if ( !init_dh(server_sni, cbinfo->dhparam, NULL, &dummy_errstr)
1423 || !init_ecdh(server_sni, NULL, &dummy_errstr)
1425 return SSL_TLSEXT_ERR_NOACK;
1427 if ( cbinfo->server_cipher_list
1428 && !SSL_CTX_set_cipher_list(server_sni, CS cbinfo->server_cipher_list))
1429 return SSL_TLSEXT_ERR_NOACK;
1431 #ifndef DISABLE_OCSP
1432 if (cbinfo->u_ocsp.server.file)
1434 SSL_CTX_set_tlsext_status_cb(server_sni, tls_server_stapling_cb);
1435 SSL_CTX_set_tlsext_status_arg(server_sni, cbinfo);
1439 if ((rc = setup_certs(server_sni, tls_verify_certificates, tls_crl, NULL, FALSE,
1440 verify_callback_server, &dummy_errstr)) != OK)
1441 return SSL_TLSEXT_ERR_NOACK;
1443 /* do this after setup_certs, because this can require the certs for verifying
1444 OCSP information. */
1445 if ((rc = tls_expand_session_files(server_sni, cbinfo, &dummy_errstr)) != OK)
1446 return SSL_TLSEXT_ERR_NOACK;
1448 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
1449 SSL_set_SSL_CTX(s, server_sni);
1451 return SSL_TLSEXT_ERR_OK;
1453 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
1458 #ifndef DISABLE_OCSP
1460 /*************************************************
1461 * Callback to handle OCSP Stapling *
1462 *************************************************/
1464 /* Called when acting as server during the TLS session setup if the client
1465 requests OCSP information with a Certificate Status Request.
1467 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
1473 tls_server_stapling_cb(SSL *s, void *arg)
1475 const tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
1476 uschar *response_der; /*XXX blob */
1477 int response_der_len;
1479 /*XXX stack: use SSL_get_certificate() to see which cert; from that work
1480 out which ocsp blob to send. Unfortunately, SSL_get_certificate is known
1481 buggy in current OpenSSL; it returns the last cert loaded always rather than
1482 the one actually presented. So we can't support a stack of OCSP proofs at
1486 debug_printf("Received TLS status request (OCSP stapling); %s response\n",
1487 cbinfo->u_ocsp.server.response ? "have" : "lack");
1489 tls_in.ocsp = OCSP_NOT_RESP;
1490 if (!cbinfo->u_ocsp.server.response)
1491 return SSL_TLSEXT_ERR_NOACK;
1493 response_der = NULL;
1494 response_der_len = i2d_OCSP_RESPONSE(cbinfo->u_ocsp.server.response, /*XXX stack*/
1496 if (response_der_len <= 0)
1497 return SSL_TLSEXT_ERR_NOACK;
1499 SSL_set_tlsext_status_ocsp_resp(server_ssl, response_der, response_der_len);
1500 tls_in.ocsp = OCSP_VFIED;
1501 return SSL_TLSEXT_ERR_OK;
1506 time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
1508 BIO_printf(bp, "\t%s: ", str);
1509 ASN1_GENERALIZEDTIME_print(bp, time);
1514 tls_client_stapling_cb(SSL *s, void *arg)
1516 tls_ext_ctx_cb * cbinfo = arg;
1517 const unsigned char * p;
1519 OCSP_RESPONSE * rsp;
1520 OCSP_BASICRESP * bs;
1523 DEBUG(D_tls) debug_printf("Received TLS status response (OCSP stapling):");
1524 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
1527 /* Expect this when we requested ocsp but got none */
1528 if (cbinfo->u_ocsp.client.verify_required && LOGGING(tls_cipher))
1529 log_write(0, LOG_MAIN, "Received TLS status callback, null content");
1531 DEBUG(D_tls) debug_printf(" null\n");
1532 return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1535 if(!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
1537 tls_out.ocsp = OCSP_FAILED;
1538 if (LOGGING(tls_cipher))
1539 log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
1541 DEBUG(D_tls) debug_printf(" parse error\n");
1545 if(!(bs = OCSP_response_get1_basic(rsp)))
1547 tls_out.ocsp = OCSP_FAILED;
1548 if (LOGGING(tls_cipher))
1549 log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
1551 DEBUG(D_tls) debug_printf(" error parsing response\n");
1552 OCSP_RESPONSE_free(rsp);
1556 /* We'd check the nonce here if we'd put one in the request. */
1557 /* However that would defeat cacheability on the server so we don't. */
1559 /* This section of code reworked from OpenSSL apps source;
1560 The OpenSSL Project retains copyright:
1561 Copyright (c) 1999 The OpenSSL Project. All rights reserved.
1566 ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
1568 DEBUG(D_tls) bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
1570 /*OCSP_RESPONSE_print(bp, rsp, 0); extreme debug: stapling content */
1572 /* Use the chain that verified the server cert to verify the stapled info */
1573 /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
1575 if ((i = OCSP_basic_verify(bs, cbinfo->verify_stack,
1576 cbinfo->u_ocsp.client.verify_store, 0)) <= 0)
1578 tls_out.ocsp = OCSP_FAILED;
1579 if (LOGGING(tls_cipher)) log_write(0, LOG_MAIN,
1580 "Received TLS cert status response, itself unverifiable: %s",
1581 ERR_reason_error_string(ERR_peek_error()));
1582 BIO_printf(bp, "OCSP response verify failure\n");
1583 ERR_print_errors(bp);
1584 OCSP_RESPONSE_print(bp, rsp, 0);
1588 BIO_printf(bp, "OCSP response well-formed and signed OK\n");
1590 /*XXX So we have a good stapled OCSP status. How do we know
1591 it is for the cert of interest? OpenSSL 1.1.0 has a routine
1592 OCSP_resp_find_status() which matches on a cert id, which presumably
1593 we should use. Making an id needs OCSP_cert_id_new(), which takes
1594 issuerName, issuerKey, serialNumber. Are they all in the cert?
1596 For now, carry on blindly accepting the resp. */
1599 OCSP_SINGLERESP * single;
1601 #ifdef EXIM_HAVE_OCSP_RESP_COUNT
1602 if (OCSP_resp_count(bs) != 1)
1604 STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
1605 if (sk_OCSP_SINGLERESP_num(sresp) != 1)
1608 tls_out.ocsp = OCSP_FAILED;
1609 log_write(0, LOG_MAIN, "OCSP stapling "
1610 "with multiple responses not handled");
1613 single = OCSP_resp_get0(bs, 0);
1614 status = OCSP_single_get0_status(single, &reason, &rev,
1615 &thisupd, &nextupd);
1618 DEBUG(D_tls) time_print(bp, "This OCSP Update", thisupd);
1619 DEBUG(D_tls) if(nextupd) time_print(bp, "Next OCSP Update", nextupd);
1620 if (!OCSP_check_validity(thisupd, nextupd,
1621 EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1623 tls_out.ocsp = OCSP_FAILED;
1624 DEBUG(D_tls) ERR_print_errors(bp);
1625 log_write(0, LOG_MAIN, "Server OSCP dates invalid");
1629 DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
1630 OCSP_cert_status_str(status));
1633 case V_OCSP_CERTSTATUS_GOOD:
1634 tls_out.ocsp = OCSP_VFIED;
1637 case V_OCSP_CERTSTATUS_REVOKED:
1638 tls_out.ocsp = OCSP_FAILED;
1639 log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
1640 reason != -1 ? "; reason: " : "",
1641 reason != -1 ? OCSP_crl_reason_str(reason) : "");
1642 DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
1645 tls_out.ocsp = OCSP_FAILED;
1646 log_write(0, LOG_MAIN,
1647 "Server certificate status unknown, in OCSP stapling");
1652 i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1657 OCSP_RESPONSE_free(rsp);
1660 #endif /*!DISABLE_OCSP*/
1663 /*************************************************
1664 * Initialize for TLS *
1665 *************************************************/
1667 /* Called from both server and client code, to do preliminary initialization
1668 of the library. We allocate and return a context structure.
1671 ctxp returned SSL context
1672 host connected host, if client; NULL if server
1673 dhparam DH parameter file
1674 certificate certificate file
1675 privatekey private key
1676 ocsp_file file of stapling info (server); flag for require ocsp (client)
1677 addr address if client; NULL if server (for some randomness)
1678 cbp place to put allocated callback context
1679 errstr error string pointer
1681 Returns: OK/DEFER/FAIL
1685 tls_init(SSL_CTX **ctxp, host_item *host, uschar *dhparam, uschar *certificate,
1687 #ifndef DISABLE_OCSP
1688 uschar *ocsp_file, /*XXX stack, in server*/
1690 address_item *addr, tls_ext_ctx_cb ** cbp, uschar ** errstr)
1695 tls_ext_ctx_cb * cbinfo;
1697 cbinfo = store_malloc(sizeof(tls_ext_ctx_cb));
1698 cbinfo->certificate = certificate;
1699 cbinfo->privatekey = privatekey;
1700 cbinfo->is_server = host==NULL;
1701 #ifndef DISABLE_OCSP
1702 cbinfo->verify_stack = NULL;
1705 cbinfo->u_ocsp.server.file = ocsp_file;
1706 cbinfo->u_ocsp.server.file_expanded = NULL;
1707 cbinfo->u_ocsp.server.response = NULL;
1710 cbinfo->u_ocsp.client.verify_store = NULL;
1712 cbinfo->dhparam = dhparam;
1713 cbinfo->server_cipher_list = NULL;
1714 cbinfo->host = host;
1715 #ifndef DISABLE_EVENT
1716 cbinfo->event_action = NULL;
1719 #ifdef EXIM_NEED_OPENSSL_INIT
1720 SSL_load_error_strings(); /* basic set up */
1721 OpenSSL_add_ssl_algorithms();
1724 #ifdef EXIM_HAVE_SHA256
1725 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
1726 list of available digests. */
1727 EVP_add_digest(EVP_sha256());
1730 /* Create a context.
1731 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
1732 negotiation in the different methods; as far as I can tell, the only
1733 *_{server,client}_method which allows negotiation is SSLv23, which exists even
1734 when OpenSSL is built without SSLv2 support.
1735 By disabling with openssl_options, we can let admins re-enable with the
1738 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
1739 if (!(ctx = SSL_CTX_new(host ? TLS_client_method() : TLS_server_method())))
1741 if (!(ctx = SSL_CTX_new(host ? SSLv23_client_method() : SSLv23_server_method())))
1743 return tls_error(US"SSL_CTX_new", host, NULL, errstr);
1745 /* It turns out that we need to seed the random number generator this early in
1746 order to get the full complement of ciphers to work. It took me roughly a day
1747 of work to discover this by experiment.
1749 On systems that have /dev/urandom, SSL may automatically seed itself from
1750 there. Otherwise, we have to make something up as best we can. Double check
1756 gettimeofday(&r.tv, NULL);
1759 RAND_seed(US (&r), sizeof(r));
1760 RAND_seed(US big_buffer, big_buffer_size);
1761 if (addr != NULL) RAND_seed(US addr, sizeof(addr));
1764 return tls_error(US"RAND_status", host,
1765 US"unable to seed random number generator", errstr);
1768 /* Set up the information callback, which outputs if debugging is at a suitable
1771 DEBUG(D_tls) SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
1773 /* Automatically re-try reads/writes after renegotiation. */
1774 (void) SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
1776 /* Apply administrator-supplied work-arounds.
1777 Historically we applied just one requested option,
1778 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
1779 moved to an administrator-controlled list of options to specify and
1780 grandfathered in the first one as the default value for "openssl_options".
1782 No OpenSSL version number checks: the options we accept depend upon the
1783 availability of the option value macros from OpenSSL. */
1785 if (!tls_openssl_options_parse(openssl_options, &init_options))
1786 return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
1790 DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
1791 if (!(SSL_CTX_set_options(ctx, init_options)))
1792 return tls_error(string_sprintf(
1793 "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
1796 DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
1798 /* We'd like to disable session cache unconditionally, but foolish Outlook
1799 Express clients then give up the first TLS connection and make a second one
1800 (which works). Only when there is an IMAP service on the same machine.
1801 Presumably OE is trying to use the cache for A on B. Leave it enabled for
1802 now, until we work out a decent way of presenting control to the config. It
1803 will never be used because we use a new context every time. */
1805 (void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
1808 /* Initialize with DH parameters if supplied */
1809 /* Initialize ECDH temp key parameter selection */
1811 if ( !init_dh(ctx, dhparam, host, errstr)
1812 || !init_ecdh(ctx, host, errstr)
1816 /* Set up certificate and key (and perhaps OCSP info) */
1818 if ((rc = tls_expand_session_files(ctx, cbinfo, errstr)) != OK)
1821 /* If we need to handle SNI or OCSP, do so */
1823 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1824 # ifndef DISABLE_OCSP
1825 if (!(cbinfo->verify_stack = sk_X509_new_null()))
1827 DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
1832 if (!host) /* server */
1834 # ifndef DISABLE_OCSP
1835 /* We check u_ocsp.server.file, not server.response, because we care about if
1836 the option exists, not what the current expansion might be, as SNI might
1837 change the certificate and OCSP file in use between now and the time the
1838 callback is invoked. */
1839 if (cbinfo->u_ocsp.server.file)
1841 SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
1842 SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
1845 /* We always do this, so that $tls_sni is available even if not used in
1847 SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
1848 SSL_CTX_set_tlsext_servername_arg(ctx, cbinfo);
1850 # ifndef DISABLE_OCSP
1852 if(ocsp_file) /* wanting stapling */
1854 if (!(cbinfo->u_ocsp.client.verify_store = X509_STORE_new()))
1856 DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
1859 SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
1860 SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
1865 cbinfo->verify_cert_hostnames = NULL;
1867 #ifdef EXIM_HAVE_EPHEM_RSA_KEX
1868 /* Set up the RSA callback */
1869 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
1872 /* Finally, set the timeout, and we are done */
1874 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
1875 DEBUG(D_tls) debug_printf("Initialized TLS\n");
1886 /*************************************************
1887 * Get name of cipher in use *
1888 *************************************************/
1891 Argument: pointer to an SSL structure for the connection
1892 buffer to use for answer
1894 pointer to number of bits for cipher
1899 construct_cipher_name(SSL *ssl, uschar *cipherbuf, int bsize, int *bits)
1901 /* With OpenSSL 1.0.0a, 'c' needs to be const but the documentation doesn't
1902 yet reflect that. It should be a safe change anyway, even 0.9.8 versions have
1903 the accessor functions use const in the prototype. */
1905 const uschar * ver = CUS SSL_get_version(ssl);
1906 const SSL_CIPHER * c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
1908 SSL_CIPHER_get_bits(c, bits);
1910 string_format(cipherbuf, bsize, "%s:%s:%u", ver,
1911 SSL_CIPHER_get_name(c), *bits);
1913 DEBUG(D_tls) debug_printf("Cipher: %s\n", cipherbuf);
1918 peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned siz)
1920 /*XXX we might consider a list-of-certs variable for the cert chain.
1921 SSL_get_peer_cert_chain(SSL*). We'd need a new variable type and support
1922 in list-handling functions, also consider the difference between the entire
1923 chain and the elements sent by the peer. */
1925 tlsp->peerdn = NULL;
1927 /* Will have already noted peercert on a verify fail; possibly not the leaf */
1928 if (!tlsp->peercert)
1929 tlsp->peercert = SSL_get_peer_certificate(ssl);
1930 /* Beware anonymous ciphers which lead to server_cert being NULL */
1932 if (!X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, siz))
1933 { DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n"); }
1936 peerdn[siz-1] = '\0';
1937 tlsp->peerdn = peerdn; /*XXX a static buffer... */
1945 /*************************************************
1946 * Set up for verifying certificates *
1947 *************************************************/
1949 #ifndef DISABLE_OCSP
1950 /* Load certs from file, return TRUE on success */
1953 chain_from_pem_file(const uschar * file, STACK_OF(X509) * verify_stack)
1958 while (sk_X509_num(verify_stack) > 0)
1959 X509_free(sk_X509_pop(verify_stack));
1961 if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
1962 while ((x = PEM_read_bio_X509(bp, NULL, 0, NULL)))
1963 sk_X509_push(verify_stack, x);
1971 /* Called by both client and server startup; on the server possibly
1972 repeated after a Server Name Indication.
1975 sctx SSL_CTX* to initialise
1976 certs certs file or NULL
1977 crl CRL file or NULL
1978 host NULL in a server; the remote host in a client
1979 optional TRUE if called from a server for a host in tls_try_verify_hosts;
1980 otherwise passed as FALSE
1981 cert_vfy_cb Callback function for certificate verification
1982 errstr error string pointer
1984 Returns: OK/DEFER/FAIL
1988 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
1989 int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr)
1991 uschar *expcerts, *expcrl;
1993 if (!expand_check(certs, US"tls_verify_certificates", &expcerts, errstr))
1995 DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
1997 if (expcerts && *expcerts)
1999 /* Tell the library to use its compiled-in location for the system default
2000 CA bundle. Then add the ones specified in the config, if any. */
2002 if (!SSL_CTX_set_default_verify_paths(sctx))
2003 return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
2005 if (Ustrcmp(expcerts, "system") != 0)
2007 struct stat statbuf;
2009 if (Ustat(expcerts, &statbuf) < 0)
2011 log_write(0, LOG_MAIN|LOG_PANIC,
2012 "failed to stat %s for certificates", expcerts);
2018 if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
2019 { file = NULL; dir = expcerts; }
2022 file = expcerts; dir = NULL;
2023 #ifndef DISABLE_OCSP
2024 /* In the server if we will be offering an OCSP proof, load chain from
2025 file for verifying the OCSP proof at load time. */
2028 && statbuf.st_size > 0
2029 && server_static_cbinfo->u_ocsp.server.file
2030 && !chain_from_pem_file(file, server_static_cbinfo->verify_stack)
2033 log_write(0, LOG_MAIN|LOG_PANIC,
2034 "failed to load cert chain from %s", file);
2040 /* If a certificate file is empty, the next function fails with an
2041 unhelpful error message. If we skip it, we get the correct behaviour (no
2042 certificates are recognized, but the error message is still misleading (it
2043 says no certificate was supplied). But this is better. */
2045 if ( (!file || statbuf.st_size > 0)
2046 && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
2047 return tls_error(US"SSL_CTX_load_verify_locations", host, NULL, errstr);
2049 /* Load the list of CAs for which we will accept certs, for sending
2050 to the client. This is only for the one-file tls_verify_certificates
2052 If a list isn't loaded into the server, but
2053 some verify locations are set, the server end appears to make
2054 a wildcard request for client certs.
2055 Meanwhile, the client library as default behaviour *ignores* the list
2056 we send over the wire - see man SSL_CTX_set_client_cert_cb.
2057 Because of this, and that the dir variant is likely only used for
2058 the public-CA bundle (not for a private CA), not worth fixing.
2062 STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
2064 SSL_CTX_set_client_CA_list(sctx, names);
2065 DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n",
2066 sk_X509_NAME_num(names));
2071 /* Handle a certificate revocation list. */
2073 #if OPENSSL_VERSION_NUMBER > 0x00907000L
2075 /* This bit of code is now the version supplied by Lars Mainka. (I have
2076 merely reformatted it into the Exim code style.)
2078 "From here I changed the code to add support for multiple crl's
2079 in pem format in one file or to support hashed directory entries in
2080 pem format instead of a file. This method now uses the library function
2081 X509_STORE_load_locations to add the CRL location to the SSL context.
2082 OpenSSL will then handle the verify against CA certs and CRLs by
2083 itself in the verify callback." */
2085 if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
2086 if (expcrl && *expcrl)
2088 struct stat statbufcrl;
2089 if (Ustat(expcrl, &statbufcrl) < 0)
2091 log_write(0, LOG_MAIN|LOG_PANIC,
2092 "failed to stat %s for certificates revocation lists", expcrl);
2097 /* is it a file or directory? */
2099 X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
2100 if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
2104 DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
2110 DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
2112 if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
2113 return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
2115 /* setting the flags to check against the complete crl chain */
2117 X509_STORE_set_flags(cvstore,
2118 X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
2122 #endif /* OPENSSL_VERSION_NUMBER > 0x00907000L */
2124 /* If verification is optional, don't fail if no certificate */
2126 SSL_CTX_set_verify(sctx,
2127 SSL_VERIFY_PEER | (optional? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
2136 /*************************************************
2137 * Start a TLS session in a server *
2138 *************************************************/
2140 /* This is called when Exim is running as a server, after having received
2141 the STARTTLS command. It must respond to that command, and then negotiate
2145 require_ciphers allowed ciphers
2146 errstr pointer to error message
2148 Returns: OK on success
2149 DEFER for errors before the start of the negotiation
2150 FAIL for errors during the negotiation; the server can't
2155 tls_server_start(const uschar * require_ciphers, uschar ** errstr)
2158 uschar * expciphers;
2159 tls_ext_ctx_cb * cbinfo;
2160 static uschar peerdn[256];
2161 static uschar cipherbuf[256];
2163 /* Check for previous activation */
2165 if (tls_in.active.sock >= 0)
2167 tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
2168 smtp_printf("554 Already in TLS\r\n", FALSE);
2172 /* Initialize the SSL library. If it fails, it will already have logged
2175 rc = tls_init(&server_ctx, NULL, tls_dhparam, tls_certificate, tls_privatekey,
2176 #ifndef DISABLE_OCSP
2177 tls_ocsp_file, /*XXX stack*/
2179 NULL, &server_static_cbinfo, errstr);
2180 if (rc != OK) return rc;
2181 cbinfo = server_static_cbinfo;
2183 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
2186 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2187 were historically separated by underscores. So that I can use either form in my
2188 tests, and also for general convenience, we turn underscores into hyphens here.
2190 XXX SSL_CTX_set_cipher_list() is replaced by SSL_CTX_set_ciphersuites()
2191 for TLS 1.3 . Since we do not call it at present we get the default list:
2192 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
2197 uschar * s = expciphers;
2198 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
2199 DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2200 if (!SSL_CTX_set_cipher_list(server_ctx, CS expciphers))
2201 return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL, errstr);
2202 cbinfo->server_cipher_list = expciphers;
2205 /* If this is a host for which certificate verification is mandatory or
2206 optional, set up appropriately. */
2208 tls_in.certificate_verified = FALSE;
2210 tls_in.dane_verified = FALSE;
2212 server_verify_callback_called = FALSE;
2214 if (verify_check_host(&tls_verify_hosts) == OK)
2216 rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2217 FALSE, verify_callback_server, errstr);
2218 if (rc != OK) return rc;
2219 server_verify_optional = FALSE;
2221 else if (verify_check_host(&tls_try_verify_hosts) == OK)
2223 rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2224 TRUE, verify_callback_server, errstr);
2225 if (rc != OK) return rc;
2226 server_verify_optional = TRUE;
2229 /* Prepare for new connection */
2231 if (!(server_ssl = SSL_new(server_ctx)))
2232 return tls_error(US"SSL_new", NULL, NULL, errstr);
2234 /* Warning: we used to SSL_clear(ssl) here, it was removed.
2236 * With the SSL_clear(), we get strange interoperability bugs with
2237 * OpenSSL 1.0.1b and TLS1.1/1.2. It looks as though this may be a bug in
2238 * OpenSSL itself, as a clear should not lead to inability to follow protocols.
2240 * The SSL_clear() call is to let an existing SSL* be reused, typically after
2241 * session shutdown. In this case, we have a brand new object and there's no
2242 * obvious reason to immediately clear it. I'm guessing that this was
2243 * originally added because of incomplete initialisation which the clear fixed,
2244 * in some historic release.
2247 /* Set context and tell client to go ahead, except in the case of TLS startup
2248 on connection, where outputting anything now upsets the clients and tends to
2249 make them disconnect. We need to have an explicit fflush() here, to force out
2250 the response. Other smtp_printf() calls do not need it, because in non-TLS
2251 mode, the fflush() happens when smtp_getc() is called. */
2253 SSL_set_session_id_context(server_ssl, sid_ctx, Ustrlen(sid_ctx));
2254 if (!tls_in.on_connect)
2256 smtp_printf("220 TLS go ahead\r\n", FALSE);
2260 /* Now negotiate the TLS session. We put our own timer on it, since it seems
2261 that the OpenSSL library doesn't. */
2263 SSL_set_wfd(server_ssl, fileno(smtp_out));
2264 SSL_set_rfd(server_ssl, fileno(smtp_in));
2265 SSL_set_accept_state(server_ssl);
2267 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
2269 sigalrm_seen = FALSE;
2270 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
2271 rc = SSL_accept(server_ssl);
2276 (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
2280 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
2282 /* TLS has been set up. Adjust the input functions to read via TLS,
2283 and initialize things. */
2285 peer_cert(server_ssl, &tls_in, peerdn, sizeof(peerdn));
2287 construct_cipher_name(server_ssl, cipherbuf, sizeof(cipherbuf), &tls_in.bits);
2288 tls_in.cipher = cipherbuf;
2293 if (SSL_get_shared_ciphers(server_ssl, CS buf, sizeof(buf)) != NULL)
2294 debug_printf("Shared ciphers: %s\n", buf);
2297 /* Record the certificate we presented */
2299 X509 * crt = SSL_get_certificate(server_ssl);
2300 tls_in.ourcert = crt ? X509_dup(crt) : NULL;
2303 /* Only used by the server-side tls (tls_in), including tls_getc.
2304 Client-side (tls_out) reads (seem to?) go via
2305 smtp_read_response()/ip_recv().
2306 Hence no need to duplicate for _in and _out.
2308 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
2309 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
2310 ssl_xfer_eof = ssl_xfer_error = FALSE;
2312 receive_getc = tls_getc;
2313 receive_getbuf = tls_getbuf;
2314 receive_get_cache = tls_get_cache;
2315 receive_ungetc = tls_ungetc;
2316 receive_feof = tls_feof;
2317 receive_ferror = tls_ferror;
2318 receive_smtp_buffered = tls_smtp_buffered;
2320 tls_in.active.sock = fileno(smtp_out);
2321 tls_in.active.tls_ctx = NULL; /* not using explicit ctx for server-side */
2329 tls_client_basic_ctx_init(SSL_CTX * ctx,
2330 host_item * host, smtp_transport_options_block * ob, tls_ext_ctx_cb * cbinfo,
2334 /* stick to the old behaviour for compatibility if tls_verify_certificates is
2335 set but both tls_verify_hosts and tls_try_verify_hosts is not set. Check only
2336 the specified host patterns if one of them is defined */
2338 if ( ( !ob->tls_verify_hosts
2339 && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
2341 || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
2343 client_verify_optional = FALSE;
2344 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
2345 client_verify_optional = TRUE;
2349 if ((rc = setup_certs(ctx, ob->tls_verify_certificates,
2350 ob->tls_crl, host, client_verify_optional, verify_callback_client,
2354 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
2356 cbinfo->verify_cert_hostnames =
2358 string_domain_utf8_to_alabel(host->name, NULL);
2362 DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
2363 cbinfo->verify_cert_hostnames);
2371 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
2375 const char * hostnames[2] = { CS host->name, NULL };
2378 if (DANESSL_init(ssl, NULL, hostnames) != 1)
2379 return tls_error(US"hostnames load", host, NULL, errstr);
2381 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
2383 rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2384 ) if (rr->type == T_TLSA && rr->size > 3)
2386 const uschar * p = rr->data;
2387 uint8_t usage, selector, mtype;
2388 const char * mdname;
2392 /* Only DANE-TA(2) and DANE-EE(3) are supported */
2393 if (usage != 2 && usage != 3) continue;
2400 default: continue; /* Only match-types 0, 1, 2 are supported */
2401 case 0: mdname = NULL; break;
2402 case 1: mdname = "sha256"; break;
2403 case 2: mdname = "sha512"; break;
2407 switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
2410 return tls_error(US"tlsa load", host, NULL, errstr);
2411 case 0: /* action not taken */
2415 tls_out.tlsa_usage |= 1<<usage;
2421 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
2424 #endif /*SUPPORT_DANE*/
2428 /*************************************************
2429 * Start a TLS session in a client *
2430 *************************************************/
2432 /* Called from the smtp transport after STARTTLS has been accepted.
2435 fd the fd of the connection
2436 host connected host (for messages and option-tests)
2437 addr the first address (for some randomness; can be NULL)
2438 tb transport (always smtp)
2439 tlsa_dnsa tlsa lookup, if DANE, else null
2440 tlsp record details of channel configuration here; must be non-NULL
2441 errstr error string pointer
2443 Returns: Pointer to TLS session context, or NULL on error
2447 tls_client_start(int fd, host_item *host, address_item *addr,
2448 transport_instance * tb,
2450 dns_answer * tlsa_dnsa,
2452 tls_support * tlsp, uschar ** errstr)
2454 smtp_transport_options_block * ob = tb
2455 ? (smtp_transport_options_block *)tb->options_block
2456 : &smtp_transport_option_defaults;
2457 exim_openssl_client_tls_ctx * exim_client_ctx;
2458 static uschar peerdn[256];
2459 uschar * expciphers;
2461 static uschar cipherbuf[256];
2463 #ifndef DISABLE_OCSP
2464 BOOL request_ocsp = FALSE;
2465 BOOL require_ocsp = FALSE;
2469 store_pool = POOL_PERM;
2470 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx));
2474 tlsp->tlsa_usage = 0;
2477 #ifndef DISABLE_OCSP
2479 # ifdef SUPPORT_DANE
2481 && ob->hosts_request_ocsp[0] == '*'
2482 && ob->hosts_request_ocsp[1] == '\0'
2485 /* Unchanged from default. Use a safer one under DANE */
2486 request_ocsp = TRUE;
2487 ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
2488 " {= {4}{$tls_out_tlsa_usage}} } "
2494 verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK))
2495 request_ocsp = TRUE;
2497 # ifdef SUPPORT_DANE
2501 verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
2505 rc = tls_init(&exim_client_ctx->ctx, host, NULL,
2506 ob->tls_certificate, ob->tls_privatekey,
2507 #ifndef DISABLE_OCSP
2508 (void *)(long)request_ocsp,
2510 addr, &client_static_cbinfo, errstr);
2511 if (rc != OK) return NULL;
2513 tlsp->certificate_verified = FALSE;
2514 client_verify_callback_called = FALSE;
2520 /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
2521 other failures should be treated as problems. */
2522 if (ob->dane_require_tls_ciphers &&
2523 !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
2524 &expciphers, errstr))
2526 if (expciphers && *expciphers == '\0')
2531 !expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
2532 &expciphers, errstr))
2535 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2536 are separated by underscores. So that I can use either form in my tests, and
2537 also for general convenience, we turn underscores into hyphens here. */
2541 uschar *s = expciphers;
2542 while (*s) { if (*s == '_') *s = '-'; s++; }
2543 DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2544 if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
2546 tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
2554 SSL_CTX_set_verify(exim_client_ctx->ctx,
2555 SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2556 verify_callback_client_dane);
2558 if (!DANESSL_library_init())
2560 tls_error(US"library init", host, NULL, errstr);
2563 if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
2565 tls_error(US"context init", host, NULL, errstr);
2573 if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
2574 client_static_cbinfo, errstr) != OK)
2577 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
2579 tls_error(US"SSL_new", host, NULL, errstr);
2582 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
2583 SSL_set_fd(exim_client_ctx->ssl, fd);
2584 SSL_set_connect_state(exim_client_ctx->ssl);
2588 if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
2592 DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
2594 else if (!Ustrlen(tlsp->sni))
2598 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2599 DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
2600 SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
2602 log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
2610 if (dane_tlsa_load(exim_client_ctx->ssl, host, tlsa_dnsa, errstr) != OK)
2614 #ifndef DISABLE_OCSP
2615 /* Request certificate status at connection-time. If the server
2616 does OCSP stapling we will get the callback (set in tls_init()) */
2617 # ifdef SUPPORT_DANE
2621 if ( ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
2622 || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
2624 { /* Re-eval now $tls_out_tlsa_usage is populated. If
2625 this means we avoid the OCSP request, we wasted the setup
2626 cost in tls_init(). */
2627 require_ocsp = verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
2628 request_ocsp = require_ocsp
2629 || verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
2636 SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
2637 client_static_cbinfo->u_ocsp.client.verify_required = require_ocsp;
2638 tlsp->ocsp = OCSP_NOT_RESP;
2642 #ifndef DISABLE_EVENT
2643 client_static_cbinfo->event_action = tb ? tb->event_action : NULL;
2646 /* There doesn't seem to be a built-in timeout on connection. */
2648 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
2649 sigalrm_seen = FALSE;
2650 ALARM(ob->command_timeout);
2651 rc = SSL_connect(exim_client_ctx->ssl);
2656 DANESSL_cleanup(exim_client_ctx->ssl);
2661 tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
2665 DEBUG(D_tls) debug_printf("SSL_connect succeeded\n");
2667 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
2669 construct_cipher_name(exim_client_ctx->ssl, cipherbuf, sizeof(cipherbuf), &tlsp->bits);
2670 tlsp->cipher = cipherbuf;
2672 /* Record the certificate we presented */
2674 X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
2675 tlsp->ourcert = crt ? X509_dup(crt) : NULL;
2678 tlsp->active.sock = fd;
2679 tlsp->active.tls_ctx = exim_client_ctx;
2680 return exim_client_ctx;
2688 tls_refill(unsigned lim)
2693 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", server_ssl,
2694 ssl_xfer_buffer, ssl_xfer_buffer_size);
2696 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
2697 inbytes = SSL_read(server_ssl, CS ssl_xfer_buffer,
2698 MIN(ssl_xfer_buffer_size, lim));
2699 error = SSL_get_error(server_ssl, inbytes);
2700 if (smtp_receive_timeout > 0) ALARM_CLR(0);
2702 if (had_command_timeout) /* set by signal handler */
2703 smtp_command_timeout_exit(); /* does not return */
2704 if (had_command_sigterm)
2705 smtp_command_sigterm_exit();
2706 if (had_data_timeout)
2707 smtp_data_timeout_exit();
2708 if (had_data_sigint)
2709 smtp_data_sigint_exit();
2711 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
2712 closed down, not that the socket itself has been closed down. Revert to
2713 non-SSL handling. */
2717 case SSL_ERROR_NONE:
2720 case SSL_ERROR_ZERO_RETURN:
2721 DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2723 receive_getc = smtp_getc;
2724 receive_getbuf = smtp_getbuf;
2725 receive_get_cache = smtp_get_cache;
2726 receive_ungetc = smtp_ungetc;
2727 receive_feof = smtp_feof;
2728 receive_ferror = smtp_ferror;
2729 receive_smtp_buffered = smtp_buffered;
2731 if (SSL_get_shutdown(server_ssl) == SSL_RECEIVED_SHUTDOWN)
2732 SSL_shutdown(server_ssl);
2734 #ifndef DISABLE_OCSP
2735 sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
2736 server_static_cbinfo->verify_stack = NULL;
2738 SSL_free(server_ssl);
2739 SSL_CTX_free(server_ctx);
2742 tls_in.active.sock = -1;
2743 tls_in.active.tls_ctx = NULL;
2745 tls_in.cipher = NULL;
2746 tls_in.peerdn = NULL;
2751 /* Handle genuine errors */
2753 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
2754 log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
2755 ssl_xfer_error = TRUE;
2759 DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
2760 DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
2761 debug_printf(" - syscall %s\n", strerror(errno));
2762 ssl_xfer_error = TRUE;
2766 #ifndef DISABLE_DKIM
2767 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
2769 ssl_xfer_buffer_hwm = inbytes;
2770 ssl_xfer_buffer_lwm = 0;
2775 /*************************************************
2776 * TLS version of getc *
2777 *************************************************/
2779 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
2780 it refills the buffer via the SSL reading function.
2782 Arguments: lim Maximum amount to read/buffer
2783 Returns: the next character or EOF
2785 Only used by the server-side TLS.
2789 tls_getc(unsigned lim)
2791 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
2792 if (!tls_refill(lim))
2793 return ssl_xfer_error ? EOF : smtp_getc(lim);
2795 /* Something in the buffer; return next uschar */
2797 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
2801 tls_getbuf(unsigned * len)
2806 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
2807 if (!tls_refill(*len))
2809 if (!ssl_xfer_error) return smtp_getbuf(len);
2814 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
2816 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
2817 ssl_xfer_buffer_lwm += size;
2826 #ifndef DISABLE_DKIM
2827 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
2829 dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
2835 tls_could_read(void)
2837 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm || SSL_pending(server_ssl) > 0;
2841 /*************************************************
2842 * Read bytes from TLS channel *
2843 *************************************************/
2847 ct_ctx client context pointer, or NULL for the one global server context
2851 Returns: the number of bytes read
2852 -1 after a failed read, including EOF
2854 Only used by the client-side TLS.
2858 tls_read(void * ct_ctx, uschar *buff, size_t len)
2860 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
2864 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
2865 buff, (unsigned int)len);
2867 inbytes = SSL_read(ssl, CS buff, len);
2868 error = SSL_get_error(ssl, inbytes);
2870 if (error == SSL_ERROR_ZERO_RETURN)
2872 DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2875 else if (error != SSL_ERROR_NONE)
2885 /*************************************************
2886 * Write bytes down TLS channel *
2887 *************************************************/
2891 ct_ctx client context pointer, or NULL for the one global server context
2894 more further data expected soon
2896 Returns: the number of bytes after a successful write,
2897 -1 after a failed write
2899 Used by both server-side and client-side TLS.
2903 tls_write(void * ct_ctx, const uschar *buff, size_t len, BOOL more)
2905 int outbytes, error, left;
2906 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
2907 static gstring * corked = NULL;
2909 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
2910 buff, (unsigned long)len, more ? ", more" : "");
2912 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
2913 "more" is notified. This hack is only ok if small amounts are involved AND only
2914 one stream does it, in one context (i.e. no store reset). Currently it is used
2915 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only. */
2916 /*XXX + if PIPE_COMMAND, banner & ehlo-resp for smmtp-on-connect. Suspect there's
2917 a store reset there. */
2919 if (!ct_ctx && (more || corked))
2921 #ifdef EXPERIMENTAL_PIPE_CONNECT
2922 int save_pool = store_pool;
2923 store_pool = POOL_PERM;
2926 corked = string_catn(corked, buff, len);
2928 #ifdef EXPERIMENTAL_PIPE_CONNECT
2929 store_pool = save_pool;
2934 buff = CUS corked->s;
2939 for (left = len; left > 0;)
2941 DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
2942 outbytes = SSL_write(ssl, CS buff, left);
2943 error = SSL_get_error(ssl, outbytes);
2944 DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
2948 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
2949 log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
2952 case SSL_ERROR_NONE:
2957 case SSL_ERROR_ZERO_RETURN:
2958 log_write(0, LOG_MAIN, "SSL channel closed on write");
2961 case SSL_ERROR_SYSCALL:
2962 log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
2963 sender_fullhost ? sender_fullhost : US"<unknown>",
2968 log_write(0, LOG_MAIN, "SSL_write error %d", error);
2977 /*************************************************
2978 * Close down a TLS session *
2979 *************************************************/
2981 /* This is also called from within a delivery subprocess forked from the
2982 daemon, to shut down the TLS library, without actually doing a shutdown (which
2983 would tamper with the SSL session in the parent process).
2986 ct_ctx client TLS context pointer, or NULL for the one global server context
2987 shutdown 1 if TLS close-alert is to be sent,
2988 2 if also response to be waited for
2992 Used by both server-side and client-side TLS.
2996 tls_close(void * ct_ctx, int shutdown)
2998 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
2999 SSL_CTX **ctxp = o_ctx ? &o_ctx->ctx : &server_ctx;
3000 SSL **sslp = o_ctx ? &o_ctx->ssl : &server_ssl;
3001 int *fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
3003 if (*fdp < 0) return; /* TLS was not active */
3008 DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
3009 shutdown > 1 ? " (with response-wait)" : "");
3011 if ( (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
3015 rc = SSL_shutdown(*sslp); /* wait for response */
3019 if (rc < 0) DEBUG(D_tls)
3021 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3022 debug_printf("SSL_shutdown: %s\n", ssl_errstring);
3026 #ifndef DISABLE_OCSP
3027 if (!o_ctx) /* server side */
3029 sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
3030 server_static_cbinfo->verify_stack = NULL;
3034 SSL_CTX_free(*ctxp);
3044 /*************************************************
3045 * Let tls_require_ciphers be checked at startup *
3046 *************************************************/
3048 /* The tls_require_ciphers option, if set, must be something which the
3051 Returns: NULL on success, or error message
3055 tls_validate_require_cipher(void)
3058 uschar *s, *expciphers, *err;
3060 /* this duplicates from tls_init(), we need a better "init just global
3061 state, for no specific purpose" singleton function of our own */
3063 #ifdef EXIM_NEED_OPENSSL_INIT
3064 SSL_load_error_strings();
3065 OpenSSL_add_ssl_algorithms();
3067 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
3068 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
3069 list of available digests. */
3070 EVP_add_digest(EVP_sha256());
3073 if (!(tls_require_ciphers && *tls_require_ciphers))
3076 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
3078 return US"failed to expand tls_require_ciphers";
3080 if (!(expciphers && *expciphers))
3083 /* normalisation ripped from above */
3085 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
3089 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
3090 if (!(ctx = SSL_CTX_new(TLS_server_method())))
3092 if (!(ctx = SSL_CTX_new(SSLv23_server_method())))
3095 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3096 return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
3100 debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
3102 if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
3104 ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3105 err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
3106 expciphers, ssl_errstring);
3117 /*************************************************
3118 * Report the library versions. *
3119 *************************************************/
3121 /* There have historically been some issues with binary compatibility in
3122 OpenSSL libraries; if Exim (like many other applications) is built against
3123 one version of OpenSSL but the run-time linker picks up another version,
3124 it can result in serious failures, including crashing with a SIGSEGV. So
3125 report the version found by the compiler and the run-time version.
3127 Note: some OS vendors backport security fixes without changing the version
3128 number/string, and the version date remains unchanged. The _build_ date
3129 will change, so we can more usefully assist with version diagnosis by also
3130 reporting the build date.
3132 Arguments: a FILE* to print the results to
3137 tls_version_report(FILE *f)
3139 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
3142 OPENSSL_VERSION_TEXT,
3143 SSLeay_version(SSLEAY_VERSION),
3144 SSLeay_version(SSLEAY_BUILT_ON));
3145 /* third line is 38 characters for the %s and the line is 73 chars long;
3146 the OpenSSL output includes a "built on: " prefix already. */
3152 /*************************************************
3153 * Random number generation *
3154 *************************************************/
3156 /* Pseudo-random number generation. The result is not expected to be
3157 cryptographically strong but not so weak that someone will shoot themselves
3158 in the foot using it as a nonce in input in some email header scheme or
3159 whatever weirdness they'll twist this into. The result should handle fork()
3160 and avoid repeating sequences. OpenSSL handles that for us.
3164 Returns a random number in range [0, max-1]
3168 vaguely_random_number(int max)
3172 static pid_t pidlast = 0;
3175 uschar smallbuf[sizeof(r)];
3181 if (pidnow != pidlast)
3183 /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
3184 is unique for each thread", this doesn't apparently apply across processes,
3185 so our own warning from vaguely_random_number_fallback() applies here too.
3186 Fix per PostgreSQL. */
3192 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
3196 gettimeofday(&r.tv, NULL);
3199 RAND_seed(US (&r), sizeof(r));
3201 /* We're after pseudo-random, not random; if we still don't have enough data
3202 in the internal PRNG then our options are limited. We could sleep and hope
3203 for entropy to come along (prayer technique) but if the system is so depleted
3204 in the first place then something is likely to just keep taking it. Instead,
3205 we'll just take whatever little bit of pseudo-random we can still manage to
3208 needed_len = sizeof(r);
3209 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
3210 asked for a number less than 10. */
3211 for (r = max, i = 0; r; ++i)
3217 #ifdef EXIM_HAVE_RAND_PSEUDO
3218 /* We do not care if crypto-strong */
3219 i = RAND_pseudo_bytes(smallbuf, needed_len);
3221 i = RAND_bytes(smallbuf, needed_len);
3227 debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
3228 return vaguely_random_number_fallback(max);
3232 for (p = smallbuf; needed_len; --needed_len, ++p)
3238 /* We don't particularly care about weighted results; if someone wants
3239 smooth distribution and cares enough then they should submit a patch then. */
3246 /*************************************************
3247 * OpenSSL option parse *
3248 *************************************************/
3250 /* Parse one option for tls_openssl_options_parse below
3253 name one option name
3254 value place to store a value for it
3255 Returns success or failure in parsing
3261 tls_openssl_one_option_parse(uschar *name, long *value)
3264 int last = exim_openssl_options_size;
3265 while (last > first)
3267 int middle = (first + last)/2;
3268 int c = Ustrcmp(name, exim_openssl_options[middle].name);
3271 *value = exim_openssl_options[middle].value;
3285 /*************************************************
3286 * OpenSSL option parsing logic *
3287 *************************************************/
3289 /* OpenSSL has a number of compatibility options which an administrator might
3290 reasonably wish to set. Interpret a list similarly to decode_bits(), so that
3291 we look like log_selector.
3294 option_spec the administrator-supplied string of options
3295 results ptr to long storage for the options bitmap
3296 Returns success or failure
3300 tls_openssl_options_parse(uschar *option_spec, long *results)
3305 BOOL adding, item_parsed;
3307 result = SSL_OP_NO_TICKET;
3308 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
3309 * from default because it increases BEAST susceptibility. */
3310 #ifdef SSL_OP_NO_SSLv2
3311 result |= SSL_OP_NO_SSLv2;
3313 #ifdef SSL_OP_SINGLE_DH_USE
3314 result |= SSL_OP_SINGLE_DH_USE;
3323 for (s=option_spec; *s != '\0'; /**/)
3325 while (isspace(*s)) ++s;
3328 if (*s != '+' && *s != '-')
3330 DEBUG(D_tls) debug_printf("malformed openssl option setting: "
3331 "+ or - expected but found \"%s\"\n", s);
3334 adding = *s++ == '+';
3335 for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
3338 item_parsed = tls_openssl_one_option_parse(s, &item);
3342 DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
3345 DEBUG(D_tls) debug_printf("openssl option, %s from %lx: %lx (%s)\n",
3346 adding ? "adding" : "removing", result, item, s);
3358 #endif /*!MACRO_PREDEF*/
3361 /* End of tls-openssl.c */