src/src/tls-openssl.c

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