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