Merge 4.80.1 security fix in.
[exim.git] / src / src / tls-openssl.c
1 /*************************************************
2 *     Exim - an Internet mail transport agent    *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2012 */
6 /* See the file NOTICE for conditions of use and distribution. */
7
8 /* This module provides the TLS (aka SSL) support for Exim using the OpenSSL
9 library. It is #included into the tls.c file when that library is used. The
10 code herein is based on a patch that was originally contributed by Steve
11 Haslam. It was adapted from stunnel, a GPL program by Michal Trojnara.
12
13 No cryptographic code is included in Exim. All this module does is to call
14 functions from the OpenSSL library. */
15
16
17 /* Heading stuff */
18
19 #include <openssl/lhash.h>
20 #include <openssl/ssl.h>
21 #include <openssl/err.h>
22 #include <openssl/rand.h>
23 #ifdef EXPERIMENTAL_OCSP
24 #include <openssl/ocsp.h>
25 #endif
26
27 #ifdef EXPERIMENTAL_OCSP
28 #define EXIM_OCSP_SKEW_SECONDS (300L)
29 #define EXIM_OCSP_MAX_AGE (-1L)
30 #endif
31
32 #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
33 #define EXIM_HAVE_OPENSSL_TLSEXT
34 #endif
35
36 /* Structure for collecting random data for seeding. */
37
38 typedef struct randstuff {
39   struct timeval tv;
40   pid_t          p;
41 } randstuff;
42
43 /* Local static variables */
44
45 static BOOL client_verify_callback_called = FALSE;
46 static BOOL server_verify_callback_called = FALSE;
47 static const uschar *sid_ctx = US"exim";
48
49 static SSL_CTX *client_ctx = NULL;
50 static SSL_CTX *server_ctx = NULL;
51 static SSL     *client_ssl = NULL;
52 static SSL     *server_ssl = NULL;
53
54 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
55 static SSL_CTX *server_sni = NULL;
56 #endif
57
58 static char ssl_errstring[256];
59
60 static int  ssl_session_timeout = 200;
61 static BOOL client_verify_optional = FALSE;
62 static BOOL server_verify_optional = FALSE;
63
64 static BOOL    reexpand_tls_files_for_sni = FALSE;
65
66
67 typedef struct tls_ext_ctx_cb {
68   uschar *certificate;
69   uschar *privatekey;
70 #ifdef EXPERIMENTAL_OCSP
71   uschar *ocsp_file;
72   uschar *ocsp_file_expanded;
73   OCSP_RESPONSE *ocsp_response;
74 #endif
75   uschar *dhparam;
76   /* these are cached from first expand */
77   uschar *server_cipher_list;
78   /* only passed down to tls_error: */
79   host_item *host;
80 } tls_ext_ctx_cb;
81
82 /* should figure out a cleanup of API to handle state preserved per
83 implementation, for various reasons, which can be void * in the APIs.
84 For now, we hack around it. */
85 tls_ext_ctx_cb *client_static_cbinfo = NULL;
86 tls_ext_ctx_cb *server_static_cbinfo = NULL;
87
88 static int
89 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional, BOOL client);
90
91 /* Callbacks */
92 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
93 static int tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg);
94 #endif
95 #ifdef EXPERIMENTAL_OCSP
96 static int tls_stapling_cb(SSL *s, void *arg);
97 #endif
98
99
100 /*************************************************
101 *               Handle TLS error                 *
102 *************************************************/
103
104 /* Called from lots of places when errors occur before actually starting to do
105 the TLS handshake, that is, while the session is still in clear. Always returns
106 DEFER for a server and FAIL for a client so that most calls can use "return
107 tls_error(...)" to do this processing and then give an appropriate return. A
108 single function is used for both server and client, because it is called from
109 some shared functions.
110
111 Argument:
112   prefix    text to include in the logged error
113   host      NULL if setting up a server;
114             the connected host if setting up a client
115   msg       error message or NULL if we should ask OpenSSL
116
117 Returns:    OK/DEFER/FAIL
118 */
119
120 static int
121 tls_error(uschar *prefix, host_item *host, uschar *msg)
122 {
123 if (msg == NULL)
124   {
125   ERR_error_string(ERR_get_error(), ssl_errstring);
126   msg = (uschar *)ssl_errstring;
127   }
128
129 if (host == NULL)
130   {
131   uschar *conn_info = smtp_get_connection_info();
132   if (Ustrncmp(conn_info, US"SMTP ", 5) == 0)
133     conn_info += 5;
134   log_write(0, LOG_MAIN, "TLS error on %s (%s): %s",
135     conn_info, prefix, msg);
136   return DEFER;
137   }
138 else
139   {
140   log_write(0, LOG_MAIN, "TLS error on connection to %s [%s] (%s): %s",
141     host->name, host->address, prefix, msg);
142   return FAIL;
143   }
144 }
145
146
147
148 /*************************************************
149 *        Callback to generate RSA key            *
150 *************************************************/
151
152 /*
153 Arguments:
154   s          SSL connection
155   export     not used
156   keylength  keylength
157
158 Returns:     pointer to generated key
159 */
160
161 static RSA *
162 rsa_callback(SSL *s, int export, int keylength)
163 {
164 RSA *rsa_key;
165 export = export;     /* Shut picky compilers up */
166 DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
167 rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL);
168 if (rsa_key == NULL)
169   {
170   ERR_error_string(ERR_get_error(), ssl_errstring);
171   log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
172     ssl_errstring);
173   return NULL;
174   }
175 return rsa_key;
176 }
177
178
179
180
181 /*************************************************
182 *        Callback for verification               *
183 *************************************************/
184
185 /* The SSL library does certificate verification if set up to do so. This
186 callback has the current yes/no state is in "state". If verification succeeded,
187 we set up the tls_peerdn string. If verification failed, what happens depends
188 on whether the client is required to present a verifiable certificate or not.
189
190 If verification is optional, we change the state to yes, but still log the
191 verification error. For some reason (it really would help to have proper
192 documentation of OpenSSL), this callback function then gets called again, this
193 time with state = 1. In fact, that's useful, because we can set up the peerdn
194 value, but we must take care not to set the private verified flag on the second
195 time through.
196
197 Note: this function is not called if the client fails to present a certificate
198 when asked. We get here only if a certificate has been received. Handling of
199 optional verification for this case is done when requesting SSL to verify, by
200 setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
201
202 Arguments:
203   state      current yes/no state as 1/0
204   x509ctx    certificate information.
205   client     TRUE for client startup, FALSE for server startup
206
207 Returns:     1 if verified, 0 if not
208 */
209
210 static int
211 verify_callback(int state, X509_STORE_CTX *x509ctx, BOOL client)
212 {
213 static uschar txt[256];
214 tls_support * tlsp;
215 BOOL * calledp;
216 BOOL * optionalp;
217
218 if (client)
219   {
220   tlsp= &tls_out;
221   calledp= &client_verify_callback_called;
222   optionalp= &client_verify_optional;
223   }
224 else
225   {
226   tlsp= &tls_in;
227   calledp= &server_verify_callback_called;
228   optionalp= &server_verify_optional;
229   }
230
231 X509_NAME_oneline(X509_get_subject_name(x509ctx->current_cert),
232   CS txt, sizeof(txt));
233
234 if (state == 0)
235   {
236   log_write(0, LOG_MAIN, "SSL verify error: depth=%d error=%s cert=%s",
237     x509ctx->error_depth,
238     X509_verify_cert_error_string(x509ctx->error),
239     txt);
240   tlsp->certificate_verified = FALSE;
241   *calledp = TRUE;
242   if (!*optionalp) return 0;    /* reject */
243   DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
244     "tls_try_verify_hosts)\n");
245   return 1;                          /* accept */
246   }
247
248 if (x509ctx->error_depth != 0)
249   {
250   DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d cert=%s\n",
251      x509ctx->error_depth, txt);
252   }
253 else
254   {
255   DEBUG(D_tls) debug_printf("SSL%s peer: %s\n",
256     *calledp ? "" : " authenticated", txt);
257   tlsp->peerdn = txt;
258   }
259
260 if (!*calledp) tlsp->certificate_verified = TRUE;
261 *calledp = TRUE;
262
263 return 1;   /* accept */
264 }
265
266 static int
267 verify_callback_client(int state, X509_STORE_CTX *x509ctx)
268 {
269 return verify_callback(state, x509ctx, TRUE);
270 }
271
272 static int
273 verify_callback_server(int state, X509_STORE_CTX *x509ctx)
274 {
275 return verify_callback(state, x509ctx, FALSE);
276 }
277
278
279
280 /*************************************************
281 *           Information callback                 *
282 *************************************************/
283
284 /* The SSL library functions call this from time to time to indicate what they
285 are doing. We copy the string to the debugging output when TLS debugging has
286 been requested.
287
288 Arguments:
289   s         the SSL connection
290   where
291   ret
292
293 Returns:    nothing
294 */
295
296 static void
297 info_callback(SSL *s, int where, int ret)
298 {
299 where = where;
300 ret = ret;
301 DEBUG(D_tls) debug_printf("SSL info: %s\n", SSL_state_string_long(s));
302 }
303
304
305
306 /*************************************************
307 *                Initialize for DH               *
308 *************************************************/
309
310 /* If dhparam is set, expand it, and load up the parameters for DH encryption.
311
312 Arguments:
313   dhparam   DH parameter file or fixed parameter identity string
314   host      connected host, if client; NULL if server
315
316 Returns:    TRUE if OK (nothing to set up, or setup worked)
317 */
318
319 static BOOL
320 init_dh(SSL_CTX *sctx, uschar *dhparam, host_item *host)
321 {
322 BIO *bio;
323 DH *dh;
324 uschar *dhexpanded;
325 const char *pem;
326
327 if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded))
328   return FALSE;
329
330 if (dhexpanded == NULL || *dhexpanded == '\0')
331   {
332   bio = BIO_new_mem_buf(CS std_dh_prime_default(), -1);
333   }
334 else if (dhexpanded[0] == '/')
335   {
336   bio = BIO_new_file(CS dhexpanded, "r");
337   if (bio == NULL)
338     {
339     tls_error(string_sprintf("could not read dhparams file %s", dhexpanded),
340           host, US strerror(errno));
341     return FALSE;
342     }
343   }
344 else
345   {
346   if (Ustrcmp(dhexpanded, "none") == 0)
347     {
348     DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
349     return TRUE;
350     }
351
352   pem = std_dh_prime_named(dhexpanded);
353   if (!pem)
354     {
355     tls_error(string_sprintf("Unknown standard DH prime \"%s\"", dhexpanded),
356         host, US strerror(errno));
357     return FALSE;
358     }
359   bio = BIO_new_mem_buf(CS pem, -1);
360   }
361
362 dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL);
363 if (dh == NULL)
364   {
365   BIO_free(bio);
366   tls_error(string_sprintf("Could not read tls_dhparams \"%s\"", dhexpanded),
367       host, NULL);
368   return FALSE;
369   }
370
371 /* Even if it is larger, we silently return success rather than cause things
372  * to fail out, so that a too-large DH will not knock out all TLS; it's a
373  * debatable choice. */
374 if ((8*DH_size(dh)) > tls_dh_max_bits)
375   {
376   DEBUG(D_tls)
377     debug_printf("dhparams file %d bits, is > tls_dh_max_bits limit of %d",
378         8*DH_size(dh), tls_dh_max_bits);
379   }
380 else
381   {
382   SSL_CTX_set_tmp_dh(sctx, dh);
383   DEBUG(D_tls)
384     debug_printf("Diffie-Hellman initialized from %s with %d-bit prime\n",
385       dhexpanded ? dhexpanded : US"default", 8*DH_size(dh));
386   }
387
388 DH_free(dh);
389 BIO_free(bio);
390
391 return TRUE;
392 }
393
394
395
396
397 #ifdef EXPERIMENTAL_OCSP
398 /*************************************************
399 *       Load OCSP information into state         *
400 *************************************************/
401
402 /* Called to load the OCSP response from the given file into memory, once
403 caller has determined this is needed.  Checks validity.  Debugs a message
404 if invalid.
405
406 ASSUMES: single response, for single cert.
407
408 Arguments:
409   sctx            the SSL_CTX* to update
410   cbinfo          various parts of session state
411   expanded        the filename putatively holding an OCSP response
412
413 */
414
415 static void
416 ocsp_load_response(SSL_CTX *sctx,
417     tls_ext_ctx_cb *cbinfo,
418     const uschar *expanded)
419 {
420 BIO *bio;
421 OCSP_RESPONSE *resp;
422 OCSP_BASICRESP *basic_response;
423 OCSP_SINGLERESP *single_response;
424 ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
425 X509_STORE *store;
426 unsigned long verify_flags;
427 int status, reason, i;
428
429 cbinfo->ocsp_file_expanded = string_copy(expanded);
430 if (cbinfo->ocsp_response)
431   {
432   OCSP_RESPONSE_free(cbinfo->ocsp_response);
433   cbinfo->ocsp_response = NULL;
434   }
435
436 bio = BIO_new_file(CS cbinfo->ocsp_file_expanded, "rb");
437 if (!bio)
438   {
439   DEBUG(D_tls) debug_printf("Failed to open OCSP response file \"%s\"\n",
440       cbinfo->ocsp_file_expanded);
441   return;
442   }
443
444 resp = d2i_OCSP_RESPONSE_bio(bio, NULL);
445 BIO_free(bio);
446 if (!resp)
447   {
448   DEBUG(D_tls) debug_printf("Error reading OCSP response.\n");
449   return;
450   }
451
452 status = OCSP_response_status(resp);
453 if (status != OCSP_RESPONSE_STATUS_SUCCESSFUL)
454   {
455   DEBUG(D_tls) debug_printf("OCSP response not valid: %s (%d)\n",
456       OCSP_response_status_str(status), status);
457   return;
458   }
459
460 basic_response = OCSP_response_get1_basic(resp);
461 if (!basic_response)
462   {
463   DEBUG(D_tls)
464     debug_printf("OCSP response parse error: unable to extract basic response.\n");
465   return;
466   }
467
468 store = SSL_CTX_get_cert_store(sctx);
469 verify_flags = OCSP_NOVERIFY; /* check sigs, but not purpose */
470
471 /* May need to expose ability to adjust those flags?
472 OCSP_NOSIGS OCSP_NOVERIFY OCSP_NOCHAIN OCSP_NOCHECKS OCSP_NOEXPLICIT
473 OCSP_TRUSTOTHER OCSP_NOINTERN */
474
475 i = OCSP_basic_verify(basic_response, NULL, store, verify_flags);
476 if (i <= 0)
477   {
478   DEBUG(D_tls) {
479     ERR_error_string(ERR_get_error(), ssl_errstring);
480     debug_printf("OCSP response verify failure: %s\n", US ssl_errstring);
481   }
482   return;
483   }
484
485 /* Here's the simplifying assumption: there's only one response, for the
486 one certificate we use, and nothing for anything else in a chain.  If this
487 proves false, we need to extract a cert id from our issued cert
488 (tls_certificate) and use that for OCSP_resp_find_status() (which finds the
489 right cert in the stack and then calls OCSP_single_get0_status()).
490
491 I'm hoping to avoid reworking a bunch more of how we handle state here. */
492 single_response = OCSP_resp_get0(basic_response, 0);
493 if (!single_response)
494   {
495   DEBUG(D_tls)
496     debug_printf("Unable to get first response from OCSP basic response.\n");
497   return;
498   }
499
500 status = OCSP_single_get0_status(single_response, &reason, &rev, &thisupd, &nextupd);
501 /* how does this status differ from the one above? */
502 if (status != OCSP_RESPONSE_STATUS_SUCCESSFUL)
503   {
504   DEBUG(D_tls) debug_printf("OCSP response not valid (take 2): %s (%d)\n",
505       OCSP_response_status_str(status), status);
506   return;
507   }
508
509 if (!OCSP_check_validity(thisupd, nextupd, EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
510   {
511   DEBUG(D_tls) debug_printf("OCSP status invalid times.\n");
512   return;
513   }
514
515 cbinfo->ocsp_response = resp;
516 }
517 #endif
518
519
520
521
522 /*************************************************
523 *        Expand key and cert file specs          *
524 *************************************************/
525
526 /* Called once during tls_init and possibly againt during TLS setup, for a
527 new context, if Server Name Indication was used and tls_sni was seen in
528 the certificate string.
529
530 Arguments:
531   sctx            the SSL_CTX* to update
532   cbinfo          various parts of session state
533
534 Returns:          OK/DEFER/FAIL
535 */
536
537 static int
538 tls_expand_session_files(SSL_CTX *sctx, tls_ext_ctx_cb *cbinfo)
539 {
540 uschar *expanded;
541
542 if (cbinfo->certificate == NULL)
543   return OK;
544
545 if (Ustrstr(cbinfo->certificate, US"tls_sni") ||
546     Ustrstr(cbinfo->certificate, US"tls_in_sni") ||
547     Ustrstr(cbinfo->certificate, US"tls_out_sni")
548    )
549   reexpand_tls_files_for_sni = TRUE;
550
551 if (!expand_check(cbinfo->certificate, US"tls_certificate", &expanded))
552   return DEFER;
553
554 if (expanded != NULL)
555   {
556   DEBUG(D_tls) debug_printf("tls_certificate file %s\n", expanded);
557   if (!SSL_CTX_use_certificate_chain_file(sctx, CS expanded))
558     return tls_error(string_sprintf(
559       "SSL_CTX_use_certificate_chain_file file=%s", expanded),
560         cbinfo->host, NULL);
561   }
562
563 if (cbinfo->privatekey != NULL &&
564     !expand_check(cbinfo->privatekey, US"tls_privatekey", &expanded))
565   return DEFER;
566
567 /* If expansion was forced to fail, key_expanded will be NULL. If the result
568 of the expansion is an empty string, ignore it also, and assume the private
569 key is in the same file as the certificate. */
570
571 if (expanded != NULL && *expanded != 0)
572   {
573   DEBUG(D_tls) debug_printf("tls_privatekey file %s\n", expanded);
574   if (!SSL_CTX_use_PrivateKey_file(sctx, CS expanded, SSL_FILETYPE_PEM))
575     return tls_error(string_sprintf(
576       "SSL_CTX_use_PrivateKey_file file=%s", expanded), cbinfo->host, NULL);
577   }
578
579 #ifdef EXPERIMENTAL_OCSP
580 if (cbinfo->ocsp_file != NULL)
581   {
582   if (!expand_check(cbinfo->ocsp_file, US"tls_ocsp_file", &expanded))
583     return DEFER;
584
585   if (expanded != NULL && *expanded != 0)
586     {
587     DEBUG(D_tls) debug_printf("tls_ocsp_file %s\n", expanded);
588     if (cbinfo->ocsp_file_expanded &&
589         (Ustrcmp(expanded, cbinfo->ocsp_file_expanded) == 0))
590       {
591       DEBUG(D_tls)
592         debug_printf("tls_ocsp_file value unchanged, using existing values.\n");
593       } else {
594         ocsp_load_response(sctx, cbinfo, expanded);
595       }
596     }
597   }
598 #endif
599
600 return OK;
601 }
602
603
604
605
606 /*************************************************
607 *            Callback to handle SNI              *
608 *************************************************/
609
610 /* Called when acting as server during the TLS session setup if a Server Name
611 Indication extension was sent by the client.
612
613 API documentation is OpenSSL s_server.c implementation.
614
615 Arguments:
616   s               SSL* of the current session
617   ad              unknown (part of OpenSSL API) (unused)
618   arg             Callback of "our" registered data
619
620 Returns:          SSL_TLSEXT_ERR_{OK,ALERT_WARNING,ALERT_FATAL,NOACK}
621 */
622
623 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
624 static int
625 tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg)
626 {
627 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
628 tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
629 int rc;
630 int old_pool = store_pool;
631
632 if (!servername)
633   return SSL_TLSEXT_ERR_OK;
634
635 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", servername,
636     reexpand_tls_files_for_sni ? "" : " (unused for certificate selection)");
637
638 /* Make the extension value available for expansion */
639 store_pool = POOL_PERM;
640 tls_in.sni = string_copy(US servername);
641 store_pool = old_pool;
642
643 if (!reexpand_tls_files_for_sni)
644   return SSL_TLSEXT_ERR_OK;
645
646 /* Can't find an SSL_CTX_clone() or equivalent, so we do it manually;
647 not confident that memcpy wouldn't break some internal reference counting.
648 Especially since there's a references struct member, which would be off. */
649
650 server_sni = SSL_CTX_new(SSLv23_server_method());
651 if (!server_sni)
652   {
653   ERR_error_string(ERR_get_error(), ssl_errstring);
654   DEBUG(D_tls) debug_printf("SSL_CTX_new() failed: %s\n", ssl_errstring);
655   return SSL_TLSEXT_ERR_NOACK;
656   }
657
658 /* Not sure how many of these are actually needed, since SSL object
659 already exists.  Might even need this selfsame callback, for reneg? */
660
661 SSL_CTX_set_info_callback(server_sni, SSL_CTX_get_info_callback(server_ctx));
662 SSL_CTX_set_mode(server_sni, SSL_CTX_get_mode(server_ctx));
663 SSL_CTX_set_options(server_sni, SSL_CTX_get_options(server_ctx));
664 SSL_CTX_set_timeout(server_sni, SSL_CTX_get_timeout(server_ctx));
665 SSL_CTX_set_tlsext_servername_callback(server_sni, tls_servername_cb);
666 SSL_CTX_set_tlsext_servername_arg(server_sni, cbinfo);
667 if (cbinfo->server_cipher_list)
668   SSL_CTX_set_cipher_list(server_sni, CS cbinfo->server_cipher_list);
669 #ifdef EXPERIMENTAL_OCSP
670 if (cbinfo->ocsp_file)
671   {
672   SSL_CTX_set_tlsext_status_cb(server_sni, tls_stapling_cb);
673   SSL_CTX_set_tlsext_status_arg(server_ctx, cbinfo);
674   }
675 #endif
676
677 rc = setup_certs(server_sni, tls_verify_certificates, tls_crl, NULL, FALSE, FALSE);
678 if (rc != OK) return SSL_TLSEXT_ERR_NOACK;
679
680 /* do this after setup_certs, because this can require the certs for verifying
681 OCSP information. */
682 rc = tls_expand_session_files(server_sni, cbinfo);
683 if (rc != OK) return SSL_TLSEXT_ERR_NOACK;
684
685 rc = init_dh(server_sni, cbinfo->dhparam, NULL);
686 if (rc != OK) return SSL_TLSEXT_ERR_NOACK;
687
688 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
689 SSL_set_SSL_CTX(s, server_sni);
690
691 return SSL_TLSEXT_ERR_OK;
692 }
693 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
694
695
696
697
698 #ifdef EXPERIMENTAL_OCSP
699 /*************************************************
700 *        Callback to handle OCSP Stapling        *
701 *************************************************/
702
703 /* Called when acting as server during the TLS session setup if the client
704 requests OCSP information with a Certificate Status Request.
705
706 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
707 project.
708
709 */
710
711 static int
712 tls_stapling_cb(SSL *s, void *arg)
713 {
714 const tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
715 uschar *response_der;
716 int response_der_len;
717
718 DEBUG(D_tls) debug_printf("Received TLS status request (OCSP stapling); %s response.\n",
719     cbinfo->ocsp_response ? "have" : "lack");
720 if (!cbinfo->ocsp_response)
721   return SSL_TLSEXT_ERR_NOACK;
722
723 response_der = NULL;
724 response_der_len = i2d_OCSP_RESPONSE(cbinfo->ocsp_response, &response_der);
725 if (response_der_len <= 0)
726   return SSL_TLSEXT_ERR_NOACK;
727
728 SSL_set_tlsext_status_ocsp_resp(server_ssl, response_der, response_der_len);
729 return SSL_TLSEXT_ERR_OK;
730 }
731
732 #endif /* EXPERIMENTAL_OCSP */
733
734
735
736
737 /*************************************************
738 *            Initialize for TLS                  *
739 *************************************************/
740
741 /* Called from both server and client code, to do preliminary initialization of
742 the library.
743
744 Arguments:
745   host            connected host, if client; NULL if server
746   dhparam         DH parameter file
747   certificate     certificate file
748   privatekey      private key
749   addr            address if client; NULL if server (for some randomness)
750
751 Returns:          OK/DEFER/FAIL
752 */
753
754 static int
755 tls_init(SSL_CTX **ctxp, host_item *host, uschar *dhparam, uschar *certificate,
756   uschar *privatekey,
757 #ifdef EXPERIMENTAL_OCSP
758   uschar *ocsp_file,
759 #endif
760   address_item *addr, tls_ext_ctx_cb ** cbp)
761 {
762 long init_options;
763 int rc;
764 BOOL okay;
765 tls_ext_ctx_cb *cbinfo;
766
767 cbinfo = store_malloc(sizeof(tls_ext_ctx_cb));
768 cbinfo->certificate = certificate;
769 cbinfo->privatekey = privatekey;
770 #ifdef EXPERIMENTAL_OCSP
771 cbinfo->ocsp_file = ocsp_file;
772 #endif
773 cbinfo->dhparam = dhparam;
774 cbinfo->host = host;
775
776 SSL_load_error_strings();          /* basic set up */
777 OpenSSL_add_ssl_algorithms();
778
779 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
780 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
781 list of available digests. */
782 EVP_add_digest(EVP_sha256());
783 #endif
784
785 /* Create a context.
786 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
787 negotiation in the different methods; as far as I can tell, the only
788 *_{server,client}_method which allows negotiation is SSLv23, which exists even
789 when OpenSSL is built without SSLv2 support.
790 By disabling with openssl_options, we can let admins re-enable with the
791 existing knob. */
792
793 *ctxp = SSL_CTX_new((host == NULL)?
794   SSLv23_server_method() : SSLv23_client_method());
795
796 if (*ctxp == NULL) return tls_error(US"SSL_CTX_new", host, NULL);
797
798 /* It turns out that we need to seed the random number generator this early in
799 order to get the full complement of ciphers to work. It took me roughly a day
800 of work to discover this by experiment.
801
802 On systems that have /dev/urandom, SSL may automatically seed itself from
803 there. Otherwise, we have to make something up as best we can. Double check
804 afterwards. */
805
806 if (!RAND_status())
807   {
808   randstuff r;
809   gettimeofday(&r.tv, NULL);
810   r.p = getpid();
811
812   RAND_seed((uschar *)(&r), sizeof(r));
813   RAND_seed((uschar *)big_buffer, big_buffer_size);
814   if (addr != NULL) RAND_seed((uschar *)addr, sizeof(addr));
815
816   if (!RAND_status())
817     return tls_error(US"RAND_status", host,
818       US"unable to seed random number generator");
819   }
820
821 /* Set up the information callback, which outputs if debugging is at a suitable
822 level. */
823
824 SSL_CTX_set_info_callback(*ctxp, (void (*)())info_callback);
825
826 /* Automatically re-try reads/writes after renegotiation. */
827 (void) SSL_CTX_set_mode(*ctxp, SSL_MODE_AUTO_RETRY);
828
829 /* Apply administrator-supplied work-arounds.
830 Historically we applied just one requested option,
831 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
832 moved to an administrator-controlled list of options to specify and
833 grandfathered in the first one as the default value for "openssl_options".
834
835 No OpenSSL version number checks: the options we accept depend upon the
836 availability of the option value macros from OpenSSL.  */
837
838 okay = tls_openssl_options_parse(openssl_options, &init_options);
839 if (!okay)
840   return tls_error(US"openssl_options parsing failed", host, NULL);
841
842 if (init_options)
843   {
844   DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
845   if (!(SSL_CTX_set_options(*ctxp, init_options)))
846     return tls_error(string_sprintf(
847           "SSL_CTX_set_option(%#lx)", init_options), host, NULL);
848   }
849 else
850   DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
851
852 /* Initialize with DH parameters if supplied */
853
854 if (!init_dh(*ctxp, dhparam, host)) return DEFER;
855
856 /* Set up certificate and key (and perhaps OCSP info) */
857
858 rc = tls_expand_session_files(*ctxp, cbinfo);
859 if (rc != OK) return rc;
860
861 /* If we need to handle SNI, do so */
862 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
863 if (host == NULL)
864   {
865 #ifdef EXPERIMENTAL_OCSP
866   /* We check ocsp_file, not ocsp_response, because we care about if
867   the option exists, not what the current expansion might be, as SNI might
868   change the certificate and OCSP file in use between now and the time the
869   callback is invoked. */
870   if (cbinfo->ocsp_file)
871     {
872     SSL_CTX_set_tlsext_status_cb(server_ctx, tls_stapling_cb);
873     SSL_CTX_set_tlsext_status_arg(server_ctx, cbinfo);
874     }
875 #endif
876   /* We always do this, so that $tls_sni is available even if not used in
877   tls_certificate */
878   SSL_CTX_set_tlsext_servername_callback(*ctxp, tls_servername_cb);
879   SSL_CTX_set_tlsext_servername_arg(*ctxp, cbinfo);
880   }
881 #endif
882
883 /* Set up the RSA callback */
884
885 SSL_CTX_set_tmp_rsa_callback(*ctxp, rsa_callback);
886
887 /* Finally, set the timeout, and we are done */
888
889 SSL_CTX_set_timeout(*ctxp, ssl_session_timeout);
890 DEBUG(D_tls) debug_printf("Initialized TLS\n");
891
892 *cbp = cbinfo;
893
894 return OK;
895 }
896
897
898
899
900 /*************************************************
901 *           Get name of cipher in use            *
902 *************************************************/
903
904 /*
905 Argument:   pointer to an SSL structure for the connection
906             buffer to use for answer
907             size of buffer
908             pointer to number of bits for cipher
909 Returns:    nothing
910 */
911
912 static void
913 construct_cipher_name(SSL *ssl, uschar *cipherbuf, int bsize, int *bits)
914 {
915 /* With OpenSSL 1.0.0a, this needs to be const but the documentation doesn't
916 yet reflect that.  It should be a safe change anyway, even 0.9.8 versions have
917 the accessor functions use const in the prototype. */
918 const SSL_CIPHER *c;
919 uschar *ver;
920
921 switch (ssl->session->ssl_version)
922   {
923   case SSL2_VERSION:
924   ver = US"SSLv2";
925   break;
926
927   case SSL3_VERSION:
928   ver = US"SSLv3";
929   break;
930
931   case TLS1_VERSION:
932   ver = US"TLSv1";
933   break;
934
935 #ifdef TLS1_1_VERSION
936   case TLS1_1_VERSION:
937   ver = US"TLSv1.1";
938   break;
939 #endif
940
941 #ifdef TLS1_2_VERSION
942   case TLS1_2_VERSION:
943   ver = US"TLSv1.2";
944   break;
945 #endif
946
947   default:
948   ver = US"UNKNOWN";
949   }
950
951 c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
952 SSL_CIPHER_get_bits(c, bits);
953
954 string_format(cipherbuf, bsize, "%s:%s:%u", ver,
955   SSL_CIPHER_get_name(c), *bits);
956
957 DEBUG(D_tls) debug_printf("Cipher: %s\n", cipherbuf);
958 }
959
960
961
962
963
964 /*************************************************
965 *        Set up for verifying certificates       *
966 *************************************************/
967
968 /* Called by both client and server startup
969
970 Arguments:
971   sctx          SSL_CTX* to initialise
972   certs         certs file or NULL
973   crl           CRL file or NULL
974   host          NULL in a server; the remote host in a client
975   optional      TRUE if called from a server for a host in tls_try_verify_hosts;
976                 otherwise passed as FALSE
977   client        TRUE if called for client startup, FALSE for server startup
978
979 Returns:        OK/DEFER/FAIL
980 */
981
982 static int
983 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional, BOOL client)
984 {
985 uschar *expcerts, *expcrl;
986
987 if (!expand_check(certs, US"tls_verify_certificates", &expcerts))
988   return DEFER;
989
990 if (expcerts != NULL)
991   {
992   struct stat statbuf;
993   if (!SSL_CTX_set_default_verify_paths(sctx))
994     return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL);
995
996   if (Ustat(expcerts, &statbuf) < 0)
997     {
998     log_write(0, LOG_MAIN|LOG_PANIC,
999       "failed to stat %s for certificates", expcerts);
1000     return DEFER;
1001     }
1002   else
1003     {
1004     uschar *file, *dir;
1005     if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
1006       { file = NULL; dir = expcerts; }
1007     else
1008       { file = expcerts; dir = NULL; }
1009
1010     /* If a certificate file is empty, the next function fails with an
1011     unhelpful error message. If we skip it, we get the correct behaviour (no
1012     certificates are recognized, but the error message is still misleading (it
1013     says no certificate was supplied.) But this is better. */
1014
1015     if ((file == NULL || statbuf.st_size > 0) &&
1016           !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
1017       return tls_error(US"SSL_CTX_load_verify_locations", host, NULL);
1018
1019     if (file != NULL)
1020       {
1021       SSL_CTX_set_client_CA_list(sctx, SSL_load_client_CA_file(CS file));
1022       }
1023     }
1024
1025   /* Handle a certificate revocation list. */
1026
1027   #if OPENSSL_VERSION_NUMBER > 0x00907000L
1028
1029   /* This bit of code is now the version supplied by Lars Mainka. (I have
1030    * merely reformatted it into the Exim code style.)
1031
1032    * "From here I changed the code to add support for multiple crl's
1033    * in pem format in one file or to support hashed directory entries in
1034    * pem format instead of a file. This method now uses the library function
1035    * X509_STORE_load_locations to add the CRL location to the SSL context.
1036    * OpenSSL will then handle the verify against CA certs and CRLs by
1037    * itself in the verify callback." */
1038
1039   if (!expand_check(crl, US"tls_crl", &expcrl)) return DEFER;
1040   if (expcrl != NULL && *expcrl != 0)
1041     {
1042     struct stat statbufcrl;
1043     if (Ustat(expcrl, &statbufcrl) < 0)
1044       {
1045       log_write(0, LOG_MAIN|LOG_PANIC,
1046         "failed to stat %s for certificates revocation lists", expcrl);
1047       return DEFER;
1048       }
1049     else
1050       {
1051       /* is it a file or directory? */
1052       uschar *file, *dir;
1053       X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
1054       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
1055         {
1056         file = NULL;
1057         dir = expcrl;
1058         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
1059         }
1060       else
1061         {
1062         file = expcrl;
1063         dir = NULL;
1064         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
1065         }
1066       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
1067         return tls_error(US"X509_STORE_load_locations", host, NULL);
1068
1069       /* setting the flags to check against the complete crl chain */
1070
1071       X509_STORE_set_flags(cvstore,
1072         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
1073       }
1074     }
1075
1076   #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
1077
1078   /* If verification is optional, don't fail if no certificate */
1079
1080   SSL_CTX_set_verify(sctx,
1081     SSL_VERIFY_PEER | (optional? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
1082     client ? verify_callback_client : verify_callback_server);
1083   }
1084
1085 return OK;
1086 }
1087
1088
1089
1090 /*************************************************
1091 *       Start a TLS session in a server          *
1092 *************************************************/
1093
1094 /* This is called when Exim is running as a server, after having received
1095 the STARTTLS command. It must respond to that command, and then negotiate
1096 a TLS session.
1097
1098 Arguments:
1099   require_ciphers   allowed ciphers
1100
1101 Returns:            OK on success
1102                     DEFER for errors before the start of the negotiation
1103                     FAIL for errors during the negotation; the server can't
1104                       continue running.
1105 */
1106
1107 int
1108 tls_server_start(const uschar *require_ciphers)
1109 {
1110 int rc;
1111 uschar *expciphers;
1112 tls_ext_ctx_cb *cbinfo;
1113 static uschar cipherbuf[256];
1114
1115 /* Check for previous activation */
1116
1117 if (tls_in.active >= 0)
1118   {
1119   tls_error(US"STARTTLS received after TLS started", NULL, US"");
1120   smtp_printf("554 Already in TLS\r\n");
1121   return FAIL;
1122   }
1123
1124 /* Initialize the SSL library. If it fails, it will already have logged
1125 the error. */
1126
1127 rc = tls_init(&server_ctx, NULL, tls_dhparam, tls_certificate, tls_privatekey,
1128 #ifdef EXPERIMENTAL_OCSP
1129     tls_ocsp_file,
1130 #endif
1131     NULL, &server_static_cbinfo);
1132 if (rc != OK) return rc;
1133 cbinfo = server_static_cbinfo;
1134
1135 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers))
1136   return FAIL;
1137
1138 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
1139 were historically separated by underscores. So that I can use either form in my
1140 tests, and also for general convenience, we turn underscores into hyphens here.
1141 */
1142
1143 if (expciphers != NULL)
1144   {
1145   uschar *s = expciphers;
1146   while (*s != 0) { if (*s == '_') *s = '-'; s++; }
1147   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
1148   if (!SSL_CTX_set_cipher_list(server_ctx, CS expciphers))
1149     return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL);
1150   cbinfo->server_cipher_list = expciphers;
1151   }
1152
1153 /* If this is a host for which certificate verification is mandatory or
1154 optional, set up appropriately. */
1155
1156 tls_in.certificate_verified = FALSE;
1157 server_verify_callback_called = FALSE;
1158
1159 if (verify_check_host(&tls_verify_hosts) == OK)
1160   {
1161   rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL, FALSE, FALSE);
1162   if (rc != OK) return rc;
1163   server_verify_optional = FALSE;
1164   }
1165 else if (verify_check_host(&tls_try_verify_hosts) == OK)
1166   {
1167   rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL, TRUE, FALSE);
1168   if (rc != OK) return rc;
1169   server_verify_optional = TRUE;
1170   }
1171
1172 /* Prepare for new connection */
1173
1174 if ((server_ssl = SSL_new(server_ctx)) == NULL) return tls_error(US"SSL_new", NULL, NULL);
1175
1176 /* Warning: we used to SSL_clear(ssl) here, it was removed.
1177  *
1178  * With the SSL_clear(), we get strange interoperability bugs with
1179  * OpenSSL 1.0.1b and TLS1.1/1.2.  It looks as though this may be a bug in
1180  * OpenSSL itself, as a clear should not lead to inability to follow protocols.
1181  *
1182  * The SSL_clear() call is to let an existing SSL* be reused, typically after
1183  * session shutdown.  In this case, we have a brand new object and there's no
1184  * obvious reason to immediately clear it.  I'm guessing that this was
1185  * originally added because of incomplete initialisation which the clear fixed,
1186  * in some historic release.
1187  */
1188
1189 /* Set context and tell client to go ahead, except in the case of TLS startup
1190 on connection, where outputting anything now upsets the clients and tends to
1191 make them disconnect. We need to have an explicit fflush() here, to force out
1192 the response. Other smtp_printf() calls do not need it, because in non-TLS
1193 mode, the fflush() happens when smtp_getc() is called. */
1194
1195 SSL_set_session_id_context(server_ssl, sid_ctx, Ustrlen(sid_ctx));
1196 if (!tls_in.on_connect)
1197   {
1198   smtp_printf("220 TLS go ahead\r\n");
1199   fflush(smtp_out);
1200   }
1201
1202 /* Now negotiate the TLS session. We put our own timer on it, since it seems
1203 that the OpenSSL library doesn't. */
1204
1205 SSL_set_wfd(server_ssl, fileno(smtp_out));
1206 SSL_set_rfd(server_ssl, fileno(smtp_in));
1207 SSL_set_accept_state(server_ssl);
1208
1209 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
1210
1211 sigalrm_seen = FALSE;
1212 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1213 rc = SSL_accept(server_ssl);
1214 alarm(0);
1215
1216 if (rc <= 0)
1217   {
1218   tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL);
1219   if (ERR_get_error() == 0)
1220     log_write(0, LOG_MAIN,
1221         "TLS client disconnected cleanly (rejected our certificate?)");
1222   return FAIL;
1223   }
1224
1225 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
1226
1227 /* TLS has been set up. Adjust the input functions to read via TLS,
1228 and initialize things. */
1229
1230 construct_cipher_name(server_ssl, cipherbuf, sizeof(cipherbuf), &tls_in.bits);
1231 tls_in.cipher = cipherbuf;
1232
1233 DEBUG(D_tls)
1234   {
1235   uschar buf[2048];
1236   if (SSL_get_shared_ciphers(server_ssl, CS buf, sizeof(buf)) != NULL)
1237     debug_printf("Shared ciphers: %s\n", buf);
1238   }
1239
1240
1241 /* Only used by the server-side tls (tls_in), including tls_getc.
1242    Client-side (tls_out) reads (seem to?) go via
1243    smtp_read_response()/ip_recv().
1244    Hence no need to duplicate for _in and _out.
1245  */
1246 ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
1247 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
1248 ssl_xfer_eof = ssl_xfer_error = 0;
1249
1250 receive_getc = tls_getc;
1251 receive_ungetc = tls_ungetc;
1252 receive_feof = tls_feof;
1253 receive_ferror = tls_ferror;
1254 receive_smtp_buffered = tls_smtp_buffered;
1255
1256 tls_in.active = fileno(smtp_out);
1257 return OK;
1258 }
1259
1260
1261
1262
1263
1264 /*************************************************
1265 *    Start a TLS session in a client             *
1266 *************************************************/
1267
1268 /* Called from the smtp transport after STARTTLS has been accepted.
1269
1270 Argument:
1271   fd               the fd of the connection
1272   host             connected host (for messages)
1273   addr             the first address
1274   dhparam          DH parameter file
1275   certificate      certificate file
1276   privatekey       private key file
1277   sni              TLS SNI to send to remote host
1278   verify_certs     file for certificate verify
1279   crl              file containing CRL
1280   require_ciphers  list of allowed ciphers
1281   dh_min_bits      minimum number of bits acceptable in server's DH prime
1282                    (unused in OpenSSL)
1283   timeout          startup timeout
1284
1285 Returns:           OK on success
1286                    FAIL otherwise - note that tls_error() will not give DEFER
1287                      because this is not a server
1288 */
1289
1290 int
1291 tls_client_start(int fd, host_item *host, address_item *addr, uschar *dhparam,
1292   uschar *certificate, uschar *privatekey, uschar *sni,
1293   uschar *verify_certs, uschar *crl,
1294   uschar *require_ciphers, int dh_min_bits ARG_UNUSED, int timeout)
1295 {
1296 static uschar txt[256];
1297 uschar *expciphers;
1298 X509* server_cert;
1299 int rc;
1300 static uschar cipherbuf[256];
1301
1302 rc = tls_init(&client_ctx, host, dhparam, certificate, privatekey,
1303 #ifdef EXPERIMENTAL_OCSP
1304     NULL,
1305 #endif
1306     addr, &client_static_cbinfo);
1307 if (rc != OK) return rc;
1308
1309 tls_out.certificate_verified = FALSE;
1310 client_verify_callback_called = FALSE;
1311
1312 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers))
1313   return FAIL;
1314
1315 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
1316 are separated by underscores. So that I can use either form in my tests, and
1317 also for general convenience, we turn underscores into hyphens here. */
1318
1319 if (expciphers != NULL)
1320   {
1321   uschar *s = expciphers;
1322   while (*s != 0) { if (*s == '_') *s = '-'; s++; }
1323   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
1324   if (!SSL_CTX_set_cipher_list(client_ctx, CS expciphers))
1325     return tls_error(US"SSL_CTX_set_cipher_list", host, NULL);
1326   }
1327
1328 rc = setup_certs(client_ctx, verify_certs, crl, host, FALSE, TRUE);
1329 if (rc != OK) return rc;
1330
1331 if ((client_ssl = SSL_new(client_ctx)) == NULL) return tls_error(US"SSL_new", host, NULL);
1332 SSL_set_session_id_context(client_ssl, sid_ctx, Ustrlen(sid_ctx));
1333 SSL_set_fd(client_ssl, fd);
1334 SSL_set_connect_state(client_ssl);
1335
1336 if (sni)
1337   {
1338   if (!expand_check(sni, US"tls_sni", &tls_out.sni))
1339     return FAIL;
1340   if (tls_out.sni == NULL)
1341     {
1342     DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
1343     }
1344   else if (!Ustrlen(tls_out.sni))
1345     tls_out.sni = NULL;
1346   else
1347     {
1348 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1349     DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tls_out.sni);
1350     SSL_set_tlsext_host_name(client_ssl, tls_out.sni);
1351 #else
1352     DEBUG(D_tls)
1353       debug_printf("OpenSSL at build-time lacked SNI support, ignoring \"%s\"\n",
1354           tls_sni);
1355 #endif
1356     }
1357   }
1358
1359 /* There doesn't seem to be a built-in timeout on connection. */
1360
1361 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
1362 sigalrm_seen = FALSE;
1363 alarm(timeout);
1364 rc = SSL_connect(client_ssl);
1365 alarm(0);
1366
1367 if (rc <= 0)
1368   return tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL);
1369
1370 DEBUG(D_tls) debug_printf("SSL_connect succeeded\n");
1371
1372 /* Beware anonymous ciphers which lead to server_cert being NULL */
1373 server_cert = SSL_get_peer_certificate (client_ssl);
1374 if (server_cert)
1375   {
1376   tls_out.peerdn = US X509_NAME_oneline(X509_get_subject_name(server_cert),
1377     CS txt, sizeof(txt));
1378   tls_out.peerdn = txt;
1379   }
1380 else
1381   tls_out.peerdn = NULL;
1382
1383 construct_cipher_name(client_ssl, cipherbuf, sizeof(cipherbuf), &tls_out.bits);
1384 tls_out.cipher = cipherbuf;
1385
1386 tls_out.active = fd;
1387 return OK;
1388 }
1389
1390
1391
1392
1393
1394 /*************************************************
1395 *            TLS version of getc                 *
1396 *************************************************/
1397
1398 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
1399 it refills the buffer via the SSL reading function.
1400
1401 Arguments:  none
1402 Returns:    the next character or EOF
1403
1404 Only used by the server-side TLS.
1405 */
1406
1407 int
1408 tls_getc(void)
1409 {
1410 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
1411   {
1412   int error;
1413   int inbytes;
1414
1415   DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", server_ssl,
1416     ssl_xfer_buffer, ssl_xfer_buffer_size);
1417
1418   if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
1419   inbytes = SSL_read(server_ssl, CS ssl_xfer_buffer, ssl_xfer_buffer_size);
1420   error = SSL_get_error(server_ssl, inbytes);
1421   alarm(0);
1422
1423   /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
1424   closed down, not that the socket itself has been closed down. Revert to
1425   non-SSL handling. */
1426
1427   if (error == SSL_ERROR_ZERO_RETURN)
1428     {
1429     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
1430
1431     receive_getc = smtp_getc;
1432     receive_ungetc = smtp_ungetc;
1433     receive_feof = smtp_feof;
1434     receive_ferror = smtp_ferror;
1435     receive_smtp_buffered = smtp_buffered;
1436
1437     SSL_free(server_ssl);
1438     server_ssl = NULL;
1439     tls_in.active = -1;
1440     tls_in.bits = 0;
1441     tls_in.cipher = NULL;
1442     tls_in.peerdn = NULL;
1443     tls_in.sni = NULL;
1444
1445     return smtp_getc();
1446     }
1447
1448   /* Handle genuine errors */
1449
1450   else if (error == SSL_ERROR_SSL)
1451     {
1452     ERR_error_string(ERR_get_error(), ssl_errstring);
1453     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
1454     ssl_xfer_error = 1;
1455     return EOF;
1456     }
1457
1458   else if (error != SSL_ERROR_NONE)
1459     {
1460     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
1461     ssl_xfer_error = 1;
1462     return EOF;
1463     }
1464
1465 #ifndef DISABLE_DKIM
1466   dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
1467 #endif
1468   ssl_xfer_buffer_hwm = inbytes;
1469   ssl_xfer_buffer_lwm = 0;
1470   }
1471
1472 /* Something in the buffer; return next uschar */
1473
1474 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
1475 }
1476
1477
1478
1479 /*************************************************
1480 *          Read bytes from TLS channel           *
1481 *************************************************/
1482
1483 /*
1484 Arguments:
1485   buff      buffer of data
1486   len       size of buffer
1487
1488 Returns:    the number of bytes read
1489             -1 after a failed read
1490
1491 Only used by the client-side TLS.
1492 */
1493
1494 int
1495 tls_read(BOOL is_server, uschar *buff, size_t len)
1496 {
1497 SSL *ssl = is_server ? server_ssl : client_ssl;
1498 int inbytes;
1499 int error;
1500
1501 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
1502   buff, (unsigned int)len);
1503
1504 inbytes = SSL_read(ssl, CS buff, len);
1505 error = SSL_get_error(ssl, inbytes);
1506
1507 if (error == SSL_ERROR_ZERO_RETURN)
1508   {
1509   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
1510   return -1;
1511   }
1512 else if (error != SSL_ERROR_NONE)
1513   {
1514   return -1;
1515   }
1516
1517 return inbytes;
1518 }
1519
1520
1521
1522
1523
1524 /*************************************************
1525 *         Write bytes down TLS channel           *
1526 *************************************************/
1527
1528 /*
1529 Arguments:
1530   is_server channel specifier
1531   buff      buffer of data
1532   len       number of bytes
1533
1534 Returns:    the number of bytes after a successful write,
1535             -1 after a failed write
1536
1537 Used by both server-side and client-side TLS.
1538 */
1539
1540 int
1541 tls_write(BOOL is_server, const uschar *buff, size_t len)
1542 {
1543 int outbytes;
1544 int error;
1545 int left = len;
1546 SSL *ssl = is_server ? server_ssl : client_ssl;
1547
1548 DEBUG(D_tls) debug_printf("tls_do_write(%p, %d)\n", buff, left);
1549 while (left > 0)
1550   {
1551   DEBUG(D_tls) debug_printf("SSL_write(SSL, %p, %d)\n", buff, left);
1552   outbytes = SSL_write(ssl, CS buff, left);
1553   error = SSL_get_error(ssl, outbytes);
1554   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
1555   switch (error)
1556     {
1557     case SSL_ERROR_SSL:
1558     ERR_error_string(ERR_get_error(), ssl_errstring);
1559     log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
1560     return -1;
1561
1562     case SSL_ERROR_NONE:
1563     left -= outbytes;
1564     buff += outbytes;
1565     break;
1566
1567     case SSL_ERROR_ZERO_RETURN:
1568     log_write(0, LOG_MAIN, "SSL channel closed on write");
1569     return -1;
1570
1571     case SSL_ERROR_SYSCALL:
1572     log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
1573       sender_fullhost ? sender_fullhost : US"<unknown>",
1574       strerror(errno));
1575
1576     default:
1577     log_write(0, LOG_MAIN, "SSL_write error %d", error);
1578     return -1;
1579     }
1580   }
1581 return len;
1582 }
1583
1584
1585
1586 /*************************************************
1587 *         Close down a TLS session               *
1588 *************************************************/
1589
1590 /* This is also called from within a delivery subprocess forked from the
1591 daemon, to shut down the TLS library, without actually doing a shutdown (which
1592 would tamper with the SSL session in the parent process).
1593
1594 Arguments:   TRUE if SSL_shutdown is to be called
1595 Returns:     nothing
1596
1597 Used by both server-side and client-side TLS.
1598 */
1599
1600 void
1601 tls_close(BOOL is_server, BOOL shutdown)
1602 {
1603 SSL **sslp = is_server ? &server_ssl : &client_ssl;
1604 int *fdp = is_server ? &tls_in.active : &tls_out.active;
1605
1606 if (*fdp < 0) return;  /* TLS was not active */
1607
1608 if (shutdown)
1609   {
1610   DEBUG(D_tls) debug_printf("tls_close(): shutting down SSL\n");
1611   SSL_shutdown(*sslp);
1612   }
1613
1614 SSL_free(*sslp);
1615 *sslp = NULL;
1616
1617 *fdp = -1;
1618 }
1619
1620
1621
1622
1623 /*************************************************
1624 *  Let tls_require_ciphers be checked at startup *
1625 *************************************************/
1626
1627 /* The tls_require_ciphers option, if set, must be something which the
1628 library can parse.
1629
1630 Returns:     NULL on success, or error message
1631 */
1632
1633 uschar *
1634 tls_validate_require_cipher(void)
1635 {
1636 SSL_CTX *ctx;
1637 uschar *s, *expciphers, *err;
1638
1639 /* this duplicates from tls_init(), we need a better "init just global
1640 state, for no specific purpose" singleton function of our own */
1641
1642 SSL_load_error_strings();
1643 OpenSSL_add_ssl_algorithms();
1644 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
1645 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
1646 list of available digests. */
1647 EVP_add_digest(EVP_sha256());
1648 #endif
1649
1650 if (!(tls_require_ciphers && *tls_require_ciphers))
1651   return NULL;
1652
1653 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers))
1654   return US"failed to expand tls_require_ciphers";
1655
1656 if (!(expciphers && *expciphers))
1657   return NULL;
1658
1659 /* normalisation ripped from above */
1660 s = expciphers;
1661 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
1662
1663 err = NULL;
1664
1665 ctx = SSL_CTX_new(SSLv23_server_method());
1666 if (!ctx)
1667   {
1668   ERR_error_string(ERR_get_error(), ssl_errstring);
1669   return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
1670   }
1671
1672 DEBUG(D_tls)
1673   debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
1674
1675 if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
1676   {
1677   ERR_error_string(ERR_get_error(), ssl_errstring);
1678   err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed", expciphers);
1679   }
1680
1681 SSL_CTX_free(ctx);
1682
1683 return err;
1684 }
1685
1686
1687
1688
1689 /*************************************************
1690 *         Report the library versions.           *
1691 *************************************************/
1692
1693 /* There have historically been some issues with binary compatibility in
1694 OpenSSL libraries; if Exim (like many other applications) is built against
1695 one version of OpenSSL but the run-time linker picks up another version,
1696 it can result in serious failures, including crashing with a SIGSEGV.  So
1697 report the version found by the compiler and the run-time version.
1698
1699 Arguments:   a FILE* to print the results to
1700 Returns:     nothing
1701 */
1702
1703 void
1704 tls_version_report(FILE *f)
1705 {
1706 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
1707            "                          Runtime: %s\n",
1708            OPENSSL_VERSION_TEXT,
1709            SSLeay_version(SSLEAY_VERSION));
1710 }
1711
1712
1713
1714
1715 /*************************************************
1716 *            Random number generation            *
1717 *************************************************/
1718
1719 /* Pseudo-random number generation.  The result is not expected to be
1720 cryptographically strong but not so weak that someone will shoot themselves
1721 in the foot using it as a nonce in input in some email header scheme or
1722 whatever weirdness they'll twist this into.  The result should handle fork()
1723 and avoid repeating sequences.  OpenSSL handles that for us.
1724
1725 Arguments:
1726   max       range maximum
1727 Returns     a random number in range [0, max-1]
1728 */
1729
1730 int
1731 vaguely_random_number(int max)
1732 {
1733 unsigned int r;
1734 int i, needed_len;
1735 uschar *p;
1736 uschar smallbuf[sizeof(r)];
1737
1738 if (max <= 1)
1739   return 0;
1740
1741 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
1742 if (!RAND_status())
1743   {
1744   randstuff r;
1745   gettimeofday(&r.tv, NULL);
1746   r.p = getpid();
1747
1748   RAND_seed((uschar *)(&r), sizeof(r));
1749   }
1750 /* We're after pseudo-random, not random; if we still don't have enough data
1751 in the internal PRNG then our options are limited.  We could sleep and hope
1752 for entropy to come along (prayer technique) but if the system is so depleted
1753 in the first place then something is likely to just keep taking it.  Instead,
1754 we'll just take whatever little bit of pseudo-random we can still manage to
1755 get. */
1756
1757 needed_len = sizeof(r);
1758 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
1759 asked for a number less than 10. */
1760 for (r = max, i = 0; r; ++i)
1761   r >>= 1;
1762 i = (i + 7) / 8;
1763 if (i < needed_len)
1764   needed_len = i;
1765
1766 /* We do not care if crypto-strong */
1767 i = RAND_pseudo_bytes(smallbuf, needed_len);
1768 if (i < 0)
1769   {
1770   DEBUG(D_all)
1771     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
1772   return vaguely_random_number_fallback(max);
1773   }
1774
1775 r = 0;
1776 for (p = smallbuf; needed_len; --needed_len, ++p)
1777   {
1778   r *= 256;
1779   r += *p;
1780   }
1781
1782 /* We don't particularly care about weighted results; if someone wants
1783 smooth distribution and cares enough then they should submit a patch then. */
1784 return r % max;
1785 }
1786
1787
1788
1789
1790 /*************************************************
1791 *        OpenSSL option parse                    *
1792 *************************************************/
1793
1794 /* Parse one option for tls_openssl_options_parse below
1795
1796 Arguments:
1797   name    one option name
1798   value   place to store a value for it
1799 Returns   success or failure in parsing
1800 */
1801
1802 struct exim_openssl_option {
1803   uschar *name;
1804   long    value;
1805 };
1806 /* We could use a macro to expand, but we need the ifdef and not all the
1807 options document which version they were introduced in.  Policylet: include
1808 all options unless explicitly for DTLS, let the administrator choose which
1809 to apply.
1810
1811 This list is current as of:
1812   ==>  1.0.1b  <==  */
1813 static struct exim_openssl_option exim_openssl_options[] = {
1814 /* KEEP SORTED ALPHABETICALLY! */
1815 #ifdef SSL_OP_ALL
1816   { US"all", SSL_OP_ALL },
1817 #endif
1818 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
1819   { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
1820 #endif
1821 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
1822   { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
1823 #endif
1824 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
1825   { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
1826 #endif
1827 #ifdef SSL_OP_EPHEMERAL_RSA
1828   { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
1829 #endif
1830 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
1831   { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
1832 #endif
1833 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
1834   { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
1835 #endif
1836 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
1837   { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
1838 #endif
1839 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
1840   { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
1841 #endif
1842 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
1843   { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
1844 #endif
1845 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
1846   { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
1847 #endif
1848 #ifdef SSL_OP_NO_COMPRESSION
1849   { US"no_compression", SSL_OP_NO_COMPRESSION },
1850 #endif
1851 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
1852   { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
1853 #endif
1854 #ifdef SSL_OP_NO_SSLv2
1855   { US"no_sslv2", SSL_OP_NO_SSLv2 },
1856 #endif
1857 #ifdef SSL_OP_NO_SSLv3
1858   { US"no_sslv3", SSL_OP_NO_SSLv3 },
1859 #endif
1860 #ifdef SSL_OP_NO_TICKET
1861   { US"no_ticket", SSL_OP_NO_TICKET },
1862 #endif
1863 #ifdef SSL_OP_NO_TLSv1
1864   { US"no_tlsv1", SSL_OP_NO_TLSv1 },
1865 #endif
1866 #ifdef SSL_OP_NO_TLSv1_1
1867 #if SSL_OP_NO_TLSv1_1 == 0x00000400L
1868   /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
1869 #warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
1870 #else
1871   { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
1872 #endif
1873 #endif
1874 #ifdef SSL_OP_NO_TLSv1_2
1875   { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
1876 #endif
1877 #ifdef SSL_OP_SINGLE_DH_USE
1878   { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
1879 #endif
1880 #ifdef SSL_OP_SINGLE_ECDH_USE
1881   { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
1882 #endif
1883 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
1884   { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
1885 #endif
1886 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
1887   { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
1888 #endif
1889 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
1890   { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
1891 #endif
1892 #ifdef SSL_OP_TLS_D5_BUG
1893   { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
1894 #endif
1895 #ifdef SSL_OP_TLS_ROLLBACK_BUG
1896   { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
1897 #endif
1898 };
1899 static int exim_openssl_options_size =
1900   sizeof(exim_openssl_options)/sizeof(struct exim_openssl_option);
1901
1902
1903 static BOOL
1904 tls_openssl_one_option_parse(uschar *name, long *value)
1905 {
1906 int first = 0;
1907 int last = exim_openssl_options_size;
1908 while (last > first)
1909   {
1910   int middle = (first + last)/2;
1911   int c = Ustrcmp(name, exim_openssl_options[middle].name);
1912   if (c == 0)
1913     {
1914     *value = exim_openssl_options[middle].value;
1915     return TRUE;
1916     }
1917   else if (c > 0)
1918     first = middle + 1;
1919   else
1920     last = middle;
1921   }
1922 return FALSE;
1923 }
1924
1925
1926
1927
1928 /*************************************************
1929 *        OpenSSL option parsing logic            *
1930 *************************************************/
1931
1932 /* OpenSSL has a number of compatibility options which an administrator might
1933 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
1934 we look like log_selector.
1935
1936 Arguments:
1937   option_spec  the administrator-supplied string of options
1938   results      ptr to long storage for the options bitmap
1939 Returns        success or failure
1940 */
1941
1942 BOOL
1943 tls_openssl_options_parse(uschar *option_spec, long *results)
1944 {
1945 long result, item;
1946 uschar *s, *end;
1947 uschar keep_c;
1948 BOOL adding, item_parsed;
1949
1950 result = 0L;
1951 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
1952  * from default because it increases BEAST susceptibility. */
1953 #ifdef SSL_OP_NO_SSLv2
1954 result |= SSL_OP_NO_SSLv2;
1955 #endif
1956
1957 if (option_spec == NULL)
1958   {
1959   *results = result;
1960   return TRUE;
1961   }
1962
1963 for (s=option_spec; *s != '\0'; /**/)
1964   {
1965   while (isspace(*s)) ++s;
1966   if (*s == '\0')
1967     break;
1968   if (*s != '+' && *s != '-')
1969     {
1970     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
1971         "+ or - expected but found \"%s\"\n", s);
1972     return FALSE;
1973     }
1974   adding = *s++ == '+';
1975   for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
1976   keep_c = *end;
1977   *end = '\0';
1978   item_parsed = tls_openssl_one_option_parse(s, &item);
1979   if (!item_parsed)
1980     {
1981     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
1982     return FALSE;
1983     }
1984   DEBUG(D_tls) debug_printf("openssl option, %s from %lx: %lx (%s)\n",
1985       adding ? "adding" : "removing", result, item, s);
1986   if (adding)
1987     result |= item;
1988   else
1989     result &= ~item;
1990   *end = keep_c;
1991   s = end;
1992   }
1993
1994 *results = result;
1995 return TRUE;
1996 }
1997
1998 /* End of tls-openssl.c */