51eeedc5b5ad5273cbfc4e6c50f4935973d883ae
[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
2239   for (; olist; olist = olist->next)
2240     {
2241     OCSP_BASICRESP * bs = OCSP_response_get1_basic(olist->resp);
2242     const OCSP_SINGLERESP * single = OCSP_resp_get0(bs, 0);
2243     const OCSP_CERTID * cid = OCSP_SINGLERESP_get0_id(single);
2244     ASN1_INTEGER * res_cert_serial;
2245     const BIGNUM * resp_bn;
2246     ASN1_OCTET_STRING * res_cert_iNameHash;
2247
2248
2249     (void) OCSP_id_get0_info(&res_cert_iNameHash, NULL, NULL, &res_cert_serial,
2250       (OCSP_CERTID *) cid);
2251     resp_bn = ASN1_INTEGER_to_BN(res_cert_serial, NULL);
2252
2253     DEBUG(D_tls)
2254       {
2255       debug_printf("cert serial: %s\n", BN_bn2hex(cert_bn));
2256       debug_printf("resp serial: %s\n", BN_bn2hex(resp_bn));
2257       }
2258
2259     if (BN_cmp(cert_bn, resp_bn) == 0)
2260       {
2261       DEBUG(D_tls) debug_printf("matched serial for ocsp\n");
2262
2263       /*XXX TODO: check the rest of the list for duplicate matches.
2264       If any, need to also check the Issuer Name hash.
2265       Without this, we will provide the wrong status in the case of
2266       duplicate id. */
2267
2268       break;
2269       }
2270     DEBUG(D_tls) debug_printf("not match serial for ocsp\n");
2271     }
2272   if (!olist)
2273     {
2274     DEBUG(D_tls) debug_printf("failed to find match for ocsp\n");
2275     return SSL_TLSEXT_ERR_NOACK;
2276     }
2277  }
2278 #else
2279 if (olist->next)
2280   {
2281   DEBUG(D_tls) debug_printf("OpenSSL version too early to support multi-leaf OCSP\n");
2282   return SSL_TLSEXT_ERR_NOACK;
2283   }
2284 #endif
2285
2286 /*XXX could we do the i2d earlier, rather than during the callback? */
2287 response_der = NULL;
2288 response_der_len = i2d_OCSP_RESPONSE(olist->resp, &response_der);
2289 if (response_der_len <= 0)
2290   return SSL_TLSEXT_ERR_NOACK;
2291
2292 SSL_set_tlsext_status_ocsp_resp(state_server.lib_state.lib_ssl,
2293                                 response_der, response_der_len);
2294 tls_in.ocsp = OCSP_VFIED;
2295 return SSL_TLSEXT_ERR_OK;
2296 }
2297
2298
2299 static void
2300 time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
2301 {
2302 BIO_printf(bp, "\t%s: ", str);
2303 ASN1_GENERALIZEDTIME_print(bp, time);
2304 BIO_puts(bp, "\n");
2305 }
2306
2307 static int
2308 tls_client_stapling_cb(SSL *s, void *arg)
2309 {
2310 exim_openssl_state_st * cbinfo = arg;
2311 const unsigned char * p;
2312 int len;
2313 OCSP_RESPONSE * rsp;
2314 OCSP_BASICRESP * bs;
2315 int i;
2316
2317 DEBUG(D_tls) debug_printf("Received TLS status callback (OCSP stapling):\n");
2318 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
2319 if(!p)
2320  {
2321   /* Expect this when we requested ocsp but got none */
2322   if (cbinfo->u_ocsp.client.verify_required && LOGGING(tls_cipher))
2323     log_write(0, LOG_MAIN, "Required TLS certificate status not received");
2324   else
2325     DEBUG(D_tls) debug_printf(" null\n");
2326   return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
2327  }
2328
2329 if (!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
2330   {
2331   tls_out.ocsp = OCSP_FAILED;   /*XXX should use tlsp-> to permit concurrent outbound */
2332   if (LOGGING(tls_cipher))
2333     log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
2334   else
2335     DEBUG(D_tls) debug_printf(" parse error\n");
2336   return 0;
2337   }
2338
2339 if (!(bs = OCSP_response_get1_basic(rsp)))
2340   {
2341   tls_out.ocsp = OCSP_FAILED;
2342   if (LOGGING(tls_cipher))
2343     log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
2344   else
2345     DEBUG(D_tls) debug_printf(" error parsing response\n");
2346   OCSP_RESPONSE_free(rsp);
2347   return 0;
2348   }
2349
2350 /* We'd check the nonce here if we'd put one in the request. */
2351 /* However that would defeat cacheability on the server so we don't. */
2352
2353 /* This section of code reworked from OpenSSL apps source;
2354    The OpenSSL Project retains copyright:
2355    Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
2356 */
2357   {
2358     BIO * bp = NULL;
2359 #ifndef EXIM_HAVE_OCSP_RESP_COUNT
2360     STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
2361 #endif
2362
2363     DEBUG(D_tls) bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
2364
2365     /*OCSP_RESPONSE_print(bp, rsp, 0);   extreme debug: stapling content */
2366
2367     /* Use the chain that verified the server cert to verify the stapled info */
2368     /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
2369
2370     if ((i = OCSP_basic_verify(bs, cbinfo->verify_stack,
2371               cbinfo->u_ocsp.client.verify_store, OCSP_NOEXPLICIT)) <= 0)
2372       if (ERR_peek_error())
2373         {
2374         tls_out.ocsp = OCSP_FAILED;
2375         if (LOGGING(tls_cipher)) log_write(0, LOG_MAIN,
2376                 "Received TLS cert status response, itself unverifiable: %s",
2377                 ERR_reason_error_string(ERR_peek_error()));
2378         BIO_printf(bp, "OCSP response verify failure\n");
2379         ERR_print_errors(bp);
2380         OCSP_RESPONSE_print(bp, rsp, 0);
2381         goto failed;
2382         }
2383       else
2384         DEBUG(D_tls) debug_printf("no explicit trust for OCSP signing"
2385           " in the root CA certificate; ignoring\n");
2386
2387     DEBUG(D_tls) debug_printf("OCSP response well-formed and signed OK\n");
2388
2389     /*XXX So we have a good stapled OCSP status.  How do we know
2390     it is for the cert of interest?  OpenSSL 1.1.0 has a routine
2391     OCSP_resp_find_status() which matches on a cert id, which presumably
2392     we should use. Making an id needs OCSP_cert_id_new(), which takes
2393     issuerName, issuerKey, serialNumber.  Are they all in the cert?
2394
2395     For now, carry on blindly accepting the resp. */
2396
2397     for (int idx =
2398 #ifdef EXIM_HAVE_OCSP_RESP_COUNT
2399             OCSP_resp_count(bs) - 1;
2400 #else
2401             sk_OCSP_SINGLERESP_num(sresp) - 1;
2402 #endif
2403          idx >= 0; idx--)
2404       {
2405       OCSP_SINGLERESP * single = OCSP_resp_get0(bs, idx);
2406       int status, reason;
2407       ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
2408
2409   /*XXX so I can see putting a loop in here to handle a rsp with >1 singleresp
2410   - but what happens with a GnuTLS-style input?
2411
2412   we could do with a debug label for each singleresp
2413   - it has a certID with a serialNumber, but I see no API to get that
2414   */
2415       status = OCSP_single_get0_status(single, &reason, &rev,
2416                   &thisupd, &nextupd);
2417
2418       DEBUG(D_tls) time_print(bp, "This OCSP Update", thisupd);
2419       DEBUG(D_tls) if(nextupd) time_print(bp, "Next OCSP Update", nextupd);
2420       if (!OCSP_check_validity(thisupd, nextupd,
2421             EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
2422         {
2423         tls_out.ocsp = OCSP_FAILED;
2424         DEBUG(D_tls) ERR_print_errors(bp);
2425         log_write(0, LOG_MAIN, "Server OSCP dates invalid");
2426         goto failed;
2427         }
2428
2429       DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
2430                     OCSP_cert_status_str(status));
2431       switch(status)
2432         {
2433         case V_OCSP_CERTSTATUS_GOOD:
2434           continue;     /* the idx loop */
2435         case V_OCSP_CERTSTATUS_REVOKED:
2436           log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
2437               reason != -1 ? "; reason: " : "",
2438               reason != -1 ? OCSP_crl_reason_str(reason) : "");
2439           DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
2440           break;
2441         default:
2442           log_write(0, LOG_MAIN,
2443               "Server certificate status unknown, in OCSP stapling");
2444           break;
2445         }
2446
2447       goto failed;
2448       }
2449
2450     i = 1;
2451     tls_out.ocsp = OCSP_VFIED;
2452     goto good;
2453
2454   failed:
2455     tls_out.ocsp = OCSP_FAILED;
2456     i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
2457   good:
2458     BIO_free(bp);
2459   }
2460
2461 OCSP_RESPONSE_free(rsp);
2462 return i;
2463 }
2464 #endif  /*!DISABLE_OCSP*/
2465
2466
2467 /*************************************************
2468 *            Initialize for TLS                  *
2469 *************************************************/
2470 /* Called from both server and client code, to do preliminary initialization
2471 of the library.  We allocate and return a context structure.
2472
2473 Arguments:
2474   host            connected host, if client; NULL if server
2475   ob              transport options block, if client; NULL if server
2476   ocsp_file       file of stapling info (server); flag for require ocsp (client)
2477   addr            address if client; NULL if server (for some randomness)
2478   caller_state    place to put pointer to allocated state-struct
2479   errstr          error string pointer
2480
2481 Returns:          OK/DEFER/FAIL
2482 */
2483
2484 static int
2485 tls_init(host_item * host, smtp_transport_options_block * ob,
2486 #ifndef DISABLE_OCSP
2487   uschar *ocsp_file,
2488 #endif
2489   address_item *addr, exim_openssl_state_st ** caller_state,
2490   tls_support * tlsp,
2491   uschar ** errstr)
2492 {
2493 SSL_CTX * ctx;
2494 exim_openssl_state_st * state;
2495 int rc;
2496
2497 if (host)                       /* client */
2498   {
2499   state = store_malloc(sizeof(exim_openssl_state_st));
2500   memset(state, 0, sizeof(*state));
2501   state->certificate = ob->tls_certificate;
2502   state->privatekey =  ob->tls_privatekey;
2503   state->is_server = FALSE;
2504   state->dhparam = NULL;
2505   state->lib_state = ob->tls_preload;
2506   }
2507 else                            /* server */
2508   {
2509   state = &state_server;
2510   state->certificate = tls_certificate;
2511   state->privatekey =  tls_privatekey;
2512   state->is_server = TRUE;
2513   state->dhparam = tls_dhparam;
2514   state->lib_state = state_server.lib_state;
2515   }
2516
2517 state->tlsp = tlsp;
2518 state->host = host;
2519
2520 if (!state->lib_state.pri_string)
2521   state->server_cipher_list = NULL;
2522
2523 #ifndef DISABLE_EVENT
2524 state->event_action = NULL;
2525 #endif
2526
2527 tls_openssl_init();
2528
2529 /* It turns out that we need to seed the random number generator this early in
2530 order to get the full complement of ciphers to work. It took me roughly a day
2531 of work to discover this by experiment.
2532
2533 On systems that have /dev/urandom, SSL may automatically seed itself from
2534 there. Otherwise, we have to make something up as best we can. Double check
2535 afterwards.
2536
2537 Although we likely called this before, at daemon startup, this is a chance
2538 to mix in further variable info (time, pid) if needed. */
2539
2540 if (!lib_rand_init(addr))
2541   return tls_error(US"RAND_status", host,
2542     US"unable to seed random number generator", errstr);
2543
2544 /* Apply administrator-supplied work-arounds.
2545 Historically we applied just one requested option,
2546 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
2547 moved to an administrator-controlled list of options to specify and
2548 grandfathered in the first one as the default value for "openssl_options".
2549
2550 No OpenSSL version number checks: the options we accept depend upon the
2551 availability of the option value macros from OpenSSL.  */
2552
2553 if (!init_options)
2554   if (!tls_openssl_options_parse(openssl_options, &init_options))
2555     return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
2556
2557 /* Create a context.
2558 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
2559 negotiation in the different methods; as far as I can tell, the only
2560 *_{server,client}_method which allows negotiation is SSLv23, which exists even
2561 when OpenSSL is built without SSLv2 support.
2562 By disabling with openssl_options, we can let admins re-enable with the
2563 existing knob. */
2564
2565 if (!(ctx = state->lib_state.lib_ctx))
2566   {
2567   if ((rc = lib_ctx_new(&ctx, host, errstr)) != OK)
2568     return rc;
2569   state->lib_state.lib_ctx = ctx;
2570   }
2571
2572 #ifndef DISABLE_TLS_RESUME
2573 tlsp->resumption = RESUME_SUPPORTED;
2574 #endif
2575 if (init_options)
2576   {
2577 #ifndef DISABLE_TLS_RESUME
2578   /* Should the server offer session resumption? */
2579   if (!host && verify_check_host(&tls_resumption_hosts) == OK)
2580     {
2581     DEBUG(D_tls) debug_printf("tls_resumption_hosts overrides openssl_options\n");
2582     init_options &= ~SSL_OP_NO_TICKET;
2583     tlsp->resumption |= RESUME_SERVER_TICKET; /* server will give ticket on request */
2584     tlsp->host_resumable = TRUE;
2585     }
2586 #endif
2587
2588   DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
2589   if (!(SSL_CTX_set_options(ctx, init_options)))
2590     return tls_error(string_sprintf(
2591           "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
2592   }
2593 else
2594   DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
2595
2596 /* We'd like to disable session cache unconditionally, but foolish Outlook
2597 Express clients then give up the first TLS connection and make a second one
2598 (which works).  Only when there is an IMAP service on the same machine.
2599 Presumably OE is trying to use the cache for A on B.  Leave it enabled for
2600 now, until we work out a decent way of presenting control to the config.  It
2601 will never be used because we use a new context every time. */
2602 #ifdef notdef
2603 (void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
2604 #endif
2605
2606 /* Initialize with DH parameters if supplied */
2607 /* Initialize ECDH temp key parameter selection */
2608
2609 if (state->lib_state.dh)
2610   { DEBUG(D_tls) debug_printf("TLS: DH params were preloaded\n"); }
2611 else
2612   if (!init_dh(ctx, state->dhparam, host, errstr)) return DEFER;
2613
2614 if (state->lib_state.ecdh)
2615   { DEBUG(D_tls) debug_printf("TLS: ECDH curve was preloaded\n"); }
2616 else
2617   if (!init_ecdh(ctx, host, errstr)) return DEFER;
2618
2619 /* Set up certificate and key (and perhaps OCSP info) */
2620
2621 if (state->lib_state.conn_certs)
2622   {
2623   DEBUG(D_tls)
2624     debug_printf("TLS: %s certs were preloaded\n", host ? "client":"server");
2625   }
2626 else
2627   {
2628 #ifndef DISABLE_OCSP
2629   if (!host)
2630     {
2631     state->u_ocsp.server.file = ocsp_file;
2632     state->u_ocsp.server.file_expanded = NULL;
2633     state->u_ocsp.server.olist = NULL;
2634     }
2635 #endif
2636   if ((rc = tls_expand_session_files(ctx, state, errstr)) != OK) return rc;
2637   }
2638
2639 /* If we need to handle SNI or OCSP, do so */
2640
2641 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2642 # ifndef DISABLE_OCSP
2643   if (!(state->verify_stack = sk_X509_new_null()))
2644     {
2645     DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
2646     return FAIL;
2647     }
2648 # endif
2649
2650 if (!host)              /* server */
2651   {
2652 # ifndef DISABLE_OCSP
2653   /* We check u_ocsp.server.file, not server.olist, because we care about if
2654   the option exists, not what the current expansion might be, as SNI might
2655   change the certificate and OCSP file in use between now and the time the
2656   callback is invoked. */
2657   if (state->u_ocsp.server.file)
2658     {
2659     SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
2660     SSL_CTX_set_tlsext_status_arg(ctx, state);
2661     }
2662 # endif
2663   /* We always do this, so that $tls_sni is available even if not used in
2664   tls_certificate */
2665   SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
2666   SSL_CTX_set_tlsext_servername_arg(ctx, state);
2667
2668 # ifdef EXIM_HAVE_ALPN
2669   if (tls_alpn && *tls_alpn)
2670     {
2671     uschar * exp_alpn;
2672     if (  expand_check(tls_alpn, US"tls_alpn", &exp_alpn, errstr)
2673        && *exp_alpn && !isblank(*exp_alpn))
2674       {
2675       tls_alpn = exp_alpn;      /* subprocess so ok to overwrite */
2676       SSL_CTX_set_alpn_select_cb(ctx, tls_server_alpn_cb, state);
2677       }
2678     else
2679       tls_alpn = NULL;
2680     }
2681 # endif
2682   }
2683 # ifndef DISABLE_OCSP
2684 else                    /* client */
2685   if(ocsp_file)         /* wanting stapling */
2686     {
2687     if (!(state->u_ocsp.client.verify_store = X509_STORE_new()))
2688       {
2689       DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
2690       return FAIL;
2691       }
2692     SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
2693     SSL_CTX_set_tlsext_status_arg(ctx, state);
2694     }
2695 # endif
2696 #endif
2697
2698 state->verify_cert_hostnames = NULL;
2699
2700 #ifdef EXIM_HAVE_EPHEM_RSA_KEX
2701 /* Set up the RSA callback */
2702 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
2703 #endif
2704
2705 /* Finally, set the session cache timeout, and we are done.
2706 The period appears to be also used for (server-generated) session tickets */
2707
2708 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
2709 DEBUG(D_tls) debug_printf("Initialized TLS\n");
2710
2711 *caller_state = state;
2712
2713 return OK;
2714 }
2715
2716
2717
2718
2719 /*************************************************
2720 *           Get name of cipher in use            *
2721 *************************************************/
2722
2723 /*
2724 Argument:   pointer to an SSL structure for the connection
2725             pointer to number of bits for cipher
2726 Returns:    pointer to allocated string in perm-pool
2727 */
2728
2729 static uschar *
2730 construct_cipher_name(SSL * ssl, const uschar * ver, int * bits)
2731 {
2732 int pool = store_pool;
2733 /* With OpenSSL 1.0.0a, 'c' needs to be const but the documentation doesn't
2734 yet reflect that.  It should be a safe change anyway, even 0.9.8 versions have
2735 the accessor functions use const in the prototype. */
2736
2737 const SSL_CIPHER * c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
2738 uschar * s;
2739
2740 SSL_CIPHER_get_bits(c, bits);
2741
2742 store_pool = POOL_PERM;
2743 s = string_sprintf("%s:%s:%u", ver, SSL_CIPHER_get_name(c), *bits);
2744 store_pool = pool;
2745 DEBUG(D_tls) debug_printf("Cipher: %s\n", s);
2746 return s;
2747 }
2748
2749
2750 /* Get IETF-standard name for ciphersuite.
2751 Argument:   pointer to an SSL structure for the connection
2752 Returns:    pointer to string
2753 */
2754
2755 static const uschar *
2756 cipher_stdname_ssl(SSL * ssl)
2757 {
2758 #ifdef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
2759 return CUS SSL_CIPHER_standard_name(SSL_get_current_cipher(ssl));
2760 #else
2761 ushort id = 0xffff & SSL_CIPHER_get_id(SSL_get_current_cipher(ssl));
2762 return cipher_stdname(id >> 8, id & 0xff);
2763 #endif
2764 }
2765
2766
2767 static const uschar *
2768 tlsver_name(SSL * ssl)
2769 {
2770 uschar * s, * p;
2771 int pool = store_pool;
2772
2773 store_pool = POOL_PERM;
2774 s = string_copy(US SSL_get_version(ssl));
2775 store_pool = pool;
2776 if ((p = Ustrchr(s, 'v')))      /* TLSv1.2 -> TLS1.2 */
2777   for (;; p++) if (!(*p = p[1])) break;
2778 return CUS s;
2779 }
2780
2781
2782 static void
2783 peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned siz)
2784 {
2785 /*XXX we might consider a list-of-certs variable for the cert chain.
2786 SSL_get_peer_cert_chain(SSL*).  We'd need a new variable type and support
2787 in list-handling functions, also consider the difference between the entire
2788 chain and the elements sent by the peer. */
2789
2790 tlsp->peerdn = NULL;
2791
2792 /* Will have already noted peercert on a verify fail; possibly not the leaf */
2793 if (!tlsp->peercert)
2794   tlsp->peercert = SSL_get_peer_certificate(ssl);
2795 /* Beware anonymous ciphers which lead to server_cert being NULL */
2796 if (tlsp->peercert)
2797   if (!X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, siz))
2798     { DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n"); }
2799   else
2800     {
2801     int oldpool = store_pool;
2802
2803     peerdn[siz-1] = '\0';               /* paranoia */
2804     store_pool = POOL_PERM;
2805     tlsp->peerdn = string_copy(peerdn);
2806     store_pool = oldpool;
2807
2808     /* We used to set CV in the cert-verify callbacks (either plain or dane)
2809     but they don't get called on session-resumption.  So use the official
2810     interface, which uses the resumed value.  Unfortunately this claims verified
2811     when it actually failed but we're in try-verify mode, due to us wanting the
2812     knowlege that it failed so needing to have the callback and forcing a
2813     permissive return.  If we don't force it, the TLS startup is failed.
2814     The extra bit of information is set in verify_override in the cb, stashed
2815     for resumption next to the TLS session, and used here. */
2816
2817     if (!tlsp->verify_override)
2818       tlsp->certificate_verified =
2819 #ifdef SUPPORT_DANE
2820         tlsp->dane_verified ||
2821 #endif
2822         SSL_get_verify_result(ssl) == X509_V_OK;
2823     }
2824 }
2825
2826
2827
2828
2829
2830 /*************************************************
2831 *        Set up for verifying certificates       *
2832 *************************************************/
2833
2834 #ifndef DISABLE_OCSP
2835 /* Load certs from file, return TRUE on success */
2836
2837 static BOOL
2838 chain_from_pem_file(const uschar * file, STACK_OF(X509) ** vp)
2839 {
2840 BIO * bp;
2841 STACK_OF(X509) * verify_stack = *vp;
2842
2843 if (verify_stack)
2844   while (sk_X509_num(verify_stack) > 0)
2845     X509_free(sk_X509_pop(verify_stack));
2846 else
2847   verify_stack = sk_X509_new_null();
2848
2849 if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
2850 for (X509 * x; x = PEM_read_bio_X509(bp, NULL, 0, NULL); )
2851   sk_X509_push(verify_stack, x);
2852 BIO_free(bp);
2853 *vp = verify_stack;
2854 return TRUE;
2855 }
2856 #endif
2857
2858
2859
2860 /* Called by both client and server startup; on the server possibly
2861 repeated after a Server Name Indication.
2862
2863 Arguments:
2864   sctx          SSL_CTX* to initialise
2865   certs         certs file, expanded
2866   crl           CRL file or NULL
2867   host          NULL in a server; the remote host in a client
2868   errstr        error string pointer
2869
2870 Returns:        OK/DEFER/FAIL
2871 */
2872
2873 static int
2874 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host,
2875     uschar ** errstr)
2876 {
2877 uschar *expcerts, *expcrl;
2878
2879 if (!expand_check(certs, US"tls_verify_certificates", &expcerts, errstr))
2880   return DEFER;
2881 DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
2882
2883 if (expcerts && *expcerts)
2884   {
2885   /* Tell the library to use its compiled-in location for the system default
2886   CA bundle. Then add the ones specified in the config, if any. */
2887
2888   if (!SSL_CTX_set_default_verify_paths(sctx))
2889     return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
2890
2891   if (Ustrcmp(expcerts, "system") != 0 && Ustrncmp(expcerts, "system,", 7) != 0)
2892     {
2893     struct stat statbuf;
2894
2895     if (Ustat(expcerts, &statbuf) < 0)
2896       {
2897       log_write(0, LOG_MAIN|LOG_PANIC,
2898         "failed to stat %s for certificates", expcerts);
2899       return DEFER;
2900       }
2901     else
2902       {
2903       uschar *file, *dir;
2904       if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
2905         { file = NULL; dir = expcerts; }
2906       else
2907         {
2908         STACK_OF(X509) * verify_stack =
2909 #ifndef DISABLE_OCSP
2910           !host ? state_server.verify_stack :
2911 #endif
2912           NULL;
2913         STACK_OF(X509) ** vp = &verify_stack;
2914
2915         file = expcerts; dir = NULL;
2916 #ifndef DISABLE_OCSP
2917         /* In the server if we will be offering an OCSP proof, load chain from
2918         file for verifying the OCSP proof at load time. */
2919
2920 /*XXX Glitch!   The file here is tls_verify_certs: the chain for verifying the client cert.
2921 This is inconsistent with the need to verify the OCSP proof of the server cert.
2922 */
2923         if (  !host
2924            && statbuf.st_size > 0
2925            && state_server.u_ocsp.server.file
2926            && !chain_from_pem_file(file, vp)
2927            )
2928           {
2929           log_write(0, LOG_MAIN|LOG_PANIC,
2930             "failed to load cert chain from %s", file);
2931           return DEFER;
2932           }
2933 #endif
2934         }
2935
2936       /* If a certificate file is empty, the load function fails with an
2937       unhelpful error message. If we skip it, we get the correct behaviour (no
2938       certificates are recognized, but the error message is still misleading (it
2939       says no certificate was supplied).  But this is better. */
2940
2941       if (  (!file || statbuf.st_size > 0)
2942          && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
2943           return tls_error(US"SSL_CTX_load_verify_locations",
2944                             host, NULL, errstr);
2945
2946       /* On the server load the list of CAs for which we will accept certs, for
2947       sending to the client.  This is only for the one-file
2948       tls_verify_certificates variant.
2949       If a list isn't loaded into the server, but some verify locations are set,
2950       the server end appears to make a wildcard request for client certs.
2951       Meanwhile, the client library as default behaviour *ignores* the list
2952       we send over the wire - see man SSL_CTX_set_client_cert_cb.
2953       Because of this, and that the dir variant is likely only used for
2954       the public-CA bundle (not for a private CA), not worth fixing.  */
2955
2956       if (file)
2957         {
2958         STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
2959         int i = sk_X509_NAME_num(names);
2960
2961         if (!host) SSL_CTX_set_client_CA_list(sctx, names);
2962         DEBUG(D_tls) debug_printf("Added %d additional certificate authorit%s\n",
2963                                     i, i>1 ? "ies":"y");
2964         }
2965       else
2966         DEBUG(D_tls)
2967           debug_printf("Added dir for additional certificate authorities\n");
2968       }
2969     }
2970
2971   /* Handle a certificate revocation list. */
2972
2973 #if OPENSSL_VERSION_NUMBER > 0x00907000L
2974
2975   /* This bit of code is now the version supplied by Lars Mainka. (I have
2976   merely reformatted it into the Exim code style.)
2977
2978   "From here I changed the code to add support for multiple crl's
2979   in pem format in one file or to support hashed directory entries in
2980   pem format instead of a file. This method now uses the library function
2981   X509_STORE_load_locations to add the CRL location to the SSL context.
2982   OpenSSL will then handle the verify against CA certs and CRLs by
2983   itself in the verify callback." */
2984
2985   if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
2986   if (expcrl && *expcrl)
2987     {
2988     struct stat statbufcrl;
2989     if (Ustat(expcrl, &statbufcrl) < 0)
2990       {
2991       log_write(0, LOG_MAIN|LOG_PANIC,
2992         "failed to stat %s for certificates revocation lists", expcrl);
2993       return DEFER;
2994       }
2995     else
2996       {
2997       /* is it a file or directory? */
2998       uschar *file, *dir;
2999       X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
3000       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
3001         {
3002         file = NULL;
3003         dir = expcrl;
3004         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
3005         }
3006       else
3007         {
3008         file = expcrl;
3009         dir = NULL;
3010         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
3011         }
3012       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
3013         return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
3014
3015       /* setting the flags to check against the complete crl chain */
3016
3017       X509_STORE_set_flags(cvstore,
3018         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
3019       }
3020     }
3021
3022 #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
3023   }
3024
3025 return OK;
3026 }
3027
3028
3029
3030 /*************************************************
3031 *       Start a TLS session in a server          *
3032 *************************************************/
3033 /* This is called when Exim is running as a server, after having received
3034 the STARTTLS command. It must respond to that command, and then negotiate
3035 a TLS session.
3036
3037 Arguments:
3038   errstr            pointer to error message
3039
3040 Returns:            OK on success
3041                     DEFER for errors before the start of the negotiation
3042                     FAIL for errors during the negotiation; the server can't
3043                       continue running.
3044 */
3045
3046 int
3047 tls_server_start(uschar ** errstr)
3048 {
3049 int rc;
3050 uschar * expciphers;
3051 exim_openssl_state_st * dummy_statep;
3052 SSL_CTX * ctx;
3053 SSL * ssl;
3054 static uschar peerdn[256];
3055
3056 /* Check for previous activation */
3057
3058 if (tls_in.active.sock >= 0)
3059   {
3060   tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
3061   smtp_printf("554 Already in TLS\r\n", FALSE);
3062   return FAIL;
3063   }
3064
3065 /* Initialize the SSL library. If it fails, it will already have logged
3066 the error. */
3067
3068 rc = tls_init(NULL, NULL,
3069 #ifndef DISABLE_OCSP
3070     tls_ocsp_file,
3071 #endif
3072     NULL, &dummy_statep, &tls_in, errstr);
3073 if (rc != OK) return rc;
3074 ctx = state_server.lib_state.lib_ctx;
3075
3076 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
3077 were historically separated by underscores. So that I can use either form in my
3078 tests, and also for general convenience, we turn underscores into hyphens here.
3079
3080 XXX SSL_CTX_set_cipher_list() is replaced by SSL_CTX_set_ciphersuites()
3081 for TLS 1.3 .  Since we do not call it at present we get the default list:
3082 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
3083 */
3084
3085 if (state_server.lib_state.pri_string)
3086   { DEBUG(D_tls) debug_printf("TLS: cipher list was preloaded\n"); }
3087 else 
3088   {
3089   if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
3090     return FAIL;
3091
3092   if (  expciphers
3093      && (rc = server_load_ciphers(ctx, &state_server, expciphers, errstr)) != OK)
3094     return rc;
3095   }
3096
3097 /* If this is a host for which certificate verification is mandatory or
3098 optional, set up appropriately. */
3099
3100 tls_in.certificate_verified = FALSE;
3101 #ifdef SUPPORT_DANE
3102 tls_in.dane_verified = FALSE;
3103 #endif
3104 server_verify_callback_called = FALSE;
3105
3106 if (verify_check_host(&tls_verify_hosts) == OK)
3107   server_verify_optional = FALSE;
3108 else if (verify_check_host(&tls_try_verify_hosts) == OK)
3109   server_verify_optional = TRUE;
3110 else
3111   goto skip_certs;
3112
3113   {
3114   uschar * expcerts;
3115   if (!expand_check(tls_verify_certificates, US"tls_verify_certificates",
3116                     &expcerts, errstr))
3117     return DEFER;
3118   DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
3119
3120   if (state_server.lib_state.cabundle)
3121     { DEBUG(D_tls) debug_printf("TLS: CA bundle for server was preloaded\n"); }
3122   else
3123     if ((rc = setup_certs(ctx, expcerts, tls_crl, NULL, errstr)) != OK)
3124       return rc;
3125
3126   if (expcerts && *expcerts)
3127     setup_cert_verify(ctx, server_verify_optional, verify_callback_server);
3128   }
3129 skip_certs: ;
3130
3131 #ifndef DISABLE_TLS_RESUME
3132 SSL_CTX_set_tlsext_ticket_key_cb(ctx, ticket_key_callback);
3133 /* despite working, appears to always return failure, so ignoring */
3134 #endif
3135 #ifdef OPENSSL_HAVE_NUM_TICKETS
3136 # ifndef DISABLE_TLS_RESUME
3137 SSL_CTX_set_num_tickets(ctx, tls_in.host_resumable ? 1 : 0);
3138 # else
3139 SSL_CTX_set_num_tickets(ctx, 0);        /* send no TLS1.3 stateful-tickets */
3140 # endif
3141 #endif
3142
3143
3144 /* Prepare for new connection */
3145
3146 if (!(ssl = SSL_new(ctx)))
3147   return tls_error(US"SSL_new", NULL, NULL, errstr);
3148 state_server.lib_state.lib_ssl = ssl;
3149
3150 /* Warning: we used to SSL_clear(ssl) here, it was removed.
3151  *
3152  * With the SSL_clear(), we get strange interoperability bugs with
3153  * OpenSSL 1.0.1b and TLS1.1/1.2.  It looks as though this may be a bug in
3154  * OpenSSL itself, as a clear should not lead to inability to follow protocols.
3155  *
3156  * The SSL_clear() call is to let an existing SSL* be reused, typically after
3157  * session shutdown.  In this case, we have a brand new object and there's no
3158  * obvious reason to immediately clear it.  I'm guessing that this was
3159  * originally added because of incomplete initialisation which the clear fixed,
3160  * in some historic release.
3161  */
3162
3163 /* Set context and tell client to go ahead, except in the case of TLS startup
3164 on connection, where outputting anything now upsets the clients and tends to
3165 make them disconnect. We need to have an explicit fflush() here, to force out
3166 the response. Other smtp_printf() calls do not need it, because in non-TLS
3167 mode, the fflush() happens when smtp_getc() is called. */
3168
3169 SSL_set_session_id_context(ssl, sid_ctx, Ustrlen(sid_ctx));
3170 if (!tls_in.on_connect)
3171   {
3172   smtp_printf("220 TLS go ahead\r\n", FALSE);
3173   fflush(smtp_out);
3174   }
3175
3176 /* Now negotiate the TLS session. We put our own timer on it, since it seems
3177 that the OpenSSL library doesn't. */
3178
3179 SSL_set_wfd(ssl, fileno(smtp_out));
3180 SSL_set_rfd(ssl, fileno(smtp_in));
3181 SSL_set_accept_state(ssl);
3182
3183 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
3184
3185 ERR_clear_error();
3186 sigalrm_seen = FALSE;
3187 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3188 rc = SSL_accept(ssl);
3189 ALARM_CLR(0);
3190
3191 if (rc <= 0)
3192   {
3193   int error = SSL_get_error(ssl, rc);
3194   switch(error)
3195     {
3196     case SSL_ERROR_NONE:
3197       break;
3198
3199     case SSL_ERROR_ZERO_RETURN:
3200       DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3201       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
3202
3203       if (SSL_get_shutdown(ssl) == SSL_RECEIVED_SHUTDOWN)
3204             SSL_shutdown(ssl);
3205
3206       tls_close(NULL, TLS_NO_SHUTDOWN);
3207       return FAIL;
3208
3209     /* Handle genuine errors */
3210     case SSL_ERROR_SSL:
3211       {
3212       uschar * s = NULL;
3213       int r = ERR_GET_REASON(ERR_peek_error());
3214       if (  r == SSL_R_WRONG_VERSION_NUMBER
3215 #ifdef SSL_R_VERSION_TOO_LOW
3216          || r == SSL_R_VERSION_TOO_LOW
3217 #endif
3218          || r == SSL_R_UNKNOWN_PROTOCOL || r == SSL_R_UNSUPPORTED_PROTOCOL)
3219         s = string_sprintf("%s (%s)", s, SSL_get_version(ssl));
3220       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : s, errstr);
3221       return FAIL;
3222       }
3223
3224     default:
3225       DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
3226       if (error == SSL_ERROR_SYSCALL)
3227         {
3228         if (!errno)
3229           {
3230           *errstr = US"SSL_accept: TCP connection closed by peer";
3231           return FAIL;
3232           }
3233         DEBUG(D_tls) debug_printf(" - syscall %s\n", strerror(errno));
3234         }
3235       (void) tls_error(US"SSL_accept", NULL,
3236                       sigalrm_seen ? US"timed out"
3237                       : ERR_peek_error() ? NULL : string_sprintf("ret %d", error),
3238                       errstr);
3239       return FAIL;
3240     }
3241   }
3242
3243 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
3244 ERR_clear_error();      /* Even success can leave errors in the stack. Seen with
3245                         anon-authentication ciphersuite negotiated. */
3246
3247 #ifndef DISABLE_TLS_RESUME
3248 if (SSL_session_reused(ssl))
3249   {
3250   tls_in.resumption |= RESUME_USED;
3251   DEBUG(D_tls) debug_printf("Session reused\n");
3252   }
3253 #endif
3254
3255 #ifdef EXIM_HAVE_ALPN
3256 /* If require-alpn, check server_seen_alpn here.  Else abort TLS */
3257 if (!tls_alpn || !*tls_alpn)
3258   { DEBUG(D_tls) debug_printf("TLS: was not watching for ALPN\n"); }
3259 else if (!server_seen_alpn)
3260   if (verify_check_host(&hosts_require_alpn) == OK)
3261     {
3262     /* We'd like to send a definitive Alert but OpenSSL provides no facility */
3263     SSL_shutdown(ssl);
3264     tls_error(US"handshake", NULL, US"ALPN required but not negotiated", errstr);
3265     return FAIL;
3266     }
3267   else
3268     { DEBUG(D_tls) debug_printf("TLS: no ALPN presented in handshake\n"); }
3269 else DEBUG(D_tls)
3270   {
3271   const uschar * name;
3272   unsigned len;
3273   SSL_get0_alpn_selected(ssl, &name, &len);
3274   if (len && name)
3275     debug_printf("ALPN negotiated: '%.*s'\n", (int)*name, name+1);
3276   else
3277     debug_printf("ALPN: no protocol negotiated\n");
3278   }
3279 #endif
3280
3281
3282 /* TLS has been set up. Record data for the connection,
3283 adjust the input functions to read via TLS, and initialize things. */
3284
3285 #ifdef SSL_get_extms_support
3286 tls_in.ext_master_secret = SSL_get_extms_support(ssl) == 1;
3287 #endif
3288 peer_cert(ssl, &tls_in, peerdn, sizeof(peerdn));
3289
3290 tls_in.ver = tlsver_name(ssl);
3291 tls_in.cipher = construct_cipher_name(ssl, tls_in.ver, &tls_in.bits);
3292 tls_in.cipher_stdname = cipher_stdname_ssl(ssl);
3293
3294 DEBUG(D_tls)
3295   {
3296   uschar buf[2048];
3297   if (SSL_get_shared_ciphers(ssl, CS buf, sizeof(buf)))
3298     debug_printf("Shared ciphers: %s\n", buf);
3299
3300 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3301   {
3302   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
3303   SSL_SESSION_print_keylog(bp, SSL_get_session(ssl));
3304   BIO_free(bp);
3305   }
3306 #endif
3307
3308 #ifdef EXIM_HAVE_SESSION_TICKET
3309   {
3310   SSL_SESSION * ss = SSL_get_session(ssl);
3311   if (SSL_SESSION_has_ticket(ss))       /* 1.1.0 */
3312     debug_printf("The session has a ticket, life %lu seconds\n",
3313       SSL_SESSION_get_ticket_lifetime_hint(ss));
3314   }
3315 #endif
3316   }
3317
3318 /* Record the certificate we presented */
3319   {
3320   X509 * crt = SSL_get_certificate(ssl);
3321   tls_in.ourcert = crt ? X509_dup(crt) : NULL;
3322   }
3323
3324 /* Channel-binding info for authenticators
3325 See description in https://paquier.xyz/postgresql-2/channel-binding-openssl/ */
3326   {
3327   uschar c, * s;
3328   size_t len = SSL_get_peer_finished(ssl, &c, 0);
3329   int old_pool = store_pool;
3330
3331   SSL_get_peer_finished(ssl, s = store_get((int)len, FALSE), len);
3332   store_pool = POOL_PERM;
3333     tls_in.channelbinding = b64encode_taint(CUS s, (int)len, FALSE);
3334   store_pool = old_pool;
3335   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage %p\n", tls_in.channelbinding);
3336   }
3337
3338 /* Only used by the server-side tls (tls_in), including tls_getc.
3339    Client-side (tls_out) reads (seem to?) go via
3340    smtp_read_response()/ip_recv().
3341    Hence no need to duplicate for _in and _out.
3342  */
3343 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
3344 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
3345 ssl_xfer_eof = ssl_xfer_error = FALSE;
3346
3347 receive_getc = tls_getc;
3348 receive_getbuf = tls_getbuf;
3349 receive_get_cache = tls_get_cache;
3350 receive_hasc = tls_hasc;
3351 receive_ungetc = tls_ungetc;
3352 receive_feof = tls_feof;
3353 receive_ferror = tls_ferror;
3354 receive_smtp_buffered = tls_smtp_buffered;
3355
3356 tls_in.active.sock = fileno(smtp_out);
3357 tls_in.active.tls_ctx = NULL;   /* not using explicit ctx for server-side */
3358 return OK;
3359 }
3360
3361
3362
3363
3364 static int
3365 tls_client_basic_ctx_init(SSL_CTX * ctx,
3366     host_item * host, smtp_transport_options_block * ob, exim_openssl_state_st * state,
3367     uschar ** errstr)
3368 {
3369 int rc;
3370
3371 /* Back-compatible old behaviour if tls_verify_certificates is set but both
3372 tls_verify_hosts and tls_try_verify_hosts are not set. Check only the specified
3373 host patterns if one of them is set with content. */
3374
3375 if (  (  (  !ob->tls_verify_hosts || !ob->tls_verify_hosts
3376          || Ustrcmp(ob->tls_try_verify_hosts, ":") == 0
3377          )
3378       && (  !ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts
3379          || Ustrcmp(ob->tls_try_verify_hosts, ":") == 0
3380          )
3381       )
3382    || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
3383    )
3384   client_verify_optional = FALSE;
3385 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
3386   client_verify_optional = TRUE;
3387 else
3388   return OK;
3389
3390   {
3391   uschar * expcerts;
3392   if (!expand_check(ob->tls_verify_certificates, US"tls_verify_certificates",
3393                     &expcerts, errstr))
3394     return DEFER;
3395   DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
3396
3397   if (state->lib_state.cabundle)
3398     { DEBUG(D_tls) debug_printf("TLS: CA bundle was preloaded\n"); }
3399   else
3400     if ((rc = setup_certs(ctx, expcerts, ob->tls_crl, host, errstr)) != OK)
3401       return rc;
3402
3403   if (expcerts && *expcerts)
3404     setup_cert_verify(ctx, client_verify_optional, verify_callback_client);
3405   }
3406
3407 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
3408   {
3409   state->verify_cert_hostnames =
3410 #ifdef SUPPORT_I18N
3411     string_domain_utf8_to_alabel(host->certname, NULL);
3412 #else
3413     host->certname;
3414 #endif
3415   DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
3416                     state->verify_cert_hostnames);
3417   }
3418 return OK;
3419 }
3420
3421
3422 #ifdef SUPPORT_DANE
3423 static int
3424 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
3425 {
3426 dns_scan dnss;
3427 const char * hostnames[2] = { CS host->name, NULL };
3428 int found = 0;
3429
3430 if (DANESSL_init(ssl, NULL, hostnames) != 1)
3431   return tls_error(US"hostnames load", host, NULL, errstr);
3432
3433 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
3434      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
3435     ) if (rr->type == T_TLSA && rr->size > 3)
3436   {
3437   const uschar * p = rr->data;
3438   uint8_t usage, selector, mtype;
3439   const char * mdname;
3440
3441   usage = *p++;
3442
3443   /* Only DANE-TA(2) and DANE-EE(3) are supported */
3444   if (usage != 2 && usage != 3) continue;
3445
3446   selector = *p++;
3447   mtype = *p++;
3448
3449   switch (mtype)
3450     {
3451     default: continue;  /* Only match-types 0, 1, 2 are supported */
3452     case 0:  mdname = NULL; break;
3453     case 1:  mdname = "sha256"; break;
3454     case 2:  mdname = "sha512"; break;
3455     }
3456
3457   found++;
3458   switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
3459     {
3460     default:
3461       return tls_error(US"tlsa load", host, NULL, errstr);
3462     case 0:     /* action not taken */
3463     case 1:     break;
3464     }
3465
3466   tls_out.tlsa_usage |= 1<<usage;
3467   }
3468
3469 if (found)
3470   return OK;
3471
3472 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
3473 return DEFER;
3474 }
3475 #endif  /*SUPPORT_DANE*/
3476
3477
3478
3479 #ifndef DISABLE_TLS_RESUME
3480 /* On the client, get any stashed session for the given IP from hints db
3481 and apply it to the ssl-connection for attempted resumption. */
3482
3483 static void
3484 tls_retrieve_session(tls_support * tlsp, SSL * ssl, const uschar * key)
3485 {
3486 tlsp->resumption |= RESUME_SUPPORTED;
3487 if (tlsp->host_resumable)
3488   {
3489   dbdata_tls_session * dt;
3490   int len;
3491   open_db dbblock, * dbm_file;
3492
3493   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
3494   DEBUG(D_tls) debug_printf("checking for resumable session for %s\n", key);
3495   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3496     {
3497     /* key for the db is the IP */
3498     if ((dt = dbfn_read_with_length(dbm_file, key, &len)))
3499       {
3500       SSL_SESSION * ss = NULL;
3501       const uschar * sess_asn1 = dt->session;
3502
3503       len -= sizeof(dbdata_tls_session);
3504       if (!(d2i_SSL_SESSION(&ss, &sess_asn1, (long)len)))
3505         {
3506         DEBUG(D_tls)
3507           {
3508           ERR_error_string_n(ERR_get_error(),
3509             ssl_errstring, sizeof(ssl_errstring));
3510           debug_printf("decoding session: %s\n", ssl_errstring);
3511           }
3512         }
3513       else
3514         {
3515         unsigned long lifetime =
3516 #ifdef EXIM_HAVE_SESSION_TICKET
3517           SSL_SESSION_get_ticket_lifetime_hint(ss);
3518 #else                   /* Use, fairly arbitrilarily, what we as server would */
3519           f.running_in_test_harness ? 6 : ssl_session_timeout;
3520 #endif
3521         if (lifetime + dt->time_stamp < time(NULL))
3522           {
3523           DEBUG(D_tls) debug_printf("session expired\n");
3524           dbfn_delete(dbm_file, key);
3525           }
3526         else if (!SSL_set_session(ssl, ss))
3527           {
3528           DEBUG(D_tls)
3529             {
3530             ERR_error_string_n(ERR_get_error(),
3531               ssl_errstring, sizeof(ssl_errstring));
3532             debug_printf("applying session to ssl: %s\n", ssl_errstring);
3533             }
3534           }
3535         else
3536           {
3537           DEBUG(D_tls) debug_printf("good session\n");
3538           tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
3539           tlsp->verify_override = dt->verify_override;
3540           tlsp->ocsp = dt->ocsp;
3541           }
3542         }
3543       }
3544     else
3545       DEBUG(D_tls) debug_printf("no session record\n");
3546     dbfn_close(dbm_file);
3547     }
3548   }
3549 }
3550
3551
3552 /* On the client, save the session for later resumption */
3553
3554 static int
3555 tls_save_session_cb(SSL * ssl, SSL_SESSION * ss)
3556 {
3557 exim_openssl_state_st * cbinfo = SSL_get_ex_data(ssl, tls_exdata_idx);
3558 tls_support * tlsp;
3559
3560 DEBUG(D_tls) debug_printf("tls_save_session_cb\n");
3561
3562 if (!cbinfo || !(tlsp = cbinfo->tlsp)->host_resumable) return 0;
3563
3564 # ifdef OPENSSL_HAVE_NUM_TICKETS
3565 if (SSL_SESSION_is_resumable(ss))       /* 1.1.1 */
3566 # endif
3567   {
3568   int len = i2d_SSL_SESSION(ss, NULL);
3569   int dlen = sizeof(dbdata_tls_session) + len;
3570   dbdata_tls_session * dt = store_get(dlen, TRUE);
3571   uschar * s = dt->session;
3572   open_db dbblock, * dbm_file;
3573
3574   DEBUG(D_tls) debug_printf("session is resumable\n");
3575   tlsp->resumption |= RESUME_SERVER_TICKET;     /* server gave us a ticket */
3576
3577   dt->verify_override = tlsp->verify_override;
3578   dt->ocsp = tlsp->ocsp;
3579   (void) i2d_SSL_SESSION(ss, &s);               /* s gets bumped to end */
3580
3581   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3582     {
3583     const uschar * key = cbinfo->host->address;
3584     dbfn_delete(dbm_file, key);
3585     dbfn_write(dbm_file, key, dt, dlen);
3586     dbfn_close(dbm_file);
3587     DEBUG(D_tls) debug_printf("wrote session (len %u) to db\n",
3588                   (unsigned)dlen);
3589     }
3590   }
3591 return 1;
3592 }
3593
3594
3595 static void
3596 tls_client_ctx_resume_prehandshake(
3597   exim_openssl_client_tls_ctx * exim_client_ctx, tls_support * tlsp,
3598   smtp_transport_options_block * ob, host_item * host)
3599 {
3600 /* Should the client request a session resumption ticket? */
3601 if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
3602   {
3603   tlsp->host_resumable = TRUE;
3604
3605   SSL_CTX_set_session_cache_mode(exim_client_ctx->ctx,
3606         SSL_SESS_CACHE_CLIENT
3607         | SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_NO_AUTO_CLEAR);
3608   SSL_CTX_sess_set_new_cb(exim_client_ctx->ctx, tls_save_session_cb);
3609   }
3610 }
3611
3612 static BOOL
3613 tls_client_ssl_resume_prehandshake(SSL * ssl, tls_support * tlsp,
3614   host_item * host, uschar ** errstr)
3615 {
3616 if (tlsp->host_resumable)
3617   {
3618   DEBUG(D_tls)
3619     debug_printf("tls_resumption_hosts overrides openssl_options, enabling tickets\n");
3620   SSL_clear_options(ssl, SSL_OP_NO_TICKET);
3621
3622   tls_exdata_idx = SSL_get_ex_new_index(0, 0, 0, 0, 0);
3623   if (!SSL_set_ex_data(ssl, tls_exdata_idx, client_static_state))
3624     {
3625     tls_error(US"set ex_data", host, NULL, errstr);
3626     return FALSE;
3627     }
3628   debug_printf("tls_exdata_idx %d cbinfo %p\n", tls_exdata_idx, client_static_state);
3629   }
3630
3631 tlsp->resumption = RESUME_SUPPORTED;
3632 /* Pick up a previous session, saved on an old ticket */
3633 tls_retrieve_session(tlsp, ssl, host->address);
3634 return TRUE;
3635 }
3636
3637 static void
3638 tls_client_resume_posthandshake(exim_openssl_client_tls_ctx * exim_client_ctx,
3639   tls_support * tlsp)
3640 {
3641 if (SSL_session_reused(exim_client_ctx->ssl))
3642   {
3643   DEBUG(D_tls) debug_printf("The session was reused\n");
3644   tlsp->resumption |= RESUME_USED;
3645   }
3646 }
3647 #endif  /* !DISABLE_TLS_RESUME */
3648
3649
3650 #ifdef EXIM_HAVE_ALPN
3651 /* Expand and convert an Exim list to an ALPN list.  False return for fail.
3652 NULL plist return for silent no-ALPN.
3653 */
3654
3655 static BOOL
3656 tls_alpn_plist(const uschar * tls_alpn, const uschar ** plist, unsigned * plen,
3657   uschar ** errstr)
3658 {
3659 uschar * exp_alpn;
3660
3661 if (!expand_check(tls_alpn, US"tls_alpn", &exp_alpn, errstr))
3662   return FALSE;
3663
3664 if (!exp_alpn)
3665   {
3666   DEBUG(D_tls) debug_printf("Setting TLS ALPN forced to fail, not sending\n");
3667   *plist = NULL;
3668   }
3669 else
3670   {
3671   /* The server implementation only accepts exactly one protocol name
3672   but it's little extra code complexity in the client. */
3673
3674   const uschar * list = exp_alpn;
3675   uschar * p = store_get(Ustrlen(exp_alpn), is_tainted(exp_alpn)), * s, * t;
3676   int sep = 0;
3677   uschar len;
3678
3679   for (t = p; s = string_nextinlist(&list, &sep, NULL, 0); t += len)
3680     {
3681     *t++ = len = (uschar) Ustrlen(s);
3682     memcpy(t, s, len);
3683     }
3684   *plist = (*plen = t - p) ? p : NULL;
3685   }
3686 return TRUE;
3687 }
3688 #endif  /* EXIM_HAVE_ALPN */
3689
3690
3691 /*************************************************
3692 *    Start a TLS session in a client             *
3693 *************************************************/
3694
3695 /* Called from the smtp transport after STARTTLS has been accepted.
3696
3697 Arguments:
3698   cctx          connection context
3699   conn_args     connection details
3700   cookie        datum for randomness; can be NULL
3701   tlsp          record details of TLS channel configuration here; must be non-NULL
3702   errstr        error string pointer
3703
3704 Returns:        TRUE for success with TLS session context set in connection context,
3705                 FALSE on error
3706 */
3707
3708 BOOL
3709 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
3710   void * cookie, tls_support * tlsp, uschar ** errstr)
3711 {
3712 host_item * host = conn_args->host;             /* for msgs and option-tests */
3713 transport_instance * tb = conn_args->tblock;    /* always smtp or NULL */
3714 smtp_transport_options_block * ob = tb
3715   ? (smtp_transport_options_block *)tb->options_block
3716   : &smtp_transport_option_defaults;
3717 exim_openssl_client_tls_ctx * exim_client_ctx;
3718 uschar * expciphers;
3719 int rc;
3720 static uschar peerdn[256];
3721
3722 #ifndef DISABLE_OCSP
3723 BOOL request_ocsp = FALSE;
3724 BOOL require_ocsp = FALSE;
3725 #endif
3726
3727 rc = store_pool;
3728 store_pool = POOL_PERM;
3729 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx), FALSE);
3730 exim_client_ctx->corked = NULL;
3731 store_pool = rc;
3732
3733 #ifdef SUPPORT_DANE
3734 tlsp->tlsa_usage = 0;
3735 #endif
3736
3737 #ifndef DISABLE_OCSP
3738   {
3739 # ifdef SUPPORT_DANE
3740   /*XXX this should be moved to caller, to be common across gnutls/openssl */
3741   if (  conn_args->dane
3742      && ob->hosts_request_ocsp[0] == '*'
3743      && ob->hosts_request_ocsp[1] == '\0'
3744      )
3745     {
3746     /* Unchanged from default.  Use a safer one under DANE */
3747     request_ocsp = TRUE;
3748     ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
3749                                       "   {= {4}{$tls_out_tlsa_usage}} } "
3750                                  " {*}{}}";
3751     }
3752 # endif
3753
3754   if ((require_ocsp =
3755         verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK))
3756     request_ocsp = TRUE;
3757   else
3758 # ifdef SUPPORT_DANE
3759     if (!request_ocsp)
3760 # endif
3761       request_ocsp =
3762         verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3763   }
3764 #endif
3765
3766 rc = tls_init(host, ob,
3767 #ifndef DISABLE_OCSP
3768     (void *)(long)request_ocsp,
3769 #endif
3770     cookie, &client_static_state, tlsp, errstr);
3771 if (rc != OK) return FALSE;
3772
3773 exim_client_ctx->ctx = client_static_state->lib_state.lib_ctx;
3774
3775 tlsp->certificate_verified = FALSE;
3776 client_verify_callback_called = FALSE;
3777
3778 expciphers = NULL;
3779 #ifdef SUPPORT_DANE
3780 if (conn_args->dane)
3781   {
3782   /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
3783   other failures should be treated as problems. */
3784   if (ob->dane_require_tls_ciphers &&
3785       !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
3786         &expciphers, errstr))
3787     return FALSE;
3788   if (expciphers && *expciphers == '\0')
3789     expciphers = NULL;
3790   }
3791 #endif
3792 if (!expciphers &&
3793     !expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
3794       &expciphers, errstr))
3795   return FALSE;
3796
3797 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
3798 are separated by underscores. So that I can use either form in my tests, and
3799 also for general convenience, we turn underscores into hyphens here. */
3800
3801 if (expciphers)
3802   {
3803   uschar *s = expciphers;
3804   while (*s) { if (*s == '_') *s = '-'; s++; }
3805   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
3806   if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
3807     {
3808     tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
3809     return FALSE;
3810     }
3811   }
3812
3813 #ifdef SUPPORT_DANE
3814 if (conn_args->dane)
3815   {
3816   SSL_CTX_set_verify(exim_client_ctx->ctx,
3817     SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
3818     verify_callback_client_dane);
3819
3820   if (!DANESSL_library_init())
3821     {
3822     tls_error(US"library init", host, NULL, errstr);
3823     return FALSE;
3824     }
3825   if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
3826     {
3827     tls_error(US"context init", host, NULL, errstr);
3828     return FALSE;
3829     }
3830   }
3831 else
3832
3833 #endif
3834
3835 if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
3836       client_static_state, errstr) != OK)
3837   return FALSE;
3838
3839 #ifndef DISABLE_TLS_RESUME
3840 tls_client_ctx_resume_prehandshake(exim_client_ctx, tlsp, ob, host);
3841 #endif
3842
3843
3844 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
3845   {
3846   tls_error(US"SSL_new", host, NULL, errstr);
3847   return FALSE;
3848   }
3849 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
3850
3851 SSL_set_fd(exim_client_ctx->ssl, cctx->sock);
3852 SSL_set_connect_state(exim_client_ctx->ssl);
3853
3854 if (ob->tls_sni)
3855   {
3856   if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
3857     return FALSE;
3858   if (!tlsp->sni)
3859     {
3860     DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
3861     }
3862   else if (!Ustrlen(tlsp->sni))
3863     tlsp->sni = NULL;
3864   else
3865     {
3866 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
3867     DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
3868     SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
3869 #else
3870     log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
3871           tlsp->sni);
3872 #endif
3873     }
3874   }
3875
3876 if (ob->tls_alpn)
3877 #ifdef EXIM_HAVE_ALPN
3878   {
3879   const uschar * plist;
3880   unsigned plen;
3881
3882   if (!tls_alpn_plist(ob->tls_alpn, &plist, &plen, errstr))
3883     return FALSE;
3884   if (plist)
3885     if (SSL_set_alpn_protos(exim_client_ctx->ssl, plist, plen) != 0)
3886       {
3887       tls_error(US"alpn init", host, NULL, errstr);
3888       return FALSE;
3889       }
3890     else
3891       DEBUG(D_tls) debug_printf("Setting TLS ALPN '%s'\n", ob->tls_alpn);
3892   }
3893 #else
3894   log_write(0, LOG_MAIN, "ALPN unusable with this OpenSSL library version; ignoring \"%s\"\n",
3895           ob->tls_alpn);
3896 #endif
3897
3898 #ifdef SUPPORT_DANE
3899 if (conn_args->dane)
3900   if (dane_tlsa_load(exim_client_ctx->ssl, host, &conn_args->tlsa_dnsa, errstr) != OK)
3901     return FALSE;
3902 #endif
3903
3904 #ifndef DISABLE_OCSP
3905 /* Request certificate status at connection-time.  If the server
3906 does OCSP stapling we will get the callback (set in tls_init()) */
3907 # ifdef SUPPORT_DANE
3908 if (request_ocsp)
3909   {
3910   const uschar * s;
3911   if (  ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3912      || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3913      )
3914     {   /* Re-eval now $tls_out_tlsa_usage is populated.  If
3915         this means we avoid the OCSP request, we wasted the setup
3916         cost in tls_init(). */
3917     require_ocsp = verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
3918     request_ocsp = require_ocsp
3919       || verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3920     }
3921   }
3922 # endif
3923
3924 if (request_ocsp)
3925   {
3926   SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
3927   client_static_state->u_ocsp.client.verify_required = require_ocsp;
3928   tlsp->ocsp = OCSP_NOT_RESP;
3929   }
3930 #endif
3931
3932 #ifndef DISABLE_TLS_RESUME
3933 if (!tls_client_ssl_resume_prehandshake(exim_client_ctx->ssl, tlsp, host,
3934       errstr))
3935   return FALSE;
3936 #endif
3937
3938 #ifndef DISABLE_EVENT
3939 client_static_state->event_action = tb ? tb->event_action : NULL;
3940 #endif
3941
3942 /* There doesn't seem to be a built-in timeout on connection. */
3943
3944 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
3945 sigalrm_seen = FALSE;
3946 ALARM(ob->command_timeout);
3947 rc = SSL_connect(exim_client_ctx->ssl);
3948 ALARM_CLR(0);
3949
3950 #ifdef SUPPORT_DANE
3951 if (conn_args->dane)
3952   DANESSL_cleanup(exim_client_ctx->ssl);
3953 #endif
3954
3955 if (rc <= 0)
3956   {
3957   tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
3958   return FALSE;
3959   }
3960
3961 DEBUG(D_tls)
3962   {
3963   debug_printf("SSL_connect succeeded\n");
3964 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3965   {
3966   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
3967   SSL_SESSION_print_keylog(bp, SSL_get_session(exim_client_ctx->ssl));
3968   BIO_free(bp);
3969   }
3970 #endif
3971   }
3972
3973 #ifndef DISABLE_TLS_RESUME
3974 tls_client_resume_posthandshake(exim_client_ctx, tlsp);
3975 #endif
3976
3977 #ifdef EXIM_HAVE_ALPN
3978 if (ob->tls_alpn)       /* We requested. See what was negotiated. */
3979   {
3980   const uschar * name;
3981   unsigned len;
3982
3983   SSL_get0_alpn_selected(exim_client_ctx->ssl, &name, &len);
3984   if (len > 0)
3985     { DEBUG(D_tls) debug_printf("ALPN negotiated %u: '%.*s'\n", len, (int)*name, name+1); }
3986   else if (verify_check_given_host(CUSS &ob->hosts_require_alpn, host) == OK)
3987     {
3988     /* Would like to send a relevant fatal Alert, but OpenSSL has no API */
3989     tls_error(US"handshake", host, US"ALPN required but not negotiated", errstr);
3990     return FALSE;
3991     }
3992   }
3993 #endif
3994
3995 #ifdef SSL_get_extms_support
3996 tlsp->ext_master_secret = SSL_get_extms_support(exim_client_ctx->ssl) == 1;
3997 #endif
3998 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
3999
4000 tlsp->ver = tlsver_name(exim_client_ctx->ssl);
4001 tlsp->cipher = construct_cipher_name(exim_client_ctx->ssl, tlsp->ver, &tlsp->bits);
4002 tlsp->cipher_stdname = cipher_stdname_ssl(exim_client_ctx->ssl);
4003
4004 /* Record the certificate we presented */
4005   {
4006   X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
4007   tlsp->ourcert = crt ? X509_dup(crt) : NULL;
4008   }
4009
4010 /*XXX will this work with continued-TLS? */
4011 /* Channel-binding info for authenticators */
4012   {
4013   uschar c, * s;
4014   size_t len = SSL_get_finished(exim_client_ctx->ssl, &c, 0);
4015   int old_pool = store_pool;
4016
4017   SSL_get_finished(exim_client_ctx->ssl, s = store_get((int)len, TRUE), len);
4018   store_pool = POOL_PERM;
4019     tlsp->channelbinding = b64encode_taint(CUS s, (int)len, TRUE);
4020   store_pool = old_pool;
4021   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage %p %p\n", tlsp->channelbinding, tlsp);
4022   }
4023
4024 tlsp->active.sock = cctx->sock;
4025 tlsp->active.tls_ctx = exim_client_ctx;
4026 cctx->tls_ctx = exim_client_ctx;
4027 return TRUE;
4028 }
4029
4030
4031
4032
4033
4034 static BOOL
4035 tls_refill(unsigned lim)
4036 {
4037 SSL * ssl = state_server.lib_state.lib_ssl;
4038 int error;
4039 int inbytes;
4040
4041 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
4042   ssl_xfer_buffer, ssl_xfer_buffer_size);
4043
4044 ERR_clear_error();
4045 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
4046 inbytes = SSL_read(ssl, CS ssl_xfer_buffer,
4047                   MIN(ssl_xfer_buffer_size, lim));
4048 error = SSL_get_error(ssl, inbytes);
4049 if (smtp_receive_timeout > 0) ALARM_CLR(0);
4050
4051 if (had_command_timeout)                /* set by signal handler */
4052   smtp_command_timeout_exit();          /* does not return */
4053 if (had_command_sigterm)
4054   smtp_command_sigterm_exit();
4055 if (had_data_timeout)
4056   smtp_data_timeout_exit();
4057 if (had_data_sigint)
4058   smtp_data_sigint_exit();
4059
4060 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
4061 closed down, not that the socket itself has been closed down. Revert to
4062 non-SSL handling. */
4063
4064 switch(error)
4065   {
4066   case SSL_ERROR_NONE:
4067     break;
4068
4069   case SSL_ERROR_ZERO_RETURN:
4070     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
4071
4072     if (SSL_get_shutdown(ssl) == SSL_RECEIVED_SHUTDOWN)
4073           SSL_shutdown(ssl);
4074
4075     tls_close(NULL, TLS_NO_SHUTDOWN);
4076     return FALSE;
4077
4078   /* Handle genuine errors */
4079   case SSL_ERROR_SSL:
4080     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4081     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
4082     ssl_xfer_error = TRUE;
4083     return FALSE;
4084
4085   default:
4086     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
4087     DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
4088       debug_printf(" - syscall %s\n", strerror(errno));
4089     ssl_xfer_error = TRUE;
4090     return FALSE;
4091   }
4092
4093 #ifndef DISABLE_DKIM
4094 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
4095 #endif
4096 ssl_xfer_buffer_hwm = inbytes;
4097 ssl_xfer_buffer_lwm = 0;
4098 return TRUE;
4099 }
4100
4101
4102 /*************************************************
4103 *            TLS version of getc                 *
4104 *************************************************/
4105
4106 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
4107 it refills the buffer via the SSL reading function.
4108
4109 Arguments:  lim         Maximum amount to read/buffer
4110 Returns:    the next character or EOF
4111
4112 Only used by the server-side TLS.
4113 */
4114
4115 int
4116 tls_getc(unsigned lim)
4117 {
4118 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
4119   if (!tls_refill(lim))
4120     return ssl_xfer_error ? EOF : smtp_getc(lim);
4121
4122 /* Something in the buffer; return next uschar */
4123
4124 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
4125 }
4126
4127 BOOL
4128 tls_hasc(void)
4129 {
4130 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm;
4131 }
4132
4133 uschar *
4134 tls_getbuf(unsigned * len)
4135 {
4136 unsigned size;
4137 uschar * buf;
4138
4139 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
4140   if (!tls_refill(*len))
4141     {
4142     if (!ssl_xfer_error) return smtp_getbuf(len);
4143     *len = 0;
4144     return NULL;
4145     }
4146
4147 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
4148   size = *len;
4149 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
4150 ssl_xfer_buffer_lwm += size;
4151 *len = size;
4152 return buf;
4153 }
4154
4155
4156 void
4157 tls_get_cache(unsigned lim)
4158 {
4159 #ifndef DISABLE_DKIM
4160 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
4161 debug_printf("tls_get_cache\n");
4162 if (n > lim)
4163   n = lim;
4164 if (n > 0)
4165   dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
4166 #endif
4167 }
4168
4169
4170 BOOL
4171 tls_could_read(void)
4172 {
4173 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm
4174     || SSL_pending(state_server.lib_state.lib_ssl) > 0;
4175 }
4176
4177
4178 /*************************************************
4179 *          Read bytes from TLS channel           *
4180 *************************************************/
4181
4182 /*
4183 Arguments:
4184   ct_ctx    client context pointer, or NULL for the one global server context
4185   buff      buffer of data
4186   len       size of buffer
4187
4188 Returns:    the number of bytes read
4189             -1 after a failed read, including EOF
4190
4191 Only used by the client-side TLS.
4192 */
4193
4194 int
4195 tls_read(void * ct_ctx, uschar *buff, size_t len)
4196 {
4197 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl
4198                   : state_server.lib_state.lib_ssl;
4199 int inbytes;
4200 int error;
4201
4202 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
4203   buff, (unsigned int)len);
4204
4205 ERR_clear_error();
4206 inbytes = SSL_read(ssl, CS buff, len);
4207 error = SSL_get_error(ssl, inbytes);
4208
4209 if (error == SSL_ERROR_ZERO_RETURN)
4210   {
4211   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
4212   return -1;
4213   }
4214 else if (error != SSL_ERROR_NONE)
4215   return -1;
4216
4217 return inbytes;
4218 }
4219
4220
4221
4222
4223
4224 /*************************************************
4225 *         Write bytes down TLS channel           *
4226 *************************************************/
4227
4228 /*
4229 Arguments:
4230   ct_ctx    client context pointer, or NULL for the one global server context
4231   buff      buffer of data
4232   len       number of bytes
4233   more      further data expected soon
4234
4235 Returns:    the number of bytes after a successful write,
4236             -1 after a failed write
4237
4238 Used by both server-side and client-side TLS.  Calling with len zero and more unset
4239 will flush buffered writes; buff can be null for this case.
4240 */
4241
4242 int
4243 tls_write(void * ct_ctx, const uschar * buff, size_t len, BOOL more)
4244 {
4245 size_t olen = len;
4246 int outbytes, error;
4247 SSL * ssl = ct_ctx
4248   ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl
4249   : state_server.lib_state.lib_ssl;
4250 static gstring * server_corked = NULL;
4251 gstring ** corkedp = ct_ctx
4252   ? &((exim_openssl_client_tls_ctx *)ct_ctx)->corked : &server_corked;
4253 gstring * corked = *corkedp;
4254
4255 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
4256   buff, (unsigned long)len, more ? ", more" : "");
4257
4258 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
4259 "more" is notified.  This hack is only ok if small amounts are involved AND only
4260 one stream does it, in one context (i.e. no store reset).  Currently it is used
4261 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only.
4262 We support callouts done by the server process by using a separate client
4263 context for the stashed information. */
4264 /* + if PIPE_COMMAND, banner & ehlo-resp for smmtp-on-connect. Suspect there's
4265 a store reset there, so use POOL_PERM. */
4266 /* + if CHUNKING, cmds EHLO,MAIL,RCPT(s),BDAT */
4267
4268 if (more || corked)
4269   {
4270   if (!len) buff = US &error;   /* dummy just so that string_catn is ok */
4271
4272   int save_pool = store_pool;
4273   store_pool = POOL_PERM;
4274
4275   corked = string_catn(corked, buff, len);
4276
4277   store_pool = save_pool;
4278
4279   if (more)
4280     {
4281     *corkedp = corked;
4282     return len;
4283     }
4284   buff = CUS corked->s;
4285   len = corked->ptr;
4286   *corkedp = NULL;
4287   }
4288
4289 for (int left = len; left > 0;)
4290   {
4291   DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
4292   ERR_clear_error();
4293   outbytes = SSL_write(ssl, CS buff, left);
4294   error = SSL_get_error(ssl, outbytes);
4295   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
4296   switch (error)
4297     {
4298     case SSL_ERROR_NONE:        /* the usual case */
4299       left -= outbytes;
4300       buff += outbytes;
4301       break;
4302
4303     case SSL_ERROR_SSL:
4304       ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4305       log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
4306       return -1;
4307
4308     case SSL_ERROR_ZERO_RETURN:
4309       log_write(0, LOG_MAIN, "SSL channel closed on write");
4310       return -1;
4311
4312     case SSL_ERROR_SYSCALL:
4313       if (ct_ctx || errno != ECONNRESET || !f.smtp_in_quit)
4314         log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
4315           sender_fullhost ? sender_fullhost : US"<unknown>",
4316           strerror(errno));
4317       else if (LOGGING(protocol_detail))
4318         log_write(0, LOG_MAIN, "[%s] after QUIT, client reset TCP before"
4319           " SMTP response and TLS close\n", sender_host_address);
4320       else
4321         DEBUG(D_tls) debug_printf("[%s] SSL_write: after QUIT,"
4322           " client reset TCP before TLS close\n", sender_host_address);
4323       return -1;
4324
4325     default:
4326       log_write(0, LOG_MAIN, "SSL_write error %d", error);
4327       return -1;
4328     }
4329   }
4330 return olen;
4331 }
4332
4333
4334
4335 /*
4336 Arguments:
4337   ct_ctx        client TLS context pointer, or NULL for the one global server context
4338 */
4339
4340 void
4341 tls_shutdown_wr(void * ct_ctx)
4342 {
4343 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
4344 SSL ** sslp = o_ctx ? &o_ctx->ssl : (SSL **) &state_server.lib_state.lib_ssl;
4345 int * fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
4346 int rc;
4347
4348 if (*fdp < 0) return;  /* TLS was not active */
4349
4350 tls_write(ct_ctx, NULL, 0, FALSE);      /* flush write buffer */
4351
4352 HDEBUG(D_transport|D_tls|D_acl|D_v) debug_printf_indent("  SMTP(TLS shutdown)>>\n");
4353 rc = SSL_shutdown(*sslp);
4354 if (rc < 0) DEBUG(D_tls)
4355   {
4356   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4357   debug_printf("SSL_shutdown: %s\n", ssl_errstring);
4358   }
4359 }
4360
4361 /*************************************************
4362 *         Close down a TLS session               *
4363 *************************************************/
4364
4365 /* This is also called from within a delivery subprocess forked from the
4366 daemon, to shut down the TLS library, without actually doing a shutdown (which
4367 would tamper with the SSL session in the parent process).
4368
4369 Arguments:
4370   ct_ctx        client TLS context pointer, or NULL for the one global server context
4371   do_shutdown   0 no data-flush or TLS close-alert
4372                 1 if TLS close-alert is to be sent,
4373                 2 if also response to be waited for
4374
4375 Returns:     nothing
4376
4377 Used by both server-side and client-side TLS.
4378 */
4379
4380 void
4381 tls_close(void * ct_ctx, int do_shutdown)
4382 {
4383 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
4384 SSL ** sslp = o_ctx ? &o_ctx->ssl : (SSL **) &state_server.lib_state.lib_ssl;
4385 int * fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
4386
4387 if (*fdp < 0) return;  /* TLS was not active */
4388
4389 if (do_shutdown)
4390   {
4391   int rc;
4392   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
4393     do_shutdown > 1 ? " (with response-wait)" : "");
4394
4395   tls_write(ct_ctx, NULL, 0, FALSE);    /* flush write buffer */
4396
4397   if (  (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
4398      && do_shutdown > 1)
4399     {
4400     ALARM(2);
4401     rc = SSL_shutdown(*sslp);           /* wait for response */
4402     ALARM_CLR(0);
4403     }
4404
4405   if (rc < 0) DEBUG(D_tls)
4406     {
4407     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4408     debug_printf("SSL_shutdown: %s\n", ssl_errstring);
4409     }
4410   }
4411
4412 if (!o_ctx)             /* server side */
4413   {
4414 #ifndef DISABLE_OCSP
4415   sk_X509_pop_free(state_server.verify_stack, X509_free);
4416   state_server.verify_stack = NULL;
4417 #endif
4418
4419   receive_getc =        smtp_getc;
4420   receive_getbuf =      smtp_getbuf;
4421   receive_get_cache =   smtp_get_cache;
4422   receive_hasc =        smtp_hasc;
4423   receive_ungetc =      smtp_ungetc;
4424   receive_feof =        smtp_feof;
4425   receive_ferror =      smtp_ferror;
4426   receive_smtp_buffered = smtp_buffered;
4427   tls_in.active.tls_ctx = NULL;
4428   tls_in.sni = NULL;
4429   /* Leave bits, peercert, cipher, peerdn, certificate_verified set, for logging */
4430   }
4431
4432 SSL_free(*sslp);
4433 *sslp = NULL;
4434 *fdp = -1;
4435 }
4436
4437
4438
4439
4440 /*************************************************
4441 *  Let tls_require_ciphers be checked at startup *
4442 *************************************************/
4443
4444 /* The tls_require_ciphers option, if set, must be something which the
4445 library can parse.
4446
4447 Returns:     NULL on success, or error message
4448 */
4449
4450 uschar *
4451 tls_validate_require_cipher(void)
4452 {
4453 SSL_CTX *ctx;
4454 uschar *s, *expciphers, *err;
4455
4456 tls_openssl_init();
4457
4458 if (!(tls_require_ciphers && *tls_require_ciphers))
4459   return NULL;
4460
4461 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
4462                   &err))
4463   return US"failed to expand tls_require_ciphers";
4464
4465 if (!(expciphers && *expciphers))
4466   return NULL;
4467
4468 /* normalisation ripped from above */
4469 s = expciphers;
4470 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
4471
4472 err = NULL;
4473
4474 if (lib_ctx_new(&ctx, NULL, &err) == OK)
4475   {
4476   DEBUG(D_tls)
4477     debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
4478
4479   if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
4480     {
4481     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4482     err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
4483                         expciphers, ssl_errstring);
4484     }
4485
4486   SSL_CTX_free(ctx);
4487   }
4488 return err;
4489 }
4490
4491
4492
4493
4494 /*************************************************
4495 *         Report the library versions.           *
4496 *************************************************/
4497
4498 /* There have historically been some issues with binary compatibility in
4499 OpenSSL libraries; if Exim (like many other applications) is built against
4500 one version of OpenSSL but the run-time linker picks up another version,
4501 it can result in serious failures, including crashing with a SIGSEGV.  So
4502 report the version found by the compiler and the run-time version.
4503
4504 Note: some OS vendors backport security fixes without changing the version
4505 number/string, and the version date remains unchanged.  The _build_ date
4506 will change, so we can more usefully assist with version diagnosis by also
4507 reporting the build date.
4508
4509 Arguments:   a FILE* to print the results to
4510 Returns:     nothing
4511 */
4512
4513 void
4514 tls_version_report(FILE *f)
4515 {
4516 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
4517            "                          Runtime: %s\n"
4518            "                                 : %s\n",
4519            OPENSSL_VERSION_TEXT,
4520            SSLeay_version(SSLEAY_VERSION),
4521            SSLeay_version(SSLEAY_BUILT_ON));
4522 /* third line is 38 characters for the %s and the line is 73 chars long;
4523 the OpenSSL output includes a "built on: " prefix already. */
4524 }
4525
4526
4527
4528
4529 /*************************************************
4530 *            Random number generation            *
4531 *************************************************/
4532
4533 /* Pseudo-random number generation.  The result is not expected to be
4534 cryptographically strong but not so weak that someone will shoot themselves
4535 in the foot using it as a nonce in input in some email header scheme or
4536 whatever weirdness they'll twist this into.  The result should handle fork()
4537 and avoid repeating sequences.  OpenSSL handles that for us.
4538
4539 Arguments:
4540   max       range maximum
4541 Returns     a random number in range [0, max-1]
4542 */
4543
4544 int
4545 vaguely_random_number(int max)
4546 {
4547 unsigned int r;
4548 int i, needed_len;
4549 static pid_t pidlast = 0;
4550 pid_t pidnow;
4551 uschar smallbuf[sizeof(r)];
4552
4553 if (max <= 1)
4554   return 0;
4555
4556 pidnow = getpid();
4557 if (pidnow != pidlast)
4558   {
4559   /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
4560   is unique for each thread", this doesn't apparently apply across processes,
4561   so our own warning from vaguely_random_number_fallback() applies here too.
4562   Fix per PostgreSQL. */
4563   if (pidlast != 0)
4564     RAND_cleanup();
4565   pidlast = pidnow;
4566   }
4567
4568 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
4569 if (!RAND_status())
4570   {
4571   randstuff r;
4572   gettimeofday(&r.tv, NULL);
4573   r.p = getpid();
4574
4575   RAND_seed(US (&r), sizeof(r));
4576   }
4577 /* We're after pseudo-random, not random; if we still don't have enough data
4578 in the internal PRNG then our options are limited.  We could sleep and hope
4579 for entropy to come along (prayer technique) but if the system is so depleted
4580 in the first place then something is likely to just keep taking it.  Instead,
4581 we'll just take whatever little bit of pseudo-random we can still manage to
4582 get. */
4583
4584 needed_len = sizeof(r);
4585 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
4586 asked for a number less than 10. */
4587 for (r = max, i = 0; r; ++i)
4588   r >>= 1;
4589 i = (i + 7) / 8;
4590 if (i < needed_len)
4591   needed_len = i;
4592
4593 #ifdef EXIM_HAVE_RAND_PSEUDO
4594 /* We do not care if crypto-strong */
4595 i = RAND_pseudo_bytes(smallbuf, needed_len);
4596 #else
4597 i = RAND_bytes(smallbuf, needed_len);
4598 #endif
4599
4600 if (i < 0)
4601   {
4602   DEBUG(D_all)
4603     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
4604   return vaguely_random_number_fallback(max);
4605   }
4606
4607 r = 0;
4608 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
4609   r = 256 * r + *p;
4610
4611 /* We don't particularly care about weighted results; if someone wants
4612 smooth distribution and cares enough then they should submit a patch then. */
4613 return r % max;
4614 }
4615
4616
4617
4618
4619 /*************************************************
4620 *        OpenSSL option parse                    *
4621 *************************************************/
4622
4623 /* Parse one option for tls_openssl_options_parse below
4624
4625 Arguments:
4626   name    one option name
4627   value   place to store a value for it
4628 Returns   success or failure in parsing
4629 */
4630
4631
4632
4633 static BOOL
4634 tls_openssl_one_option_parse(uschar *name, long *value)
4635 {
4636 int first = 0;
4637 int last = exim_openssl_options_size;
4638 while (last > first)
4639   {
4640   int middle = (first + last)/2;
4641   int c = Ustrcmp(name, exim_openssl_options[middle].name);
4642   if (c == 0)
4643     {
4644     *value = exim_openssl_options[middle].value;
4645     return TRUE;
4646     }
4647   else if (c > 0)
4648     first = middle + 1;
4649   else
4650     last = middle;
4651   }
4652 return FALSE;
4653 }
4654
4655
4656
4657
4658 /*************************************************
4659 *        OpenSSL option parsing logic            *
4660 *************************************************/
4661
4662 /* OpenSSL has a number of compatibility options which an administrator might
4663 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
4664 we look like log_selector.
4665
4666 Arguments:
4667   option_spec  the administrator-supplied string of options
4668   results      ptr to long storage for the options bitmap
4669 Returns        success or failure
4670 */
4671
4672 BOOL
4673 tls_openssl_options_parse(uschar *option_spec, long *results)
4674 {
4675 long result, item;
4676 uschar * exp, * end;
4677 BOOL adding, item_parsed;
4678
4679 /* Server: send no (<= TLS1.2) session tickets */
4680 result = SSL_OP_NO_TICKET;
4681
4682 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
4683 from default because it increases BEAST susceptibility. */
4684 #ifdef SSL_OP_NO_SSLv2
4685 result |= SSL_OP_NO_SSLv2;
4686 #endif
4687 #ifdef SSL_OP_NO_SSLv3
4688 result |= SSL_OP_NO_SSLv3;
4689 #endif
4690 #ifdef SSL_OP_SINGLE_DH_USE
4691 result |= SSL_OP_SINGLE_DH_USE;
4692 #endif
4693 #ifdef SSL_OP_NO_RENEGOTIATION
4694 result |= SSL_OP_NO_RENEGOTIATION;
4695 #endif
4696
4697 if (!option_spec)
4698   {
4699   *results = result;
4700   return TRUE;
4701   }
4702
4703 if (!expand_check(option_spec, US"openssl_options", &exp, &end))
4704   return FALSE;
4705
4706 for (uschar * s = exp; *s; /**/)
4707   {
4708   while (isspace(*s)) ++s;
4709   if (*s == '\0')
4710     break;
4711   if (*s != '+' && *s != '-')
4712     {
4713     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
4714         "+ or - expected but found \"%s\"\n", s);
4715     return FALSE;
4716     }
4717   adding = *s++ == '+';
4718   for (end = s; *end && !isspace(*end); ) end++;
4719   item_parsed = tls_openssl_one_option_parse(string_copyn(s, end-s), &item);
4720   if (!item_parsed)
4721     {
4722     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
4723     return FALSE;
4724     }
4725   DEBUG(D_tls) debug_printf("openssl option, %s %08lx: %08lx (%s)\n",
4726       adding ? "adding to    " : "removing from", result, item, s);
4727   if (adding)
4728     result |= item;
4729   else
4730     result &= ~item;
4731   s = end;
4732   }
4733
4734 *results = result;
4735 return TRUE;
4736 }
4737
4738 #endif  /*!MACRO_PREDEF*/
4739 /* vi: aw ai sw=2
4740 */
4741 /* End of tls-openssl.c */