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