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