e8d14398f1b5dab04544b246ddaaf6218035abc1
[exim.git] / src / src / tls-openssl.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2019 */
6 /* Copyright (c) The Exim Maintainers 2020 - 2021 */
7 /* See the file NOTICE for conditions of use and distribution. */
8
9 /* Portions Copyright (c) The OpenSSL Project 1999 */
10
11 /* This module provides the TLS (aka SSL) support for Exim using the OpenSSL
12 library. It is #included into the tls.c file when that library is used. The
13 code herein is based on a patch that was originally contributed by Steve
14 Haslam. It was adapted from stunnel, a GPL program by Michal Trojnara.
15
16 No cryptographic code is included in Exim. All this module does is to call
17 functions from the OpenSSL library. */
18
19
20 /* Heading stuff */
21
22 #include <openssl/lhash.h>
23 #include <openssl/ssl.h>
24 #include <openssl/err.h>
25 #include <openssl/rand.h>
26 #ifndef OPENSSL_NO_ECDH
27 # include <openssl/ec.h>
28 #endif
29 #ifndef DISABLE_OCSP
30 # include <openssl/ocsp.h>
31 #endif
32 #ifdef SUPPORT_DANE
33 # include "danessl.h"
34 #endif
35
36
37 #ifndef DISABLE_OCSP
38 # define EXIM_OCSP_SKEW_SECONDS (300L)
39 # define EXIM_OCSP_MAX_AGE (-1L)
40 #endif
41
42 #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
43 # define EXIM_HAVE_OPENSSL_TLSEXT
44 #endif
45 #if OPENSSL_VERSION_NUMBER >= 0x00908000L
46 # define EXIM_HAVE_RSA_GENKEY_EX
47 #endif
48 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
49 # define EXIM_HAVE_OCSP_RESP_COUNT
50 # define OPENSSL_AUTO_SHA256
51 #else
52 # define EXIM_HAVE_EPHEM_RSA_KEX
53 # define EXIM_HAVE_RAND_PSEUDO
54 #endif
55 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
56 # define EXIM_HAVE_SHA256
57 #endif
58
59 /* X509_check_host provides sane certificate hostname checking, but was added
60 to OpenSSL late, after other projects forked off the code-base.  So in
61 addition to guarding against the base version number, beware that LibreSSL
62 does not (at this time) support this function.
63
64 If LibreSSL gains a different API, perhaps via libtls, then we'll probably
65 opt to disentangle and ask a LibreSSL user to provide glue for a third
66 crypto provider for libtls instead of continuing to tie the OpenSSL glue
67 into even twistier knots.  If LibreSSL gains the same API, we can just
68 change this guard and punt the issue for a while longer. */
69
70 #ifndef LIBRESSL_VERSION_NUMBER
71 # if OPENSSL_VERSION_NUMBER >= 0x010100000L
72 #  define EXIM_HAVE_OPENSSL_CHECKHOST
73 #  define EXIM_HAVE_OPENSSL_DH_BITS
74 #  define EXIM_HAVE_OPENSSL_TLS_METHOD
75 #  define EXIM_HAVE_OPENSSL_KEYLOG
76 #  define EXIM_HAVE_OPENSSL_CIPHER_GET_ID
77 #  define EXIM_HAVE_SESSION_TICKET
78 #  define EXIM_HAVE_OPESSL_TRACE
79 #  define EXIM_HAVE_OPESSL_GET0_SERIAL
80 #  ifndef DISABLE_OCSP
81 #   define EXIM_HAVE_OCSP
82 #  endif
83 #  define EXIM_HAVE_ALPN /* fail ret from hshake-cb is ignored by LibreSSL */
84 # else
85 #  define EXIM_NEED_OPENSSL_INIT
86 # endif
87 # if OPENSSL_VERSION_NUMBER >= 0x010000000L \
88     && (OPENSSL_VERSION_NUMBER & 0x0000ff000L) >= 0x000002000L
89 #  define EXIM_HAVE_OPENSSL_CHECKHOST
90 # endif
91 #endif
92
93 #if LIBRESSL_VERSION_NUMBER >= 0x3040000fL
94 # define EXIM_HAVE_OPENSSL_CIPHER_GET_ID
95 #endif
96
97 #if !defined(LIBRESSL_VERSION_NUMBER) \
98     || LIBRESSL_VERSION_NUMBER >= 0x20010000L
99 # if !defined(OPENSSL_NO_ECDH)
100 #  if OPENSSL_VERSION_NUMBER >= 0x0090800fL
101 #   define EXIM_HAVE_ECDH
102 #  endif
103 #  if OPENSSL_VERSION_NUMBER >= 0x10002000L
104 #   define EXIM_HAVE_OPENSSL_EC_NIST2NID
105 #  endif
106 # endif
107 #endif
108
109 #ifndef LIBRESSL_VERSION_NUMBER
110 # if OPENSSL_VERSION_NUMBER >= 0x010101000L
111 #  define OPENSSL_HAVE_KEYLOG_CB
112 #  define OPENSSL_HAVE_NUM_TICKETS
113 #  define EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
114 # else
115 #  define OPENSSL_BAD_SRVR_OURCERT
116 # endif
117 #endif
118
119 #if !defined(EXIM_HAVE_OPENSSL_TLSEXT) && !defined(DISABLE_OCSP)
120 # warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
121 # define DISABLE_OCSP
122 #endif
123
124 #ifndef DISABLE_TLS_RESUME
125 # if OPENSSL_VERSION_NUMBER < 0x0101010L
126 #  error OpenSSL version too old for session-resumption
127 # endif
128 #endif
129
130 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
131 # include <openssl/x509v3.h>
132 #endif
133
134 #ifndef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
135 # ifndef EXIM_HAVE_OPENSSL_CIPHER_GET_ID
136 #  define SSL_CIPHER_get_id(c) (c->id)
137 # endif
138 # ifndef MACRO_PREDEF
139 #  include "tls-cipher-stdname.c"
140 # endif
141 #endif
142
143 /*************************************************
144 *        OpenSSL option parse                    *
145 *************************************************/
146
147 typedef struct exim_openssl_option {
148   uschar *name;
149   long    value;
150 } exim_openssl_option;
151 /* We could use a macro to expand, but we need the ifdef and not all the
152 options document which version they were introduced in.  Policylet: include
153 all options unless explicitly for DTLS, let the administrator choose which
154 to apply.
155
156 This list is current as of:
157   ==>  1.1.1c  <==
158
159 XXX could we autobuild this list, as with predefined-macros?
160 Seems just parsing ssl.h for SSL_OP_.* would be enough (except to exclude DTLS).
161 Also allow a numeric literal?
162 */
163 static exim_openssl_option exim_openssl_options[] = {
164 /* KEEP SORTED ALPHABETICALLY! */
165 #ifdef SSL_OP_ALL
166   { US"all", (long) SSL_OP_ALL },
167 #endif
168 #ifdef SSL_OP_ALLOW_NO_DHE_KEX
169   { US"allow_no_dhe_kex", SSL_OP_ALLOW_NO_DHE_KEX },
170 #endif
171 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
172   { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
173 #endif
174 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
175   { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
176 #endif
177 #ifdef SSL_OP_CRYPTOPRO_TLSEXT_BUG
178   { US"cryptopro_tlsext_bug", SSL_OP_CRYPTOPRO_TLSEXT_BUG },
179 #endif
180 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
181   { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
182 #endif
183 #ifdef SSL_OP_ENABLE_MIDDLEBOX_COMPAT
184   { US"enable_middlebox_compat", SSL_OP_ENABLE_MIDDLEBOX_COMPAT },
185 #endif
186 #ifdef SSL_OP_EPHEMERAL_RSA
187   { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
188 #endif
189 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
190   { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
191 #endif
192 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
193   { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
194 #endif
195 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
196   { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
197 #endif
198 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
199   { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
200 #endif
201 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
202   { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
203 #endif
204 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
205   { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
206 #endif
207 #ifdef SSL_OP_NO_ANTI_REPLAY
208   { US"no_anti_replay", SSL_OP_NO_ANTI_REPLAY },
209 #endif
210 #ifdef SSL_OP_NO_COMPRESSION
211   { US"no_compression", SSL_OP_NO_COMPRESSION },
212 #endif
213 #ifdef SSL_OP_NO_ENCRYPT_THEN_MAC
214   { US"no_encrypt_then_mac", SSL_OP_NO_ENCRYPT_THEN_MAC },
215 #endif
216 #ifdef SSL_OP_NO_RENEGOTIATION
217   { US"no_renegotiation", SSL_OP_NO_RENEGOTIATION },
218 #endif
219 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
220   { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
221 #endif
222 #ifdef SSL_OP_NO_SSLv2
223   { US"no_sslv2", SSL_OP_NO_SSLv2 },
224 #endif
225 #ifdef SSL_OP_NO_SSLv3
226   { US"no_sslv3", SSL_OP_NO_SSLv3 },
227 #endif
228 #ifdef SSL_OP_NO_TICKET
229   { US"no_ticket", SSL_OP_NO_TICKET },
230 #endif
231 #ifdef SSL_OP_NO_TLSv1
232   { US"no_tlsv1", SSL_OP_NO_TLSv1 },
233 #endif
234 #ifdef SSL_OP_NO_TLSv1_1
235 # if SSL_OP_NO_TLSv1_1 == 0x00000400L
236   /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
237 #  warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
238 # else
239   { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
240 # endif
241 #endif
242 #ifdef SSL_OP_NO_TLSv1_2
243   { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
244 #endif
245 #ifdef SSL_OP_NO_TLSv1_3
246   { US"no_tlsv1_3", SSL_OP_NO_TLSv1_3 },
247 #endif
248 #ifdef SSL_OP_PRIORITIZE_CHACHA
249   { US"prioritize_chacha", SSL_OP_PRIORITIZE_CHACHA },
250 #endif
251 #ifdef SSL_OP_SAFARI_ECDHE_ECDSA_BUG
252   { US"safari_ecdhe_ecdsa_bug", SSL_OP_SAFARI_ECDHE_ECDSA_BUG },
253 #endif
254 #ifdef SSL_OP_SINGLE_DH_USE
255   { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
256 #endif
257 #ifdef SSL_OP_SINGLE_ECDH_USE
258   { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
259 #endif
260 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
261   { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
262 #endif
263 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
264   { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
265 #endif
266 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
267   { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
268 #endif
269 #ifdef SSL_OP_TLS_D5_BUG
270   { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
271 #endif
272 #ifdef SSL_OP_TLS_ROLLBACK_BUG
273   { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
274 #endif
275 #ifdef SSL_OP_TLSEXT_PADDING
276   { US"tlsext_padding", SSL_OP_TLSEXT_PADDING },
277 #endif
278 };
279
280 #ifndef MACRO_PREDEF
281 static int exim_openssl_options_size = nelem(exim_openssl_options);
282 static long init_options = 0;
283 #endif
284
285 #ifdef MACRO_PREDEF
286 void
287 options_tls(void)
288 {
289 uschar buf[64];
290
291 for (struct exim_openssl_option * o = exim_openssl_options;
292      o < exim_openssl_options + nelem(exim_openssl_options); o++)
293   {
294   /* Trailing X is workaround for problem with _OPT_OPENSSL_NO_TLSV1
295   being a ".ifdef _OPT_OPENSSL_NO_TLSV1_3" match */
296
297   spf(buf, sizeof(buf), US"_OPT_OPENSSL_%T_X", o->name);
298   builtin_macro_create(buf);
299   }
300
301 # ifndef DISABLE_TLS_RESUME
302 builtin_macro_create_var(US"_RESUME_DECODE", RESUME_DECODE_STRING );
303 # endif
304 # ifdef SSL_OP_NO_TLSv1_3
305 builtin_macro_create(US"_HAVE_TLS1_3");
306 # endif
307 # ifdef OPENSSL_BAD_SRVR_OURCERT
308 builtin_macro_create(US"_TLS_BAD_MULTICERT_IN_OURCERT");
309 # endif
310 # ifdef EXIM_HAVE_OCSP
311 builtin_macro_create(US"_HAVE_TLS_OCSP");
312 builtin_macro_create(US"_HAVE_TLS_OCSP_LIST");
313 # endif
314 # ifdef EXIM_HAVE_ALPN
315 builtin_macro_create(US"_HAVE_TLS_ALPN");
316 # endif
317 }
318 #else
319
320 /******************************************************************************/
321
322 /* Structure for collecting random data for seeding. */
323
324 typedef struct randstuff {
325   struct timeval tv;
326   pid_t          p;
327 } randstuff;
328
329 /* Local static variables */
330
331 static BOOL client_verify_callback_called = FALSE;
332 static BOOL server_verify_callback_called = FALSE;
333 static const uschar *sid_ctx = US"exim";
334
335 /* We have three different contexts to care about.
336
337 Simple case: client, `client_ctx`
338  As a client, we can be doing a callout or cut-through delivery while receiving
339  a message.  So we have a client context, which should have options initialised
340  from the SMTP Transport.  We may also concurrently want to make TLS connections
341  to utility daemons, so client-contexts are allocated and passed around in call
342  args rather than using a gobal.
343
344 Server:
345  There are two cases: with and without ServerNameIndication from the client.
346  Given TLS SNI, we can be using different keys, certs and various other
347  configuration settings, because they're re-expanded with $tls_sni set.  This
348  allows vhosting with TLS.  This SNI is sent in the handshake.
349  A client might not send SNI, so we need a fallback, and an initial setup too.
350  So as a server, we start out using `server_ctx`.
351  If SNI is sent by the client, then we as server, mid-negotiation, try to clone
352  `server_sni` from `server_ctx` and then initialise settings by re-expanding
353  configuration.
354 */
355
356 typedef struct {
357   SSL_CTX *     ctx;
358   SSL *         ssl;
359   gstring *     corked;
360 } exim_openssl_client_tls_ctx;
361
362
363 /* static SSL_CTX *server_ctx = NULL; */
364 /* static SSL     *server_ssl = NULL; */
365
366 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
367 static SSL_CTX *server_sni = NULL;
368 #endif
369 #ifdef EXIM_HAVE_ALPN
370 static BOOL server_seen_alpn = FALSE;
371 #endif
372
373 static char ssl_errstring[256];
374
375 static int  ssl_session_timeout = 7200;         /* Two hours */
376 static BOOL client_verify_optional = FALSE;
377 static BOOL server_verify_optional = FALSE;
378
379 static BOOL reexpand_tls_files_for_sni = FALSE;
380
381
382 typedef struct ocsp_resp {
383   struct ocsp_resp *    next;
384   OCSP_RESPONSE *       resp;
385 } ocsp_resplist;
386
387 typedef struct exim_openssl_state {
388   exim_tlslib_state     lib_state;
389 #define lib_ctx                 libdata0
390 #define lib_ssl                 libdata1
391
392   tls_support * tlsp;
393   uschar *      certificate;
394   uschar *      privatekey;
395   BOOL          is_server;
396 #ifndef DISABLE_OCSP
397   STACK_OF(X509) *verify_stack;         /* chain for verifying the proof */
398   union {
399     struct {
400       uschar        *file;
401       const uschar  *file_expanded;
402       ocsp_resplist *olist;
403     } server;
404     struct {
405       X509_STORE    *verify_store;      /* non-null if status requested */
406       BOOL          verify_required;
407     } client;
408   } u_ocsp;
409 #endif
410   uschar *      dhparam;
411   /* these are cached from first expand */
412   uschar *      server_cipher_list;
413   /* only passed down to tls_error: */
414   host_item *   host;
415   const uschar * verify_cert_hostnames;
416 #ifndef DISABLE_EVENT
417   uschar *      event_action;
418 #endif
419 } exim_openssl_state_st;
420
421 /* should figure out a cleanup of API to handle state preserved per
422 implementation, for various reasons, which can be void * in the APIs.
423 For now, we hack around it. */
424 exim_openssl_state_st *client_static_state = NULL;      /*XXX should not use static; multiple concurrent clients! */
425 exim_openssl_state_st state_server = {.is_server = TRUE};
426
427 static int
428 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host,
429     uschar ** errstr );
430
431 /* Callbacks */
432 #ifndef DISABLE_OCSP
433 static int tls_server_stapling_cb(SSL *s, void *arg);
434 #endif
435
436
437
438 /* Daemon-called, before every connection, key create/rotate */
439 #ifndef DISABLE_TLS_RESUME
440 static void tk_init(void);
441 static int tls_exdata_idx = -1;
442 #endif
443
444 static void
445 tls_per_lib_daemon_tick(void)
446 {
447 #ifndef DISABLE_TLS_RESUME
448 tk_init();
449 #endif
450 }
451
452 /* Called once at daemon startup */
453
454 static void
455 tls_per_lib_daemon_init(void)
456 {
457 tls_daemon_creds_reload();
458 }
459
460
461 /*************************************************
462 *               Handle TLS error                 *
463 *************************************************/
464
465 /* Called from lots of places when errors occur before actually starting to do
466 the TLS handshake, that is, while the session is still in clear. Always returns
467 DEFER for a server and FAIL for a client so that most calls can use "return
468 tls_error(...)" to do this processing and then give an appropriate return. A
469 single function is used for both server and client, because it is called from
470 some shared functions.
471
472 Argument:
473   prefix    text to include in the logged error
474   host      NULL if setting up a server;
475             the connected host if setting up a client
476   msg       error message or NULL if we should ask OpenSSL
477   errstr    pointer to output error message
478
479 Returns:    OK/DEFER/FAIL
480 */
481
482 static int
483 tls_error(uschar * prefix, const host_item * host, uschar * msg, uschar ** errstr)
484 {
485 if (!msg)
486   {
487   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
488   msg = US ssl_errstring;
489   }
490
491 msg = string_sprintf("(%s): %s", prefix, msg);
492 DEBUG(D_tls) debug_printf("TLS error '%s'\n", msg);
493 if (errstr) *errstr = msg;
494 return host ? FAIL : DEFER;
495 }
496
497
498
499 /**************************************************
500 * General library initalisation                   *
501 **************************************************/
502
503 static BOOL
504 lib_rand_init(void * addr)
505 {
506 randstuff r;
507 if (!RAND_status()) return TRUE;
508
509 gettimeofday(&r.tv, NULL);
510 r.p = getpid();
511 RAND_seed(US (&r), sizeof(r));
512 RAND_seed(US big_buffer, big_buffer_size);
513 if (addr) RAND_seed(US addr, sizeof(addr));
514
515 return RAND_status();
516 }
517
518
519 static void
520 tls_openssl_init(void)
521 {
522 static BOOL once = FALSE;
523 if (once) return;
524 once = TRUE;
525
526 #ifdef EXIM_NEED_OPENSSL_INIT
527 SSL_load_error_strings();          /* basic set up */
528 OpenSSL_add_ssl_algorithms();
529 #endif
530
531 #if defined(EXIM_HAVE_SHA256) && !defined(OPENSSL_AUTO_SHA256)
532 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
533 list of available digests. */
534 EVP_add_digest(EVP_sha256());
535 #endif
536
537 (void) lib_rand_init(NULL);
538 (void) tls_openssl_options_parse(openssl_options, &init_options);
539 }
540
541
542
543 /*************************************************
544 *                Initialize for DH               *
545 *************************************************/
546
547 /* If dhparam is set, expand it, and load up the parameters for DH encryption.
548
549 Arguments:
550   sctx      The current SSL CTX (inbound or outbound)
551   dhparam   DH parameter file or fixed parameter identity string
552   host      connected host, if client; NULL if server
553   errstr    error string pointer
554
555 Returns:    TRUE if OK (nothing to set up, or setup worked)
556 */
557
558 static BOOL
559 init_dh(SSL_CTX *sctx, uschar *dhparam, const host_item *host, uschar ** errstr)
560 {
561 BIO *bio;
562 DH *dh;
563 uschar *dhexpanded;
564 const char *pem;
565 int dh_bitsize;
566
567 if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded, errstr))
568   return FALSE;
569
570 if (!dhexpanded || !*dhexpanded)
571   bio = BIO_new_mem_buf(CS std_dh_prime_default(), -1);
572 else if (dhexpanded[0] == '/')
573   {
574   if (!(bio = BIO_new_file(CS dhexpanded, "r")))
575     {
576     tls_error(string_sprintf("could not read dhparams file %s", dhexpanded),
577           host, US strerror(errno), errstr);
578     return FALSE;
579     }
580   }
581 else
582   {
583   if (Ustrcmp(dhexpanded, "none") == 0)
584     {
585     DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
586     return TRUE;
587     }
588
589   if (!(pem = std_dh_prime_named(dhexpanded)))
590     {
591     tls_error(string_sprintf("Unknown standard DH prime \"%s\"", dhexpanded),
592         host, US strerror(errno), errstr);
593     return FALSE;
594     }
595   bio = BIO_new_mem_buf(CS pem, -1);
596   }
597
598 if (!(dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL)))
599   {
600   BIO_free(bio);
601   tls_error(string_sprintf("Could not read tls_dhparams \"%s\"", dhexpanded),
602       host, NULL, errstr);
603   return FALSE;
604   }
605
606 /* note: our default limit of 2236 is not a multiple of 8; the limit comes from
607  * an NSS limit, and the GnuTLS APIs handle bit-sizes fine, so we went with
608  * 2236.  But older OpenSSL can only report in bytes (octets), not bits.
609  * If someone wants to dance at the edge, then they can raise the limit or use
610  * current libraries. */
611 #ifdef EXIM_HAVE_OPENSSL_DH_BITS
612 /* Added in commit 26c79d5641d; `git describe --contains` says OpenSSL_1_1_0-pre1~1022
613  * This predates OpenSSL_1_1_0 (before a, b, ...) so is in all 1.1.0 */
614 dh_bitsize = DH_bits(dh);
615 #else
616 dh_bitsize = 8 * DH_size(dh);
617 #endif
618
619 /* Even if it is larger, we silently return success rather than cause things
620  * to fail out, so that a too-large DH will not knock out all TLS; it's a
621  * debatable choice. */
622 if (dh_bitsize > tls_dh_max_bits)
623   {
624   DEBUG(D_tls)
625     debug_printf("dhparams file %d bits, is > tls_dh_max_bits limit of %d\n",
626         dh_bitsize, tls_dh_max_bits);
627   }
628 else
629   {
630   SSL_CTX_set_tmp_dh(sctx, dh);
631   DEBUG(D_tls)
632     debug_printf("Diffie-Hellman initialized from %s with %d-bit prime\n",
633       dhexpanded ? dhexpanded : US"default", dh_bitsize);
634   }
635
636 DH_free(dh);
637 BIO_free(bio);
638
639 return TRUE;
640 }
641
642
643
644
645 /*************************************************
646 *               Initialize for ECDH              *
647 *************************************************/
648
649 /* Load parameters for ECDH encryption.
650
651 For now, we stick to NIST P-256 because: it's simple and easy to configure;
652 it avoids any patent issues that might bite redistributors; despite events in
653 the news and concerns over curve choices, we're not cryptographers, we're not
654 pretending to be, and this is "good enough" to be better than no support,
655 protecting against most adversaries.  Given another year or two, there might
656 be sufficient clarity about a "right" way forward to let us make an informed
657 decision, instead of a knee-jerk reaction.
658
659 Longer-term, we should look at supporting both various named curves and
660 external files generated with "openssl ecparam", much as we do for init_dh().
661 We should also support "none" as a value, to explicitly avoid initialisation.
662
663 Patches welcome.
664
665 Arguments:
666   sctx      The current SSL CTX (inbound or outbound)
667   host      connected host, if client; NULL if server
668   errstr    error string pointer
669
670 Returns:    TRUE if OK (nothing to set up, or setup worked)
671 */
672
673 static BOOL
674 init_ecdh(SSL_CTX * sctx, host_item * host, uschar ** errstr)
675 {
676 #ifdef OPENSSL_NO_ECDH
677 return TRUE;
678 #else
679
680 EC_KEY * ecdh;
681 uschar * exp_curve;
682 int nid;
683 BOOL rv;
684
685 if (host)       /* No ECDH setup for clients, only for servers */
686   return TRUE;
687
688 # ifndef EXIM_HAVE_ECDH
689 DEBUG(D_tls)
690   debug_printf("No OpenSSL API to define ECDH parameters, skipping\n");
691 return TRUE;
692 # else
693
694 if (!expand_check(tls_eccurve, US"tls_eccurve", &exp_curve, errstr))
695   return FALSE;
696 if (!exp_curve || !*exp_curve)
697   return TRUE;
698
699 /* "auto" needs to be handled carefully.
700  * OpenSSL <  1.0.2: we do not select anything, but fallback to prime256v1
701  * OpenSSL <  1.1.0: we have to call SSL_CTX_set_ecdh_auto
702  *                   (openssl/ssl.h defines SSL_CTRL_SET_ECDH_AUTO)
703  * OpenSSL >= 1.1.0: we do not set anything, the libray does autoselection
704  *                   https://github.com/openssl/openssl/commit/fe6ef2472db933f01b59cad82aa925736935984b
705  */
706 if (Ustrcmp(exp_curve, "auto") == 0)
707   {
708 #if OPENSSL_VERSION_NUMBER < 0x10002000L
709   DEBUG(D_tls) debug_printf(
710     "ECDH OpenSSL < 1.0.2: temp key parameter settings: overriding \"auto\" with \"prime256v1\"\n");
711   exp_curve = US"prime256v1";
712 #else
713 # if defined SSL_CTRL_SET_ECDH_AUTO
714   DEBUG(D_tls) debug_printf(
715     "ECDH OpenSSL 1.0.2+: temp key parameter settings: autoselection\n");
716   SSL_CTX_set_ecdh_auto(sctx, 1);
717   return TRUE;
718 # else
719   DEBUG(D_tls) debug_printf(
720     "ECDH OpenSSL 1.1.0+: temp key parameter settings: default selection\n");
721   return TRUE;
722 # endif
723 #endif
724   }
725
726 DEBUG(D_tls) debug_printf("ECDH: curve '%s'\n", exp_curve);
727 if (  (nid = OBJ_sn2nid       (CCS exp_curve)) == NID_undef
728 #   ifdef EXIM_HAVE_OPENSSL_EC_NIST2NID
729    && (nid = EC_curve_nist2nid(CCS exp_curve)) == NID_undef
730 #   endif
731    )
732   {
733   tls_error(string_sprintf("Unknown curve name tls_eccurve '%s'", exp_curve),
734     host, NULL, errstr);
735   return FALSE;
736   }
737
738 if (!(ecdh = EC_KEY_new_by_curve_name(nid)))
739   {
740   tls_error(US"Unable to create ec curve", host, NULL, errstr);
741   return FALSE;
742   }
743
744 /* The "tmp" in the name here refers to setting a temporary key
745 not to the stability of the interface. */
746
747 if ((rv = SSL_CTX_set_tmp_ecdh(sctx, ecdh) == 0))
748   tls_error(string_sprintf("Error enabling '%s' curve", exp_curve), host, NULL, errstr);
749 else
750   DEBUG(D_tls) debug_printf("ECDH: enabled '%s' curve\n", exp_curve);
751
752 EC_KEY_free(ecdh);
753 return !rv;
754
755 # endif /*EXIM_HAVE_ECDH*/
756 #endif /*OPENSSL_NO_ECDH*/
757 }
758
759
760
761 /*************************************************
762 *        Expand key and cert file specs          *
763 *************************************************/
764
765 /*
766 Arguments:
767   s          SSL connection (not used)
768   export     not used
769   keylength  keylength
770
771 Returns:     pointer to generated key
772 */
773
774 static RSA *
775 rsa_callback(SSL *s, int export, int keylength)
776 {
777 RSA *rsa_key;
778 #ifdef EXIM_HAVE_RSA_GENKEY_EX
779 BIGNUM *bn = BN_new();
780 #endif
781
782 DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
783
784 #ifdef EXIM_HAVE_RSA_GENKEY_EX
785 if (  !BN_set_word(bn, (unsigned long)RSA_F4)
786    || !(rsa_key = RSA_new())
787    || !RSA_generate_key_ex(rsa_key, keylength, bn, NULL)
788    )
789 #else
790 if (!(rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL)))
791 #endif
792
793   {
794   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
795   log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
796     ssl_errstring);
797   return NULL;
798   }
799 return rsa_key;
800 }
801
802
803
804 /* Create and install a selfsigned certificate, for use in server mode */
805 /*XXX we could arrange to call this during prelo for a null tls_certificate option.
806 The normal cache inval + relo will suffice.
807 Just need a timer for inval. */
808
809 static int
810 tls_install_selfsign(SSL_CTX * sctx, uschar ** errstr)
811 {
812 X509 * x509 = NULL;
813 EVP_PKEY * pkey;
814 RSA * rsa;
815 X509_NAME * name;
816 uschar * where;
817
818 DEBUG(D_tls) debug_printf("TLS: generating selfsigned server cert\n");
819 where = US"allocating pkey";
820 if (!(pkey = EVP_PKEY_new()))
821   goto err;
822
823 where = US"allocating cert";
824 if (!(x509 = X509_new()))
825   goto err;
826
827 where = US"generating pkey";
828 if (!(rsa = rsa_callback(NULL, 0, 2048)))
829   goto err;
830
831 where = US"assigning pkey";
832 if (!EVP_PKEY_assign_RSA(pkey, rsa))
833   goto err;
834
835 X509_set_version(x509, 2);                              /* N+1 - version 3 */
836 ASN1_INTEGER_set(X509_get_serialNumber(x509), 1);
837 X509_gmtime_adj(X509_get_notBefore(x509), 0);
838 X509_gmtime_adj(X509_get_notAfter(x509), (long)2 * 60 * 60);    /* 2 hour */
839 X509_set_pubkey(x509, pkey);
840
841 name = X509_get_subject_name(x509);
842 X509_NAME_add_entry_by_txt(name, "C",
843                           MBSTRING_ASC, CUS "UK", -1, -1, 0);
844 X509_NAME_add_entry_by_txt(name, "O",
845                           MBSTRING_ASC, CUS "Exim Developers", -1, -1, 0);
846 X509_NAME_add_entry_by_txt(name, "CN",
847                           MBSTRING_ASC, CUS smtp_active_hostname, -1, -1, 0);
848 X509_set_issuer_name(x509, name);
849
850 where = US"signing cert";
851 if (!X509_sign(x509, pkey, EVP_md5()))
852   goto err;
853
854 where = US"installing selfsign cert";
855 if (!SSL_CTX_use_certificate(sctx, x509))
856   goto err;
857
858 where = US"installing selfsign key";
859 if (!SSL_CTX_use_PrivateKey(sctx, pkey))
860   goto err;
861
862 return OK;
863
864 err:
865   (void) tls_error(where, NULL, NULL, errstr);
866   if (x509) X509_free(x509);
867   if (pkey) EVP_PKEY_free(pkey);
868   return DEFER;
869 }
870
871
872
873
874
875
876
877 /*************************************************
878 *           Information callback                 *
879 *************************************************/
880
881 /* The SSL library functions call this from time to time to indicate what they
882 are doing. We copy the string to the debugging output when TLS debugging has
883 been requested.
884
885 Arguments:
886   s         the SSL connection
887   where
888   ret
889
890 Returns:    nothing
891 */
892
893 static void
894 info_callback(SSL *s, int where, int ret)
895 {
896 DEBUG(D_tls)
897   {
898   const uschar * str;
899
900   if (where & SSL_ST_CONNECT)
901      str = US"SSL_connect";
902   else if (where & SSL_ST_ACCEPT)
903      str = US"SSL_accept";
904   else
905      str = US"SSL info (undefined)";
906
907   if (where & SSL_CB_LOOP)
908      debug_printf("%s: %s\n", str, SSL_state_string_long(s));
909   else if (where & SSL_CB_ALERT)
910     debug_printf("SSL3 alert %s:%s:%s\n",
911           str = where & SSL_CB_READ ? US"read" : US"write",
912           SSL_alert_type_string_long(ret), SSL_alert_desc_string_long(ret));
913   else if (where & SSL_CB_EXIT)
914     {
915     if (ret == 0)
916       debug_printf("%s: failed in %s\n", str, SSL_state_string_long(s));
917     else if (ret < 0)
918       debug_printf("%s: error in %s\n", str, SSL_state_string_long(s));
919     }
920   else if (where & SSL_CB_HANDSHAKE_START)
921      debug_printf("%s: hshake start: %s\n", str, SSL_state_string_long(s));
922   else if (where & SSL_CB_HANDSHAKE_DONE)
923      debug_printf("%s: hshake done: %s\n", str, SSL_state_string_long(s));
924   }
925 }
926
927 #ifdef OPENSSL_HAVE_KEYLOG_CB
928 static void
929 keylog_callback(const SSL *ssl, const char *line)
930 {
931 char * filename;
932 FILE * fp;
933 DEBUG(D_tls) debug_printf("%.200s\n", line);
934 if (!(filename = getenv("SSLKEYLOGFILE"))) return;
935 if (!(fp = fopen(filename, "a"))) return;
936 fprintf(fp, "%s\n", line);
937 fclose(fp);
938 }
939 #endif
940
941
942
943
944
945 #ifndef DISABLE_EVENT
946 static int
947 verify_event(tls_support * tlsp, X509 * cert, int depth, const uschar * dn,
948   BOOL *calledp, const BOOL *optionalp, const uschar * what)
949 {
950 uschar * ev;
951 uschar * yield;
952 X509 * old_cert;
953
954 ev = tlsp == &tls_out ? client_static_state->event_action : event_action;
955 if (ev)
956   {
957   DEBUG(D_tls) debug_printf("verify_event: %s %d\n", what, depth);
958   old_cert = tlsp->peercert;
959   tlsp->peercert = X509_dup(cert);
960   /* NB we do not bother setting peerdn */
961   if ((yield = event_raise(ev, US"tls:cert", string_sprintf("%d", depth))))
962     {
963     log_write(0, LOG_MAIN, "[%s] %s verify denied by event-action: "
964                 "depth=%d cert=%s: %s",
965               tlsp == &tls_out ? deliver_host_address : sender_host_address,
966               what, depth, dn, yield);
967     *calledp = TRUE;
968     if (!*optionalp)
969       {
970       if (old_cert) tlsp->peercert = old_cert;  /* restore 1st failing cert */
971       return 1;                     /* reject (leaving peercert set) */
972       }
973     DEBUG(D_tls) debug_printf("Event-action verify failure overridden "
974       "(host in tls_try_verify_hosts)\n");
975     tlsp->verify_override = TRUE;
976     }
977   X509_free(tlsp->peercert);
978   tlsp->peercert = old_cert;
979   }
980 return 0;
981 }
982 #endif
983
984 /*************************************************
985 *        Callback for verification               *
986 *************************************************/
987
988 /* The SSL library does certificate verification if set up to do so. This
989 callback has the current yes/no state is in "state". If verification succeeded,
990 we set the certificate-verified flag. If verification failed, what happens
991 depends on whether the client is required to present a verifiable certificate
992 or not.
993
994 If verification is optional, we change the state to yes, but still log the
995 verification error. For some reason (it really would help to have proper
996 documentation of OpenSSL), this callback function then gets called again, this
997 time with state = 1.  We must take care not to set the private verified flag on
998 the second time through.
999
1000 Note: this function is not called if the client fails to present a certificate
1001 when asked. We get here only if a certificate has been received. Handling of
1002 optional verification for this case is done when requesting SSL to verify, by
1003 setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
1004
1005 May be called multiple times for different issues with a certificate, even
1006 for a given "depth" in the certificate chain.
1007
1008 Arguments:
1009   preverify_ok current yes/no state as 1/0
1010   x509ctx      certificate information.
1011   tlsp         per-direction (client vs. server) support data
1012   calledp      has-been-called flag
1013   optionalp    verification-is-optional flag
1014
1015 Returns:     0 if verification should fail, otherwise 1
1016 */
1017
1018 static int
1019 verify_callback(int preverify_ok, X509_STORE_CTX * x509ctx,
1020   tls_support * tlsp, BOOL * calledp, BOOL * optionalp)
1021 {
1022 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
1023 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
1024 uschar dn[256];
1025
1026 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
1027   {
1028   DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
1029   log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
1030     tlsp == &tls_out ? deliver_host_address : sender_host_address);
1031   return 0;
1032   }
1033 dn[sizeof(dn)-1] = '\0';
1034
1035 tlsp->verify_override = FALSE;
1036 if (preverify_ok == 0)
1037   {
1038   uschar * extra = verify_mode ? string_sprintf(" (during %c-verify for [%s])",
1039       *verify_mode, sender_host_address)
1040     : US"";
1041   log_write(0, LOG_MAIN, "[%s] SSL verify error%s: depth=%d error=%s cert=%s",
1042     tlsp == &tls_out ? deliver_host_address : sender_host_address,
1043     extra, depth,
1044     X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509ctx)), dn);
1045   *calledp = TRUE;
1046   if (!*optionalp)
1047     {
1048     if (!tlsp->peercert)
1049       tlsp->peercert = X509_dup(cert);  /* record failing cert */
1050     return 0;                           /* reject */
1051     }
1052   DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
1053     "tls_try_verify_hosts)\n");
1054   tlsp->verify_override = TRUE;
1055   }
1056
1057 else if (depth != 0)
1058   {
1059   DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d SN=%s\n", depth, dn);
1060 #ifndef DISABLE_OCSP
1061   if (tlsp == &tls_out && client_static_state->u_ocsp.client.verify_store)
1062     {   /* client, wanting stapling  */
1063     /* Add the server cert's signing chain as the one
1064     for the verification of the OCSP stapled information. */
1065
1066     if (!X509_STORE_add_cert(client_static_state->u_ocsp.client.verify_store,
1067                              cert))
1068       ERR_clear_error();
1069     sk_X509_push(client_static_state->verify_stack, cert);
1070     }
1071 #endif
1072 #ifndef DISABLE_EVENT
1073     if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
1074       return 0;                         /* reject, with peercert set */
1075 #endif
1076   }
1077 else
1078   {
1079   const uschar * verify_cert_hostnames;
1080
1081   if (  tlsp == &tls_out
1082      && ((verify_cert_hostnames = client_static_state->verify_cert_hostnames)))
1083         /* client, wanting hostname check */
1084     {
1085
1086 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
1087 # ifndef X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
1088 #  define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0
1089 # endif
1090 # ifndef X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS
1091 #  define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0
1092 # endif
1093     int sep = 0;
1094     const uschar * list = verify_cert_hostnames;
1095     uschar * name;
1096     int rc;
1097     while ((name = string_nextinlist(&list, &sep, NULL, 0)))
1098       if ((rc = X509_check_host(cert, CCS name, 0,
1099                   X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
1100                   | X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS,
1101                   NULL)))
1102         {
1103         if (rc < 0)
1104           {
1105           log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
1106             tlsp == &tls_out ? deliver_host_address : sender_host_address);
1107           name = NULL;
1108           }
1109         break;
1110         }
1111     if (!name)
1112 #else
1113     if (!tls_is_name_for_cert(verify_cert_hostnames, cert))
1114 #endif
1115       {
1116       uschar * extra = verify_mode
1117         ? string_sprintf(" (during %c-verify for [%s])",
1118           *verify_mode, sender_host_address)
1119         : US"";
1120       log_write(0, LOG_MAIN,
1121         "[%s] SSL verify error%s: certificate name mismatch: DN=\"%s\" H=\"%s\"",
1122         tlsp == &tls_out ? deliver_host_address : sender_host_address,
1123         extra, dn, verify_cert_hostnames);
1124       *calledp = TRUE;
1125       if (!*optionalp)
1126         {
1127         if (!tlsp->peercert)
1128           tlsp->peercert = X509_dup(cert);      /* record failing cert */
1129         return 0;                               /* reject */
1130         }
1131       DEBUG(D_tls) debug_printf("SSL verify name failure overridden (host in "
1132         "tls_try_verify_hosts)\n");
1133       tlsp->verify_override = TRUE;
1134       }
1135     }
1136
1137 #ifndef DISABLE_EVENT
1138   if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
1139     return 0;                           /* reject, with peercert set */
1140 #endif
1141
1142   DEBUG(D_tls) debug_printf("SSL%s verify ok: depth=0 SN=%s\n",
1143     *calledp ? "" : " authenticated", dn);
1144   *calledp = TRUE;
1145   }
1146
1147 return 1;   /* accept, at least for this level */
1148 }
1149
1150 static int
1151 verify_callback_client(int preverify_ok, X509_STORE_CTX *x509ctx)
1152 {
1153 return verify_callback(preverify_ok, x509ctx, &tls_out,
1154   &client_verify_callback_called, &client_verify_optional);
1155 }
1156
1157 static int
1158 verify_callback_server(int preverify_ok, X509_STORE_CTX *x509ctx)
1159 {
1160 return verify_callback(preverify_ok, x509ctx, &tls_in,
1161   &server_verify_callback_called, &server_verify_optional);
1162 }
1163
1164
1165 #ifdef SUPPORT_DANE
1166
1167 /* This gets called *by* the dane library verify callback, which interposes
1168 itself.
1169 */
1170 static int
1171 verify_callback_client_dane(int preverify_ok, X509_STORE_CTX * x509ctx)
1172 {
1173 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
1174 uschar dn[256];
1175 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
1176 #ifndef DISABLE_EVENT
1177 BOOL dummy_called, optional = FALSE;
1178 #endif
1179
1180 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
1181   {
1182   DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
1183   log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
1184     deliver_host_address);
1185   return 0;
1186   }
1187 dn[sizeof(dn)-1] = '\0';
1188
1189 DEBUG(D_tls) debug_printf("verify_callback_client_dane: %s depth %d %s\n",
1190   preverify_ok ? "ok":"BAD", depth, dn);
1191
1192 #ifndef DISABLE_EVENT
1193   if (verify_event(&tls_out, cert, depth, dn,
1194           &dummy_called, &optional, US"DANE"))
1195     return 0;                           /* reject, with peercert set */
1196 #endif
1197
1198 if (preverify_ok == 1)
1199   {
1200   tls_out.dane_verified = TRUE;
1201 #ifndef DISABLE_OCSP
1202   if (client_static_state->u_ocsp.client.verify_store)
1203     {   /* client, wanting stapling  */
1204     /* Add the server cert's signing chain as the one
1205     for the verification of the OCSP stapled information. */
1206
1207     if (!X509_STORE_add_cert(client_static_state->u_ocsp.client.verify_store,
1208                              cert))
1209       ERR_clear_error();
1210     sk_X509_push(client_static_state->verify_stack, cert);
1211     }
1212 #endif
1213   }
1214 else
1215   {
1216   int err = X509_STORE_CTX_get_error(x509ctx);
1217   DEBUG(D_tls)
1218     debug_printf(" - err %d '%s'\n", err, X509_verify_cert_error_string(err));
1219   if (err == X509_V_ERR_APPLICATION_VERIFICATION)
1220     preverify_ok = 1;
1221   }
1222 return preverify_ok;
1223 }
1224
1225 #endif  /*SUPPORT_DANE*/
1226
1227
1228 #ifndef DISABLE_OCSP
1229 /*************************************************
1230 *       Load OCSP information into state         *
1231 *************************************************/
1232 /* Called to load the server OCSP response from the given file into memory, once
1233 caller has determined this is needed.  Checks validity.  Debugs a message
1234 if invalid.
1235
1236 ASSUMES: single response, for single cert.
1237
1238 Arguments:
1239   state           various parts of session state
1240   filename        the filename putatively holding an OCSP response
1241   is_pem          file is PEM format; otherwise is DER
1242 */
1243
1244 static void
1245 ocsp_load_response(exim_openssl_state_st * state, const uschar * filename,
1246   BOOL is_pem)
1247 {
1248 BIO * bio;
1249 OCSP_RESPONSE * resp;
1250 OCSP_BASICRESP * basic_response;
1251 OCSP_SINGLERESP * single_response;
1252 ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
1253 STACK_OF(X509) * sk;
1254 unsigned long verify_flags;
1255 int status, reason, i;
1256
1257 DEBUG(D_tls)
1258   debug_printf("tls_ocsp_file (%s)  '%s'\n", is_pem ? "PEM" : "DER", filename);
1259
1260 if (!filename || !*filename) return;
1261
1262 ERR_clear_error();
1263 if (!(bio = BIO_new_file(CS filename, "rb")))
1264   {
1265   log_write(0, LOG_MAIN|LOG_PANIC,
1266     "Failed to open OCSP response file \"%s\": %.100s",
1267     filename, ERR_reason_error_string(ERR_get_error()));
1268   return;
1269   }
1270
1271 if (is_pem)
1272   {
1273   uschar * data, * freep;
1274   char * dummy;
1275   long len;
1276   if (!PEM_read_bio(bio, &dummy, &dummy, &data, &len))
1277     {
1278     log_write(0, LOG_MAIN|LOG_PANIC, "Failed to read PEM file \"%s\": %.100s",
1279       filename, ERR_reason_error_string(ERR_get_error()));
1280     return;
1281     }
1282   freep = data;
1283   resp = d2i_OCSP_RESPONSE(NULL, CUSS &data, len);
1284   OPENSSL_free(freep);
1285   }
1286 else
1287   resp = d2i_OCSP_RESPONSE_bio(bio, NULL);
1288 BIO_free(bio);
1289
1290 if (!resp)
1291   {
1292   log_write(0, LOG_MAIN|LOG_PANIC, "Error reading OCSP response from \"%s\": %s",
1293       filename, ERR_reason_error_string(ERR_get_error()));
1294   return;
1295   }
1296
1297 if ((status = OCSP_response_status(resp)) != OCSP_RESPONSE_STATUS_SUCCESSFUL)
1298   {
1299   DEBUG(D_tls) debug_printf("OCSP response not valid: %s (%d)\n",
1300       OCSP_response_status_str(status), status);
1301   goto bad;
1302   }
1303
1304 #ifdef notdef
1305   {
1306   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
1307   OCSP_RESPONSE_print(bp, resp, 0);  /* extreme debug: stapling content */
1308   BIO_free(bp);
1309   }
1310 #endif
1311
1312 if (!(basic_response = OCSP_response_get1_basic(resp)))
1313   {
1314   DEBUG(D_tls)
1315     debug_printf("OCSP response parse error: unable to extract basic response.\n");
1316   goto bad;
1317   }
1318
1319 sk = state->verify_stack;
1320 verify_flags = OCSP_NOVERIFY; /* check sigs, but not purpose */
1321
1322 /* May need to expose ability to adjust those flags?
1323 OCSP_NOSIGS OCSP_NOVERIFY OCSP_NOCHAIN OCSP_NOCHECKS OCSP_NOEXPLICIT
1324 OCSP_TRUSTOTHER OCSP_NOINTERN */
1325
1326 /* This does a full verify on the OCSP proof before we load it for serving
1327 up; possibly overkill - just date-checks might be nice enough.
1328
1329 OCSP_basic_verify takes a "store" arg, but does not
1330 use it for the chain verification, which is all we do
1331 when OCSP_NOVERIFY is set.  The content from the wire
1332 "basic_response" and a cert-stack "sk" are all that is used.
1333
1334 We have a stack, loaded in setup_certs() if tls_verify_certificates
1335 was a file (not a directory, or "system").  It is unfortunate we
1336 cannot used the connection context store, as that would neatly
1337 handle the "system" case too, but there seems to be no library
1338 function for getting a stack from a store.
1339 [ In OpenSSL 1.1 - ?  X509_STORE_CTX_get0_chain(ctx) ? ]
1340 We do not free the stack since it could be needed a second time for
1341 SNI handling.
1342
1343 Separately we might try to replace using OCSP_basic_verify() - which seems to not
1344 be a public interface into the OpenSSL library (there's no manual entry) -
1345 But what with?  We also use OCSP_basic_verify in the client stapling callback.
1346 And there we NEED it; we must verify that status... unless the
1347 library does it for us anyway?  */
1348
1349 if ((i = OCSP_basic_verify(basic_response, sk, NULL, verify_flags)) < 0)
1350   {
1351   DEBUG(D_tls)
1352     {
1353     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
1354     debug_printf("OCSP response verify failure: %s\n", US ssl_errstring);
1355     }
1356   goto bad;
1357   }
1358
1359 /* Here's the simplifying assumption: there's only one response, for the
1360 one certificate we use, and nothing for anything else in a chain.  If this
1361 proves false, we need to extract a cert id from our issued cert
1362 (tls_certificate) and use that for OCSP_resp_find_status() (which finds the
1363 right cert in the stack and then calls OCSP_single_get0_status()).
1364
1365 I'm hoping to avoid reworking a bunch more of how we handle state here.
1366
1367 XXX that will change when we add support for (TLS1.3) whole-chain stapling
1368 */
1369
1370 if (!(single_response = OCSP_resp_get0(basic_response, 0)))
1371   {
1372   DEBUG(D_tls)
1373     debug_printf("Unable to get first response from OCSP basic response.\n");
1374   goto bad;
1375   }
1376
1377 status = OCSP_single_get0_status(single_response, &reason, &rev, &thisupd, &nextupd);
1378 if (status != V_OCSP_CERTSTATUS_GOOD)
1379   {
1380   DEBUG(D_tls) debug_printf("OCSP response bad cert status: %s (%d) %s (%d)\n",
1381       OCSP_cert_status_str(status), status,
1382       OCSP_crl_reason_str(reason), reason);
1383   goto bad;
1384   }
1385
1386 if (!OCSP_check_validity(thisupd, nextupd, EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1387   {
1388   DEBUG(D_tls) debug_printf("OCSP status invalid times.\n");
1389   goto bad;
1390   }
1391
1392 supply_response:
1393   /* Add the resp to the list used by tls_server_stapling_cb() */
1394   {
1395   ocsp_resplist ** op = &state->u_ocsp.server.olist, * oentry;
1396   while (oentry = *op)
1397     op = &oentry->next;
1398   *op = oentry = store_get(sizeof(ocsp_resplist), FALSE);
1399   oentry->next = NULL;
1400   oentry->resp = resp;
1401   }
1402 return;
1403
1404 bad:
1405   if (f.running_in_test_harness)
1406     {
1407     extern char ** environ;
1408     if (environ) for (uschar ** p = USS environ; *p; p++)
1409       if (Ustrncmp(*p, "EXIM_TESTHARNESS_DISABLE_OCSPVALIDITYCHECK", 42) == 0)
1410         {
1411         DEBUG(D_tls) debug_printf("Supplying known bad OCSP response\n");
1412         goto supply_response;
1413         }
1414     }
1415 return;
1416 }
1417
1418
1419 static void
1420 ocsp_free_response_list(exim_openssl_state_st * cbinfo)
1421 {
1422 for (ocsp_resplist * olist = cbinfo->u_ocsp.server.olist; olist;
1423      olist = olist->next)
1424   OCSP_RESPONSE_free(olist->resp);
1425 cbinfo->u_ocsp.server.olist = NULL;
1426 }
1427 #endif  /*!DISABLE_OCSP*/
1428
1429
1430
1431
1432
1433 static int
1434 tls_add_certfile(SSL_CTX * sctx, exim_openssl_state_st * cbinfo, uschar * file,
1435   uschar ** errstr)
1436 {
1437 DEBUG(D_tls) debug_printf("tls_certificate file '%s'\n", file);
1438 if (!SSL_CTX_use_certificate_chain_file(sctx, CS file))
1439   return tls_error(string_sprintf(
1440     "SSL_CTX_use_certificate_chain_file file=%s", file),
1441       cbinfo->host, NULL, errstr);
1442 return 0;
1443 }
1444
1445 static int
1446 tls_add_pkeyfile(SSL_CTX * sctx, exim_openssl_state_st * cbinfo, uschar * file,
1447   uschar ** errstr)
1448 {
1449 DEBUG(D_tls) debug_printf("tls_privatekey file  '%s'\n", file);
1450 if (!SSL_CTX_use_PrivateKey_file(sctx, CS file, SSL_FILETYPE_PEM))
1451   return tls_error(string_sprintf(
1452     "SSL_CTX_use_PrivateKey_file file=%s", file), cbinfo->host, NULL, errstr);
1453 return 0;
1454 }
1455
1456
1457
1458
1459 /* Called once during tls_init and possibly again during TLS setup, for a
1460 new context, if Server Name Indication was used and tls_sni was seen in
1461 the certificate string.
1462
1463 Arguments:
1464   sctx            the SSL_CTX* to update
1465   state           various parts of session state
1466   errstr          error string pointer
1467
1468 Returns:          OK/DEFER/FAIL
1469 */
1470
1471 static int
1472 tls_expand_session_files(SSL_CTX * sctx, exim_openssl_state_st * state,
1473   uschar ** errstr)
1474 {
1475 uschar * expanded;
1476
1477 if (!state->certificate)
1478   {
1479   if (!state->is_server)                /* client */
1480     return OK;
1481                                         /* server */
1482   if (tls_install_selfsign(sctx, errstr) != OK)
1483     return DEFER;
1484   }
1485 else
1486   {
1487   int err;
1488
1489   if ( !reexpand_tls_files_for_sni
1490      && (  Ustrstr(state->certificate, US"tls_sni")
1491         || Ustrstr(state->certificate, US"tls_in_sni")
1492         || Ustrstr(state->certificate, US"tls_out_sni")
1493      )  )
1494     reexpand_tls_files_for_sni = TRUE;
1495
1496   if (!expand_check(state->certificate, US"tls_certificate", &expanded, errstr))
1497     return DEFER;
1498
1499   if (expanded)
1500     if (state->is_server)
1501       {
1502       const uschar * file_list = expanded;
1503       int sep = 0;
1504       uschar * file;
1505 #ifndef DISABLE_OCSP
1506       const uschar * olist = state->u_ocsp.server.file;
1507       int osep = 0;
1508       uschar * ofile;
1509       BOOL fmt_pem = FALSE;
1510
1511       if (olist)
1512         if (!expand_check(olist, US"tls_ocsp_file", USS &olist, errstr))
1513           return DEFER;
1514       if (olist && !*olist)
1515         olist = NULL;
1516
1517       if (  state->u_ocsp.server.file_expanded && olist
1518          && (Ustrcmp(olist, state->u_ocsp.server.file_expanded) == 0))
1519         {
1520         DEBUG(D_tls) debug_printf(" - value unchanged, using existing values\n");
1521         olist = NULL;
1522         }
1523       else
1524         {
1525         ocsp_free_response_list(state);
1526         state->u_ocsp.server.file_expanded = olist;
1527         }
1528 #endif
1529
1530       while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1531         {
1532         if ((err = tls_add_certfile(sctx, state, file, errstr)))
1533           return err;
1534
1535 #ifndef DISABLE_OCSP
1536         if (olist)
1537           if ((ofile = string_nextinlist(&olist, &osep, NULL, 0)))
1538             {
1539             if (Ustrncmp(ofile, US"PEM ", 4) == 0)
1540               {
1541               fmt_pem = TRUE;
1542               ofile += 4;
1543               }
1544             else if (Ustrncmp(ofile, US"DER ", 4) == 0)
1545               {
1546               fmt_pem = FALSE;
1547               ofile += 4;
1548               }
1549             ocsp_load_response(state, ofile, fmt_pem);
1550             }
1551           else
1552             DEBUG(D_tls) debug_printf("ran out of ocsp file list\n");
1553 #endif
1554         }
1555       }
1556     else        /* would there ever be a need for multiple client certs? */
1557       if ((err = tls_add_certfile(sctx, state, expanded, errstr)))
1558         return err;
1559
1560   if (  state->privatekey
1561      && !expand_check(state->privatekey, US"tls_privatekey", &expanded, errstr))
1562     return DEFER;
1563
1564   /* If expansion was forced to fail, key_expanded will be NULL. If the result
1565   of the expansion is an empty string, ignore it also, and assume the private
1566   key is in the same file as the certificate. */
1567
1568   if (expanded && *expanded)
1569     if (state->is_server)
1570       {
1571       const uschar * file_list = expanded;
1572       int sep = 0;
1573       uschar * file;
1574
1575       while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1576         if ((err = tls_add_pkeyfile(sctx, state, file, errstr)))
1577           return err;
1578       }
1579     else        /* would there ever be a need for multiple client certs? */
1580       if ((err = tls_add_pkeyfile(sctx, state, expanded, errstr)))
1581         return err;
1582   }
1583
1584 return OK;
1585 }
1586
1587
1588
1589
1590 /**************************************************
1591 * One-time init credentials for server and client *
1592 **************************************************/
1593
1594 static int
1595 server_load_ciphers(SSL_CTX * ctx, exim_openssl_state_st * state,
1596   uschar * ciphers, uschar ** errstr)
1597 {
1598 for (uschar * s = ciphers; *s; s++ ) if (*s == '_') *s = '-';
1599 DEBUG(D_tls) debug_printf("required ciphers: %s\n", ciphers);
1600 if (!SSL_CTX_set_cipher_list(ctx, CS ciphers))
1601   return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL, errstr);
1602 state->server_cipher_list = ciphers;
1603 return OK;
1604 }
1605
1606
1607
1608 static int
1609 lib_ctx_new(SSL_CTX ** ctxp, host_item * host, uschar ** errstr)
1610 {
1611 SSL_CTX * ctx;
1612 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
1613 if (!(ctx = SSL_CTX_new(host ? TLS_client_method() : TLS_server_method())))
1614 #else
1615 if (!(ctx = SSL_CTX_new(host ? SSLv23_client_method() : SSLv23_server_method())))
1616 #endif
1617   return tls_error(US"SSL_CTX_new", host, NULL, errstr);
1618
1619 /* Set up the information callback, which outputs if debugging is at a suitable
1620 level. */
1621
1622 DEBUG(D_tls)
1623   {
1624   SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
1625 #if defined(EXIM_HAVE_OPESSL_TRACE) && !defined(OPENSSL_NO_SSL_TRACE)
1626   /* this needs a debug build of OpenSSL */
1627   SSL_CTX_set_msg_callback(ctx, (void (*)())SSL_trace);
1628 #endif
1629 #ifdef OPENSSL_HAVE_KEYLOG_CB
1630   SSL_CTX_set_keylog_callback(ctx, (void (*)())keylog_callback);
1631 #endif
1632   }
1633
1634 /* Automatically re-try reads/writes after renegotiation. */
1635 (void) SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
1636 *ctxp = ctx;
1637 return OK;
1638 }
1639
1640
1641 static unsigned
1642 tls_server_creds_init(void)
1643 {
1644 SSL_CTX * ctx;
1645 uschar * dummy_errstr;
1646 unsigned lifetime = 0;
1647
1648 tls_openssl_init();
1649
1650 state_server.lib_state = null_tls_preload;
1651
1652 if (lib_ctx_new(&ctx, NULL, &dummy_errstr) != OK)
1653   return 0;
1654 state_server.lib_state.lib_ctx = ctx;
1655
1656 /* Preload DH params and EC curve */
1657
1658 if (opt_unset_or_noexpand(tls_dhparam))
1659   {
1660   DEBUG(D_tls) debug_printf("TLS: preloading DH params for server\n");
1661   if (init_dh(ctx, tls_dhparam, NULL, &dummy_errstr))
1662     state_server.lib_state.dh = TRUE;
1663   }
1664 if (opt_unset_or_noexpand(tls_eccurve))
1665   {
1666   DEBUG(D_tls) debug_printf("TLS: preloading ECDH curve for server\n");
1667   if (init_ecdh(ctx, NULL, &dummy_errstr))
1668     state_server.lib_state.ecdh = TRUE;
1669   }
1670
1671 #if defined(EXIM_HAVE_INOTIFY) || defined(EXIM_HAVE_KEVENT)
1672 /* If we can, preload the server-side cert, key and ocsp */
1673
1674 if (  opt_set_and_noexpand(tls_certificate)
1675 # ifndef DISABLE_OCSP
1676    && opt_unset_or_noexpand(tls_ocsp_file)
1677 #endif
1678    && opt_unset_or_noexpand(tls_privatekey))
1679   {
1680   /* Set watches on the filenames.  The implementation does de-duplication
1681   so we can just blindly do them all.  */
1682
1683   if (  tls_set_watch(tls_certificate, TRUE)
1684 # ifndef DISABLE_OCSP
1685      && tls_set_watch(tls_ocsp_file, TRUE)
1686 #endif
1687      && tls_set_watch(tls_privatekey, TRUE))
1688     {
1689     state_server.certificate = tls_certificate;
1690     state_server.privatekey = tls_privatekey;
1691 #ifndef DISABLE_OCSP
1692     state_server.u_ocsp.server.file = tls_ocsp_file;
1693 #endif
1694
1695     DEBUG(D_tls) debug_printf("TLS: preloading server certs\n");
1696     if (tls_expand_session_files(ctx, &state_server, &dummy_errstr) == OK)
1697       state_server.lib_state.conn_certs = TRUE;
1698     }
1699   }
1700 else if (  !tls_certificate && !tls_privatekey
1701 # ifndef DISABLE_OCSP
1702         && !tls_ocsp_file
1703 #endif
1704    )
1705   {             /* Generate & preload a selfsigned cert. No files to watch. */
1706   if (tls_expand_session_files(ctx, &state_server, &dummy_errstr) == OK)
1707     {
1708     state_server.lib_state.conn_certs = TRUE;
1709     lifetime = f.running_in_test_harness ? 2 : 60 * 60;         /* 1 hour */
1710     }
1711   }
1712 else
1713   DEBUG(D_tls) debug_printf("TLS: not preloading server certs\n");
1714
1715
1716 /* If we can, preload the Authorities for checking client certs against.
1717 Actual choice to do verify is made (tls_{,try_}verify_hosts)
1718 at TLS conn startup */
1719
1720 if (  opt_set_and_noexpand(tls_verify_certificates)
1721    && opt_unset_or_noexpand(tls_crl))
1722   {
1723   /* Watch the default dir also as they are always included */
1724
1725   if (  tls_set_watch(CUS X509_get_default_cert_file(), FALSE)
1726      && tls_set_watch(tls_verify_certificates, FALSE)
1727      && tls_set_watch(tls_crl, FALSE))
1728     {
1729     DEBUG(D_tls) debug_printf("TLS: preloading CA bundle for server\n");
1730
1731     if (setup_certs(ctx, tls_verify_certificates, tls_crl, NULL, &dummy_errstr)
1732         == OK)
1733       state_server.lib_state.cabundle = TRUE;
1734     }
1735   }
1736 else
1737   DEBUG(D_tls) debug_printf("TLS: not preloading CA bundle for server\n");
1738 #endif  /* EXIM_HAVE_INOTIFY */
1739
1740
1741 /* If we can, preload the ciphers control string */
1742
1743 if (opt_set_and_noexpand(tls_require_ciphers))
1744   {
1745   DEBUG(D_tls) debug_printf("TLS: preloading cipher list for server\n");
1746   if (server_load_ciphers(ctx, &state_server, tls_require_ciphers,
1747                           &dummy_errstr) == OK)
1748     state_server.lib_state.pri_string = TRUE;
1749   }
1750 else
1751   DEBUG(D_tls) debug_printf("TLS: not preloading cipher list for server\n");
1752 return lifetime;
1753 }
1754
1755
1756
1757
1758 /* Preload whatever creds are static, onto a transport.  The client can then
1759 just copy the pointer as it starts up.
1760 Called from the daemon after a cache-invalidate with watch set; called from
1761 a queue-run startup with watch clear. */
1762
1763 static void
1764 tls_client_creds_init(transport_instance * t, BOOL watch)
1765 {
1766 smtp_transport_options_block * ob = t->options_block;
1767 exim_openssl_state_st tpt_dummy_state;
1768 host_item * dummy_host = (host_item *)1;
1769 uschar * dummy_errstr;
1770 SSL_CTX * ctx;
1771
1772 tls_openssl_init();
1773
1774 ob->tls_preload = null_tls_preload;
1775 if (lib_ctx_new(&ctx, dummy_host, &dummy_errstr) != OK)
1776   return;
1777 ob->tls_preload.lib_ctx = ctx;
1778
1779 tpt_dummy_state.lib_state = ob->tls_preload;
1780
1781 if (opt_unset_or_noexpand(tls_dhparam))
1782   {
1783   DEBUG(D_tls) debug_printf("TLS: preloading DH params for transport '%s'\n", t->name);
1784   if (init_dh(ctx, tls_dhparam, NULL, &dummy_errstr))
1785     ob->tls_preload.dh = TRUE;
1786   }
1787 if (opt_unset_or_noexpand(tls_eccurve))
1788   {
1789   DEBUG(D_tls) debug_printf("TLS: preloading ECDH curve for transport '%s'\n", t->name);
1790   if (init_ecdh(ctx, NULL, &dummy_errstr))
1791     ob->tls_preload.ecdh = TRUE;
1792   }
1793
1794 #if defined(EXIM_HAVE_INOTIFY) || defined(EXIM_HAVE_KEVENT)
1795 if (  opt_set_and_noexpand(ob->tls_certificate)
1796    && opt_unset_or_noexpand(ob->tls_privatekey))
1797   {
1798   if (  !watch
1799      || (  tls_set_watch(ob->tls_certificate, FALSE)
1800         && tls_set_watch(ob->tls_privatekey, FALSE)
1801      )  )
1802     {
1803     uschar * pkey = ob->tls_privatekey;
1804
1805     DEBUG(D_tls)
1806       debug_printf("TLS: preloading client certs for transport '%s'\n",t->name);
1807
1808     if (  tls_add_certfile(ctx, &tpt_dummy_state, ob->tls_certificate,
1809                                     &dummy_errstr) == 0
1810        && tls_add_pkeyfile(ctx, &tpt_dummy_state,
1811                                     pkey ? pkey : ob->tls_certificate,
1812                                     &dummy_errstr) == 0
1813        )
1814       ob->tls_preload.conn_certs = TRUE;
1815     }
1816   }
1817 else
1818   DEBUG(D_tls)
1819     debug_printf("TLS: not preloading client certs, for transport '%s'\n", t->name);
1820
1821
1822 if (  opt_set_and_noexpand(ob->tls_verify_certificates)
1823    && opt_unset_or_noexpand(ob->tls_crl))
1824   {
1825   if (  !watch
1826      ||    tls_set_watch(CUS X509_get_default_cert_file(), FALSE)
1827         && tls_set_watch(ob->tls_verify_certificates, FALSE)
1828         && tls_set_watch(ob->tls_crl, FALSE)
1829      )
1830     {
1831     DEBUG(D_tls)
1832       debug_printf("TLS: preloading CA bundle for transport '%s'\n", t->name);
1833
1834     if (setup_certs(ctx, ob->tls_verify_certificates,
1835           ob->tls_crl, dummy_host, &dummy_errstr) == OK)
1836       ob->tls_preload.cabundle = TRUE;
1837     }
1838   }
1839 else
1840   DEBUG(D_tls)
1841       debug_printf("TLS: not preloading CA bundle, for transport '%s'\n", t->name);
1842
1843 #endif /*EXIM_HAVE_INOTIFY*/
1844 }
1845
1846
1847 #if defined(EXIM_HAVE_INOTIFY) || defined(EXIM_HAVE_KEVENT)
1848 /* Invalidate the creds cached, by dropping the current ones.
1849 Call when we notice one of the source files has changed. */
1850  
1851 static void
1852 tls_server_creds_invalidate(void)
1853 {
1854 SSL_CTX_free(state_server.lib_state.lib_ctx);
1855 state_server.lib_state = null_tls_preload;
1856 }
1857
1858
1859 static void
1860 tls_client_creds_invalidate(transport_instance * t)
1861 {
1862 smtp_transport_options_block * ob = t->options_block;
1863 SSL_CTX_free(ob->tls_preload.lib_ctx);
1864 ob->tls_preload = null_tls_preload;
1865 }
1866
1867 #else
1868
1869 static void
1870 tls_server_creds_invalidate(void)
1871 { return; }
1872
1873 static void
1874 tls_client_creds_invalidate(transport_instance * t)
1875 { return; }
1876
1877 #endif  /*EXIM_HAVE_INOTIFY*/
1878
1879
1880 /* Extreme debug
1881 #ifndef DISABLE_OCSP
1882 void
1883 x509_store_dump_cert_s_names(X509_STORE * store)
1884 {
1885 STACK_OF(X509_OBJECT) * roots= store->objs;
1886 static uschar name[256];
1887
1888 for (int i= 0; i < sk_X509_OBJECT_num(roots); i++)
1889   {
1890   X509_OBJECT * tmp_obj= sk_X509_OBJECT_value(roots, i);
1891   if(tmp_obj->type == X509_LU_X509)
1892     {
1893     X509_NAME * sn = X509_get_subject_name(tmp_obj->data.x509);
1894     if (X509_NAME_oneline(sn, CS name, sizeof(name)))
1895       {
1896       name[sizeof(name)-1] = '\0';
1897       debug_printf(" %s\n", name);
1898       }
1899     }
1900   }
1901 }
1902 #endif
1903 */
1904
1905
1906 #ifndef DISABLE_TLS_RESUME
1907 /* Manage the keysets used for encrypting the session tickets, on the server. */
1908
1909 typedef struct {                        /* Session ticket encryption key */
1910   uschar        name[16];
1911
1912   const EVP_CIPHER *    aes_cipher;
1913   uschar                aes_key[32];    /* size needed depends on cipher. aes_128 implies 128/8 = 16? */
1914   const EVP_MD *        hmac_hash;
1915   uschar                hmac_key[16];
1916   time_t                renew;
1917   time_t                expire;
1918 } exim_stek;
1919
1920 static exim_stek exim_tk;       /* current key */
1921 static exim_stek exim_tk_old;   /* previous key */
1922
1923 static void
1924 tk_init(void)
1925 {
1926 time_t t = time(NULL);
1927
1928 if (exim_tk.name[0])
1929   {
1930   if (exim_tk.renew >= t) return;
1931   exim_tk_old = exim_tk;
1932   }
1933
1934 if (f.running_in_test_harness) ssl_session_timeout = 6;
1935
1936 DEBUG(D_tls) debug_printf("OpenSSL: %s STEK\n", exim_tk.name[0] ? "rotating" : "creating");
1937 if (RAND_bytes(exim_tk.aes_key, sizeof(exim_tk.aes_key)) <= 0) return;
1938 if (RAND_bytes(exim_tk.hmac_key, sizeof(exim_tk.hmac_key)) <= 0) return;
1939 if (RAND_bytes(exim_tk.name+1, sizeof(exim_tk.name)-1) <= 0) return;
1940
1941 exim_tk.name[0] = 'E';
1942 exim_tk.aes_cipher = EVP_aes_256_cbc();
1943 exim_tk.hmac_hash = EVP_sha256();
1944 exim_tk.expire = t + ssl_session_timeout;
1945 exim_tk.renew = t + ssl_session_timeout/2;
1946 }
1947
1948 static exim_stek *
1949 tk_current(void)
1950 {
1951 if (!exim_tk.name[0]) return NULL;
1952 return &exim_tk;
1953 }
1954
1955 static exim_stek *
1956 tk_find(const uschar * name)
1957 {
1958 return memcmp(name, exim_tk.name, sizeof(exim_tk.name)) == 0 ? &exim_tk
1959   : memcmp(name, exim_tk_old.name, sizeof(exim_tk_old.name)) == 0 ? &exim_tk_old
1960   : NULL;
1961 }
1962
1963 /* Callback for session tickets, on server */
1964 static int
1965 ticket_key_callback(SSL * ssl, uschar key_name[16],
1966   uschar * iv, EVP_CIPHER_CTX * c_ctx, HMAC_CTX * hctx, int enc)
1967 {
1968 tls_support * tlsp = state_server.tlsp;
1969 exim_stek * key;
1970
1971 if (enc)
1972   {
1973   DEBUG(D_tls) debug_printf("ticket_key_callback: create new session\n");
1974   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
1975
1976   if (RAND_bytes(iv, EVP_MAX_IV_LENGTH) <= 0)
1977     return -1; /* insufficient random */
1978
1979   if (!(key = tk_current()))    /* current key doesn't exist or isn't valid */
1980      return 0;                  /* key couldn't be created */
1981   memcpy(key_name, key->name, 16);
1982   DEBUG(D_tls) debug_printf("STEK expire " TIME_T_FMT "\n", key->expire - time(NULL));
1983
1984   /*XXX will want these dependent on the ssl session strength */
1985   HMAC_Init_ex(hctx, key->hmac_key, sizeof(key->hmac_key),
1986                 key->hmac_hash, NULL);
1987   EVP_EncryptInit_ex(c_ctx, key->aes_cipher, NULL, key->aes_key, iv);
1988
1989   DEBUG(D_tls) debug_printf("ticket created\n");
1990   return 1;
1991   }
1992 else
1993   {
1994   time_t now = time(NULL);
1995
1996   DEBUG(D_tls) debug_printf("ticket_key_callback: retrieve session\n");
1997   tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
1998
1999   if (!(key = tk_find(key_name)) || key->expire < now)
2000     {
2001     DEBUG(D_tls)
2002       {
2003       debug_printf("ticket not usable (%s)\n", key ? "expired" : "not found");
2004       if (key) debug_printf("STEK expire " TIME_T_FMT "\n", key->expire - now);
2005       }
2006     return 0;
2007     }
2008
2009   HMAC_Init_ex(hctx, key->hmac_key, sizeof(key->hmac_key),
2010                 key->hmac_hash, NULL);
2011   EVP_DecryptInit_ex(c_ctx, key->aes_cipher, NULL, key->aes_key, iv);
2012
2013   DEBUG(D_tls) debug_printf("ticket usable, STEK expire " TIME_T_FMT "\n", key->expire - now);
2014
2015   /* The ticket lifetime and renewal are the same as the STEK lifetime and
2016   renewal, which is overenthusiastic.  A factor of, say, 3x longer STEK would
2017   be better.  To do that we'd have to encode ticket lifetime in the name as
2018   we don't yet see the restored session.  Could check posthandshake for TLS1.3
2019   and trigger a new ticket then, but cannot do that for TLS1.2 */
2020   return key->renew < now ? 2 : 1;
2021   }
2022 }
2023 #endif
2024
2025
2026
2027 static void
2028 setup_cert_verify(SSL_CTX * ctx, BOOL optional,
2029     int (*cert_vfy_cb)(int, X509_STORE_CTX *))
2030 {
2031 /* If verification is optional, don't fail if no certificate */
2032
2033 SSL_CTX_set_verify(ctx,
2034     SSL_VERIFY_PEER | (optional ? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
2035     cert_vfy_cb);
2036 }
2037
2038
2039 /*************************************************
2040 *            Callback to handle SNI              *
2041 *************************************************/
2042
2043 /* Called when acting as server during the TLS session setup if a Server Name
2044 Indication extension was sent by the client.
2045
2046 API documentation is OpenSSL s_server.c implementation.
2047
2048 Arguments:
2049   s               SSL* of the current session
2050   ad              unknown (part of OpenSSL API) (unused)
2051   arg             Callback of "our" registered data
2052
2053 Returns:          SSL_TLSEXT_ERR_{OK,ALERT_WARNING,ALERT_FATAL,NOACK}
2054
2055 XXX might need to change to using ClientHello callback,
2056 per https://www.openssl.org/docs/manmaster/man3/SSL_client_hello_cb_fn.html
2057 */
2058
2059 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2060 static int
2061 tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg)
2062 {
2063 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
2064 exim_openssl_state_st *state = (exim_openssl_state_st *) arg;
2065 int rc;
2066 int old_pool = store_pool;
2067 uschar * dummy_errstr;
2068
2069 if (!servername)
2070   return SSL_TLSEXT_ERR_OK;
2071
2072 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", servername,
2073     reexpand_tls_files_for_sni ? "" : " (unused for certificate selection)");
2074
2075 /* Make the extension value available for expansion */
2076 store_pool = POOL_PERM;
2077 tls_in.sni = string_copy_taint(US servername, TRUE);
2078 store_pool = old_pool;
2079
2080 if (!reexpand_tls_files_for_sni)
2081   return SSL_TLSEXT_ERR_OK;
2082
2083 /* Can't find an SSL_CTX_clone() or equivalent, so we do it manually;
2084 not confident that memcpy wouldn't break some internal reference counting.
2085 Especially since there's a references struct member, which would be off. */
2086
2087 if (lib_ctx_new(&server_sni, NULL, &dummy_errstr) != OK)
2088   goto bad;
2089
2090 /* Not sure how many of these are actually needed, since SSL object
2091 already exists.  Might even need this selfsame callback, for reneg? */
2092
2093   {
2094   SSL_CTX * ctx = state_server.lib_state.lib_ctx;
2095   SSL_CTX_set_info_callback(server_sni, SSL_CTX_get_info_callback(ctx));
2096   SSL_CTX_set_mode(server_sni, SSL_CTX_get_mode(ctx));
2097   SSL_CTX_set_options(server_sni, SSL_CTX_get_options(ctx));
2098   SSL_CTX_set_timeout(server_sni, SSL_CTX_get_timeout(ctx));
2099   SSL_CTX_set_tlsext_servername_callback(server_sni, tls_servername_cb);
2100   SSL_CTX_set_tlsext_servername_arg(server_sni, state);
2101   }
2102
2103 if (  !init_dh(server_sni, state->dhparam, NULL, &dummy_errstr)
2104    || !init_ecdh(server_sni, NULL, &dummy_errstr)
2105    )
2106   goto bad;
2107
2108 if (  state->server_cipher_list
2109    && !SSL_CTX_set_cipher_list(server_sni, CS state->server_cipher_list))
2110   goto bad;
2111
2112 #ifndef DISABLE_OCSP
2113 if (state->u_ocsp.server.file)
2114   {
2115   SSL_CTX_set_tlsext_status_cb(server_sni, tls_server_stapling_cb);
2116   SSL_CTX_set_tlsext_status_arg(server_sni, state);
2117   }
2118 #endif
2119
2120   {
2121   uschar * expcerts;
2122   if (  !expand_check(tls_verify_certificates, US"tls_verify_certificates",
2123                   &expcerts, &dummy_errstr)
2124      || (rc = setup_certs(server_sni, expcerts, tls_crl, NULL,
2125                         &dummy_errstr)) != OK)
2126     goto bad;
2127
2128   if (expcerts && *expcerts)
2129     setup_cert_verify(server_sni, FALSE, verify_callback_server);
2130   }
2131
2132 /* do this after setup_certs, because this can require the certs for verifying
2133 OCSP information. */
2134 if ((rc = tls_expand_session_files(server_sni, state, &dummy_errstr)) != OK)
2135   goto bad;
2136
2137 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
2138 SSL_set_SSL_CTX(s, server_sni);
2139 return SSL_TLSEXT_ERR_OK;
2140
2141 bad: return SSL_TLSEXT_ERR_ALERT_FATAL;
2142 }
2143 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
2144
2145
2146
2147
2148 #ifdef EXIM_HAVE_ALPN
2149 /*************************************************
2150 *        Callback to handle ALPN                 *
2151 *************************************************/
2152
2153 /* Called on server if tls_alpn nonblank after expansion,
2154 when client offers ALPN, after the SNI callback.
2155 If set and not matching the list then we dump the connection */
2156
2157 static int
2158 tls_server_alpn_cb(SSL *ssl, const uschar ** out, uschar * outlen,
2159   const uschar * in, unsigned int inlen, void * arg)
2160 {
2161 server_seen_alpn = TRUE;
2162 DEBUG(D_tls)
2163   {
2164   debug_printf("Received TLS ALPN offer:");
2165   for (int pos = 0, siz; pos < inlen; pos += siz+1)
2166     {
2167     siz = in[pos];
2168     if (pos + 1 + siz > inlen) siz = inlen - pos - 1;
2169     debug_printf(" '%.*s'", siz, in + pos + 1);
2170     }
2171   debug_printf(".  Our list: '%s'\n", tls_alpn);
2172   }
2173
2174 /* Look for an acceptable ALPN */
2175
2176 if (  inlen > 1         /* at least one name */
2177    && in[0]+1 == inlen  /* filling the vector, so exactly one name */
2178    )
2179   {
2180   const uschar * list = tls_alpn;
2181   int sep = 0;
2182   for (uschar * name; name = string_nextinlist(&list, &sep, NULL, 0); )
2183     if (Ustrncmp(in+1, name, in[0]) == 0)
2184       {
2185       *out = in+1;                      /* we checked for exactly one, so can just point to it */
2186       *outlen = inlen;
2187       return SSL_TLSEXT_ERR_OK;         /* use ALPN */
2188       }
2189   }
2190
2191 /* More than one name from clilent, or name did not match our list. */
2192
2193 /* This will be fatal to the TLS conn; would be nice to kill TCP also.
2194 Maybe as an option in future; for now leave control to the config (must-tls). */
2195
2196 DEBUG(D_tls) debug_printf("TLS ALPN rejected\n");
2197 return SSL_TLSEXT_ERR_ALERT_FATAL;
2198 }
2199 #endif  /* EXIM_HAVE_ALPN */
2200
2201
2202
2203 #ifndef DISABLE_OCSP
2204
2205 /*************************************************
2206 *        Callback to handle OCSP Stapling        *
2207 *************************************************/
2208
2209 /* Called when acting as server during the TLS session setup if the client
2210 requests OCSP information with a Certificate Status Request.
2211
2212 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
2213 project.
2214
2215 */
2216
2217 static int
2218 tls_server_stapling_cb(SSL *s, void *arg)
2219 {
2220 const exim_openssl_state_st * state = arg;
2221 ocsp_resplist * olist = state->u_ocsp.server.olist;
2222 uschar * response_der;  /*XXX blob */
2223 int response_der_len;
2224
2225 DEBUG(D_tls)
2226   debug_printf("Received TLS status request (OCSP stapling); %s response list\n",
2227     olist ? "have" : "lack");
2228
2229 tls_in.ocsp = OCSP_NOT_RESP;
2230 if (!olist)
2231   return SSL_TLSEXT_ERR_NOACK;
2232
2233 #ifdef EXIM_HAVE_OPESSL_GET0_SERIAL
2234  {
2235   const X509 * cert_sent = SSL_get_certificate(s);
2236   const ASN1_INTEGER * cert_serial = X509_get0_serialNumber(cert_sent);
2237   const BIGNUM * cert_bn = ASN1_INTEGER_to_BN(cert_serial, NULL);
2238   const X509_NAME * cert_issuer = X509_get_issuer_name(cert_sent);
2239   uschar * chash;
2240   uint chash_len;
2241
2242   for (; olist; olist = olist->next)
2243     {
2244     OCSP_BASICRESP * bs = OCSP_response_get1_basic(olist->resp);
2245     const OCSP_SINGLERESP * single = OCSP_resp_get0(bs, 0);
2246     const OCSP_CERTID * cid = OCSP_SINGLERESP_get0_id(single);
2247     ASN1_INTEGER * res_cert_serial;
2248     const BIGNUM * resp_bn;
2249     ASN1_OCTET_STRING * res_cert_iNameHash;
2250
2251
2252     (void) OCSP_id_get0_info(&res_cert_iNameHash, NULL, NULL, &res_cert_serial,
2253       (OCSP_CERTID *) cid);
2254     resp_bn = ASN1_INTEGER_to_BN(res_cert_serial, NULL);
2255
2256     DEBUG(D_tls)
2257       {
2258       debug_printf("cert serial: %s\n", BN_bn2hex(cert_bn));
2259       debug_printf("resp serial: %s\n", BN_bn2hex(resp_bn));
2260       }
2261
2262     if (BN_cmp(cert_bn, resp_bn) == 0)
2263       {
2264       DEBUG(D_tls) debug_printf("matched serial for ocsp\n");
2265
2266       /*XXX TODO: check the rest of the list for duplicate matches.
2267       If any, need to also check the Issuer Name hash.
2268       Without this, we will provide the wrong status in the case of
2269       duplicate id. */
2270
2271       break;
2272       }
2273     DEBUG(D_tls) debug_printf("not match serial for ocsp\n");
2274     }
2275   if (!olist)
2276     {
2277     DEBUG(D_tls) debug_printf("failed to find match for ocsp\n");
2278     return SSL_TLSEXT_ERR_NOACK;
2279     }
2280  }
2281 #else
2282 if (olist->next)
2283   {
2284   DEBUG(D_tls) debug_printf("OpenSSL version too early to support multi-leaf OCSP\n");
2285   return SSL_TLSEXT_ERR_NOACK;
2286   }
2287 #endif
2288
2289 /*XXX could we do the i2d earlier, rather than during the callback? */
2290 response_der = NULL;
2291 response_der_len = i2d_OCSP_RESPONSE(olist->resp, &response_der);
2292 if (response_der_len <= 0)
2293   return SSL_TLSEXT_ERR_NOACK;
2294
2295 SSL_set_tlsext_status_ocsp_resp(state_server.lib_state.lib_ssl,
2296                                 response_der, response_der_len);
2297 tls_in.ocsp = OCSP_VFIED;
2298 return SSL_TLSEXT_ERR_OK;
2299 }
2300
2301
2302 static void
2303 time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
2304 {
2305 BIO_printf(bp, "\t%s: ", str);
2306 ASN1_GENERALIZEDTIME_print(bp, time);
2307 BIO_puts(bp, "\n");
2308 }
2309
2310 static int
2311 tls_client_stapling_cb(SSL *s, void *arg)
2312 {
2313 exim_openssl_state_st * cbinfo = arg;
2314 const unsigned char * p;
2315 int len;
2316 OCSP_RESPONSE * rsp;
2317 OCSP_BASICRESP * bs;
2318 int i;
2319
2320 DEBUG(D_tls) debug_printf("Received TLS status callback (OCSP stapling):\n");
2321 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
2322 if(!p)
2323  {
2324   /* Expect this when we requested ocsp but got none */
2325   if (cbinfo->u_ocsp.client.verify_required && LOGGING(tls_cipher))
2326     log_write(0, LOG_MAIN, "Required TLS certificate status not received");
2327   else
2328     DEBUG(D_tls) debug_printf(" null\n");
2329   return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
2330  }
2331
2332 if (!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
2333   {
2334   tls_out.ocsp = OCSP_FAILED;   /*XXX should use tlsp-> to permit concurrent outbound */
2335   if (LOGGING(tls_cipher))
2336     log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
2337   else
2338     DEBUG(D_tls) debug_printf(" parse error\n");
2339   return 0;
2340   }
2341
2342 if (!(bs = OCSP_response_get1_basic(rsp)))
2343   {
2344   tls_out.ocsp = OCSP_FAILED;
2345   if (LOGGING(tls_cipher))
2346     log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
2347   else
2348     DEBUG(D_tls) debug_printf(" error parsing response\n");
2349   OCSP_RESPONSE_free(rsp);
2350   return 0;
2351   }
2352
2353 /* We'd check the nonce here if we'd put one in the request. */
2354 /* However that would defeat cacheability on the server so we don't. */
2355
2356 /* This section of code reworked from OpenSSL apps source;
2357    The OpenSSL Project retains copyright:
2358    Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
2359 */
2360   {
2361     BIO * bp = NULL;
2362 #ifndef EXIM_HAVE_OCSP_RESP_COUNT
2363     STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
2364 #endif
2365
2366     DEBUG(D_tls) bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
2367
2368     /*OCSP_RESPONSE_print(bp, rsp, 0);   extreme debug: stapling content */
2369
2370     /* Use the chain that verified the server cert to verify the stapled info */
2371     /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
2372
2373     if ((i = OCSP_basic_verify(bs, cbinfo->verify_stack,
2374               cbinfo->u_ocsp.client.verify_store, OCSP_NOEXPLICIT)) <= 0)
2375       if (ERR_peek_error())
2376         {
2377         tls_out.ocsp = OCSP_FAILED;
2378         if (LOGGING(tls_cipher)) log_write(0, LOG_MAIN,
2379                 "Received TLS cert status response, itself unverifiable: %s",
2380                 ERR_reason_error_string(ERR_peek_error()));
2381         BIO_printf(bp, "OCSP response verify failure\n");
2382         ERR_print_errors(bp);
2383         OCSP_RESPONSE_print(bp, rsp, 0);
2384         goto failed;
2385         }
2386       else
2387         DEBUG(D_tls) debug_printf("no explicit trust for OCSP signing"
2388           " in the root CA certificate; ignoring\n");
2389
2390     DEBUG(D_tls) debug_printf("OCSP response well-formed and signed OK\n");
2391
2392     /*XXX So we have a good stapled OCSP status.  How do we know
2393     it is for the cert of interest?  OpenSSL 1.1.0 has a routine
2394     OCSP_resp_find_status() which matches on a cert id, which presumably
2395     we should use. Making an id needs OCSP_cert_id_new(), which takes
2396     issuerName, issuerKey, serialNumber.  Are they all in the cert?
2397
2398     For now, carry on blindly accepting the resp. */
2399
2400     for (int idx =
2401 #ifdef EXIM_HAVE_OCSP_RESP_COUNT
2402             OCSP_resp_count(bs) - 1;
2403 #else
2404             sk_OCSP_SINGLERESP_num(sresp) - 1;
2405 #endif
2406          idx >= 0; idx--)
2407       {
2408       OCSP_SINGLERESP * single = OCSP_resp_get0(bs, idx);
2409       int status, reason;
2410       ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
2411
2412   /*XXX so I can see putting a loop in here to handle a rsp with >1 singleresp
2413   - but what happens with a GnuTLS-style input?
2414
2415   we could do with a debug label for each singleresp
2416   - it has a certID with a serialNumber, but I see no API to get that
2417   */
2418       status = OCSP_single_get0_status(single, &reason, &rev,
2419                   &thisupd, &nextupd);
2420
2421       DEBUG(D_tls) time_print(bp, "This OCSP Update", thisupd);
2422       DEBUG(D_tls) if(nextupd) time_print(bp, "Next OCSP Update", nextupd);
2423       if (!OCSP_check_validity(thisupd, nextupd,
2424             EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
2425         {
2426         tls_out.ocsp = OCSP_FAILED;
2427         DEBUG(D_tls) ERR_print_errors(bp);
2428         log_write(0, LOG_MAIN, "Server OSCP dates invalid");
2429         goto failed;
2430         }
2431
2432       DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
2433                     OCSP_cert_status_str(status));
2434       switch(status)
2435         {
2436         case V_OCSP_CERTSTATUS_GOOD:
2437           continue;     /* the idx loop */
2438         case V_OCSP_CERTSTATUS_REVOKED:
2439           log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
2440               reason != -1 ? "; reason: " : "",
2441               reason != -1 ? OCSP_crl_reason_str(reason) : "");
2442           DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
2443           break;
2444         default:
2445           log_write(0, LOG_MAIN,
2446               "Server certificate status unknown, in OCSP stapling");
2447           break;
2448         }
2449
2450       goto failed;
2451       }
2452
2453     i = 1;
2454     tls_out.ocsp = OCSP_VFIED;
2455     goto good;
2456
2457   failed:
2458     tls_out.ocsp = OCSP_FAILED;
2459     i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
2460   good:
2461     BIO_free(bp);
2462   }
2463
2464 OCSP_RESPONSE_free(rsp);
2465 return i;
2466 }
2467 #endif  /*!DISABLE_OCSP*/
2468
2469
2470 /*************************************************
2471 *            Initialize for TLS                  *
2472 *************************************************/
2473 /* Called from both server and client code, to do preliminary initialization
2474 of the library.  We allocate and return a context structure.
2475
2476 Arguments:
2477   host            connected host, if client; NULL if server
2478   ob              transport options block, if client; NULL if server
2479   ocsp_file       file of stapling info (server); flag for require ocsp (client)
2480   addr            address if client; NULL if server (for some randomness)
2481   caller_state    place to put pointer to allocated state-struct
2482   errstr          error string pointer
2483
2484 Returns:          OK/DEFER/FAIL
2485 */
2486
2487 static int
2488 tls_init(host_item * host, smtp_transport_options_block * ob,
2489 #ifndef DISABLE_OCSP
2490   uschar *ocsp_file,
2491 #endif
2492   address_item *addr, exim_openssl_state_st ** caller_state,
2493   tls_support * tlsp,
2494   uschar ** errstr)
2495 {
2496 SSL_CTX * ctx;
2497 exim_openssl_state_st * state;
2498 int rc;
2499
2500 if (host)                       /* client */
2501   {
2502   state = store_malloc(sizeof(exim_openssl_state_st));
2503   memset(state, 0, sizeof(*state));
2504   state->certificate = ob->tls_certificate;
2505   state->privatekey =  ob->tls_privatekey;
2506   state->is_server = FALSE;
2507   state->dhparam = NULL;
2508   state->lib_state = ob->tls_preload;
2509   }
2510 else                            /* server */
2511   {
2512   state = &state_server;
2513   state->certificate = tls_certificate;
2514   state->privatekey =  tls_privatekey;
2515   state->is_server = TRUE;
2516   state->dhparam = tls_dhparam;
2517   state->lib_state = state_server.lib_state;
2518   }
2519
2520 state->tlsp = tlsp;
2521 state->host = host;
2522
2523 if (!state->lib_state.pri_string)
2524   state->server_cipher_list = NULL;
2525
2526 #ifndef DISABLE_EVENT
2527 state->event_action = NULL;
2528 #endif
2529
2530 tls_openssl_init();
2531
2532 /* It turns out that we need to seed the random number generator this early in
2533 order to get the full complement of ciphers to work. It took me roughly a day
2534 of work to discover this by experiment.
2535
2536 On systems that have /dev/urandom, SSL may automatically seed itself from
2537 there. Otherwise, we have to make something up as best we can. Double check
2538 afterwards.
2539
2540 Although we likely called this before, at daemon startup, this is a chance
2541 to mix in further variable info (time, pid) if needed. */
2542
2543 if (!lib_rand_init(addr))
2544   return tls_error(US"RAND_status", host,
2545     US"unable to seed random number generator", errstr);
2546
2547 /* Apply administrator-supplied work-arounds.
2548 Historically we applied just one requested option,
2549 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
2550 moved to an administrator-controlled list of options to specify and
2551 grandfathered in the first one as the default value for "openssl_options".
2552
2553 No OpenSSL version number checks: the options we accept depend upon the
2554 availability of the option value macros from OpenSSL.  */
2555
2556 if (!init_options)
2557   if (!tls_openssl_options_parse(openssl_options, &init_options))
2558     return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
2559
2560 /* Create a context.
2561 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
2562 negotiation in the different methods; as far as I can tell, the only
2563 *_{server,client}_method which allows negotiation is SSLv23, which exists even
2564 when OpenSSL is built without SSLv2 support.
2565 By disabling with openssl_options, we can let admins re-enable with the
2566 existing knob. */
2567
2568 if (!(ctx = state->lib_state.lib_ctx))
2569   {
2570   if ((rc = lib_ctx_new(&ctx, host, errstr)) != OK)
2571     return rc;
2572   state->lib_state.lib_ctx = ctx;
2573   }
2574
2575 #ifndef DISABLE_TLS_RESUME
2576 tlsp->resumption = RESUME_SUPPORTED;
2577 #endif
2578 if (init_options)
2579   {
2580 #ifndef DISABLE_TLS_RESUME
2581   /* Should the server offer session resumption? */
2582   if (!host && verify_check_host(&tls_resumption_hosts) == OK)
2583     {
2584     DEBUG(D_tls) debug_printf("tls_resumption_hosts overrides openssl_options\n");
2585     init_options &= ~SSL_OP_NO_TICKET;
2586     tlsp->resumption |= RESUME_SERVER_TICKET; /* server will give ticket on request */
2587     tlsp->host_resumable = TRUE;
2588     }
2589 #endif
2590
2591   DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
2592   if (!(SSL_CTX_set_options(ctx, init_options)))
2593     return tls_error(string_sprintf(
2594           "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
2595   }
2596 else
2597   DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
2598
2599 /* We'd like to disable session cache unconditionally, but foolish Outlook
2600 Express clients then give up the first TLS connection and make a second one
2601 (which works).  Only when there is an IMAP service on the same machine.
2602 Presumably OE is trying to use the cache for A on B.  Leave it enabled for
2603 now, until we work out a decent way of presenting control to the config.  It
2604 will never be used because we use a new context every time. */
2605 #ifdef notdef
2606 (void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
2607 #endif
2608
2609 /* Initialize with DH parameters if supplied */
2610 /* Initialize ECDH temp key parameter selection */
2611
2612 if (state->lib_state.dh)
2613   { DEBUG(D_tls) debug_printf("TLS: DH params were preloaded\n"); }
2614 else
2615   if (!init_dh(ctx, state->dhparam, host, errstr)) return DEFER;
2616
2617 if (state->lib_state.ecdh)
2618   { DEBUG(D_tls) debug_printf("TLS: ECDH curve was preloaded\n"); }
2619 else
2620   if (!init_ecdh(ctx, host, errstr)) return DEFER;
2621
2622 /* Set up certificate and key (and perhaps OCSP info) */
2623
2624 if (state->lib_state.conn_certs)
2625   {
2626   DEBUG(D_tls)
2627     debug_printf("TLS: %s certs were preloaded\n", host ? "client":"server");
2628   }
2629 else
2630   {
2631 #ifndef DISABLE_OCSP
2632   if (!host)
2633     {
2634     state->u_ocsp.server.file = ocsp_file;
2635     state->u_ocsp.server.file_expanded = NULL;
2636     state->u_ocsp.server.olist = NULL;
2637     }
2638 #endif
2639   if ((rc = tls_expand_session_files(ctx, state, errstr)) != OK) return rc;
2640   }
2641
2642 /* If we need to handle SNI or OCSP, do so */
2643
2644 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2645 # ifndef DISABLE_OCSP
2646   if (!(state->verify_stack = sk_X509_new_null()))
2647     {
2648     DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
2649     return FAIL;
2650     }
2651 # endif
2652
2653 if (!host)              /* server */
2654   {
2655 # ifndef DISABLE_OCSP
2656   /* We check u_ocsp.server.file, not server.olist, because we care about if
2657   the option exists, not what the current expansion might be, as SNI might
2658   change the certificate and OCSP file in use between now and the time the
2659   callback is invoked. */
2660   if (state->u_ocsp.server.file)
2661     {
2662     SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
2663     SSL_CTX_set_tlsext_status_arg(ctx, state);
2664     }
2665 # endif
2666   /* We always do this, so that $tls_sni is available even if not used in
2667   tls_certificate */
2668   SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
2669   SSL_CTX_set_tlsext_servername_arg(ctx, state);
2670
2671 # ifdef EXIM_HAVE_ALPN
2672   if (tls_alpn && *tls_alpn)
2673     {
2674     uschar * exp_alpn;
2675     if (  expand_check(tls_alpn, US"tls_alpn", &exp_alpn, errstr)
2676        && *exp_alpn && !isblank(*exp_alpn))
2677       {
2678       tls_alpn = exp_alpn;      /* subprocess so ok to overwrite */
2679       SSL_CTX_set_alpn_select_cb(ctx, tls_server_alpn_cb, state);
2680       }
2681     else
2682       tls_alpn = NULL;
2683     }
2684 # endif
2685   }
2686 # ifndef DISABLE_OCSP
2687 else                    /* client */
2688   if(ocsp_file)         /* wanting stapling */
2689     {
2690     if (!(state->u_ocsp.client.verify_store = X509_STORE_new()))
2691       {
2692       DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
2693       return FAIL;
2694       }
2695     SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
2696     SSL_CTX_set_tlsext_status_arg(ctx, state);
2697     }
2698 # endif
2699 #endif
2700
2701 state->verify_cert_hostnames = NULL;
2702
2703 #ifdef EXIM_HAVE_EPHEM_RSA_KEX
2704 /* Set up the RSA callback */
2705 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
2706 #endif
2707
2708 /* Finally, set the session cache timeout, and we are done.
2709 The period appears to be also used for (server-generated) session tickets */
2710
2711 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
2712 DEBUG(D_tls) debug_printf("Initialized TLS\n");
2713
2714 *caller_state = state;
2715
2716 return OK;
2717 }
2718
2719
2720
2721
2722 /*************************************************
2723 *           Get name of cipher in use            *
2724 *************************************************/
2725
2726 /*
2727 Argument:   pointer to an SSL structure for the connection
2728             pointer to number of bits for cipher
2729 Returns:    pointer to allocated string in perm-pool
2730 */
2731
2732 static uschar *
2733 construct_cipher_name(SSL * ssl, const uschar * ver, int * bits)
2734 {
2735 int pool = store_pool;
2736 /* With OpenSSL 1.0.0a, 'c' needs to be const but the documentation doesn't
2737 yet reflect that.  It should be a safe change anyway, even 0.9.8 versions have
2738 the accessor functions use const in the prototype. */
2739
2740 const SSL_CIPHER * c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
2741 uschar * s;
2742
2743 SSL_CIPHER_get_bits(c, bits);
2744
2745 store_pool = POOL_PERM;
2746 s = string_sprintf("%s:%s:%u", ver, SSL_CIPHER_get_name(c), *bits);
2747 store_pool = pool;
2748 DEBUG(D_tls) debug_printf("Cipher: %s\n", s);
2749 return s;
2750 }
2751
2752
2753 /* Get IETF-standard name for ciphersuite.
2754 Argument:   pointer to an SSL structure for the connection
2755 Returns:    pointer to string
2756 */
2757
2758 static const uschar *
2759 cipher_stdname_ssl(SSL * ssl)
2760 {
2761 #ifdef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
2762 return CUS SSL_CIPHER_standard_name(SSL_get_current_cipher(ssl));
2763 #else
2764 ushort id = 0xffff & SSL_CIPHER_get_id(SSL_get_current_cipher(ssl));
2765 return cipher_stdname(id >> 8, id & 0xff);
2766 #endif
2767 }
2768
2769
2770 static const uschar *
2771 tlsver_name(SSL * ssl)
2772 {
2773 uschar * s, * p;
2774 int pool = store_pool;
2775
2776 store_pool = POOL_PERM;
2777 s = string_copy(US SSL_get_version(ssl));
2778 store_pool = pool;
2779 if ((p = Ustrchr(s, 'v')))      /* TLSv1.2 -> TLS1.2 */
2780   for (;; p++) if (!(*p = p[1])) break;
2781 return CUS s;
2782 }
2783
2784
2785 static void
2786 peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned siz)
2787 {
2788 /*XXX we might consider a list-of-certs variable for the cert chain.
2789 SSL_get_peer_cert_chain(SSL*).  We'd need a new variable type and support
2790 in list-handling functions, also consider the difference between the entire
2791 chain and the elements sent by the peer. */
2792
2793 tlsp->peerdn = NULL;
2794
2795 /* Will have already noted peercert on a verify fail; possibly not the leaf */
2796 if (!tlsp->peercert)
2797   tlsp->peercert = SSL_get_peer_certificate(ssl);
2798 /* Beware anonymous ciphers which lead to server_cert being NULL */
2799 if (tlsp->peercert)
2800   if (!X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, siz))
2801     { DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n"); }
2802   else
2803     {
2804     int oldpool = store_pool;
2805
2806     peerdn[siz-1] = '\0';               /* paranoia */
2807     store_pool = POOL_PERM;
2808     tlsp->peerdn = string_copy(peerdn);
2809     store_pool = oldpool;
2810
2811     /* We used to set CV in the cert-verify callbacks (either plain or dane)
2812     but they don't get called on session-resumption.  So use the official
2813     interface, which uses the resumed value.  Unfortunately this claims verified
2814     when it actually failed but we're in try-verify mode, due to us wanting the
2815     knowlege that it failed so needing to have the callback and forcing a
2816     permissive return.  If we don't force it, the TLS startup is failed.
2817     The extra bit of information is set in verify_override in the cb, stashed
2818     for resumption next to the TLS session, and used here. */
2819
2820     if (!tlsp->verify_override)
2821       tlsp->certificate_verified =
2822 #ifdef SUPPORT_DANE
2823         tlsp->dane_verified ||
2824 #endif
2825         SSL_get_verify_result(ssl) == X509_V_OK;
2826     }
2827 }
2828
2829
2830
2831
2832
2833 /*************************************************
2834 *        Set up for verifying certificates       *
2835 *************************************************/
2836
2837 #ifndef DISABLE_OCSP
2838 /* Load certs from file, return TRUE on success */
2839
2840 static BOOL
2841 chain_from_pem_file(const uschar * file, STACK_OF(X509) ** vp)
2842 {
2843 BIO * bp;
2844 STACK_OF(X509) * verify_stack = *vp;
2845
2846 if (verify_stack)
2847   while (sk_X509_num(verify_stack) > 0)
2848     X509_free(sk_X509_pop(verify_stack));
2849 else
2850   verify_stack = sk_X509_new_null();
2851
2852 if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
2853 for (X509 * x; x = PEM_read_bio_X509(bp, NULL, 0, NULL); )
2854   sk_X509_push(verify_stack, x);
2855 BIO_free(bp);
2856 *vp = verify_stack;
2857 return TRUE;
2858 }
2859 #endif
2860
2861
2862
2863 /* Called by both client and server startup; on the server possibly
2864 repeated after a Server Name Indication.
2865
2866 Arguments:
2867   sctx          SSL_CTX* to initialise
2868   certs         certs file, expanded
2869   crl           CRL file or NULL
2870   host          NULL in a server; the remote host in a client
2871   errstr        error string pointer
2872
2873 Returns:        OK/DEFER/FAIL
2874 */
2875
2876 static int
2877 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host,
2878     uschar ** errstr)
2879 {
2880 uschar *expcerts, *expcrl;
2881
2882 if (!expand_check(certs, US"tls_verify_certificates", &expcerts, errstr))
2883   return DEFER;
2884 DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
2885
2886 if (expcerts && *expcerts)
2887   {
2888   /* Tell the library to use its compiled-in location for the system default
2889   CA bundle. Then add the ones specified in the config, if any. */
2890
2891   if (!SSL_CTX_set_default_verify_paths(sctx))
2892     return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
2893
2894   if (Ustrcmp(expcerts, "system") != 0 && Ustrncmp(expcerts, "system,", 7) != 0)
2895     {
2896     struct stat statbuf;
2897
2898     if (Ustat(expcerts, &statbuf) < 0)
2899       {
2900       log_write(0, LOG_MAIN|LOG_PANIC,
2901         "failed to stat %s for certificates", expcerts);
2902       return DEFER;
2903       }
2904     else
2905       {
2906       uschar *file, *dir;
2907       if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
2908         { file = NULL; dir = expcerts; }
2909       else
2910         {
2911         STACK_OF(X509) * verify_stack =
2912 #ifndef DISABLE_OCSP
2913           !host ? state_server.verify_stack :
2914 #endif
2915           NULL;
2916         STACK_OF(X509) ** vp = &verify_stack;
2917
2918         file = expcerts; dir = NULL;
2919 #ifndef DISABLE_OCSP
2920         /* In the server if we will be offering an OCSP proof, load chain from
2921         file for verifying the OCSP proof at load time. */
2922
2923 /*XXX Glitch!   The file here is tls_verify_certs: the chain for verifying the client cert.
2924 This is inconsistent with the need to verify the OCSP proof of the server cert.
2925 */
2926         if (  !host
2927            && statbuf.st_size > 0
2928            && state_server.u_ocsp.server.file
2929            && !chain_from_pem_file(file, vp)
2930            )
2931           {
2932           log_write(0, LOG_MAIN|LOG_PANIC,
2933             "failed to load cert chain from %s", file);
2934           return DEFER;
2935           }
2936 #endif
2937         }
2938
2939       /* If a certificate file is empty, the load function fails with an
2940       unhelpful error message. If we skip it, we get the correct behaviour (no
2941       certificates are recognized, but the error message is still misleading (it
2942       says no certificate was supplied).  But this is better. */
2943
2944       if (  (!file || statbuf.st_size > 0)
2945          && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
2946           return tls_error(US"SSL_CTX_load_verify_locations",
2947                             host, NULL, errstr);
2948
2949       /* On the server load the list of CAs for which we will accept certs, for
2950       sending to the client.  This is only for the one-file
2951       tls_verify_certificates variant.
2952       If a list isn't loaded into the server, but some verify locations are set,
2953       the server end appears to make a wildcard request for client certs.
2954       Meanwhile, the client library as default behaviour *ignores* the list
2955       we send over the wire - see man SSL_CTX_set_client_cert_cb.
2956       Because of this, and that the dir variant is likely only used for
2957       the public-CA bundle (not for a private CA), not worth fixing.  */
2958
2959       if (file)
2960         {
2961         STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
2962         int i = sk_X509_NAME_num(names);
2963
2964         if (!host) SSL_CTX_set_client_CA_list(sctx, names);
2965         DEBUG(D_tls) debug_printf("Added %d additional certificate authorit%s\n",
2966                                     i, i>1 ? "ies":"y");
2967         }
2968       else
2969         DEBUG(D_tls)
2970           debug_printf("Added dir for additional certificate authorities\n");
2971       }
2972     }
2973
2974   /* Handle a certificate revocation list. */
2975
2976 #if OPENSSL_VERSION_NUMBER > 0x00907000L
2977
2978   /* This bit of code is now the version supplied by Lars Mainka. (I have
2979   merely reformatted it into the Exim code style.)
2980
2981   "From here I changed the code to add support for multiple crl's
2982   in pem format in one file or to support hashed directory entries in
2983   pem format instead of a file. This method now uses the library function
2984   X509_STORE_load_locations to add the CRL location to the SSL context.
2985   OpenSSL will then handle the verify against CA certs and CRLs by
2986   itself in the verify callback." */
2987
2988   if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
2989   if (expcrl && *expcrl)
2990     {
2991     struct stat statbufcrl;
2992     if (Ustat(expcrl, &statbufcrl) < 0)
2993       {
2994       log_write(0, LOG_MAIN|LOG_PANIC,
2995         "failed to stat %s for certificates revocation lists", expcrl);
2996       return DEFER;
2997       }
2998     else
2999       {
3000       /* is it a file or directory? */
3001       uschar *file, *dir;
3002       X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
3003       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
3004         {
3005         file = NULL;
3006         dir = expcrl;
3007         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
3008         }
3009       else
3010         {
3011         file = expcrl;
3012         dir = NULL;
3013         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
3014         }
3015       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
3016         return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
3017
3018       /* setting the flags to check against the complete crl chain */
3019
3020       X509_STORE_set_flags(cvstore,
3021         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
3022       }
3023     }
3024
3025 #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
3026   }
3027
3028 return OK;
3029 }
3030
3031
3032
3033 /*************************************************
3034 *       Start a TLS session in a server          *
3035 *************************************************/
3036 /* This is called when Exim is running as a server, after having received
3037 the STARTTLS command. It must respond to that command, and then negotiate
3038 a TLS session.
3039
3040 Arguments:
3041   errstr            pointer to error message
3042
3043 Returns:            OK on success
3044                     DEFER for errors before the start of the negotiation
3045                     FAIL for errors during the negotiation; the server can't
3046                       continue running.
3047 */
3048
3049 int
3050 tls_server_start(uschar ** errstr)
3051 {
3052 int rc;
3053 uschar * expciphers;
3054 exim_openssl_state_st * dummy_statep;
3055 SSL_CTX * ctx;
3056 SSL * ssl;
3057 static uschar peerdn[256];
3058
3059 /* Check for previous activation */
3060
3061 if (tls_in.active.sock >= 0)
3062   {
3063   tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
3064   smtp_printf("554 Already in TLS\r\n", FALSE);
3065   return FAIL;
3066   }
3067
3068 /* Initialize the SSL library. If it fails, it will already have logged
3069 the error. */
3070
3071 rc = tls_init(NULL, NULL,
3072 #ifndef DISABLE_OCSP
3073     tls_ocsp_file,
3074 #endif
3075     NULL, &dummy_statep, &tls_in, errstr);
3076 if (rc != OK) return rc;
3077 ctx = state_server.lib_state.lib_ctx;
3078
3079 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
3080 were historically separated by underscores. So that I can use either form in my
3081 tests, and also for general convenience, we turn underscores into hyphens here.
3082
3083 XXX SSL_CTX_set_cipher_list() is replaced by SSL_CTX_set_ciphersuites()
3084 for TLS 1.3 .  Since we do not call it at present we get the default list:
3085 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
3086 */
3087
3088 if (state_server.lib_state.pri_string)
3089   { DEBUG(D_tls) debug_printf("TLS: cipher list was preloaded\n"); }
3090 else 
3091   {
3092   if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
3093     return FAIL;
3094
3095   if (  expciphers
3096      && (rc = server_load_ciphers(ctx, &state_server, expciphers, errstr)) != OK)
3097     return rc;
3098   }
3099
3100 /* If this is a host for which certificate verification is mandatory or
3101 optional, set up appropriately. */
3102
3103 tls_in.certificate_verified = FALSE;
3104 #ifdef SUPPORT_DANE
3105 tls_in.dane_verified = FALSE;
3106 #endif
3107 server_verify_callback_called = FALSE;
3108
3109 if (verify_check_host(&tls_verify_hosts) == OK)
3110   server_verify_optional = FALSE;
3111 else if (verify_check_host(&tls_try_verify_hosts) == OK)
3112   server_verify_optional = TRUE;
3113 else
3114   goto skip_certs;
3115
3116   {
3117   uschar * expcerts;
3118   if (!expand_check(tls_verify_certificates, US"tls_verify_certificates",
3119                     &expcerts, errstr))
3120     return DEFER;
3121   DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
3122
3123   if (state_server.lib_state.cabundle)
3124     { DEBUG(D_tls) debug_printf("TLS: CA bundle for server was preloaded\n"); }
3125   else
3126     if ((rc = setup_certs(ctx, expcerts, tls_crl, NULL, errstr)) != OK)
3127       return rc;
3128
3129   if (expcerts && *expcerts)
3130     setup_cert_verify(ctx, server_verify_optional, verify_callback_server);
3131   }
3132 skip_certs: ;
3133
3134 #ifndef DISABLE_TLS_RESUME
3135 SSL_CTX_set_tlsext_ticket_key_cb(ctx, ticket_key_callback);
3136 /* despite working, appears to always return failure, so ignoring */
3137 #endif
3138 #ifdef OPENSSL_HAVE_NUM_TICKETS
3139 # ifndef DISABLE_TLS_RESUME
3140 SSL_CTX_set_num_tickets(ctx, tls_in.host_resumable ? 1 : 0);
3141 # else
3142 SSL_CTX_set_num_tickets(ctx, 0);        /* send no TLS1.3 stateful-tickets */
3143 # endif
3144 #endif
3145
3146
3147 /* Prepare for new connection */
3148
3149 if (!(ssl = SSL_new(ctx)))
3150   return tls_error(US"SSL_new", NULL, NULL, errstr);
3151 state_server.lib_state.lib_ssl = ssl;
3152
3153 /* Warning: we used to SSL_clear(ssl) here, it was removed.
3154  *
3155  * With the SSL_clear(), we get strange interoperability bugs with
3156  * OpenSSL 1.0.1b and TLS1.1/1.2.  It looks as though this may be a bug in
3157  * OpenSSL itself, as a clear should not lead to inability to follow protocols.
3158  *
3159  * The SSL_clear() call is to let an existing SSL* be reused, typically after
3160  * session shutdown.  In this case, we have a brand new object and there's no
3161  * obvious reason to immediately clear it.  I'm guessing that this was
3162  * originally added because of incomplete initialisation which the clear fixed,
3163  * in some historic release.
3164  */
3165
3166 /* Set context and tell client to go ahead, except in the case of TLS startup
3167 on connection, where outputting anything now upsets the clients and tends to
3168 make them disconnect. We need to have an explicit fflush() here, to force out
3169 the response. Other smtp_printf() calls do not need it, because in non-TLS
3170 mode, the fflush() happens when smtp_getc() is called. */
3171
3172 SSL_set_session_id_context(ssl, sid_ctx, Ustrlen(sid_ctx));
3173 if (!tls_in.on_connect)
3174   {
3175   smtp_printf("220 TLS go ahead\r\n", FALSE);
3176   fflush(smtp_out);
3177   }
3178
3179 /* Now negotiate the TLS session. We put our own timer on it, since it seems
3180 that the OpenSSL library doesn't. */
3181
3182 SSL_set_wfd(ssl, fileno(smtp_out));
3183 SSL_set_rfd(ssl, fileno(smtp_in));
3184 SSL_set_accept_state(ssl);
3185
3186 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
3187
3188 ERR_clear_error();
3189 sigalrm_seen = FALSE;
3190 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3191 rc = SSL_accept(ssl);
3192 ALARM_CLR(0);
3193
3194 if (rc <= 0)
3195   {
3196   int error = SSL_get_error(ssl, rc);
3197   switch(error)
3198     {
3199     case SSL_ERROR_NONE:
3200       break;
3201
3202     case SSL_ERROR_ZERO_RETURN:
3203       DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3204       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
3205
3206       if (SSL_get_shutdown(ssl) == SSL_RECEIVED_SHUTDOWN)
3207             SSL_shutdown(ssl);
3208
3209       tls_close(NULL, TLS_NO_SHUTDOWN);
3210       return FAIL;
3211
3212     /* Handle genuine errors */
3213     case SSL_ERROR_SSL:
3214       {
3215       uschar * s = NULL;
3216       int r = ERR_GET_REASON(ERR_peek_error());
3217       if (  r == SSL_R_WRONG_VERSION_NUMBER
3218 #ifdef SSL_R_VERSION_TOO_LOW
3219          || r == SSL_R_VERSION_TOO_LOW
3220 #endif
3221          || r == SSL_R_UNKNOWN_PROTOCOL || r == SSL_R_UNSUPPORTED_PROTOCOL)
3222         s = string_sprintf("%s (%s)", s, SSL_get_version(ssl));
3223       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : s, errstr);
3224       return FAIL;
3225       }
3226
3227     default:
3228       DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
3229       if (error == SSL_ERROR_SYSCALL)
3230         {
3231         if (!errno)
3232           {
3233           *errstr = US"SSL_accept: TCP connection closed by peer";
3234           return FAIL;
3235           }
3236         DEBUG(D_tls) debug_printf(" - syscall %s\n", strerror(errno));
3237         }
3238       (void) tls_error(US"SSL_accept", NULL,
3239                       sigalrm_seen ? US"timed out"
3240                       : ERR_peek_error() ? NULL : string_sprintf("ret %d", error),
3241                       errstr);
3242       return FAIL;
3243     }
3244   }
3245
3246 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
3247 ERR_clear_error();      /* Even success can leave errors in the stack. Seen with
3248                         anon-authentication ciphersuite negotiated. */
3249
3250 #ifndef DISABLE_TLS_RESUME
3251 if (SSL_session_reused(ssl))
3252   {
3253   tls_in.resumption |= RESUME_USED;
3254   DEBUG(D_tls) debug_printf("Session reused\n");
3255   }
3256 #endif
3257
3258 #ifdef EXIM_HAVE_ALPN
3259 /* If require-alpn, check server_seen_alpn here.  Else abort TLS */
3260 if (!tls_alpn || !*tls_alpn)
3261   { DEBUG(D_tls) debug_printf("TLS: was not watching for ALPN\n"); }
3262 else if (!server_seen_alpn)
3263   if (verify_check_host(&hosts_require_alpn) == OK)
3264     {
3265     /* We'd like to send a definitive Alert but OpenSSL provides no facility */
3266     SSL_shutdown(ssl);
3267     tls_error(US"handshake", NULL, US"ALPN required but not negotiated", errstr);
3268     return FAIL;
3269     }
3270   else
3271     { DEBUG(D_tls) debug_printf("TLS: no ALPN presented in handshake\n"); }
3272 else DEBUG(D_tls)
3273   {
3274   const uschar * name;
3275   unsigned len;
3276   SSL_get0_alpn_selected(ssl, &name, &len);
3277   if (len && name)
3278     debug_printf("ALPN negotiated: '%.*s'\n", (int)*name, name+1);
3279   else
3280     debug_printf("ALPN: no protocol negotiated\n");
3281   }
3282 #endif
3283
3284
3285 /* TLS has been set up. Record data for the connection,
3286 adjust the input functions to read via TLS, and initialize things. */
3287
3288 #ifdef SSL_get_extms_support
3289 tls_in.ext_master_secret = SSL_get_extms_support(ssl) == 1;
3290 #endif
3291 peer_cert(ssl, &tls_in, peerdn, sizeof(peerdn));
3292
3293 tls_in.ver = tlsver_name(ssl);
3294 tls_in.cipher = construct_cipher_name(ssl, tls_in.ver, &tls_in.bits);
3295 tls_in.cipher_stdname = cipher_stdname_ssl(ssl);
3296
3297 DEBUG(D_tls)
3298   {
3299   uschar buf[2048];
3300   if (SSL_get_shared_ciphers(ssl, CS buf, sizeof(buf)))
3301     debug_printf("Shared ciphers: %s\n", buf);
3302
3303 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3304   {
3305   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
3306   SSL_SESSION_print_keylog(bp, SSL_get_session(ssl));
3307   BIO_free(bp);
3308   }
3309 #endif
3310
3311 #ifdef EXIM_HAVE_SESSION_TICKET
3312   {
3313   SSL_SESSION * ss = SSL_get_session(ssl);
3314   if (SSL_SESSION_has_ticket(ss))       /* 1.1.0 */
3315     debug_printf("The session has a ticket, life %lu seconds\n",
3316       SSL_SESSION_get_ticket_lifetime_hint(ss));
3317   }
3318 #endif
3319   }
3320
3321 /* Record the certificate we presented */
3322   {
3323   X509 * crt = SSL_get_certificate(ssl);
3324   tls_in.ourcert = crt ? X509_dup(crt) : NULL;
3325   }
3326
3327 /* Channel-binding info for authenticators
3328 See description in https://paquier.xyz/postgresql-2/channel-binding-openssl/ */
3329   {
3330   uschar c, * s;
3331   size_t len = SSL_get_peer_finished(ssl, &c, 0);
3332   int old_pool = store_pool;
3333
3334   SSL_get_peer_finished(ssl, s = store_get((int)len, FALSE), len);
3335   store_pool = POOL_PERM;
3336     tls_in.channelbinding = b64encode_taint(CUS s, (int)len, FALSE);
3337   store_pool = old_pool;
3338   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage %p\n", tls_in.channelbinding);
3339   }
3340
3341 /* Only used by the server-side tls (tls_in), including tls_getc.
3342    Client-side (tls_out) reads (seem to?) go via
3343    smtp_read_response()/ip_recv().
3344    Hence no need to duplicate for _in and _out.
3345  */
3346 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
3347 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
3348 ssl_xfer_eof = ssl_xfer_error = FALSE;
3349
3350 receive_getc = tls_getc;
3351 receive_getbuf = tls_getbuf;
3352 receive_get_cache = tls_get_cache;
3353 receive_hasc = tls_hasc;
3354 receive_ungetc = tls_ungetc;
3355 receive_feof = tls_feof;
3356 receive_ferror = tls_ferror;
3357 receive_smtp_buffered = tls_smtp_buffered;
3358
3359 tls_in.active.sock = fileno(smtp_out);
3360 tls_in.active.tls_ctx = NULL;   /* not using explicit ctx for server-side */
3361 return OK;
3362 }
3363
3364
3365
3366
3367 static int
3368 tls_client_basic_ctx_init(SSL_CTX * ctx,
3369     host_item * host, smtp_transport_options_block * ob, exim_openssl_state_st * state,
3370     uschar ** errstr)
3371 {
3372 int rc;
3373
3374 /* Back-compatible old behaviour if tls_verify_certificates is set but both
3375 tls_verify_hosts and tls_try_verify_hosts are not set. Check only the specified
3376 host patterns if one of them is set with content. */
3377
3378 if (  (  (  !ob->tls_verify_hosts || !ob->tls_verify_hosts
3379          || Ustrcmp(ob->tls_try_verify_hosts, ":") == 0
3380          )
3381       && (  !ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts
3382          || Ustrcmp(ob->tls_try_verify_hosts, ":") == 0
3383          )
3384       )
3385    || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
3386    )
3387   client_verify_optional = FALSE;
3388 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
3389   client_verify_optional = TRUE;
3390 else
3391   return OK;
3392
3393   {
3394   uschar * expcerts;
3395   if (!expand_check(ob->tls_verify_certificates, US"tls_verify_certificates",
3396                     &expcerts, errstr))
3397     return DEFER;
3398   DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
3399
3400   if (state->lib_state.cabundle)
3401     { DEBUG(D_tls) debug_printf("TLS: CA bundle was preloaded\n"); }
3402   else
3403     if ((rc = setup_certs(ctx, expcerts, ob->tls_crl, host, errstr)) != OK)
3404       return rc;
3405
3406   if (expcerts && *expcerts)
3407     setup_cert_verify(ctx, client_verify_optional, verify_callback_client);
3408   }
3409
3410 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
3411   {
3412   state->verify_cert_hostnames =
3413 #ifdef SUPPORT_I18N
3414     string_domain_utf8_to_alabel(host->certname, NULL);
3415 #else
3416     host->certname;
3417 #endif
3418   DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
3419                     state->verify_cert_hostnames);
3420   }
3421 return OK;
3422 }
3423
3424
3425 #ifdef SUPPORT_DANE
3426 static int
3427 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
3428 {
3429 dns_scan dnss;
3430 const char * hostnames[2] = { CS host->name, NULL };
3431 int found = 0;
3432
3433 if (DANESSL_init(ssl, NULL, hostnames) != 1)
3434   return tls_error(US"hostnames load", host, NULL, errstr);
3435
3436 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
3437      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
3438     ) if (rr->type == T_TLSA && rr->size > 3)
3439   {
3440   const uschar * p = rr->data;
3441   uint8_t usage, selector, mtype;
3442   const char * mdname;
3443
3444   usage = *p++;
3445
3446   /* Only DANE-TA(2) and DANE-EE(3) are supported */
3447   if (usage != 2 && usage != 3) continue;
3448
3449   selector = *p++;
3450   mtype = *p++;
3451
3452   switch (mtype)
3453     {
3454     default: continue;  /* Only match-types 0, 1, 2 are supported */
3455     case 0:  mdname = NULL; break;
3456     case 1:  mdname = "sha256"; break;
3457     case 2:  mdname = "sha512"; break;
3458     }
3459
3460   found++;
3461   switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
3462     {
3463     default:
3464       return tls_error(US"tlsa load", host, NULL, errstr);
3465     case 0:     /* action not taken */
3466     case 1:     break;
3467     }
3468
3469   tls_out.tlsa_usage |= 1<<usage;
3470   }
3471
3472 if (found)
3473   return OK;
3474
3475 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
3476 return DEFER;
3477 }
3478 #endif  /*SUPPORT_DANE*/
3479
3480
3481
3482 #ifndef DISABLE_TLS_RESUME
3483 /* On the client, get any stashed session for the given IP from hints db
3484 and apply it to the ssl-connection for attempted resumption. */
3485
3486 static void
3487 tls_retrieve_session(tls_support * tlsp, SSL * ssl, const uschar * key)
3488 {
3489 tlsp->resumption |= RESUME_SUPPORTED;
3490 if (tlsp->host_resumable)
3491   {
3492   dbdata_tls_session * dt;
3493   int len;
3494   open_db dbblock, * dbm_file;
3495
3496   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
3497   DEBUG(D_tls) debug_printf("checking for resumable session for %s\n", key);
3498   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3499     {
3500     /* key for the db is the IP */
3501     if ((dt = dbfn_read_with_length(dbm_file, key, &len)))
3502       {
3503       SSL_SESSION * ss = NULL;
3504       const uschar * sess_asn1 = dt->session;
3505
3506       len -= sizeof(dbdata_tls_session);
3507       if (!(d2i_SSL_SESSION(&ss, &sess_asn1, (long)len)))
3508         {
3509         DEBUG(D_tls)
3510           {
3511           ERR_error_string_n(ERR_get_error(),
3512             ssl_errstring, sizeof(ssl_errstring));
3513           debug_printf("decoding session: %s\n", ssl_errstring);
3514           }
3515         }
3516       else
3517         {
3518         unsigned long lifetime =
3519 #ifdef EXIM_HAVE_SESSION_TICKET
3520           SSL_SESSION_get_ticket_lifetime_hint(ss);
3521 #else                   /* Use, fairly arbitrilarily, what we as server would */
3522           f.running_in_test_harness ? 6 : ssl_session_timeout;
3523 #endif
3524         if (lifetime + dt->time_stamp < time(NULL))
3525           {
3526           DEBUG(D_tls) debug_printf("session expired\n");
3527           dbfn_delete(dbm_file, key);
3528           }
3529         else if (!SSL_set_session(ssl, ss))
3530           {
3531           DEBUG(D_tls)
3532             {
3533             ERR_error_string_n(ERR_get_error(),
3534               ssl_errstring, sizeof(ssl_errstring));
3535             debug_printf("applying session to ssl: %s\n", ssl_errstring);
3536             }
3537           }
3538         else
3539           {
3540           DEBUG(D_tls) debug_printf("good session\n");
3541           tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
3542           tlsp->verify_override = dt->verify_override;
3543           tlsp->ocsp = dt->ocsp;
3544           }
3545         }
3546       }
3547     else
3548       DEBUG(D_tls) debug_printf("no session record\n");
3549     dbfn_close(dbm_file);
3550     }
3551   }
3552 }
3553
3554
3555 /* On the client, save the session for later resumption */
3556
3557 static int
3558 tls_save_session_cb(SSL * ssl, SSL_SESSION * ss)
3559 {
3560 exim_openssl_state_st * cbinfo = SSL_get_ex_data(ssl, tls_exdata_idx);
3561 tls_support * tlsp;
3562
3563 DEBUG(D_tls) debug_printf("tls_save_session_cb\n");
3564
3565 if (!cbinfo || !(tlsp = cbinfo->tlsp)->host_resumable) return 0;
3566
3567 # ifdef OPENSSL_HAVE_NUM_TICKETS
3568 if (SSL_SESSION_is_resumable(ss))       /* 1.1.1 */
3569 # endif
3570   {
3571   int len = i2d_SSL_SESSION(ss, NULL);
3572   int dlen = sizeof(dbdata_tls_session) + len;
3573   dbdata_tls_session * dt = store_get(dlen, TRUE);
3574   uschar * s = dt->session;
3575   open_db dbblock, * dbm_file;
3576
3577   DEBUG(D_tls) debug_printf("session is resumable\n");
3578   tlsp->resumption |= RESUME_SERVER_TICKET;     /* server gave us a ticket */
3579
3580   dt->verify_override = tlsp->verify_override;
3581   dt->ocsp = tlsp->ocsp;
3582   (void) i2d_SSL_SESSION(ss, &s);               /* s gets bumped to end */
3583
3584   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3585     {
3586     const uschar * key = cbinfo->host->address;
3587     dbfn_delete(dbm_file, key);
3588     dbfn_write(dbm_file, key, dt, dlen);
3589     dbfn_close(dbm_file);
3590     DEBUG(D_tls) debug_printf("wrote session (len %u) to db\n",
3591                   (unsigned)dlen);
3592     }
3593   }
3594 return 1;
3595 }
3596
3597
3598 static void
3599 tls_client_ctx_resume_prehandshake(
3600   exim_openssl_client_tls_ctx * exim_client_ctx, tls_support * tlsp,
3601   smtp_transport_options_block * ob, host_item * host)
3602 {
3603 /* Should the client request a session resumption ticket? */
3604 if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
3605   {
3606   tlsp->host_resumable = TRUE;
3607
3608   SSL_CTX_set_session_cache_mode(exim_client_ctx->ctx,
3609         SSL_SESS_CACHE_CLIENT
3610         | SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_NO_AUTO_CLEAR);
3611   SSL_CTX_sess_set_new_cb(exim_client_ctx->ctx, tls_save_session_cb);
3612   }
3613 }
3614
3615 static BOOL
3616 tls_client_ssl_resume_prehandshake(SSL * ssl, tls_support * tlsp,
3617   host_item * host, uschar ** errstr)
3618 {
3619 if (tlsp->host_resumable)
3620   {
3621   DEBUG(D_tls)
3622     debug_printf("tls_resumption_hosts overrides openssl_options, enabling tickets\n");
3623   SSL_clear_options(ssl, SSL_OP_NO_TICKET);
3624
3625   tls_exdata_idx = SSL_get_ex_new_index(0, 0, 0, 0, 0);
3626   if (!SSL_set_ex_data(ssl, tls_exdata_idx, client_static_state))
3627     {
3628     tls_error(US"set ex_data", host, NULL, errstr);
3629     return FALSE;
3630     }
3631   debug_printf("tls_exdata_idx %d cbinfo %p\n", tls_exdata_idx, client_static_state);
3632   }
3633
3634 tlsp->resumption = RESUME_SUPPORTED;
3635 /* Pick up a previous session, saved on an old ticket */
3636 tls_retrieve_session(tlsp, ssl, host->address);
3637 return TRUE;
3638 }
3639
3640 static void
3641 tls_client_resume_posthandshake(exim_openssl_client_tls_ctx * exim_client_ctx,
3642   tls_support * tlsp)
3643 {
3644 if (SSL_session_reused(exim_client_ctx->ssl))
3645   {
3646   DEBUG(D_tls) debug_printf("The session was reused\n");
3647   tlsp->resumption |= RESUME_USED;
3648   }
3649 }
3650 #endif  /* !DISABLE_TLS_RESUME */
3651
3652
3653 #ifdef EXIM_HAVE_ALPN
3654 /* Expand and convert an Exim list to an ALPN list.  False return for fail.
3655 NULL plist return for silent no-ALPN.
3656 */
3657
3658 static BOOL
3659 tls_alpn_plist(const uschar * tls_alpn, const uschar ** plist, unsigned * plen,
3660   uschar ** errstr)
3661 {
3662 uschar * exp_alpn;
3663
3664 if (!expand_check(tls_alpn, US"tls_alpn", &exp_alpn, errstr))
3665   return FALSE;
3666
3667 if (!exp_alpn)
3668   {
3669   DEBUG(D_tls) debug_printf("Setting TLS ALPN forced to fail, not sending\n");
3670   *plist = NULL;
3671   }
3672 else
3673   {
3674   /* The server implementation only accepts exactly one protocol name
3675   but it's little extra code complexity in the client. */
3676
3677   const uschar * list = exp_alpn;
3678   uschar * p = store_get(Ustrlen(exp_alpn), is_tainted(exp_alpn)), * s, * t;
3679   int sep = 0;
3680   uschar len;
3681
3682   for (t = p; s = string_nextinlist(&list, &sep, NULL, 0); t += len)
3683     {
3684     *t++ = len = (uschar) Ustrlen(s);
3685     memcpy(t, s, len);
3686     }
3687   *plist = (*plen = t - p) ? p : NULL;
3688   }
3689 return TRUE;
3690 }
3691 #endif  /* EXIM_HAVE_ALPN */
3692
3693
3694 /*************************************************
3695 *    Start a TLS session in a client             *
3696 *************************************************/
3697
3698 /* Called from the smtp transport after STARTTLS has been accepted.
3699
3700 Arguments:
3701   cctx          connection context
3702   conn_args     connection details
3703   cookie        datum for randomness; can be NULL
3704   tlsp          record details of TLS channel configuration here; must be non-NULL
3705   errstr        error string pointer
3706
3707 Returns:        TRUE for success with TLS session context set in connection context,
3708                 FALSE on error
3709 */
3710
3711 BOOL
3712 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
3713   void * cookie, tls_support * tlsp, uschar ** errstr)
3714 {
3715 host_item * host = conn_args->host;             /* for msgs and option-tests */
3716 transport_instance * tb = conn_args->tblock;    /* always smtp or NULL */
3717 smtp_transport_options_block * ob = tb
3718   ? (smtp_transport_options_block *)tb->options_block
3719   : &smtp_transport_option_defaults;
3720 exim_openssl_client_tls_ctx * exim_client_ctx;
3721 uschar * expciphers;
3722 int rc;
3723 static uschar peerdn[256];
3724
3725 #ifndef DISABLE_OCSP
3726 BOOL request_ocsp = FALSE;
3727 BOOL require_ocsp = FALSE;
3728 #endif
3729
3730 rc = store_pool;
3731 store_pool = POOL_PERM;
3732 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx), FALSE);
3733 exim_client_ctx->corked = NULL;
3734 store_pool = rc;
3735
3736 #ifdef SUPPORT_DANE
3737 tlsp->tlsa_usage = 0;
3738 #endif
3739
3740 #ifndef DISABLE_OCSP
3741   {
3742 # ifdef SUPPORT_DANE
3743   /*XXX this should be moved to caller, to be common across gnutls/openssl */
3744   if (  conn_args->dane
3745      && ob->hosts_request_ocsp[0] == '*'
3746      && ob->hosts_request_ocsp[1] == '\0'
3747      )
3748     {
3749     /* Unchanged from default.  Use a safer one under DANE */
3750     request_ocsp = TRUE;
3751     ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
3752                                       "   {= {4}{$tls_out_tlsa_usage}} } "
3753                                  " {*}{}}";
3754     }
3755 # endif
3756
3757   if ((require_ocsp =
3758         verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK))
3759     request_ocsp = TRUE;
3760   else
3761 # ifdef SUPPORT_DANE
3762     if (!request_ocsp)
3763 # endif
3764       request_ocsp =
3765         verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3766   }
3767 #endif
3768
3769 rc = tls_init(host, ob,
3770 #ifndef DISABLE_OCSP
3771     (void *)(long)request_ocsp,
3772 #endif
3773     cookie, &client_static_state, tlsp, errstr);
3774 if (rc != OK) return FALSE;
3775
3776 exim_client_ctx->ctx = client_static_state->lib_state.lib_ctx;
3777
3778 tlsp->certificate_verified = FALSE;
3779 client_verify_callback_called = FALSE;
3780
3781 expciphers = NULL;
3782 #ifdef SUPPORT_DANE
3783 if (conn_args->dane)
3784   {
3785   /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
3786   other failures should be treated as problems. */
3787   if (ob->dane_require_tls_ciphers &&
3788       !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
3789         &expciphers, errstr))
3790     return FALSE;
3791   if (expciphers && *expciphers == '\0')
3792     expciphers = NULL;
3793   }
3794 #endif
3795 if (!expciphers &&
3796     !expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
3797       &expciphers, errstr))
3798   return FALSE;
3799
3800 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
3801 are separated by underscores. So that I can use either form in my tests, and
3802 also for general convenience, we turn underscores into hyphens here. */
3803
3804 if (expciphers)
3805   {
3806   uschar *s = expciphers;
3807   while (*s) { if (*s == '_') *s = '-'; s++; }
3808   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
3809   if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
3810     {
3811     tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
3812     return FALSE;
3813     }
3814   }
3815
3816 #ifdef SUPPORT_DANE
3817 if (conn_args->dane)
3818   {
3819   SSL_CTX_set_verify(exim_client_ctx->ctx,
3820     SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
3821     verify_callback_client_dane);
3822
3823   if (!DANESSL_library_init())
3824     {
3825     tls_error(US"library init", host, NULL, errstr);
3826     return FALSE;
3827     }
3828   if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
3829     {
3830     tls_error(US"context init", host, NULL, errstr);
3831     return FALSE;
3832     }
3833   }
3834 else
3835
3836 #endif
3837
3838 if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
3839       client_static_state, errstr) != OK)
3840   return FALSE;
3841
3842 #ifndef DISABLE_TLS_RESUME
3843 tls_client_ctx_resume_prehandshake(exim_client_ctx, tlsp, ob, host);
3844 #endif
3845
3846
3847 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
3848   {
3849   tls_error(US"SSL_new", host, NULL, errstr);
3850   return FALSE;
3851   }
3852 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
3853
3854 SSL_set_fd(exim_client_ctx->ssl, cctx->sock);
3855 SSL_set_connect_state(exim_client_ctx->ssl);
3856
3857 if (ob->tls_sni)
3858   {
3859   if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
3860     return FALSE;
3861   if (!tlsp->sni)
3862     {
3863     DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
3864     }
3865   else if (!Ustrlen(tlsp->sni))
3866     tlsp->sni = NULL;
3867   else
3868     {
3869 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
3870     DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
3871     SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
3872 #else
3873     log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
3874           tlsp->sni);
3875 #endif
3876     }
3877   }
3878
3879 if (ob->tls_alpn)
3880 #ifdef EXIM_HAVE_ALPN
3881   {
3882   const uschar * plist;
3883   unsigned plen;
3884
3885   if (!tls_alpn_plist(ob->tls_alpn, &plist, &plen, errstr))
3886     return FALSE;
3887   if (plist)
3888     if (SSL_set_alpn_protos(exim_client_ctx->ssl, plist, plen) != 0)
3889       {
3890       tls_error(US"alpn init", host, NULL, errstr);
3891       return FALSE;
3892       }
3893     else
3894       DEBUG(D_tls) debug_printf("Setting TLS ALPN '%s'\n", ob->tls_alpn);
3895   }
3896 #else
3897   log_write(0, LOG_MAIN, "ALPN unusable with this OpenSSL library version; ignoring \"%s\"\n",
3898           ob->tls_alpn);
3899 #endif
3900
3901 #ifdef SUPPORT_DANE
3902 if (conn_args->dane)
3903   if (dane_tlsa_load(exim_client_ctx->ssl, host, &conn_args->tlsa_dnsa, errstr) != OK)
3904     return FALSE;
3905 #endif
3906
3907 #ifndef DISABLE_OCSP
3908 /* Request certificate status at connection-time.  If the server
3909 does OCSP stapling we will get the callback (set in tls_init()) */
3910 # ifdef SUPPORT_DANE
3911 if (request_ocsp)
3912   {
3913   const uschar * s;
3914   if (  ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3915      || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3916      )
3917     {   /* Re-eval now $tls_out_tlsa_usage is populated.  If
3918         this means we avoid the OCSP request, we wasted the setup
3919         cost in tls_init(). */
3920     require_ocsp = verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
3921     request_ocsp = require_ocsp
3922       || verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3923     }
3924   }
3925 # endif
3926
3927 if (request_ocsp)
3928   {
3929   SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
3930   client_static_state->u_ocsp.client.verify_required = require_ocsp;
3931   tlsp->ocsp = OCSP_NOT_RESP;
3932   }
3933 #endif
3934
3935 #ifndef DISABLE_TLS_RESUME
3936 if (!tls_client_ssl_resume_prehandshake(exim_client_ctx->ssl, tlsp, host,
3937       errstr))
3938   return FALSE;
3939 #endif
3940
3941 #ifndef DISABLE_EVENT
3942 client_static_state->event_action = tb ? tb->event_action : NULL;
3943 #endif
3944
3945 /* There doesn't seem to be a built-in timeout on connection. */
3946
3947 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
3948 sigalrm_seen = FALSE;
3949 ALARM(ob->command_timeout);
3950 rc = SSL_connect(exim_client_ctx->ssl);
3951 ALARM_CLR(0);
3952
3953 #ifdef SUPPORT_DANE
3954 if (conn_args->dane)
3955   DANESSL_cleanup(exim_client_ctx->ssl);
3956 #endif
3957
3958 if (rc <= 0)
3959   {
3960   tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
3961   return FALSE;
3962   }
3963
3964 DEBUG(D_tls)
3965   {
3966   debug_printf("SSL_connect succeeded\n");
3967 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3968   {
3969   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
3970   SSL_SESSION_print_keylog(bp, SSL_get_session(exim_client_ctx->ssl));
3971   BIO_free(bp);
3972   }
3973 #endif
3974   }
3975
3976 #ifndef DISABLE_TLS_RESUME
3977 tls_client_resume_posthandshake(exim_client_ctx, tlsp);
3978 #endif
3979
3980 #ifdef EXIM_HAVE_ALPN
3981 if (ob->tls_alpn)       /* We requested. See what was negotiated. */
3982   {
3983   const uschar * name;
3984   unsigned len;
3985
3986   SSL_get0_alpn_selected(exim_client_ctx->ssl, &name, &len);
3987   if (len > 0)
3988     { DEBUG(D_tls) debug_printf("ALPN negotiated %u: '%.*s'\n", len, (int)*name, name+1); }
3989   else if (verify_check_given_host(CUSS &ob->hosts_require_alpn, host) == OK)
3990     {
3991     /* Would like to send a relevant fatal Alert, but OpenSSL has no API */
3992     tls_error(US"handshake", host, US"ALPN required but not negotiated", errstr);
3993     return FALSE;
3994     }
3995   }
3996 #endif
3997
3998 #ifdef SSL_get_extms_support
3999 tlsp->ext_master_secret = SSL_get_extms_support(exim_client_ctx->ssl) == 1;
4000 #endif
4001 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
4002
4003 tlsp->ver = tlsver_name(exim_client_ctx->ssl);
4004 tlsp->cipher = construct_cipher_name(exim_client_ctx->ssl, tlsp->ver, &tlsp->bits);
4005 tlsp->cipher_stdname = cipher_stdname_ssl(exim_client_ctx->ssl);
4006
4007 /* Record the certificate we presented */
4008   {
4009   X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
4010   tlsp->ourcert = crt ? X509_dup(crt) : NULL;
4011   }
4012
4013 /*XXX will this work with continued-TLS? */
4014 /* Channel-binding info for authenticators */
4015   {
4016   uschar c, * s;
4017   size_t len = SSL_get_finished(exim_client_ctx->ssl, &c, 0);
4018   int old_pool = store_pool;
4019
4020   SSL_get_finished(exim_client_ctx->ssl, s = store_get((int)len, TRUE), len);
4021   store_pool = POOL_PERM;
4022     tlsp->channelbinding = b64encode_taint(CUS s, (int)len, TRUE);
4023   store_pool = old_pool;
4024   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage %p %p\n", tlsp->channelbinding, tlsp);
4025   }
4026
4027 tlsp->active.sock = cctx->sock;
4028 tlsp->active.tls_ctx = exim_client_ctx;
4029 cctx->tls_ctx = exim_client_ctx;
4030 return TRUE;
4031 }
4032
4033
4034
4035
4036
4037 static BOOL
4038 tls_refill(unsigned lim)
4039 {
4040 SSL * ssl = state_server.lib_state.lib_ssl;
4041 int error;
4042 int inbytes;
4043
4044 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
4045   ssl_xfer_buffer, ssl_xfer_buffer_size);
4046
4047 ERR_clear_error();
4048 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
4049 inbytes = SSL_read(ssl, CS ssl_xfer_buffer,
4050                   MIN(ssl_xfer_buffer_size, lim));
4051 error = SSL_get_error(ssl, inbytes);
4052 if (smtp_receive_timeout > 0) ALARM_CLR(0);
4053
4054 if (had_command_timeout)                /* set by signal handler */
4055   smtp_command_timeout_exit();          /* does not return */
4056 if (had_command_sigterm)
4057   smtp_command_sigterm_exit();
4058 if (had_data_timeout)
4059   smtp_data_timeout_exit();
4060 if (had_data_sigint)
4061   smtp_data_sigint_exit();
4062
4063 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
4064 closed down, not that the socket itself has been closed down. Revert to
4065 non-SSL handling. */
4066
4067 switch(error)
4068   {
4069   case SSL_ERROR_NONE:
4070     break;
4071
4072   case SSL_ERROR_ZERO_RETURN:
4073     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
4074
4075     if (SSL_get_shutdown(ssl) == SSL_RECEIVED_SHUTDOWN)
4076           SSL_shutdown(ssl);
4077
4078     tls_close(NULL, TLS_NO_SHUTDOWN);
4079     return FALSE;
4080
4081   /* Handle genuine errors */
4082   case SSL_ERROR_SSL:
4083     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4084     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
4085     ssl_xfer_error = TRUE;
4086     return FALSE;
4087
4088   default:
4089     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
4090     DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
4091       debug_printf(" - syscall %s\n", strerror(errno));
4092     ssl_xfer_error = TRUE;
4093     return FALSE;
4094   }
4095
4096 #ifndef DISABLE_DKIM
4097 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
4098 #endif
4099 ssl_xfer_buffer_hwm = inbytes;
4100 ssl_xfer_buffer_lwm = 0;
4101 return TRUE;
4102 }
4103
4104
4105 /*************************************************
4106 *            TLS version of getc                 *
4107 *************************************************/
4108
4109 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
4110 it refills the buffer via the SSL reading function.
4111
4112 Arguments:  lim         Maximum amount to read/buffer
4113 Returns:    the next character or EOF
4114
4115 Only used by the server-side TLS.
4116 */
4117
4118 int
4119 tls_getc(unsigned lim)
4120 {
4121 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
4122   if (!tls_refill(lim))
4123     return ssl_xfer_error ? EOF : smtp_getc(lim);
4124
4125 /* Something in the buffer; return next uschar */
4126
4127 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
4128 }
4129
4130 BOOL
4131 tls_hasc(void)
4132 {
4133 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm;
4134 }
4135
4136 uschar *
4137 tls_getbuf(unsigned * len)
4138 {
4139 unsigned size;
4140 uschar * buf;
4141
4142 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
4143   if (!tls_refill(*len))
4144     {
4145     if (!ssl_xfer_error) return smtp_getbuf(len);
4146     *len = 0;
4147     return NULL;
4148     }
4149
4150 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
4151   size = *len;
4152 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
4153 ssl_xfer_buffer_lwm += size;
4154 *len = size;
4155 return buf;
4156 }
4157
4158
4159 void
4160 tls_get_cache(unsigned lim)
4161 {
4162 #ifndef DISABLE_DKIM
4163 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
4164 debug_printf("tls_get_cache\n");
4165 if (n > lim)
4166   n = lim;
4167 if (n > 0)
4168   dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
4169 #endif
4170 }
4171
4172
4173 BOOL
4174 tls_could_read(void)
4175 {
4176 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm
4177     || SSL_pending(state_server.lib_state.lib_ssl) > 0;
4178 }
4179
4180
4181 /*************************************************
4182 *          Read bytes from TLS channel           *
4183 *************************************************/
4184
4185 /*
4186 Arguments:
4187   ct_ctx    client context pointer, or NULL for the one global server context
4188   buff      buffer of data
4189   len       size of buffer
4190
4191 Returns:    the number of bytes read
4192             -1 after a failed read, including EOF
4193
4194 Only used by the client-side TLS.
4195 */
4196
4197 int
4198 tls_read(void * ct_ctx, uschar *buff, size_t len)
4199 {
4200 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl
4201                   : state_server.lib_state.lib_ssl;
4202 int inbytes;
4203 int error;
4204
4205 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
4206   buff, (unsigned int)len);
4207
4208 ERR_clear_error();
4209 inbytes = SSL_read(ssl, CS buff, len);
4210 error = SSL_get_error(ssl, inbytes);
4211
4212 if (error == SSL_ERROR_ZERO_RETURN)
4213   {
4214   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
4215   return -1;
4216   }
4217 else if (error != SSL_ERROR_NONE)
4218   return -1;
4219
4220 return inbytes;
4221 }
4222
4223
4224
4225
4226
4227 /*************************************************
4228 *         Write bytes down TLS channel           *
4229 *************************************************/
4230
4231 /*
4232 Arguments:
4233   ct_ctx    client context pointer, or NULL for the one global server context
4234   buff      buffer of data
4235   len       number of bytes
4236   more      further data expected soon
4237
4238 Returns:    the number of bytes after a successful write,
4239             -1 after a failed write
4240
4241 Used by both server-side and client-side TLS.  Calling with len zero and more unset
4242 will flush buffered writes; buff can be null for this case.
4243 */
4244
4245 int
4246 tls_write(void * ct_ctx, const uschar * buff, size_t len, BOOL more)
4247 {
4248 size_t olen = len;
4249 int outbytes, error;
4250 SSL * ssl = ct_ctx
4251   ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl
4252   : state_server.lib_state.lib_ssl;
4253 static gstring * server_corked = NULL;
4254 gstring ** corkedp = ct_ctx
4255   ? &((exim_openssl_client_tls_ctx *)ct_ctx)->corked : &server_corked;
4256 gstring * corked = *corkedp;
4257
4258 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
4259   buff, (unsigned long)len, more ? ", more" : "");
4260
4261 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
4262 "more" is notified.  This hack is only ok if small amounts are involved AND only
4263 one stream does it, in one context (i.e. no store reset).  Currently it is used
4264 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only.
4265 We support callouts done by the server process by using a separate client
4266 context for the stashed information. */
4267 /* + if PIPE_COMMAND, banner & ehlo-resp for smmtp-on-connect. Suspect there's
4268 a store reset there, so use POOL_PERM. */
4269 /* + if CHUNKING, cmds EHLO,MAIL,RCPT(s),BDAT */
4270
4271 if (more || corked)
4272   {
4273   if (!len) buff = US &error;   /* dummy just so that string_catn is ok */
4274
4275   int save_pool = store_pool;
4276   store_pool = POOL_PERM;
4277
4278   corked = string_catn(corked, buff, len);
4279
4280   store_pool = save_pool;
4281
4282   if (more)
4283     {
4284     *corkedp = corked;
4285     return len;
4286     }
4287   buff = CUS corked->s;
4288   len = corked->ptr;
4289   *corkedp = NULL;
4290   }
4291
4292 for (int left = len; left > 0;)
4293   {
4294   DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
4295   ERR_clear_error();
4296   outbytes = SSL_write(ssl, CS buff, left);
4297   error = SSL_get_error(ssl, outbytes);
4298   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
4299   switch (error)
4300     {
4301     case SSL_ERROR_NONE:        /* the usual case */
4302       left -= outbytes;
4303       buff += outbytes;
4304       break;
4305
4306     case SSL_ERROR_SSL:
4307       ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4308       log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
4309       return -1;
4310
4311     case SSL_ERROR_ZERO_RETURN:
4312       log_write(0, LOG_MAIN, "SSL channel closed on write");
4313       return -1;
4314
4315     case SSL_ERROR_SYSCALL:
4316       if (ct_ctx || errno != ECONNRESET || !f.smtp_in_quit)
4317         log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
4318           sender_fullhost ? sender_fullhost : US"<unknown>",
4319           strerror(errno));
4320       else if (LOGGING(protocol_detail))
4321         log_write(0, LOG_MAIN, "[%s] after QUIT, client reset TCP before"
4322           " SMTP response and TLS close\n", sender_host_address);
4323       else
4324         DEBUG(D_tls) debug_printf("[%s] SSL_write: after QUIT,"
4325           " client reset TCP before TLS close\n", sender_host_address);
4326       return -1;
4327
4328     default:
4329       log_write(0, LOG_MAIN, "SSL_write error %d", error);
4330       return -1;
4331     }
4332   }
4333 return olen;
4334 }
4335
4336
4337
4338 /*
4339 Arguments:
4340   ct_ctx        client TLS context pointer, or NULL for the one global server context
4341 */
4342
4343 void
4344 tls_shutdown_wr(void * ct_ctx)
4345 {
4346 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
4347 SSL ** sslp = o_ctx ? &o_ctx->ssl : (SSL **) &state_server.lib_state.lib_ssl;
4348 int * fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
4349 int rc;
4350
4351 if (*fdp < 0) return;  /* TLS was not active */
4352
4353 tls_write(ct_ctx, NULL, 0, FALSE);      /* flush write buffer */
4354
4355 HDEBUG(D_transport|D_tls|D_acl|D_v) debug_printf_indent("  SMTP(TLS shutdown)>>\n");
4356 rc = SSL_shutdown(*sslp);
4357 if (rc < 0) DEBUG(D_tls)
4358   {
4359   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4360   debug_printf("SSL_shutdown: %s\n", ssl_errstring);
4361   }
4362 }
4363
4364 /*************************************************
4365 *         Close down a TLS session               *
4366 *************************************************/
4367
4368 /* This is also called from within a delivery subprocess forked from the
4369 daemon, to shut down the TLS library, without actually doing a shutdown (which
4370 would tamper with the SSL session in the parent process).
4371
4372 Arguments:
4373   ct_ctx        client TLS context pointer, or NULL for the one global server context
4374   do_shutdown   0 no data-flush or TLS close-alert
4375                 1 if TLS close-alert is to be sent,
4376                 2 if also response to be waited for
4377
4378 Returns:     nothing
4379
4380 Used by both server-side and client-side TLS.
4381 */
4382
4383 void
4384 tls_close(void * ct_ctx, int do_shutdown)
4385 {
4386 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
4387 SSL ** sslp = o_ctx ? &o_ctx->ssl : (SSL **) &state_server.lib_state.lib_ssl;
4388 int * fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
4389
4390 if (*fdp < 0) return;  /* TLS was not active */
4391
4392 if (do_shutdown)
4393   {
4394   int rc;
4395   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
4396     do_shutdown > 1 ? " (with response-wait)" : "");
4397
4398   tls_write(ct_ctx, NULL, 0, FALSE);    /* flush write buffer */
4399
4400   if (  (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
4401      && do_shutdown > 1)
4402     {
4403     ALARM(2);
4404     rc = SSL_shutdown(*sslp);           /* wait for response */
4405     ALARM_CLR(0);
4406     }
4407
4408   if (rc < 0) DEBUG(D_tls)
4409     {
4410     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4411     debug_printf("SSL_shutdown: %s\n", ssl_errstring);
4412     }
4413   }
4414
4415 if (!o_ctx)             /* server side */
4416   {
4417 #ifndef DISABLE_OCSP
4418   sk_X509_pop_free(state_server.verify_stack, X509_free);
4419   state_server.verify_stack = NULL;
4420 #endif
4421
4422   receive_getc =        smtp_getc;
4423   receive_getbuf =      smtp_getbuf;
4424   receive_get_cache =   smtp_get_cache;
4425   receive_hasc =        smtp_hasc;
4426   receive_ungetc =      smtp_ungetc;
4427   receive_feof =        smtp_feof;
4428   receive_ferror =      smtp_ferror;
4429   receive_smtp_buffered = smtp_buffered;
4430   tls_in.active.tls_ctx = NULL;
4431   tls_in.sni = NULL;
4432   /* Leave bits, peercert, cipher, peerdn, certificate_verified set, for logging */
4433   }
4434
4435 SSL_free(*sslp);
4436 *sslp = NULL;
4437 *fdp = -1;
4438 }
4439
4440
4441
4442
4443 /*************************************************
4444 *  Let tls_require_ciphers be checked at startup *
4445 *************************************************/
4446
4447 /* The tls_require_ciphers option, if set, must be something which the
4448 library can parse.
4449
4450 Returns:     NULL on success, or error message
4451 */
4452
4453 uschar *
4454 tls_validate_require_cipher(void)
4455 {
4456 SSL_CTX *ctx;
4457 uschar *s, *expciphers, *err;
4458
4459 tls_openssl_init();
4460
4461 if (!(tls_require_ciphers && *tls_require_ciphers))
4462   return NULL;
4463
4464 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
4465                   &err))
4466   return US"failed to expand tls_require_ciphers";
4467
4468 if (!(expciphers && *expciphers))
4469   return NULL;
4470
4471 /* normalisation ripped from above */
4472 s = expciphers;
4473 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
4474
4475 err = NULL;
4476
4477 if (lib_ctx_new(&ctx, NULL, &err) == OK)
4478   {
4479   DEBUG(D_tls)
4480     debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
4481
4482   if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
4483     {
4484     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4485     err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
4486                         expciphers, ssl_errstring);
4487     }
4488
4489   SSL_CTX_free(ctx);
4490   }
4491 return err;
4492 }
4493
4494
4495
4496
4497 /*************************************************
4498 *         Report the library versions.           *
4499 *************************************************/
4500
4501 /* There have historically been some issues with binary compatibility in
4502 OpenSSL libraries; if Exim (like many other applications) is built against
4503 one version of OpenSSL but the run-time linker picks up another version,
4504 it can result in serious failures, including crashing with a SIGSEGV.  So
4505 report the version found by the compiler and the run-time version.
4506
4507 Note: some OS vendors backport security fixes without changing the version
4508 number/string, and the version date remains unchanged.  The _build_ date
4509 will change, so we can more usefully assist with version diagnosis by also
4510 reporting the build date.
4511
4512 Arguments:   a FILE* to print the results to
4513 Returns:     nothing
4514 */
4515
4516 void
4517 tls_version_report(FILE *f)
4518 {
4519 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
4520            "                          Runtime: %s\n"
4521            "                                 : %s\n",
4522            OPENSSL_VERSION_TEXT,
4523            SSLeay_version(SSLEAY_VERSION),
4524            SSLeay_version(SSLEAY_BUILT_ON));
4525 /* third line is 38 characters for the %s and the line is 73 chars long;
4526 the OpenSSL output includes a "built on: " prefix already. */
4527 }
4528
4529
4530
4531
4532 /*************************************************
4533 *            Random number generation            *
4534 *************************************************/
4535
4536 /* Pseudo-random number generation.  The result is not expected to be
4537 cryptographically strong but not so weak that someone will shoot themselves
4538 in the foot using it as a nonce in input in some email header scheme or
4539 whatever weirdness they'll twist this into.  The result should handle fork()
4540 and avoid repeating sequences.  OpenSSL handles that for us.
4541
4542 Arguments:
4543   max       range maximum
4544 Returns     a random number in range [0, max-1]
4545 */
4546
4547 int
4548 vaguely_random_number(int max)
4549 {
4550 unsigned int r;
4551 int i, needed_len;
4552 static pid_t pidlast = 0;
4553 pid_t pidnow;
4554 uschar smallbuf[sizeof(r)];
4555
4556 if (max <= 1)
4557   return 0;
4558
4559 pidnow = getpid();
4560 if (pidnow != pidlast)
4561   {
4562   /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
4563   is unique for each thread", this doesn't apparently apply across processes,
4564   so our own warning from vaguely_random_number_fallback() applies here too.
4565   Fix per PostgreSQL. */
4566   if (pidlast != 0)
4567     RAND_cleanup();
4568   pidlast = pidnow;
4569   }
4570
4571 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
4572 if (!RAND_status())
4573   {
4574   randstuff r;
4575   gettimeofday(&r.tv, NULL);
4576   r.p = getpid();
4577
4578   RAND_seed(US (&r), sizeof(r));
4579   }
4580 /* We're after pseudo-random, not random; if we still don't have enough data
4581 in the internal PRNG then our options are limited.  We could sleep and hope
4582 for entropy to come along (prayer technique) but if the system is so depleted
4583 in the first place then something is likely to just keep taking it.  Instead,
4584 we'll just take whatever little bit of pseudo-random we can still manage to
4585 get. */
4586
4587 needed_len = sizeof(r);
4588 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
4589 asked for a number less than 10. */
4590 for (r = max, i = 0; r; ++i)
4591   r >>= 1;
4592 i = (i + 7) / 8;
4593 if (i < needed_len)
4594   needed_len = i;
4595
4596 #ifdef EXIM_HAVE_RAND_PSEUDO
4597 /* We do not care if crypto-strong */
4598 i = RAND_pseudo_bytes(smallbuf, needed_len);
4599 #else
4600 i = RAND_bytes(smallbuf, needed_len);
4601 #endif
4602
4603 if (i < 0)
4604   {
4605   DEBUG(D_all)
4606     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
4607   return vaguely_random_number_fallback(max);
4608   }
4609
4610 r = 0;
4611 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
4612   r = 256 * r + *p;
4613
4614 /* We don't particularly care about weighted results; if someone wants
4615 smooth distribution and cares enough then they should submit a patch then. */
4616 return r % max;
4617 }
4618
4619
4620
4621
4622 /*************************************************
4623 *        OpenSSL option parse                    *
4624 *************************************************/
4625
4626 /* Parse one option for tls_openssl_options_parse below
4627
4628 Arguments:
4629   name    one option name
4630   value   place to store a value for it
4631 Returns   success or failure in parsing
4632 */
4633
4634
4635
4636 static BOOL
4637 tls_openssl_one_option_parse(uschar *name, long *value)
4638 {
4639 int first = 0;
4640 int last = exim_openssl_options_size;
4641 while (last > first)
4642   {
4643   int middle = (first + last)/2;
4644   int c = Ustrcmp(name, exim_openssl_options[middle].name);
4645   if (c == 0)
4646     {
4647     *value = exim_openssl_options[middle].value;
4648     return TRUE;
4649     }
4650   else if (c > 0)
4651     first = middle + 1;
4652   else
4653     last = middle;
4654   }
4655 return FALSE;
4656 }
4657
4658
4659
4660
4661 /*************************************************
4662 *        OpenSSL option parsing logic            *
4663 *************************************************/
4664
4665 /* OpenSSL has a number of compatibility options which an administrator might
4666 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
4667 we look like log_selector.
4668
4669 Arguments:
4670   option_spec  the administrator-supplied string of options
4671   results      ptr to long storage for the options bitmap
4672 Returns        success or failure
4673 */
4674
4675 BOOL
4676 tls_openssl_options_parse(uschar *option_spec, long *results)
4677 {
4678 long result, item;
4679 uschar * exp, * end;
4680 BOOL adding, item_parsed;
4681
4682 /* Server: send no (<= TLS1.2) session tickets */
4683 result = SSL_OP_NO_TICKET;
4684
4685 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
4686 from default because it increases BEAST susceptibility. */
4687 #ifdef SSL_OP_NO_SSLv2
4688 result |= SSL_OP_NO_SSLv2;
4689 #endif
4690 #ifdef SSL_OP_NO_SSLv3
4691 result |= SSL_OP_NO_SSLv3;
4692 #endif
4693 #ifdef SSL_OP_SINGLE_DH_USE
4694 result |= SSL_OP_SINGLE_DH_USE;
4695 #endif
4696 #ifdef SSL_OP_NO_RENEGOTIATION
4697 result |= SSL_OP_NO_RENEGOTIATION;
4698 #endif
4699
4700 if (!option_spec)
4701   {
4702   *results = result;
4703   return TRUE;
4704   }
4705
4706 if (!expand_check(option_spec, US"openssl_options", &exp, &end))
4707   return FALSE;
4708
4709 for (uschar * s = exp; *s; /**/)
4710   {
4711   while (isspace(*s)) ++s;
4712   if (*s == '\0')
4713     break;
4714   if (*s != '+' && *s != '-')
4715     {
4716     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
4717         "+ or - expected but found \"%s\"\n", s);
4718     return FALSE;
4719     }
4720   adding = *s++ == '+';
4721   for (end = s; *end && !isspace(*end); ) end++;
4722   item_parsed = tls_openssl_one_option_parse(string_copyn(s, end-s), &item);
4723   if (!item_parsed)
4724     {
4725     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
4726     return FALSE;
4727     }
4728   DEBUG(D_tls) debug_printf("openssl option, %s %08lx: %08lx (%s)\n",
4729       adding ? "adding to    " : "removing from", result, item, s);
4730   if (adding)
4731     result |= item;
4732   else
4733     result &= ~item;
4734   s = end;
4735   }
4736
4737 *results = result;
4738 return TRUE;
4739 }
4740
4741 #endif  /*!MACRO_PREDEF*/
4742 /* vi: aw ai sw=2
4743 */
4744 /* End of tls-openssl.c */