830978e042bf54aa58f555feafb21a47d27a6fe2
[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
3355 tls_in.active.sock = fileno(smtp_out);
3356 tls_in.active.tls_ctx = NULL;   /* not using explicit ctx for server-side */
3357 return OK;
3358 }
3359
3360
3361
3362
3363 static int
3364 tls_client_basic_ctx_init(SSL_CTX * ctx,
3365     host_item * host, smtp_transport_options_block * ob, exim_openssl_state_st * state,
3366     uschar ** errstr)
3367 {
3368 int rc;
3369
3370 /* Back-compatible old behaviour if tls_verify_certificates is set but both
3371 tls_verify_hosts and tls_try_verify_hosts are not set. Check only the specified
3372 host patterns if one of them is set with content. */
3373
3374 if (  (  (  !ob->tls_verify_hosts || !ob->tls_verify_hosts
3375          || Ustrcmp(ob->tls_try_verify_hosts, ":") == 0
3376          )
3377       && (  !ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts
3378          || Ustrcmp(ob->tls_try_verify_hosts, ":") == 0
3379          )
3380       )
3381    || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
3382    )
3383   client_verify_optional = FALSE;
3384 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
3385   client_verify_optional = TRUE;
3386 else
3387   return OK;
3388
3389   {
3390   uschar * expcerts;
3391   if (!expand_check(ob->tls_verify_certificates, US"tls_verify_certificates",
3392                     &expcerts, errstr))
3393     return DEFER;
3394   DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
3395
3396   if (state->lib_state.cabundle)
3397     { DEBUG(D_tls) debug_printf("TLS: CA bundle was preloaded\n"); }
3398   else
3399     if ((rc = setup_certs(ctx, expcerts, ob->tls_crl, host, errstr)) != OK)
3400       return rc;
3401
3402   if (expcerts && *expcerts)
3403     setup_cert_verify(ctx, client_verify_optional, verify_callback_client);
3404   }
3405
3406 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
3407   {
3408   state->verify_cert_hostnames =
3409 #ifdef SUPPORT_I18N
3410     string_domain_utf8_to_alabel(host->certname, NULL);
3411 #else
3412     host->certname;
3413 #endif
3414   DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
3415                     state->verify_cert_hostnames);
3416   }
3417 return OK;
3418 }
3419
3420
3421 #ifdef SUPPORT_DANE
3422 static int
3423 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
3424 {
3425 dns_scan dnss;
3426 const char * hostnames[2] = { CS host->name, NULL };
3427 int found = 0;
3428
3429 if (DANESSL_init(ssl, NULL, hostnames) != 1)
3430   return tls_error(US"hostnames load", host, NULL, errstr);
3431
3432 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
3433      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
3434     ) if (rr->type == T_TLSA && rr->size > 3)
3435   {
3436   const uschar * p = rr->data;
3437   uint8_t usage, selector, mtype;
3438   const char * mdname;
3439
3440   usage = *p++;
3441
3442   /* Only DANE-TA(2) and DANE-EE(3) are supported */
3443   if (usage != 2 && usage != 3) continue;
3444
3445   selector = *p++;
3446   mtype = *p++;
3447
3448   switch (mtype)
3449     {
3450     default: continue;  /* Only match-types 0, 1, 2 are supported */
3451     case 0:  mdname = NULL; break;
3452     case 1:  mdname = "sha256"; break;
3453     case 2:  mdname = "sha512"; break;
3454     }
3455
3456   found++;
3457   switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
3458     {
3459     default:
3460       return tls_error(US"tlsa load", host, NULL, errstr);
3461     case 0:     /* action not taken */
3462     case 1:     break;
3463     }
3464
3465   tls_out.tlsa_usage |= 1<<usage;
3466   }
3467
3468 if (found)
3469   return OK;
3470
3471 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
3472 return DEFER;
3473 }
3474 #endif  /*SUPPORT_DANE*/
3475
3476
3477
3478 #ifndef DISABLE_TLS_RESUME
3479 /* On the client, get any stashed session for the given IP from hints db
3480 and apply it to the ssl-connection for attempted resumption. */
3481
3482 static void
3483 tls_retrieve_session(tls_support * tlsp, SSL * ssl, const uschar * key)
3484 {
3485 tlsp->resumption |= RESUME_SUPPORTED;
3486 if (tlsp->host_resumable)
3487   {
3488   dbdata_tls_session * dt;
3489   int len;
3490   open_db dbblock, * dbm_file;
3491
3492   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
3493   DEBUG(D_tls) debug_printf("checking for resumable session for %s\n", key);
3494   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3495     {
3496     /* key for the db is the IP */
3497     if ((dt = dbfn_read_with_length(dbm_file, key, &len)))
3498       {
3499       SSL_SESSION * ss = NULL;
3500       const uschar * sess_asn1 = dt->session;
3501
3502       len -= sizeof(dbdata_tls_session);
3503       if (!(d2i_SSL_SESSION(&ss, &sess_asn1, (long)len)))
3504         {
3505         DEBUG(D_tls)
3506           {
3507           ERR_error_string_n(ERR_get_error(),
3508             ssl_errstring, sizeof(ssl_errstring));
3509           debug_printf("decoding session: %s\n", ssl_errstring);
3510           }
3511         }
3512       else
3513         {
3514         unsigned long lifetime =
3515 #ifdef EXIM_HAVE_SESSION_TICKET
3516           SSL_SESSION_get_ticket_lifetime_hint(ss);
3517 #else                   /* Use, fairly arbitrilarily, what we as server would */
3518           f.running_in_test_harness ? 6 : ssl_session_timeout;
3519 #endif
3520         if (lifetime + dt->time_stamp < time(NULL))
3521           {
3522           DEBUG(D_tls) debug_printf("session expired\n");
3523           dbfn_delete(dbm_file, key);
3524           }
3525         else if (!SSL_set_session(ssl, ss))
3526           {
3527           DEBUG(D_tls)
3528             {
3529             ERR_error_string_n(ERR_get_error(),
3530               ssl_errstring, sizeof(ssl_errstring));
3531             debug_printf("applying session to ssl: %s\n", ssl_errstring);
3532             }
3533           }
3534         else
3535           {
3536           DEBUG(D_tls) debug_printf("good session\n");
3537           tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
3538           tlsp->verify_override = dt->verify_override;
3539           tlsp->ocsp = dt->ocsp;
3540           }
3541         }
3542       }
3543     else
3544       DEBUG(D_tls) debug_printf("no session record\n");
3545     dbfn_close(dbm_file);
3546     }
3547   }
3548 }
3549
3550
3551 /* On the client, save the session for later resumption */
3552
3553 static int
3554 tls_save_session_cb(SSL * ssl, SSL_SESSION * ss)
3555 {
3556 exim_openssl_state_st * cbinfo = SSL_get_ex_data(ssl, tls_exdata_idx);
3557 tls_support * tlsp;
3558
3559 DEBUG(D_tls) debug_printf("tls_save_session_cb\n");
3560
3561 if (!cbinfo || !(tlsp = cbinfo->tlsp)->host_resumable) return 0;
3562
3563 # ifdef OPENSSL_HAVE_NUM_TICKETS
3564 if (SSL_SESSION_is_resumable(ss))       /* 1.1.1 */
3565 # endif
3566   {
3567   int len = i2d_SSL_SESSION(ss, NULL);
3568   int dlen = sizeof(dbdata_tls_session) + len;
3569   dbdata_tls_session * dt = store_get(dlen, TRUE);
3570   uschar * s = dt->session;
3571   open_db dbblock, * dbm_file;
3572
3573   DEBUG(D_tls) debug_printf("session is resumable\n");
3574   tlsp->resumption |= RESUME_SERVER_TICKET;     /* server gave us a ticket */
3575
3576   dt->verify_override = tlsp->verify_override;
3577   dt->ocsp = tlsp->ocsp;
3578   (void) i2d_SSL_SESSION(ss, &s);               /* s gets bumped to end */
3579
3580   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3581     {
3582     const uschar * key = cbinfo->host->address;
3583     dbfn_delete(dbm_file, key);
3584     dbfn_write(dbm_file, key, dt, dlen);
3585     dbfn_close(dbm_file);
3586     DEBUG(D_tls) debug_printf("wrote session (len %u) to db\n",
3587                   (unsigned)dlen);
3588     }
3589   }
3590 return 1;
3591 }
3592
3593
3594 static void
3595 tls_client_ctx_resume_prehandshake(
3596   exim_openssl_client_tls_ctx * exim_client_ctx, tls_support * tlsp,
3597   smtp_transport_options_block * ob, host_item * host)
3598 {
3599 /* Should the client request a session resumption ticket? */
3600 if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
3601   {
3602   tlsp->host_resumable = TRUE;
3603
3604   SSL_CTX_set_session_cache_mode(exim_client_ctx->ctx,
3605         SSL_SESS_CACHE_CLIENT
3606         | SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_NO_AUTO_CLEAR);
3607   SSL_CTX_sess_set_new_cb(exim_client_ctx->ctx, tls_save_session_cb);
3608   }
3609 }
3610
3611 static BOOL
3612 tls_client_ssl_resume_prehandshake(SSL * ssl, tls_support * tlsp,
3613   host_item * host, uschar ** errstr)
3614 {
3615 if (tlsp->host_resumable)
3616   {
3617   DEBUG(D_tls)
3618     debug_printf("tls_resumption_hosts overrides openssl_options, enabling tickets\n");
3619   SSL_clear_options(ssl, SSL_OP_NO_TICKET);
3620
3621   tls_exdata_idx = SSL_get_ex_new_index(0, 0, 0, 0, 0);
3622   if (!SSL_set_ex_data(ssl, tls_exdata_idx, client_static_state))
3623     {
3624     tls_error(US"set ex_data", host, NULL, errstr);
3625     return FALSE;
3626     }
3627   debug_printf("tls_exdata_idx %d cbinfo %p\n", tls_exdata_idx, client_static_state);
3628   }
3629
3630 tlsp->resumption = RESUME_SUPPORTED;
3631 /* Pick up a previous session, saved on an old ticket */
3632 tls_retrieve_session(tlsp, ssl, host->address);
3633 return TRUE;
3634 }
3635
3636 static void
3637 tls_client_resume_posthandshake(exim_openssl_client_tls_ctx * exim_client_ctx,
3638   tls_support * tlsp)
3639 {
3640 if (SSL_session_reused(exim_client_ctx->ssl))
3641   {
3642   DEBUG(D_tls) debug_printf("The session was reused\n");
3643   tlsp->resumption |= RESUME_USED;
3644   }
3645 }
3646 #endif  /* !DISABLE_TLS_RESUME */
3647
3648
3649 #ifdef EXIM_HAVE_ALPN
3650 /* Expand and convert an Exim list to an ALPN list.  False return for fail.
3651 NULL plist return for silent no-ALPN.
3652 */
3653
3654 static BOOL
3655 tls_alpn_plist(const uschar * tls_alpn, const uschar ** plist, unsigned * plen,
3656   uschar ** errstr)
3657 {
3658 uschar * exp_alpn;
3659
3660 if (!expand_check(tls_alpn, US"tls_alpn", &exp_alpn, errstr))
3661   return FALSE;
3662
3663 if (!exp_alpn)
3664   {
3665   DEBUG(D_tls) debug_printf("Setting TLS ALPN forced to fail, not sending\n");
3666   *plist = NULL;
3667   }
3668 else
3669   {
3670   /* The server implementation only accepts exactly one protocol name
3671   but it's little extra code complexity in the client. */
3672
3673   const uschar * list = exp_alpn;
3674   uschar * p = store_get(Ustrlen(exp_alpn), is_tainted(exp_alpn)), * s, * t;
3675   int sep = 0;
3676   uschar len;
3677
3678   for (t = p; s = string_nextinlist(&list, &sep, NULL, 0); t += len)
3679     {
3680     *t++ = len = (uschar) Ustrlen(s);
3681     memcpy(t, s, len);
3682     }
3683   *plist = (*plen = t - p) ? p : NULL;
3684   }
3685 return TRUE;
3686 }
3687 #endif  /* EXIM_HAVE_ALPN */
3688
3689
3690 /*************************************************
3691 *    Start a TLS session in a client             *
3692 *************************************************/
3693
3694 /* Called from the smtp transport after STARTTLS has been accepted.
3695
3696 Arguments:
3697   cctx          connection context
3698   conn_args     connection details
3699   cookie        datum for randomness; can be NULL
3700   tlsp          record details of TLS channel configuration here; must be non-NULL
3701   errstr        error string pointer
3702
3703 Returns:        TRUE for success with TLS session context set in connection context,
3704                 FALSE on error
3705 */
3706
3707 BOOL
3708 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
3709   void * cookie, tls_support * tlsp, uschar ** errstr)
3710 {
3711 host_item * host = conn_args->host;             /* for msgs and option-tests */
3712 transport_instance * tb = conn_args->tblock;    /* always smtp or NULL */
3713 smtp_transport_options_block * ob = tb
3714   ? (smtp_transport_options_block *)tb->options_block
3715   : &smtp_transport_option_defaults;
3716 exim_openssl_client_tls_ctx * exim_client_ctx;
3717 uschar * expciphers;
3718 int rc;
3719 static uschar peerdn[256];
3720
3721 #ifndef DISABLE_OCSP
3722 BOOL request_ocsp = FALSE;
3723 BOOL require_ocsp = FALSE;
3724 #endif
3725
3726 rc = store_pool;
3727 store_pool = POOL_PERM;
3728 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx), FALSE);
3729 exim_client_ctx->corked = NULL;
3730 store_pool = rc;
3731
3732 #ifdef SUPPORT_DANE
3733 tlsp->tlsa_usage = 0;
3734 #endif
3735
3736 #ifndef DISABLE_OCSP
3737   {
3738 # ifdef SUPPORT_DANE
3739   /*XXX this should be moved to caller, to be common across gnutls/openssl */
3740   if (  conn_args->dane
3741      && ob->hosts_request_ocsp[0] == '*'
3742      && ob->hosts_request_ocsp[1] == '\0'
3743      )
3744     {
3745     /* Unchanged from default.  Use a safer one under DANE */
3746     request_ocsp = TRUE;
3747     ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
3748                                       "   {= {4}{$tls_out_tlsa_usage}} } "
3749                                  " {*}{}}";
3750     }
3751 # endif
3752
3753   if ((require_ocsp =
3754         verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK))
3755     request_ocsp = TRUE;
3756   else
3757 # ifdef SUPPORT_DANE
3758     if (!request_ocsp)
3759 # endif
3760       request_ocsp =
3761         verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3762   }
3763 #endif
3764
3765 rc = tls_init(host, ob,
3766 #ifndef DISABLE_OCSP
3767     (void *)(long)request_ocsp,
3768 #endif
3769     cookie, &client_static_state, tlsp, errstr);
3770 if (rc != OK) return FALSE;
3771
3772 exim_client_ctx->ctx = client_static_state->lib_state.lib_ctx;
3773
3774 tlsp->certificate_verified = FALSE;
3775 client_verify_callback_called = FALSE;
3776
3777 expciphers = NULL;
3778 #ifdef SUPPORT_DANE
3779 if (conn_args->dane)
3780   {
3781   /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
3782   other failures should be treated as problems. */
3783   if (ob->dane_require_tls_ciphers &&
3784       !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
3785         &expciphers, errstr))
3786     return FALSE;
3787   if (expciphers && *expciphers == '\0')
3788     expciphers = NULL;
3789   }
3790 #endif
3791 if (!expciphers &&
3792     !expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
3793       &expciphers, errstr))
3794   return FALSE;
3795
3796 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
3797 are separated by underscores. So that I can use either form in my tests, and
3798 also for general convenience, we turn underscores into hyphens here. */
3799
3800 if (expciphers)
3801   {
3802   uschar *s = expciphers;
3803   while (*s) { if (*s == '_') *s = '-'; s++; }
3804   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
3805   if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
3806     {
3807     tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
3808     return FALSE;
3809     }
3810   }
3811
3812 #ifdef SUPPORT_DANE
3813 if (conn_args->dane)
3814   {
3815   SSL_CTX_set_verify(exim_client_ctx->ctx,
3816     SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
3817     verify_callback_client_dane);
3818
3819   if (!DANESSL_library_init())
3820     {
3821     tls_error(US"library init", host, NULL, errstr);
3822     return FALSE;
3823     }
3824   if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
3825     {
3826     tls_error(US"context init", host, NULL, errstr);
3827     return FALSE;
3828     }
3829   }
3830 else
3831
3832 #endif
3833
3834 if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
3835       client_static_state, errstr) != OK)
3836   return FALSE;
3837
3838 #ifndef DISABLE_TLS_RESUME
3839 tls_client_ctx_resume_prehandshake(exim_client_ctx, tlsp, ob, host);
3840 #endif
3841
3842
3843 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
3844   {
3845   tls_error(US"SSL_new", host, NULL, errstr);
3846   return FALSE;
3847   }
3848 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
3849
3850 SSL_set_fd(exim_client_ctx->ssl, cctx->sock);
3851 SSL_set_connect_state(exim_client_ctx->ssl);
3852
3853 if (ob->tls_sni)
3854   {
3855   if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
3856     return FALSE;
3857   if (!tlsp->sni)
3858     {
3859     DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
3860     }
3861   else if (!Ustrlen(tlsp->sni))
3862     tlsp->sni = NULL;
3863   else
3864     {
3865 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
3866     DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
3867     SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
3868 #else
3869     log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
3870           tlsp->sni);
3871 #endif
3872     }
3873   }
3874
3875 if (ob->tls_alpn)
3876 #ifdef EXIM_HAVE_ALPN
3877   {
3878   const uschar * plist;
3879   unsigned plen;
3880
3881   if (!tls_alpn_plist(ob->tls_alpn, &plist, &plen, errstr))
3882     return FALSE;
3883   if (plist)
3884     if (SSL_set_alpn_protos(exim_client_ctx->ssl, plist, plen) != 0)
3885       {
3886       tls_error(US"alpn init", host, NULL, errstr);
3887       return FALSE;
3888       }
3889     else
3890       DEBUG(D_tls) debug_printf("Setting TLS ALPN '%s'\n", ob->tls_alpn);
3891   }
3892 #else
3893   log_write(0, LOG_MAIN, "ALPN unusable with this OpenSSL library version; ignoring \"%s\"\n",
3894           ob->tls_alpn);
3895 #endif
3896
3897 #ifdef SUPPORT_DANE
3898 if (conn_args->dane)
3899   if (dane_tlsa_load(exim_client_ctx->ssl, host, &conn_args->tlsa_dnsa, errstr) != OK)
3900     return FALSE;
3901 #endif
3902
3903 #ifndef DISABLE_OCSP
3904 /* Request certificate status at connection-time.  If the server
3905 does OCSP stapling we will get the callback (set in tls_init()) */
3906 # ifdef SUPPORT_DANE
3907 if (request_ocsp)
3908   {
3909   const uschar * s;
3910   if (  ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3911      || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3912      )
3913     {   /* Re-eval now $tls_out_tlsa_usage is populated.  If
3914         this means we avoid the OCSP request, we wasted the setup
3915         cost in tls_init(). */
3916     require_ocsp = verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
3917     request_ocsp = require_ocsp
3918       || verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3919     }
3920   }
3921 # endif
3922
3923 if (request_ocsp)
3924   {
3925   SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
3926   client_static_state->u_ocsp.client.verify_required = require_ocsp;
3927   tlsp->ocsp = OCSP_NOT_RESP;
3928   }
3929 #endif
3930
3931 #ifndef DISABLE_TLS_RESUME
3932 if (!tls_client_ssl_resume_prehandshake(exim_client_ctx->ssl, tlsp, host,
3933       errstr))
3934   return FALSE;
3935 #endif
3936
3937 #ifndef DISABLE_EVENT
3938 client_static_state->event_action = tb ? tb->event_action : NULL;
3939 #endif
3940
3941 /* There doesn't seem to be a built-in timeout on connection. */
3942
3943 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
3944 sigalrm_seen = FALSE;
3945 ALARM(ob->command_timeout);
3946 rc = SSL_connect(exim_client_ctx->ssl);
3947 ALARM_CLR(0);
3948
3949 #ifdef SUPPORT_DANE
3950 if (conn_args->dane)
3951   DANESSL_cleanup(exim_client_ctx->ssl);
3952 #endif
3953
3954 if (rc <= 0)
3955   {
3956   tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
3957   return FALSE;
3958   }
3959
3960 DEBUG(D_tls)
3961   {
3962   debug_printf("SSL_connect succeeded\n");
3963 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3964   {
3965   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
3966   SSL_SESSION_print_keylog(bp, SSL_get_session(exim_client_ctx->ssl));
3967   BIO_free(bp);
3968   }
3969 #endif
3970   }
3971
3972 #ifndef DISABLE_TLS_RESUME
3973 tls_client_resume_posthandshake(exim_client_ctx, tlsp);
3974 #endif
3975
3976 #ifdef EXIM_HAVE_ALPN
3977 if (ob->tls_alpn)       /* We requested. See what was negotiated. */
3978   {
3979   const uschar * name;
3980   unsigned len;
3981
3982   SSL_get0_alpn_selected(exim_client_ctx->ssl, &name, &len);
3983   if (len > 0)
3984     { DEBUG(D_tls) debug_printf("ALPN negotiated %u: '%.*s'\n", len, (int)*name, name+1); }
3985   else if (verify_check_given_host(CUSS &ob->hosts_require_alpn, host) == OK)
3986     {
3987     /* Would like to send a relevant fatal Alert, but OpenSSL has no API */
3988     tls_error(US"handshake", host, US"ALPN required but not negotiated", errstr);
3989     return FALSE;
3990     }
3991   }
3992 #endif
3993
3994 #ifdef SSL_get_extms_support
3995 tlsp->ext_master_secret = SSL_get_extms_support(exim_client_ctx->ssl) == 1;
3996 #endif
3997 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
3998
3999 tlsp->ver = tlsver_name(exim_client_ctx->ssl);
4000 tlsp->cipher = construct_cipher_name(exim_client_ctx->ssl, tlsp->ver, &tlsp->bits);
4001 tlsp->cipher_stdname = cipher_stdname_ssl(exim_client_ctx->ssl);
4002
4003 /* Record the certificate we presented */
4004   {
4005   X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
4006   tlsp->ourcert = crt ? X509_dup(crt) : NULL;
4007   }
4008
4009 /*XXX will this work with continued-TLS? */
4010 /* Channel-binding info for authenticators */
4011   {
4012   uschar c, * s;
4013   size_t len = SSL_get_finished(exim_client_ctx->ssl, &c, 0);
4014   int old_pool = store_pool;
4015
4016   SSL_get_finished(exim_client_ctx->ssl, s = store_get((int)len, TRUE), len);
4017   store_pool = POOL_PERM;
4018     tlsp->channelbinding = b64encode_taint(CUS s, (int)len, TRUE);
4019   store_pool = old_pool;
4020   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage %p %p\n", tlsp->channelbinding, tlsp);
4021   }
4022
4023 tlsp->active.sock = cctx->sock;
4024 tlsp->active.tls_ctx = exim_client_ctx;
4025 cctx->tls_ctx = exim_client_ctx;
4026 return TRUE;
4027 }
4028
4029
4030
4031
4032
4033 static BOOL
4034 tls_refill(unsigned lim)
4035 {
4036 SSL * ssl = state_server.lib_state.lib_ssl;
4037 int error;
4038 int inbytes;
4039
4040 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
4041   ssl_xfer_buffer, ssl_xfer_buffer_size);
4042
4043 ERR_clear_error();
4044 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
4045 inbytes = SSL_read(ssl, CS ssl_xfer_buffer,
4046                   MIN(ssl_xfer_buffer_size, lim));
4047 error = SSL_get_error(ssl, inbytes);
4048 if (smtp_receive_timeout > 0) ALARM_CLR(0);
4049
4050 if (had_command_timeout)                /* set by signal handler */
4051   smtp_command_timeout_exit();          /* does not return */
4052 if (had_command_sigterm)
4053   smtp_command_sigterm_exit();
4054 if (had_data_timeout)
4055   smtp_data_timeout_exit();
4056 if (had_data_sigint)
4057   smtp_data_sigint_exit();
4058
4059 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
4060 closed down, not that the socket itself has been closed down. Revert to
4061 non-SSL handling. */
4062
4063 switch(error)
4064   {
4065   case SSL_ERROR_NONE:
4066     break;
4067
4068   case SSL_ERROR_ZERO_RETURN:
4069     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
4070
4071     if (SSL_get_shutdown(ssl) == SSL_RECEIVED_SHUTDOWN)
4072           SSL_shutdown(ssl);
4073
4074     tls_close(NULL, TLS_NO_SHUTDOWN);
4075     return FALSE;
4076
4077   /* Handle genuine errors */
4078   case SSL_ERROR_SSL:
4079     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4080     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
4081     ssl_xfer_error = TRUE;
4082     return FALSE;
4083
4084   default:
4085     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
4086     DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
4087       debug_printf(" - syscall %s\n", strerror(errno));
4088     ssl_xfer_error = TRUE;
4089     return FALSE;
4090   }
4091
4092 #ifndef DISABLE_DKIM
4093 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
4094 #endif
4095 ssl_xfer_buffer_hwm = inbytes;
4096 ssl_xfer_buffer_lwm = 0;
4097 return TRUE;
4098 }
4099
4100
4101 /*************************************************
4102 *            TLS version of getc                 *
4103 *************************************************/
4104
4105 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
4106 it refills the buffer via the SSL reading function.
4107
4108 Arguments:  lim         Maximum amount to read/buffer
4109 Returns:    the next character or EOF
4110
4111 Only used by the server-side TLS.
4112 */
4113
4114 int
4115 tls_getc(unsigned lim)
4116 {
4117 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
4118   if (!tls_refill(lim))
4119     return ssl_xfer_error ? EOF : smtp_getc(lim);
4120
4121 /* Something in the buffer; return next uschar */
4122
4123 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
4124 }
4125
4126 BOOL
4127 tls_hasc(void)
4128 {
4129 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm;
4130 }
4131
4132 uschar *
4133 tls_getbuf(unsigned * len)
4134 {
4135 unsigned size;
4136 uschar * buf;
4137
4138 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
4139   if (!tls_refill(*len))
4140     {
4141     if (!ssl_xfer_error) return smtp_getbuf(len);
4142     *len = 0;
4143     return NULL;
4144     }
4145
4146 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
4147   size = *len;
4148 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
4149 ssl_xfer_buffer_lwm += size;
4150 *len = size;
4151 return buf;
4152 }
4153
4154
4155 void
4156 tls_get_cache(unsigned lim)
4157 {
4158 #ifndef DISABLE_DKIM
4159 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
4160 debug_printf("tls_get_cache\n");
4161 if (n > lim)
4162   n = lim;
4163 if (n > 0)
4164   dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
4165 #endif
4166 }
4167
4168
4169 BOOL
4170 tls_could_getc(void)
4171 {
4172 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm
4173     || SSL_pending(state_server.lib_state.lib_ssl) > 0;
4174 }
4175
4176
4177 /*************************************************
4178 *          Read bytes from TLS channel           *
4179 *************************************************/
4180
4181 /*
4182 Arguments:
4183   ct_ctx    client context pointer, or NULL for the one global server context
4184   buff      buffer of data
4185   len       size of buffer
4186
4187 Returns:    the number of bytes read
4188             -1 after a failed read, including EOF
4189
4190 Only used by the client-side TLS.
4191 */
4192
4193 int
4194 tls_read(void * ct_ctx, uschar *buff, size_t len)
4195 {
4196 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl
4197                   : state_server.lib_state.lib_ssl;
4198 int inbytes;
4199 int error;
4200
4201 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
4202   buff, (unsigned int)len);
4203
4204 ERR_clear_error();
4205 inbytes = SSL_read(ssl, CS buff, len);
4206 error = SSL_get_error(ssl, inbytes);
4207
4208 if (error == SSL_ERROR_ZERO_RETURN)
4209   {
4210   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
4211   return -1;
4212   }
4213 else if (error != SSL_ERROR_NONE)
4214   return -1;
4215
4216 return inbytes;
4217 }
4218
4219
4220
4221
4222
4223 /*************************************************
4224 *         Write bytes down TLS channel           *
4225 *************************************************/
4226
4227 /*
4228 Arguments:
4229   ct_ctx    client context pointer, or NULL for the one global server context
4230   buff      buffer of data
4231   len       number of bytes
4232   more      further data expected soon
4233
4234 Returns:    the number of bytes after a successful write,
4235             -1 after a failed write
4236
4237 Used by both server-side and client-side TLS.  Calling with len zero and more unset
4238 will flush buffered writes; buff can be null for this case.
4239 */
4240
4241 int
4242 tls_write(void * ct_ctx, const uschar * buff, size_t len, BOOL more)
4243 {
4244 size_t olen = len;
4245 int outbytes, error;
4246 SSL * ssl = ct_ctx
4247   ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl
4248   : state_server.lib_state.lib_ssl;
4249 static gstring * server_corked = NULL;
4250 gstring ** corkedp = ct_ctx
4251   ? &((exim_openssl_client_tls_ctx *)ct_ctx)->corked : &server_corked;
4252 gstring * corked = *corkedp;
4253
4254 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
4255   buff, (unsigned long)len, more ? ", more" : "");
4256
4257 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
4258 "more" is notified.  This hack is only ok if small amounts are involved AND only
4259 one stream does it, in one context (i.e. no store reset).  Currently it is used
4260 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only.
4261 We support callouts done by the server process by using a separate client
4262 context for the stashed information. */
4263 /* + if PIPE_COMMAND, banner & ehlo-resp for smmtp-on-connect. Suspect there's
4264 a store reset there, so use POOL_PERM. */
4265 /* + if CHUNKING, cmds EHLO,MAIL,RCPT(s),BDAT */
4266
4267 if (more || corked)
4268   {
4269   if (!len) buff = US &error;   /* dummy just so that string_catn is ok */
4270
4271   int save_pool = store_pool;
4272   store_pool = POOL_PERM;
4273
4274   corked = string_catn(corked, buff, len);
4275
4276   store_pool = save_pool;
4277
4278   if (more)
4279     {
4280     *corkedp = corked;
4281     return len;
4282     }
4283   buff = CUS corked->s;
4284   len = corked->ptr;
4285   *corkedp = NULL;
4286   }
4287
4288 for (int left = len; left > 0;)
4289   {
4290   DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
4291   ERR_clear_error();
4292   outbytes = SSL_write(ssl, CS buff, left);
4293   error = SSL_get_error(ssl, outbytes);
4294   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
4295   switch (error)
4296     {
4297     case SSL_ERROR_NONE:        /* the usual case */
4298       left -= outbytes;
4299       buff += outbytes;
4300       break;
4301
4302     case SSL_ERROR_SSL:
4303       ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4304       log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
4305       return -1;
4306
4307     case SSL_ERROR_ZERO_RETURN:
4308       log_write(0, LOG_MAIN, "SSL channel closed on write");
4309       return -1;
4310
4311     case SSL_ERROR_SYSCALL:
4312       if (ct_ctx || errno != ECONNRESET || !f.smtp_in_quit)
4313         log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
4314           sender_fullhost ? sender_fullhost : US"<unknown>",
4315           strerror(errno));
4316       else if (LOGGING(protocol_detail))
4317         log_write(0, LOG_MAIN, "[%s] after QUIT, client reset TCP before"
4318           " SMTP response and TLS close\n", sender_host_address);
4319       else
4320         DEBUG(D_tls) debug_printf("[%s] SSL_write: after QUIT,"
4321           " client reset TCP before TLS close\n", sender_host_address);
4322       return -1;
4323
4324     default:
4325       log_write(0, LOG_MAIN, "SSL_write error %d", error);
4326       return -1;
4327     }
4328   }
4329 return olen;
4330 }
4331
4332
4333
4334 /*
4335 Arguments:
4336   ct_ctx        client TLS context pointer, or NULL for the one global server context
4337 */
4338
4339 void
4340 tls_shutdown_wr(void * ct_ctx)
4341 {
4342 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
4343 SSL ** sslp = o_ctx ? &o_ctx->ssl : (SSL **) &state_server.lib_state.lib_ssl;
4344 int * fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
4345 int rc;
4346
4347 if (*fdp < 0) return;  /* TLS was not active */
4348
4349 tls_write(ct_ctx, NULL, 0, FALSE);      /* flush write buffer */
4350
4351 HDEBUG(D_transport|D_tls|D_acl|D_v) debug_printf_indent("  SMTP(TLS shutdown)>>\n");
4352 rc = SSL_shutdown(*sslp);
4353 if (rc < 0) DEBUG(D_tls)
4354   {
4355   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4356   debug_printf("SSL_shutdown: %s\n", ssl_errstring);
4357   }
4358 }
4359
4360 /*************************************************
4361 *         Close down a TLS session               *
4362 *************************************************/
4363
4364 /* This is also called from within a delivery subprocess forked from the
4365 daemon, to shut down the TLS library, without actually doing a shutdown (which
4366 would tamper with the SSL session in the parent process).
4367
4368 Arguments:
4369   ct_ctx        client TLS context pointer, or NULL for the one global server context
4370   do_shutdown   0 no data-flush or TLS close-alert
4371                 1 if TLS close-alert is to be sent,
4372                 2 if also response to be waited for
4373
4374 Returns:     nothing
4375
4376 Used by both server-side and client-side TLS.
4377 */
4378
4379 void
4380 tls_close(void * ct_ctx, int do_shutdown)
4381 {
4382 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
4383 SSL ** sslp = o_ctx ? &o_ctx->ssl : (SSL **) &state_server.lib_state.lib_ssl;
4384 int * fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
4385
4386 if (*fdp < 0) return;  /* TLS was not active */
4387
4388 if (do_shutdown)
4389   {
4390   int rc;
4391   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
4392     do_shutdown > 1 ? " (with response-wait)" : "");
4393
4394   tls_write(ct_ctx, NULL, 0, FALSE);    /* flush write buffer */
4395
4396   if (  (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
4397      && do_shutdown > 1)
4398     {
4399     ALARM(2);
4400     rc = SSL_shutdown(*sslp);           /* wait for response */
4401     ALARM_CLR(0);
4402     }
4403
4404   if (rc < 0) DEBUG(D_tls)
4405     {
4406     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4407     debug_printf("SSL_shutdown: %s\n", ssl_errstring);
4408     }
4409   }
4410
4411 if (!o_ctx)             /* server side */
4412   {
4413 #ifndef DISABLE_OCSP
4414   sk_X509_pop_free(state_server.verify_stack, X509_free);
4415   state_server.verify_stack = NULL;
4416 #endif
4417
4418   receive_getc =        smtp_getc;
4419   receive_getbuf =      smtp_getbuf;
4420   receive_get_cache =   smtp_get_cache;
4421   receive_hasc =        smtp_hasc;
4422   receive_ungetc =      smtp_ungetc;
4423   receive_feof =        smtp_feof;
4424   receive_ferror =      smtp_ferror;
4425   tls_in.active.tls_ctx = NULL;
4426   tls_in.sni = NULL;
4427   /* Leave bits, peercert, cipher, peerdn, certificate_verified set, for logging */
4428   }
4429
4430 SSL_free(*sslp);
4431 *sslp = NULL;
4432 *fdp = -1;
4433 }
4434
4435
4436
4437
4438 /*************************************************
4439 *  Let tls_require_ciphers be checked at startup *
4440 *************************************************/
4441
4442 /* The tls_require_ciphers option, if set, must be something which the
4443 library can parse.
4444
4445 Returns:     NULL on success, or error message
4446 */
4447
4448 uschar *
4449 tls_validate_require_cipher(void)
4450 {
4451 SSL_CTX *ctx;
4452 uschar *s, *expciphers, *err;
4453
4454 tls_openssl_init();
4455
4456 if (!(tls_require_ciphers && *tls_require_ciphers))
4457   return NULL;
4458
4459 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
4460                   &err))
4461   return US"failed to expand tls_require_ciphers";
4462
4463 if (!(expciphers && *expciphers))
4464   return NULL;
4465
4466 /* normalisation ripped from above */
4467 s = expciphers;
4468 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
4469
4470 err = NULL;
4471
4472 if (lib_ctx_new(&ctx, NULL, &err) == OK)
4473   {
4474   DEBUG(D_tls)
4475     debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
4476
4477   if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
4478     {
4479     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4480     err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
4481                         expciphers, ssl_errstring);
4482     }
4483
4484   SSL_CTX_free(ctx);
4485   }
4486 return err;
4487 }
4488
4489
4490
4491
4492 /*************************************************
4493 *         Report the library versions.           *
4494 *************************************************/
4495
4496 /* There have historically been some issues with binary compatibility in
4497 OpenSSL libraries; if Exim (like many other applications) is built against
4498 one version of OpenSSL but the run-time linker picks up another version,
4499 it can result in serious failures, including crashing with a SIGSEGV.  So
4500 report the version found by the compiler and the run-time version.
4501
4502 Note: some OS vendors backport security fixes without changing the version
4503 number/string, and the version date remains unchanged.  The _build_ date
4504 will change, so we can more usefully assist with version diagnosis by also
4505 reporting the build date.
4506
4507 Arguments:   a FILE* to print the results to
4508 Returns:     nothing
4509 */
4510
4511 void
4512 tls_version_report(FILE *f)
4513 {
4514 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
4515            "                          Runtime: %s\n"
4516            "                                 : %s\n",
4517            OPENSSL_VERSION_TEXT,
4518            SSLeay_version(SSLEAY_VERSION),
4519            SSLeay_version(SSLEAY_BUILT_ON));
4520 /* third line is 38 characters for the %s and the line is 73 chars long;
4521 the OpenSSL output includes a "built on: " prefix already. */
4522 }
4523
4524
4525
4526
4527 /*************************************************
4528 *            Random number generation            *
4529 *************************************************/
4530
4531 /* Pseudo-random number generation.  The result is not expected to be
4532 cryptographically strong but not so weak that someone will shoot themselves
4533 in the foot using it as a nonce in input in some email header scheme or
4534 whatever weirdness they'll twist this into.  The result should handle fork()
4535 and avoid repeating sequences.  OpenSSL handles that for us.
4536
4537 Arguments:
4538   max       range maximum
4539 Returns     a random number in range [0, max-1]
4540 */
4541
4542 int
4543 vaguely_random_number(int max)
4544 {
4545 unsigned int r;
4546 int i, needed_len;
4547 static pid_t pidlast = 0;
4548 pid_t pidnow;
4549 uschar smallbuf[sizeof(r)];
4550
4551 if (max <= 1)
4552   return 0;
4553
4554 pidnow = getpid();
4555 if (pidnow != pidlast)
4556   {
4557   /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
4558   is unique for each thread", this doesn't apparently apply across processes,
4559   so our own warning from vaguely_random_number_fallback() applies here too.
4560   Fix per PostgreSQL. */
4561   if (pidlast != 0)
4562     RAND_cleanup();
4563   pidlast = pidnow;
4564   }
4565
4566 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
4567 if (!RAND_status())
4568   {
4569   randstuff r;
4570   gettimeofday(&r.tv, NULL);
4571   r.p = getpid();
4572
4573   RAND_seed(US (&r), sizeof(r));
4574   }
4575 /* We're after pseudo-random, not random; if we still don't have enough data
4576 in the internal PRNG then our options are limited.  We could sleep and hope
4577 for entropy to come along (prayer technique) but if the system is so depleted
4578 in the first place then something is likely to just keep taking it.  Instead,
4579 we'll just take whatever little bit of pseudo-random we can still manage to
4580 get. */
4581
4582 needed_len = sizeof(r);
4583 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
4584 asked for a number less than 10. */
4585 for (r = max, i = 0; r; ++i)
4586   r >>= 1;
4587 i = (i + 7) / 8;
4588 if (i < needed_len)
4589   needed_len = i;
4590
4591 #ifdef EXIM_HAVE_RAND_PSEUDO
4592 /* We do not care if crypto-strong */
4593 i = RAND_pseudo_bytes(smallbuf, needed_len);
4594 #else
4595 i = RAND_bytes(smallbuf, needed_len);
4596 #endif
4597
4598 if (i < 0)
4599   {
4600   DEBUG(D_all)
4601     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
4602   return vaguely_random_number_fallback(max);
4603   }
4604
4605 r = 0;
4606 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
4607   r = 256 * r + *p;
4608
4609 /* We don't particularly care about weighted results; if someone wants
4610 smooth distribution and cares enough then they should submit a patch then. */
4611 return r % max;
4612 }
4613
4614
4615
4616
4617 /*************************************************
4618 *        OpenSSL option parse                    *
4619 *************************************************/
4620
4621 /* Parse one option for tls_openssl_options_parse below
4622
4623 Arguments:
4624   name    one option name
4625   value   place to store a value for it
4626 Returns   success or failure in parsing
4627 */
4628
4629
4630
4631 static BOOL
4632 tls_openssl_one_option_parse(uschar *name, long *value)
4633 {
4634 int first = 0;
4635 int last = exim_openssl_options_size;
4636 while (last > first)
4637   {
4638   int middle = (first + last)/2;
4639   int c = Ustrcmp(name, exim_openssl_options[middle].name);
4640   if (c == 0)
4641     {
4642     *value = exim_openssl_options[middle].value;
4643     return TRUE;
4644     }
4645   else if (c > 0)
4646     first = middle + 1;
4647   else
4648     last = middle;
4649   }
4650 return FALSE;
4651 }
4652
4653
4654
4655
4656 /*************************************************
4657 *        OpenSSL option parsing logic            *
4658 *************************************************/
4659
4660 /* OpenSSL has a number of compatibility options which an administrator might
4661 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
4662 we look like log_selector.
4663
4664 Arguments:
4665   option_spec  the administrator-supplied string of options
4666   results      ptr to long storage for the options bitmap
4667 Returns        success or failure
4668 */
4669
4670 BOOL
4671 tls_openssl_options_parse(uschar *option_spec, long *results)
4672 {
4673 long result, item;
4674 uschar * exp, * end;
4675 BOOL adding, item_parsed;
4676
4677 /* Server: send no (<= TLS1.2) session tickets */
4678 result = SSL_OP_NO_TICKET;
4679
4680 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
4681 from default because it increases BEAST susceptibility. */
4682 #ifdef SSL_OP_NO_SSLv2
4683 result |= SSL_OP_NO_SSLv2;
4684 #endif
4685 #ifdef SSL_OP_NO_SSLv3
4686 result |= SSL_OP_NO_SSLv3;
4687 #endif
4688 #ifdef SSL_OP_SINGLE_DH_USE
4689 result |= SSL_OP_SINGLE_DH_USE;
4690 #endif
4691 #ifdef SSL_OP_NO_RENEGOTIATION
4692 result |= SSL_OP_NO_RENEGOTIATION;
4693 #endif
4694
4695 if (!option_spec)
4696   {
4697   *results = result;
4698   return TRUE;
4699   }
4700
4701 if (!expand_check(option_spec, US"openssl_options", &exp, &end))
4702   return FALSE;
4703
4704 for (uschar * s = exp; *s; /**/)
4705   {
4706   while (isspace(*s)) ++s;
4707   if (*s == '\0')
4708     break;
4709   if (*s != '+' && *s != '-')
4710     {
4711     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
4712         "+ or - expected but found \"%s\"\n", s);
4713     return FALSE;
4714     }
4715   adding = *s++ == '+';
4716   for (end = s; *end && !isspace(*end); ) end++;
4717   item_parsed = tls_openssl_one_option_parse(string_copyn(s, end-s), &item);
4718   if (!item_parsed)
4719     {
4720     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
4721     return FALSE;
4722     }
4723   DEBUG(D_tls) debug_printf("openssl option, %s %08lx: %08lx (%s)\n",
4724       adding ? "adding to    " : "removing from", result, item, s);
4725   if (adding)
4726     result |= item;
4727   else
4728     result &= ~item;
4729   s = end;
4730   }
4731
4732 *results = result;
4733 return TRUE;
4734 }
4735
4736 #endif  /*!MACRO_PREDEF*/
4737 /* vi: aw ai sw=2
4738 */
4739 /* End of tls-openssl.c */