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