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