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         /*XXX somewhere down here we leak memory per-STARTTLS, on a multi-message conn, server-side */
1823         file = expcerts; dir = NULL;
1824 #ifndef DISABLE_OCSP
1825         /* In the server if we will be offering an OCSP proof, load chain from
1826         file for verifying the OCSP proof at load time. */
1827
1828         if (  !host
1829            && statbuf.st_size > 0
1830            && server_static_cbinfo->u_ocsp.server.file
1831            && !chain_from_pem_file(file, server_static_cbinfo->verify_stack)
1832            )
1833           {
1834           log_write(0, LOG_MAIN|LOG_PANIC,
1835             "failed to load cert chain from %s", file);
1836           return DEFER;
1837           }
1838 #endif
1839         }
1840
1841       /* If a certificate file is empty, the next function fails with an
1842       unhelpful error message. If we skip it, we get the correct behaviour (no
1843       certificates are recognized, but the error message is still misleading (it
1844       says no certificate was supplied).  But this is better. */
1845
1846       if (  (!file || statbuf.st_size > 0)
1847          && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
1848         return tls_error(US"SSL_CTX_load_verify_locations", host, NULL, errstr);
1849
1850       /* Load the list of CAs for which we will accept certs, for sending
1851       to the client.  This is only for the one-file tls_verify_certificates
1852       variant.
1853       If a list isn't loaded into the server, but
1854       some verify locations are set, the server end appears to make
1855       a wildcard request for client certs.
1856       Meanwhile, the client library as default behaviour *ignores* the list
1857       we send over the wire - see man SSL_CTX_set_client_cert_cb.
1858       Because of this, and that the dir variant is likely only used for
1859       the public-CA bundle (not for a private CA), not worth fixing.
1860       */
1861       if (file)
1862         {
1863         tls_ext_ctx_cb * cbinfo = host
1864           ? client_static_cbinfo : server_static_cbinfo;
1865         STACK_OF(X509_NAME) * names;
1866
1867         if ((names = cbinfo->acceptable_certnames))
1868           {
1869           sk_X509_NAME_pop_free(names, X509_NAME_free);
1870           cbinfo->acceptable_certnames = NULL;
1871           }
1872         names = SSL_load_client_CA_file(CS file);
1873
1874         SSL_CTX_set_client_CA_list(sctx, names);
1875         DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n",
1876                                     sk_X509_NAME_num(names));
1877         cbinfo->acceptable_certnames = names;
1878         }
1879       }
1880     }
1881
1882   /* Handle a certificate revocation list. */
1883
1884 #if OPENSSL_VERSION_NUMBER > 0x00907000L
1885
1886   /* This bit of code is now the version supplied by Lars Mainka. (I have
1887   merely reformatted it into the Exim code style.)
1888
1889   "From here I changed the code to add support for multiple crl's
1890   in pem format in one file or to support hashed directory entries in
1891   pem format instead of a file. This method now uses the library function
1892   X509_STORE_load_locations to add the CRL location to the SSL context.
1893   OpenSSL will then handle the verify against CA certs and CRLs by
1894   itself in the verify callback." */
1895
1896   if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
1897   if (expcrl && *expcrl)
1898     {
1899     struct stat statbufcrl;
1900     if (Ustat(expcrl, &statbufcrl) < 0)
1901       {
1902       log_write(0, LOG_MAIN|LOG_PANIC,
1903         "failed to stat %s for certificates revocation lists", expcrl);
1904       return DEFER;
1905       }
1906     else
1907       {
1908       /* is it a file or directory? */
1909       uschar *file, *dir;
1910       X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
1911       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
1912         {
1913         file = NULL;
1914         dir = expcrl;
1915         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
1916         }
1917       else
1918         {
1919         file = expcrl;
1920         dir = NULL;
1921         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
1922         }
1923       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
1924         return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
1925
1926       /* setting the flags to check against the complete crl chain */
1927
1928       X509_STORE_set_flags(cvstore,
1929         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
1930       }
1931     }
1932
1933 #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
1934
1935   /* If verification is optional, don't fail if no certificate */
1936
1937   SSL_CTX_set_verify(sctx,
1938     SSL_VERIFY_PEER | (optional? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
1939     cert_vfy_cb);
1940   }
1941
1942 return OK;
1943 }
1944
1945
1946
1947 /*************************************************
1948 *       Start a TLS session in a server          *
1949 *************************************************/
1950
1951 /* This is called when Exim is running as a server, after having received
1952 the STARTTLS command. It must respond to that command, and then negotiate
1953 a TLS session.
1954
1955 Arguments:
1956   require_ciphers   allowed ciphers
1957   errstr            pointer to error message
1958
1959 Returns:            OK on success
1960                     DEFER for errors before the start of the negotiation
1961                     FAIL for errors during the negotiation; the server can't
1962                       continue running.
1963 */
1964
1965 int
1966 tls_server_start(const uschar * require_ciphers, uschar ** errstr)
1967 {
1968 int rc;
1969 uschar * expciphers;
1970 tls_ext_ctx_cb * cbinfo;
1971 static uschar peerdn[256];
1972 static uschar cipherbuf[256];
1973
1974 /* Check for previous activation */
1975
1976 if (tls_in.active >= 0)
1977   {
1978   tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
1979   smtp_printf("554 Already in TLS\r\n", FALSE);
1980   return FAIL;
1981   }
1982
1983 /* Initialize the SSL library. If it fails, it will already have logged
1984 the error. */
1985
1986 rc = tls_init(&server_ctx, NULL, tls_dhparam, tls_certificate, tls_privatekey,
1987 #ifndef DISABLE_OCSP
1988     tls_ocsp_file,      /*XXX stack*/
1989 #endif
1990     NULL, &server_static_cbinfo, errstr);
1991 if (rc != OK) return rc;
1992 cbinfo = server_static_cbinfo;
1993
1994 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
1995   return FAIL;
1996
1997 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
1998 were historically separated by underscores. So that I can use either form in my
1999 tests, and also for general convenience, we turn underscores into hyphens here.
2000 */
2001
2002 if (expciphers)
2003   {
2004   uschar * s = expciphers;
2005   while (*s != 0) { if (*s == '_') *s = '-'; s++; }
2006   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2007   if (!SSL_CTX_set_cipher_list(server_ctx, CS expciphers))
2008     return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL, errstr);
2009   cbinfo->server_cipher_list = expciphers;
2010   }
2011
2012 /* If this is a host for which certificate verification is mandatory or
2013 optional, set up appropriately. */
2014
2015 tls_in.certificate_verified = FALSE;
2016 #ifdef SUPPORT_DANE
2017 tls_in.dane_verified = FALSE;
2018 #endif
2019 server_verify_callback_called = FALSE;
2020
2021 if (verify_check_host(&tls_verify_hosts) == OK)
2022   {
2023   rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2024                         FALSE, verify_callback_server, errstr);
2025   if (rc != OK) return rc;
2026   server_verify_optional = FALSE;
2027   }
2028 else if (verify_check_host(&tls_try_verify_hosts) == OK)
2029   {
2030   rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2031                         TRUE, verify_callback_server, errstr);
2032   if (rc != OK) return rc;
2033   server_verify_optional = TRUE;
2034   }
2035
2036 /* Prepare for new connection */
2037
2038 if (!(server_ssl = SSL_new(server_ctx)))
2039   return tls_error(US"SSL_new", NULL, NULL, errstr);
2040
2041 /* Warning: we used to SSL_clear(ssl) here, it was removed.
2042  *
2043  * With the SSL_clear(), we get strange interoperability bugs with
2044  * OpenSSL 1.0.1b and TLS1.1/1.2.  It looks as though this may be a bug in
2045  * OpenSSL itself, as a clear should not lead to inability to follow protocols.
2046  *
2047  * The SSL_clear() call is to let an existing SSL* be reused, typically after
2048  * session shutdown.  In this case, we have a brand new object and there's no
2049  * obvious reason to immediately clear it.  I'm guessing that this was
2050  * originally added because of incomplete initialisation which the clear fixed,
2051  * in some historic release.
2052  */
2053
2054 /* Set context and tell client to go ahead, except in the case of TLS startup
2055 on connection, where outputting anything now upsets the clients and tends to
2056 make them disconnect. We need to have an explicit fflush() here, to force out
2057 the response. Other smtp_printf() calls do not need it, because in non-TLS
2058 mode, the fflush() happens when smtp_getc() is called. */
2059
2060 SSL_set_session_id_context(server_ssl, sid_ctx, Ustrlen(sid_ctx));
2061 if (!tls_in.on_connect)
2062   {
2063   smtp_printf("220 TLS go ahead\r\n", FALSE);
2064   fflush(smtp_out);
2065   }
2066
2067 /* Now negotiate the TLS session. We put our own timer on it, since it seems
2068 that the OpenSSL library doesn't. */
2069
2070 SSL_set_wfd(server_ssl, fileno(smtp_out));
2071 SSL_set_rfd(server_ssl, fileno(smtp_in));
2072 SSL_set_accept_state(server_ssl);
2073
2074 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
2075
2076 sigalrm_seen = FALSE;
2077 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
2078 rc = SSL_accept(server_ssl);
2079 alarm(0);
2080
2081 if (rc <= 0)
2082   {
2083   (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
2084   return FAIL;
2085   }
2086
2087 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
2088
2089 /* TLS has been set up. Adjust the input functions to read via TLS,
2090 and initialize things. */
2091
2092 peer_cert(server_ssl, &tls_in, peerdn, sizeof(peerdn));
2093
2094 construct_cipher_name(server_ssl, cipherbuf, sizeof(cipherbuf), &tls_in.bits);
2095 tls_in.cipher = cipherbuf;
2096
2097 DEBUG(D_tls)
2098   {
2099   uschar buf[2048];
2100   if (SSL_get_shared_ciphers(server_ssl, CS buf, sizeof(buf)) != NULL)
2101     debug_printf("Shared ciphers: %s\n", buf);
2102   }
2103
2104 /* Record the certificate we presented */
2105   {
2106   X509 * crt = SSL_get_certificate(server_ssl);
2107   tls_in.ourcert = crt ? X509_dup(crt) : NULL;
2108   }
2109
2110 /* Only used by the server-side tls (tls_in), including tls_getc.
2111    Client-side (tls_out) reads (seem to?) go via
2112    smtp_read_response()/ip_recv().
2113    Hence no need to duplicate for _in and _out.
2114  */
2115 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
2116 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
2117 ssl_xfer_eof = ssl_xfer_error = 0;
2118
2119 receive_getc = tls_getc;
2120 receive_getbuf = tls_getbuf;
2121 receive_get_cache = tls_get_cache;
2122 receive_ungetc = tls_ungetc;
2123 receive_feof = tls_feof;
2124 receive_ferror = tls_ferror;
2125 receive_smtp_buffered = tls_smtp_buffered;
2126
2127 tls_in.active = fileno(smtp_out);
2128 return OK;
2129 }
2130
2131
2132
2133
2134 static int
2135 tls_client_basic_ctx_init(SSL_CTX * ctx,
2136     host_item * host, smtp_transport_options_block * ob, tls_ext_ctx_cb * cbinfo,
2137     uschar ** errstr)
2138 {
2139 int rc;
2140 /* stick to the old behaviour for compatibility if tls_verify_certificates is
2141    set but both tls_verify_hosts and tls_try_verify_hosts is not set. Check only
2142    the specified host patterns if one of them is defined */
2143
2144 if (  (  !ob->tls_verify_hosts
2145       && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
2146       )
2147    || (verify_check_given_host(&ob->tls_verify_hosts, host) == OK)
2148    )
2149   client_verify_optional = FALSE;
2150 else if (verify_check_given_host(&ob->tls_try_verify_hosts, host) == OK)
2151   client_verify_optional = TRUE;
2152 else
2153   return OK;
2154
2155 if ((rc = setup_certs(ctx, ob->tls_verify_certificates,
2156       ob->tls_crl, host, client_verify_optional, verify_callback_client,
2157       errstr)) != OK)
2158   return rc;
2159
2160 if (verify_check_given_host(&ob->tls_verify_cert_hostnames, host) == OK)
2161   {
2162   cbinfo->verify_cert_hostnames =
2163 #ifdef SUPPORT_I18N
2164     string_domain_utf8_to_alabel(host->name, NULL);
2165 #else
2166     host->name;
2167 #endif
2168   DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
2169                     cbinfo->verify_cert_hostnames);
2170   }
2171 return OK;
2172 }
2173
2174
2175 #ifdef SUPPORT_DANE
2176 static int
2177 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
2178 {
2179 dns_record * rr;
2180 dns_scan dnss;
2181 const char * hostnames[2] = { CS host->name, NULL };
2182 int found = 0;
2183
2184 if (DANESSL_init(ssl, NULL, hostnames) != 1)
2185   return tls_error(US"hostnames load", host, NULL, errstr);
2186
2187 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
2188      rr;
2189      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2190     ) if (rr->type == T_TLSA)
2191   {
2192   const uschar * p = rr->data;
2193   uint8_t usage, selector, mtype;
2194   const char * mdname;
2195
2196   usage = *p++;
2197
2198   /* Only DANE-TA(2) and DANE-EE(3) are supported */
2199   if (usage != 2 && usage != 3) continue;
2200
2201   selector = *p++;
2202   mtype = *p++;
2203
2204   switch (mtype)
2205     {
2206     default: continue;  /* Only match-types 0, 1, 2 are supported */
2207     case 0:  mdname = NULL; break;
2208     case 1:  mdname = "sha256"; break;
2209     case 2:  mdname = "sha512"; break;
2210     }
2211
2212   found++;
2213   switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
2214     {
2215     default:
2216       return tls_error(US"tlsa load", host, NULL, errstr);
2217     case 0:     /* action not taken */
2218     case 1:     break;
2219     }
2220
2221   tls_out.tlsa_usage |= 1<<usage;
2222   }
2223
2224 if (found)
2225   return OK;
2226
2227 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
2228 return DEFER;
2229 }
2230 #endif  /*SUPPORT_DANE*/
2231
2232
2233
2234 /*************************************************
2235 *    Start a TLS session in a client             *
2236 *************************************************/
2237
2238 /* Called from the smtp transport after STARTTLS has been accepted.
2239
2240 Argument:
2241   fd               the fd of the connection
2242   host             connected host (for messages)
2243   addr             the first address
2244   tb               transport (always smtp)
2245   tlsa_dnsa        tlsa lookup, if DANE, else null
2246   errstr           error string pointer
2247
2248 Returns:           OK on success
2249                    FAIL otherwise - note that tls_error() will not give DEFER
2250                      because this is not a server
2251 */
2252
2253 int
2254 tls_client_start(int fd, host_item *host, address_item *addr,
2255   transport_instance * tb,
2256 #ifdef SUPPORT_DANE
2257   dns_answer * tlsa_dnsa,
2258 #endif
2259   uschar ** errstr)
2260 {
2261 smtp_transport_options_block * ob =
2262   (smtp_transport_options_block *)tb->options_block;
2263 static uschar peerdn[256];
2264 uschar * expciphers;
2265 int rc;
2266 static uschar cipherbuf[256];
2267
2268 #ifndef DISABLE_OCSP
2269 BOOL request_ocsp = FALSE;
2270 BOOL require_ocsp = FALSE;
2271 #endif
2272
2273 #ifdef SUPPORT_DANE
2274 tls_out.tlsa_usage = 0;
2275 #endif
2276
2277 #ifndef DISABLE_OCSP
2278   {
2279 # ifdef SUPPORT_DANE
2280   if (  tlsa_dnsa
2281      && ob->hosts_request_ocsp[0] == '*'
2282      && ob->hosts_request_ocsp[1] == '\0'
2283      )
2284     {
2285     /* Unchanged from default.  Use a safer one under DANE */
2286     request_ocsp = TRUE;
2287     ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
2288                                       "   {= {4}{$tls_out_tlsa_usage}} } "
2289                                  " {*}{}}";
2290     }
2291 # endif
2292
2293   if ((require_ocsp =
2294         verify_check_given_host(&ob->hosts_require_ocsp, host) == OK))
2295     request_ocsp = TRUE;
2296   else
2297 # ifdef SUPPORT_DANE
2298     if (!request_ocsp)
2299 # endif
2300       request_ocsp =
2301         verify_check_given_host(&ob->hosts_request_ocsp, host) == OK;
2302   }
2303 #endif
2304
2305 rc = tls_init(&client_ctx, host, NULL,
2306     ob->tls_certificate, ob->tls_privatekey,
2307 #ifndef DISABLE_OCSP
2308     (void *)(long)request_ocsp,
2309 #endif
2310     addr, &client_static_cbinfo, errstr);
2311 if (rc != OK) return rc;
2312
2313 tls_out.certificate_verified = FALSE;
2314 client_verify_callback_called = FALSE;
2315
2316 if (!expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
2317     &expciphers, errstr))
2318   return FAIL;
2319
2320 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2321 are separated by underscores. So that I can use either form in my tests, and
2322 also for general convenience, we turn underscores into hyphens here. */
2323
2324 if (expciphers)
2325   {
2326   uschar *s = expciphers;
2327   while (*s) { if (*s == '_') *s = '-'; s++; }
2328   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2329   if (!SSL_CTX_set_cipher_list(client_ctx, CS expciphers))
2330     return tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
2331   }
2332
2333 #ifdef SUPPORT_DANE
2334 if (tlsa_dnsa)
2335   {
2336   SSL_CTX_set_verify(client_ctx,
2337     SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2338     verify_callback_client_dane);
2339
2340   if (!DANESSL_library_init())
2341     return tls_error(US"library init", host, NULL, errstr);
2342   if (DANESSL_CTX_init(client_ctx) <= 0)
2343     return tls_error(US"context init", host, NULL, errstr);
2344   }
2345 else
2346
2347 #endif
2348
2349   if ((rc = tls_client_basic_ctx_init(client_ctx, host, ob,
2350       client_static_cbinfo, errstr)) != OK)
2351     return rc;
2352
2353 if ((client_ssl = SSL_new(client_ctx)) == NULL)
2354   return tls_error(US"SSL_new", host, NULL, errstr);
2355 SSL_set_session_id_context(client_ssl, sid_ctx, Ustrlen(sid_ctx));
2356 SSL_set_fd(client_ssl, fd);
2357 SSL_set_connect_state(client_ssl);
2358
2359 if (ob->tls_sni)
2360   {
2361   if (!expand_check(ob->tls_sni, US"tls_sni", &tls_out.sni, errstr))
2362     return FAIL;
2363   if (!tls_out.sni)
2364     {
2365     DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
2366     }
2367   else if (!Ustrlen(tls_out.sni))
2368     tls_out.sni = NULL;
2369   else
2370     {
2371 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2372     DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tls_out.sni);
2373     SSL_set_tlsext_host_name(client_ssl, tls_out.sni);
2374 #else
2375     log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
2376           tls_out.sni);
2377 #endif
2378     }
2379   }
2380
2381 #ifdef SUPPORT_DANE
2382 if (tlsa_dnsa)
2383   if ((rc = dane_tlsa_load(client_ssl, host, tlsa_dnsa, errstr)) != OK)
2384     return rc;
2385 #endif
2386
2387 #ifndef DISABLE_OCSP
2388 /* Request certificate status at connection-time.  If the server
2389 does OCSP stapling we will get the callback (set in tls_init()) */
2390 # ifdef SUPPORT_DANE
2391 if (request_ocsp)
2392   {
2393   const uschar * s;
2394   if (  ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
2395      || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
2396      )
2397     {   /* Re-eval now $tls_out_tlsa_usage is populated.  If
2398         this means we avoid the OCSP request, we wasted the setup
2399         cost in tls_init(). */
2400     require_ocsp = verify_check_given_host(&ob->hosts_require_ocsp, host) == OK;
2401     request_ocsp = require_ocsp
2402       || verify_check_given_host(&ob->hosts_request_ocsp, host) == OK;
2403     }
2404   }
2405 # endif
2406
2407 if (request_ocsp)
2408   {
2409   SSL_set_tlsext_status_type(client_ssl, TLSEXT_STATUSTYPE_ocsp);
2410   client_static_cbinfo->u_ocsp.client.verify_required = require_ocsp;
2411   tls_out.ocsp = OCSP_NOT_RESP;
2412   }
2413 #endif
2414
2415 #ifndef DISABLE_EVENT
2416 client_static_cbinfo->event_action = tb->event_action;
2417 #endif
2418
2419 /* There doesn't seem to be a built-in timeout on connection. */
2420
2421 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
2422 sigalrm_seen = FALSE;
2423 alarm(ob->command_timeout);
2424 rc = SSL_connect(client_ssl);
2425 alarm(0);
2426
2427 #ifdef SUPPORT_DANE
2428 if (tlsa_dnsa)
2429   DANESSL_cleanup(client_ssl);
2430 #endif
2431
2432 if (rc <= 0)
2433   return tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL,
2434     errstr);
2435
2436 DEBUG(D_tls) debug_printf("SSL_connect succeeded\n");
2437
2438 peer_cert(client_ssl, &tls_out, peerdn, sizeof(peerdn));
2439
2440 construct_cipher_name(client_ssl, cipherbuf, sizeof(cipherbuf), &tls_out.bits);
2441 tls_out.cipher = cipherbuf;
2442
2443 /* Record the certificate we presented */
2444   {
2445   X509 * crt = SSL_get_certificate(client_ssl);
2446   tls_out.ourcert = crt ? X509_dup(crt) : NULL;
2447   }
2448
2449 tls_out.active = fd;
2450 return OK;
2451 }
2452
2453
2454
2455
2456
2457 static BOOL
2458 tls_refill(unsigned lim)
2459 {
2460 int error;
2461 int inbytes;
2462
2463 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", server_ssl,
2464   ssl_xfer_buffer, ssl_xfer_buffer_size);
2465
2466 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
2467 inbytes = SSL_read(server_ssl, CS ssl_xfer_buffer,
2468                   MIN(ssl_xfer_buffer_size, lim));
2469 error = SSL_get_error(server_ssl, inbytes);
2470 alarm(0);
2471
2472 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
2473 closed down, not that the socket itself has been closed down. Revert to
2474 non-SSL handling. */
2475
2476 if (error == SSL_ERROR_ZERO_RETURN)
2477   {
2478   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2479
2480   receive_getc = smtp_getc;
2481   receive_getbuf = smtp_getbuf;
2482   receive_get_cache = smtp_get_cache;
2483   receive_ungetc = smtp_ungetc;
2484   receive_feof = smtp_feof;
2485   receive_ferror = smtp_ferror;
2486   receive_smtp_buffered = smtp_buffered;
2487
2488   if (SSL_get_shutdown(server_ssl) == SSL_RECEIVED_SHUTDOWN)
2489         SSL_shutdown(server_ssl);
2490
2491   sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
2492   sk_X509_NAME_pop_free(server_static_cbinfo->acceptable_certnames, X509_NAME_free);
2493   SSL_free(server_ssl);
2494   SSL_CTX_free(server_ctx);
2495   server_static_cbinfo->verify_stack = NULL;
2496   server_static_cbinfo->acceptable_certnames = NULL;
2497   server_ctx = NULL;
2498   server_ssl = NULL;
2499   tls_in.active = -1;
2500   tls_in.bits = 0;
2501   tls_in.cipher = NULL;
2502   tls_in.peerdn = NULL;
2503   tls_in.sni = NULL;
2504
2505   return FALSE;
2506   }
2507
2508 /* Handle genuine errors */
2509
2510 else if (error == SSL_ERROR_SSL)
2511   {
2512   ERR_error_string(ERR_get_error(), ssl_errstring);
2513   log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
2514   ssl_xfer_error = 1;
2515   return FALSE;
2516   }
2517
2518 else if (error != SSL_ERROR_NONE)
2519   {
2520   DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
2521   ssl_xfer_error = 1;
2522   return FALSE;
2523   }
2524
2525 #ifndef DISABLE_DKIM
2526 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
2527 #endif
2528 ssl_xfer_buffer_hwm = inbytes;
2529 ssl_xfer_buffer_lwm = 0;
2530 return TRUE;
2531 }
2532
2533
2534 /*************************************************
2535 *            TLS version of getc                 *
2536 *************************************************/
2537
2538 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
2539 it refills the buffer via the SSL reading function.
2540
2541 Arguments:  lim         Maximum amount to read/buffer
2542 Returns:    the next character or EOF
2543
2544 Only used by the server-side TLS.
2545 */
2546
2547 int
2548 tls_getc(unsigned lim)
2549 {
2550 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
2551   if (!tls_refill(lim))
2552     return ssl_xfer_error ? EOF : smtp_getc(lim);
2553
2554 /* Something in the buffer; return next uschar */
2555
2556 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
2557 }
2558
2559 uschar *
2560 tls_getbuf(unsigned * len)
2561 {
2562 unsigned size;
2563 uschar * buf;
2564
2565 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
2566   if (!tls_refill(*len))
2567     {
2568     if (!ssl_xfer_error) return smtp_getbuf(len);
2569     *len = 0;
2570     return NULL;
2571     }
2572
2573 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
2574   size = *len;
2575 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
2576 ssl_xfer_buffer_lwm += size;
2577 *len = size;
2578 return buf;
2579 }
2580
2581
2582 void
2583 tls_get_cache()
2584 {
2585 #ifndef DISABLE_DKIM
2586 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
2587 if (n > 0)
2588   dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
2589 #endif
2590 }
2591
2592
2593 BOOL
2594 tls_could_read(void)
2595 {
2596 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm || SSL_pending(server_ssl) > 0;
2597 }
2598
2599
2600 /*************************************************
2601 *          Read bytes from TLS channel           *
2602 *************************************************/
2603
2604 /*
2605 Arguments:
2606   buff      buffer of data
2607   len       size of buffer
2608
2609 Returns:    the number of bytes read
2610             -1 after a failed read
2611
2612 Only used by the client-side TLS.
2613 */
2614
2615 int
2616 tls_read(BOOL is_server, uschar *buff, size_t len)
2617 {
2618 SSL *ssl = is_server ? server_ssl : client_ssl;
2619 int inbytes;
2620 int error;
2621
2622 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
2623   buff, (unsigned int)len);
2624
2625 inbytes = SSL_read(ssl, CS buff, len);
2626 error = SSL_get_error(ssl, inbytes);
2627
2628 if (error == SSL_ERROR_ZERO_RETURN)
2629   {
2630   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2631   return -1;
2632   }
2633 else if (error != SSL_ERROR_NONE)
2634   return -1;
2635
2636 return inbytes;
2637 }
2638
2639
2640
2641
2642
2643 /*************************************************
2644 *         Write bytes down TLS channel           *
2645 *************************************************/
2646
2647 /*
2648 Arguments:
2649   is_server channel specifier
2650   buff      buffer of data
2651   len       number of bytes
2652   more      further data expected soon
2653
2654 Returns:    the number of bytes after a successful write,
2655             -1 after a failed write
2656
2657 Used by both server-side and client-side TLS.
2658 */
2659
2660 int
2661 tls_write(BOOL is_server, const uschar *buff, size_t len, BOOL more)
2662 {
2663 int outbytes, error, left;
2664 SSL *ssl = is_server ? server_ssl : client_ssl;
2665 static gstring * corked = NULL;
2666
2667 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
2668   buff, (unsigned long)len, more ? ", more" : "");
2669
2670 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
2671 "more" is notified.  This hack is only ok if small amounts are involved AND only
2672 one stream does it, in one context (i.e. no store reset).  Currently it is used
2673 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only. */
2674
2675 if (is_server && (more || corked))
2676   {
2677   corked = string_catn(corked, buff, len);
2678   if (more)
2679     return len;
2680   buff = CUS corked->s;
2681   len = corked->ptr;
2682   corked = NULL;
2683   }
2684
2685 for (left = len; left > 0;)
2686   {
2687   DEBUG(D_tls) debug_printf("SSL_write(SSL, %p, %d)\n", buff, left);
2688   outbytes = SSL_write(ssl, CS buff, left);
2689   error = SSL_get_error(ssl, outbytes);
2690   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
2691   switch (error)
2692     {
2693     case SSL_ERROR_SSL:
2694       ERR_error_string(ERR_get_error(), ssl_errstring);
2695       log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
2696       return -1;
2697
2698     case SSL_ERROR_NONE:
2699       left -= outbytes;
2700       buff += outbytes;
2701       break;
2702
2703     case SSL_ERROR_ZERO_RETURN:
2704       log_write(0, LOG_MAIN, "SSL channel closed on write");
2705       return -1;
2706
2707     case SSL_ERROR_SYSCALL:
2708       log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
2709         sender_fullhost ? sender_fullhost : US"<unknown>",
2710         strerror(errno));
2711       return -1;
2712
2713     default:
2714       log_write(0, LOG_MAIN, "SSL_write error %d", error);
2715       return -1;
2716     }
2717   }
2718 return len;
2719 }
2720
2721
2722
2723 /*************************************************
2724 *         Close down a TLS session               *
2725 *************************************************/
2726
2727 /* This is also called from within a delivery subprocess forked from the
2728 daemon, to shut down the TLS library, without actually doing a shutdown (which
2729 would tamper with the SSL session in the parent process).
2730
2731 Arguments:
2732   shutdown      1 if TLS close-alert is to be sent,
2733                 2 if also response to be waited for
2734
2735 Returns:     nothing
2736
2737 Used by both server-side and client-side TLS.
2738 */
2739
2740 void
2741 tls_close(BOOL is_server, int shutdown)
2742 {
2743 SSL_CTX **ctxp = is_server ? &server_ctx : &client_ctx;
2744 SSL **sslp = is_server ? &server_ssl : &client_ssl;
2745 int *fdp = is_server ? &tls_in.active : &tls_out.active;
2746
2747 if (*fdp < 0) return;  /* TLS was not active */
2748
2749 if (shutdown)
2750   {
2751   int rc;
2752   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
2753     shutdown > 1 ? " (with response-wait)" : "");
2754
2755   if (  (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
2756      && shutdown > 1)
2757     {
2758     alarm(2);
2759     rc = SSL_shutdown(*sslp);           /* wait for response */
2760     alarm(0);
2761     }
2762
2763   if (rc < 0) DEBUG(D_tls)
2764     {
2765     ERR_error_string(ERR_get_error(), ssl_errstring);
2766     debug_printf("SSL_shutdown: %s\n", ssl_errstring);
2767     }
2768   }
2769
2770 if (is_server)
2771   {
2772   sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
2773   sk_X509_NAME_pop_free(server_static_cbinfo->acceptable_certnames,
2774     X509_NAME_free);
2775   server_static_cbinfo->verify_stack = NULL;
2776   server_static_cbinfo->acceptable_certnames = NULL;
2777   }
2778
2779 SSL_CTX_free(*ctxp);
2780 SSL_free(*sslp);
2781 *ctxp = NULL;
2782 *sslp = NULL;
2783 *fdp = -1;
2784 }
2785
2786
2787
2788
2789 /*************************************************
2790 *  Let tls_require_ciphers be checked at startup *
2791 *************************************************/
2792
2793 /* The tls_require_ciphers option, if set, must be something which the
2794 library can parse.
2795
2796 Returns:     NULL on success, or error message
2797 */
2798
2799 uschar *
2800 tls_validate_require_cipher(void)
2801 {
2802 SSL_CTX *ctx;
2803 uschar *s, *expciphers, *err;
2804
2805 /* this duplicates from tls_init(), we need a better "init just global
2806 state, for no specific purpose" singleton function of our own */
2807
2808 SSL_load_error_strings();
2809 OpenSSL_add_ssl_algorithms();
2810 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
2811 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
2812 list of available digests. */
2813 EVP_add_digest(EVP_sha256());
2814 #endif
2815
2816 if (!(tls_require_ciphers && *tls_require_ciphers))
2817   return NULL;
2818
2819 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
2820                   &err))
2821   return US"failed to expand tls_require_ciphers";
2822
2823 if (!(expciphers && *expciphers))
2824   return NULL;
2825
2826 /* normalisation ripped from above */
2827 s = expciphers;
2828 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
2829
2830 err = NULL;
2831
2832 ctx = SSL_CTX_new(SSLv23_server_method());
2833 if (!ctx)
2834   {
2835   ERR_error_string(ERR_get_error(), ssl_errstring);
2836   return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
2837   }
2838
2839 DEBUG(D_tls)
2840   debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
2841
2842 if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
2843   {
2844   ERR_error_string(ERR_get_error(), ssl_errstring);
2845   err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
2846                       expciphers, ssl_errstring);
2847   }
2848
2849 SSL_CTX_free(ctx);
2850
2851 return err;
2852 }
2853
2854
2855
2856
2857 /*************************************************
2858 *         Report the library versions.           *
2859 *************************************************/
2860
2861 /* There have historically been some issues with binary compatibility in
2862 OpenSSL libraries; if Exim (like many other applications) is built against
2863 one version of OpenSSL but the run-time linker picks up another version,
2864 it can result in serious failures, including crashing with a SIGSEGV.  So
2865 report the version found by the compiler and the run-time version.
2866
2867 Note: some OS vendors backport security fixes without changing the version
2868 number/string, and the version date remains unchanged.  The _build_ date
2869 will change, so we can more usefully assist with version diagnosis by also
2870 reporting the build date.
2871
2872 Arguments:   a FILE* to print the results to
2873 Returns:     nothing
2874 */
2875
2876 void
2877 tls_version_report(FILE *f)
2878 {
2879 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
2880            "                          Runtime: %s\n"
2881            "                                 : %s\n",
2882            OPENSSL_VERSION_TEXT,
2883            SSLeay_version(SSLEAY_VERSION),
2884            SSLeay_version(SSLEAY_BUILT_ON));
2885 /* third line is 38 characters for the %s and the line is 73 chars long;
2886 the OpenSSL output includes a "built on: " prefix already. */
2887 }
2888
2889
2890
2891
2892 /*************************************************
2893 *            Random number generation            *
2894 *************************************************/
2895
2896 /* Pseudo-random number generation.  The result is not expected to be
2897 cryptographically strong but not so weak that someone will shoot themselves
2898 in the foot using it as a nonce in input in some email header scheme or
2899 whatever weirdness they'll twist this into.  The result should handle fork()
2900 and avoid repeating sequences.  OpenSSL handles that for us.
2901
2902 Arguments:
2903   max       range maximum
2904 Returns     a random number in range [0, max-1]
2905 */
2906
2907 int
2908 vaguely_random_number(int max)
2909 {
2910 unsigned int r;
2911 int i, needed_len;
2912 static pid_t pidlast = 0;
2913 pid_t pidnow;
2914 uschar *p;
2915 uschar smallbuf[sizeof(r)];
2916
2917 if (max <= 1)
2918   return 0;
2919
2920 pidnow = getpid();
2921 if (pidnow != pidlast)
2922   {
2923   /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
2924   is unique for each thread", this doesn't apparently apply across processes,
2925   so our own warning from vaguely_random_number_fallback() applies here too.
2926   Fix per PostgreSQL. */
2927   if (pidlast != 0)
2928     RAND_cleanup();
2929   pidlast = pidnow;
2930   }
2931
2932 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
2933 if (!RAND_status())
2934   {
2935   randstuff r;
2936   gettimeofday(&r.tv, NULL);
2937   r.p = getpid();
2938
2939   RAND_seed(US (&r), sizeof(r));
2940   }
2941 /* We're after pseudo-random, not random; if we still don't have enough data
2942 in the internal PRNG then our options are limited.  We could sleep and hope
2943 for entropy to come along (prayer technique) but if the system is so depleted
2944 in the first place then something is likely to just keep taking it.  Instead,
2945 we'll just take whatever little bit of pseudo-random we can still manage to
2946 get. */
2947
2948 needed_len = sizeof(r);
2949 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
2950 asked for a number less than 10. */
2951 for (r = max, i = 0; r; ++i)
2952   r >>= 1;
2953 i = (i + 7) / 8;
2954 if (i < needed_len)
2955   needed_len = i;
2956
2957 #ifdef EXIM_HAVE_RAND_PSEUDO
2958 /* We do not care if crypto-strong */
2959 i = RAND_pseudo_bytes(smallbuf, needed_len);
2960 #else
2961 i = RAND_bytes(smallbuf, needed_len);
2962 #endif
2963
2964 if (i < 0)
2965   {
2966   DEBUG(D_all)
2967     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
2968   return vaguely_random_number_fallback(max);
2969   }
2970
2971 r = 0;
2972 for (p = smallbuf; needed_len; --needed_len, ++p)
2973   {
2974   r *= 256;
2975   r += *p;
2976   }
2977
2978 /* We don't particularly care about weighted results; if someone wants
2979 smooth distribution and cares enough then they should submit a patch then. */
2980 return r % max;
2981 }
2982
2983
2984
2985
2986 /*************************************************
2987 *        OpenSSL option parse                    *
2988 *************************************************/
2989
2990 /* Parse one option for tls_openssl_options_parse below
2991
2992 Arguments:
2993   name    one option name
2994   value   place to store a value for it
2995 Returns   success or failure in parsing
2996 */
2997
2998 struct exim_openssl_option {
2999   uschar *name;
3000   long    value;
3001 };
3002 /* We could use a macro to expand, but we need the ifdef and not all the
3003 options document which version they were introduced in.  Policylet: include
3004 all options unless explicitly for DTLS, let the administrator choose which
3005 to apply.
3006
3007 This list is current as of:
3008   ==>  1.0.1b  <==
3009 Plus SSL_OP_SAFARI_ECDHE_ECDSA_BUG from 2013-June patch/discussion on openssl-dev
3010 */
3011 static struct exim_openssl_option exim_openssl_options[] = {
3012 /* KEEP SORTED ALPHABETICALLY! */
3013 #ifdef SSL_OP_ALL
3014   { US"all", SSL_OP_ALL },
3015 #endif
3016 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
3017   { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
3018 #endif
3019 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
3020   { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
3021 #endif
3022 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
3023   { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
3024 #endif
3025 #ifdef SSL_OP_EPHEMERAL_RSA
3026   { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
3027 #endif
3028 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
3029   { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
3030 #endif
3031 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
3032   { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
3033 #endif
3034 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
3035   { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
3036 #endif
3037 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
3038   { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
3039 #endif
3040 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
3041   { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
3042 #endif
3043 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
3044   { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
3045 #endif
3046 #ifdef SSL_OP_NO_COMPRESSION
3047   { US"no_compression", SSL_OP_NO_COMPRESSION },
3048 #endif
3049 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
3050   { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
3051 #endif
3052 #ifdef SSL_OP_NO_SSLv2
3053   { US"no_sslv2", SSL_OP_NO_SSLv2 },
3054 #endif
3055 #ifdef SSL_OP_NO_SSLv3
3056   { US"no_sslv3", SSL_OP_NO_SSLv3 },
3057 #endif
3058 #ifdef SSL_OP_NO_TICKET
3059   { US"no_ticket", SSL_OP_NO_TICKET },
3060 #endif
3061 #ifdef SSL_OP_NO_TLSv1
3062   { US"no_tlsv1", SSL_OP_NO_TLSv1 },
3063 #endif
3064 #ifdef SSL_OP_NO_TLSv1_1
3065 #if SSL_OP_NO_TLSv1_1 == 0x00000400L
3066   /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
3067 #warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
3068 #else
3069   { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
3070 #endif
3071 #endif
3072 #ifdef SSL_OP_NO_TLSv1_2
3073   { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
3074 #endif
3075 #ifdef SSL_OP_SAFARI_ECDHE_ECDSA_BUG
3076   { US"safari_ecdhe_ecdsa_bug", SSL_OP_SAFARI_ECDHE_ECDSA_BUG },
3077 #endif
3078 #ifdef SSL_OP_SINGLE_DH_USE
3079   { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
3080 #endif
3081 #ifdef SSL_OP_SINGLE_ECDH_USE
3082   { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
3083 #endif
3084 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
3085   { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
3086 #endif
3087 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
3088   { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
3089 #endif
3090 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
3091   { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
3092 #endif
3093 #ifdef SSL_OP_TLS_D5_BUG
3094   { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
3095 #endif
3096 #ifdef SSL_OP_TLS_ROLLBACK_BUG
3097   { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
3098 #endif
3099 };
3100 static int exim_openssl_options_size =
3101   sizeof(exim_openssl_options)/sizeof(struct exim_openssl_option);
3102
3103
3104 static BOOL
3105 tls_openssl_one_option_parse(uschar *name, long *value)
3106 {
3107 int first = 0;
3108 int last = exim_openssl_options_size;
3109 while (last > first)
3110   {
3111   int middle = (first + last)/2;
3112   int c = Ustrcmp(name, exim_openssl_options[middle].name);
3113   if (c == 0)
3114     {
3115     *value = exim_openssl_options[middle].value;
3116     return TRUE;
3117     }
3118   else if (c > 0)
3119     first = middle + 1;
3120   else
3121     last = middle;
3122   }
3123 return FALSE;
3124 }
3125
3126
3127
3128
3129 /*************************************************
3130 *        OpenSSL option parsing logic            *
3131 *************************************************/
3132
3133 /* OpenSSL has a number of compatibility options which an administrator might
3134 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
3135 we look like log_selector.
3136
3137 Arguments:
3138   option_spec  the administrator-supplied string of options
3139   results      ptr to long storage for the options bitmap
3140 Returns        success or failure
3141 */
3142
3143 BOOL
3144 tls_openssl_options_parse(uschar *option_spec, long *results)
3145 {
3146 long result, item;
3147 uschar *s, *end;
3148 uschar keep_c;
3149 BOOL adding, item_parsed;
3150
3151 result = SSL_OP_NO_TICKET;
3152 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
3153  * from default because it increases BEAST susceptibility. */
3154 #ifdef SSL_OP_NO_SSLv2
3155 result |= SSL_OP_NO_SSLv2;
3156 #endif
3157 #ifdef SSL_OP_SINGLE_DH_USE
3158 result |= SSL_OP_SINGLE_DH_USE;
3159 #endif
3160
3161 if (!option_spec)
3162   {
3163   *results = result;
3164   return TRUE;
3165   }
3166
3167 for (s=option_spec; *s != '\0'; /**/)
3168   {
3169   while (isspace(*s)) ++s;
3170   if (*s == '\0')
3171     break;
3172   if (*s != '+' && *s != '-')
3173     {
3174     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
3175         "+ or - expected but found \"%s\"\n", s);
3176     return FALSE;
3177     }
3178   adding = *s++ == '+';
3179   for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
3180   keep_c = *end;
3181   *end = '\0';
3182   item_parsed = tls_openssl_one_option_parse(s, &item);
3183   *end = keep_c;
3184   if (!item_parsed)
3185     {
3186     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
3187     return FALSE;
3188     }
3189   DEBUG(D_tls) debug_printf("openssl option, %s from %lx: %lx (%s)\n",
3190       adding ? "adding" : "removing", result, item, s);
3191   if (adding)
3192     result |= item;
3193   else
3194     result &= ~item;
3195   s = end;
3196   }
3197
3198 *results = result;
3199 return TRUE;
3200 }
3201
3202 /* vi: aw ai sw=2
3203 */
3204 /* End of tls-openssl.c */