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 (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 #ifndef DISABLE_OCSP
1254 if (cbinfo->u_ocsp.server.file)
1255   {
1256   SSL_CTX_set_tlsext_status_cb(server_sni, tls_server_stapling_cb);
1257   SSL_CTX_set_tlsext_status_arg(server_sni, cbinfo);
1258   }
1259 #endif
1260
1261 if ((rc = setup_certs(server_sni, tls_verify_certificates, tls_crl, NULL, FALSE,
1262                       verify_callback_server, &dummy_errstr)) != OK)
1263   return SSL_TLSEXT_ERR_NOACK;
1264
1265 /* do this after setup_certs, because this can require the certs for verifying
1266 OCSP information. */
1267 if ((rc = tls_expand_session_files(server_sni, cbinfo, &dummy_errstr)) != OK)
1268   return SSL_TLSEXT_ERR_NOACK;
1269
1270 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
1271 SSL_set_SSL_CTX(s, server_sni);
1272
1273 return SSL_TLSEXT_ERR_OK;
1274 }
1275 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
1276
1277
1278
1279
1280 #ifndef DISABLE_OCSP
1281
1282 /*************************************************
1283 *        Callback to handle OCSP Stapling        *
1284 *************************************************/
1285
1286 /* Called when acting as server during the TLS session setup if the client
1287 requests OCSP information with a Certificate Status Request.
1288
1289 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
1290 project.
1291
1292 */
1293
1294 static int
1295 tls_server_stapling_cb(SSL *s, void *arg)
1296 {
1297 const tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
1298 uschar *response_der;   /*XXX blob */
1299 int response_der_len;
1300
1301 /*XXX stack: use SSL_get_certificate() to see which cert; from that work
1302 out which ocsp blob to send.  Unfortunately, SSL_get_certificate is known
1303 buggy in current OpenSSL; it returns the last cert loaded always rather than
1304 the one actually presented.  So we can't support a stack of OCSP proofs at
1305 this time. */
1306
1307 DEBUG(D_tls)
1308   debug_printf("Received TLS status request (OCSP stapling); %s response\n",
1309     cbinfo->u_ocsp.server.response ? "have" : "lack");
1310
1311 tls_in.ocsp = OCSP_NOT_RESP;
1312 if (!cbinfo->u_ocsp.server.response)
1313   return SSL_TLSEXT_ERR_NOACK;
1314
1315 response_der = NULL;
1316 response_der_len = i2d_OCSP_RESPONSE(cbinfo->u_ocsp.server.response,    /*XXX stack*/
1317                       &response_der);
1318 if (response_der_len <= 0)
1319   return SSL_TLSEXT_ERR_NOACK;
1320
1321 SSL_set_tlsext_status_ocsp_resp(server_ssl, response_der, response_der_len);
1322 tls_in.ocsp = OCSP_VFIED;
1323 return SSL_TLSEXT_ERR_OK;
1324 }
1325
1326
1327 static void
1328 time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
1329 {
1330 BIO_printf(bp, "\t%s: ", str);
1331 ASN1_GENERALIZEDTIME_print(bp, time);
1332 BIO_puts(bp, "\n");
1333 }
1334
1335 static int
1336 tls_client_stapling_cb(SSL *s, void *arg)
1337 {
1338 tls_ext_ctx_cb * cbinfo = arg;
1339 const unsigned char * p;
1340 int len;
1341 OCSP_RESPONSE * rsp;
1342 OCSP_BASICRESP * bs;
1343 int i;
1344
1345 DEBUG(D_tls) debug_printf("Received TLS status response (OCSP stapling):");
1346 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
1347 if(!p)
1348  {
1349   /* Expect this when we requested ocsp but got none */
1350   if (cbinfo->u_ocsp.client.verify_required && LOGGING(tls_cipher))
1351     log_write(0, LOG_MAIN, "Received TLS status callback, null content");
1352   else
1353     DEBUG(D_tls) debug_printf(" null\n");
1354   return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1355  }
1356
1357 if(!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
1358  {
1359   tls_out.ocsp = OCSP_FAILED;
1360   if (LOGGING(tls_cipher))
1361     log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
1362   else
1363     DEBUG(D_tls) debug_printf(" parse error\n");
1364   return 0;
1365  }
1366
1367 if(!(bs = OCSP_response_get1_basic(rsp)))
1368   {
1369   tls_out.ocsp = OCSP_FAILED;
1370   if (LOGGING(tls_cipher))
1371     log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
1372   else
1373     DEBUG(D_tls) debug_printf(" error parsing response\n");
1374   OCSP_RESPONSE_free(rsp);
1375   return 0;
1376   }
1377
1378 /* We'd check the nonce here if we'd put one in the request. */
1379 /* However that would defeat cacheability on the server so we don't. */
1380
1381 /* This section of code reworked from OpenSSL apps source;
1382    The OpenSSL Project retains copyright:
1383    Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
1384 */
1385   {
1386     BIO * bp = NULL;
1387     int status, reason;
1388     ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
1389
1390     DEBUG(D_tls) bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
1391
1392     /*OCSP_RESPONSE_print(bp, rsp, 0);   extreme debug: stapling content */
1393
1394     /* Use the chain that verified the server cert to verify the stapled info */
1395     /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
1396
1397     if ((i = OCSP_basic_verify(bs, cbinfo->verify_stack,
1398               cbinfo->u_ocsp.client.verify_store, 0)) <= 0)
1399       {
1400       tls_out.ocsp = OCSP_FAILED;
1401       if (LOGGING(tls_cipher)) log_write(0, LOG_MAIN,
1402               "Received TLS cert status response, itself unverifiable: %s",
1403               ERR_reason_error_string(ERR_peek_error()));
1404       BIO_printf(bp, "OCSP response verify failure\n");
1405       ERR_print_errors(bp);
1406       OCSP_RESPONSE_print(bp, rsp, 0);
1407       goto failed;
1408       }
1409
1410     BIO_printf(bp, "OCSP response well-formed and signed OK\n");
1411
1412     /*XXX So we have a good stapled OCSP status.  How do we know
1413     it is for the cert of interest?  OpenSSL 1.1.0 has a routine
1414     OCSP_resp_find_status() which matches on a cert id, which presumably
1415     we should use. Making an id needs OCSP_cert_id_new(), which takes
1416     issuerName, issuerKey, serialNumber.  Are they all in the cert?
1417
1418     For now, carry on blindly accepting the resp. */
1419
1420       {
1421       OCSP_SINGLERESP * single;
1422
1423 #ifdef EXIM_HAVE_OCSP_RESP_COUNT
1424       if (OCSP_resp_count(bs) != 1)
1425 #else
1426       STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
1427       if (sk_OCSP_SINGLERESP_num(sresp) != 1)
1428 #endif
1429         {
1430         tls_out.ocsp = OCSP_FAILED;
1431         log_write(0, LOG_MAIN, "OCSP stapling "
1432             "with multiple responses not handled");
1433         goto failed;
1434         }
1435       single = OCSP_resp_get0(bs, 0);
1436       status = OCSP_single_get0_status(single, &reason, &rev,
1437                   &thisupd, &nextupd);
1438       }
1439
1440     DEBUG(D_tls) time_print(bp, "This OCSP Update", thisupd);
1441     DEBUG(D_tls) if(nextupd) time_print(bp, "Next OCSP Update", nextupd);
1442     if (!OCSP_check_validity(thisupd, nextupd,
1443           EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1444       {
1445       tls_out.ocsp = OCSP_FAILED;
1446       DEBUG(D_tls) ERR_print_errors(bp);
1447       log_write(0, LOG_MAIN, "Server OSCP dates invalid");
1448       }
1449     else
1450       {
1451       DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
1452                     OCSP_cert_status_str(status));
1453       switch(status)
1454         {
1455         case V_OCSP_CERTSTATUS_GOOD:
1456           tls_out.ocsp = OCSP_VFIED;
1457           i = 1;
1458           goto good;
1459         case V_OCSP_CERTSTATUS_REVOKED:
1460           tls_out.ocsp = OCSP_FAILED;
1461           log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
1462               reason != -1 ? "; reason: " : "",
1463               reason != -1 ? OCSP_crl_reason_str(reason) : "");
1464           DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
1465           break;
1466         default:
1467           tls_out.ocsp = OCSP_FAILED;
1468           log_write(0, LOG_MAIN,
1469               "Server certificate status unknown, in OCSP stapling");
1470           break;
1471         }
1472       }
1473   failed:
1474     i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1475   good:
1476     BIO_free(bp);
1477   }
1478
1479 OCSP_RESPONSE_free(rsp);
1480 return i;
1481 }
1482 #endif  /*!DISABLE_OCSP*/
1483
1484
1485 /*************************************************
1486 *            Initialize for TLS                  *
1487 *************************************************/
1488
1489 /* Called from both server and client code, to do preliminary initialization
1490 of the library.  We allocate and return a context structure.
1491
1492 Arguments:
1493   ctxp            returned SSL context
1494   host            connected host, if client; NULL if server
1495   dhparam         DH parameter file
1496   certificate     certificate file
1497   privatekey      private key
1498   ocsp_file       file of stapling info (server); flag for require ocsp (client)
1499   addr            address if client; NULL if server (for some randomness)
1500   cbp             place to put allocated callback context
1501   errstr          error string pointer
1502
1503 Returns:          OK/DEFER/FAIL
1504 */
1505
1506 static int
1507 tls_init(SSL_CTX **ctxp, host_item *host, uschar *dhparam, uschar *certificate,
1508   uschar *privatekey,
1509 #ifndef DISABLE_OCSP
1510   uschar *ocsp_file,    /*XXX stack, in server*/
1511 #endif
1512   address_item *addr, tls_ext_ctx_cb ** cbp, uschar ** errstr)
1513 {
1514 SSL_CTX * ctx;
1515 long init_options;
1516 int rc;
1517 tls_ext_ctx_cb * cbinfo;
1518
1519 cbinfo = store_malloc(sizeof(tls_ext_ctx_cb));
1520 cbinfo->certificate = certificate;
1521 cbinfo->privatekey = privatekey;
1522 cbinfo->is_server = host==NULL;
1523 #ifndef DISABLE_OCSP
1524 cbinfo->verify_stack = NULL;
1525 if (!host)
1526   {
1527   cbinfo->u_ocsp.server.file = ocsp_file;
1528   cbinfo->u_ocsp.server.file_expanded = NULL;
1529   cbinfo->u_ocsp.server.response = NULL;
1530   }
1531 else
1532   cbinfo->u_ocsp.client.verify_store = NULL;
1533 #endif
1534 cbinfo->dhparam = dhparam;
1535 cbinfo->server_cipher_list = NULL;
1536 cbinfo->host = host;
1537 #ifndef DISABLE_EVENT
1538 cbinfo->event_action = NULL;
1539 #endif
1540
1541 SSL_load_error_strings();          /* basic set up */
1542 OpenSSL_add_ssl_algorithms();
1543
1544 #ifdef EXIM_HAVE_SHA256
1545 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
1546 list of available digests. */
1547 EVP_add_digest(EVP_sha256());
1548 #endif
1549
1550 /* Create a context.
1551 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
1552 negotiation in the different methods; as far as I can tell, the only
1553 *_{server,client}_method which allows negotiation is SSLv23, which exists even
1554 when OpenSSL is built without SSLv2 support.
1555 By disabling with openssl_options, we can let admins re-enable with the
1556 existing knob. */
1557
1558 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
1559 if (!(ctx = SSL_CTX_new(host ? TLS_client_method() : TLS_server_method())))
1560 #else
1561 if (!(ctx = SSL_CTX_new(host ? SSLv23_client_method() : SSLv23_server_method())))
1562 #endif
1563   return tls_error(US"SSL_CTX_new", host, NULL, errstr);
1564
1565 /* It turns out that we need to seed the random number generator this early in
1566 order to get the full complement of ciphers to work. It took me roughly a day
1567 of work to discover this by experiment.
1568
1569 On systems that have /dev/urandom, SSL may automatically seed itself from
1570 there. Otherwise, we have to make something up as best we can. Double check
1571 afterwards. */
1572
1573 if (!RAND_status())
1574   {
1575   randstuff r;
1576   gettimeofday(&r.tv, NULL);
1577   r.p = getpid();
1578
1579   RAND_seed(US (&r), sizeof(r));
1580   RAND_seed(US big_buffer, big_buffer_size);
1581   if (addr != NULL) RAND_seed(US addr, sizeof(addr));
1582
1583   if (!RAND_status())
1584     return tls_error(US"RAND_status", host,
1585       US"unable to seed random number generator", errstr);
1586   }
1587
1588 /* Set up the information callback, which outputs if debugging is at a suitable
1589 level. */
1590
1591 DEBUG(D_tls) SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
1592
1593 /* Automatically re-try reads/writes after renegotiation. */
1594 (void) SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
1595
1596 /* Apply administrator-supplied work-arounds.
1597 Historically we applied just one requested option,
1598 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
1599 moved to an administrator-controlled list of options to specify and
1600 grandfathered in the first one as the default value for "openssl_options".
1601
1602 No OpenSSL version number checks: the options we accept depend upon the
1603 availability of the option value macros from OpenSSL.  */
1604
1605 if (!tls_openssl_options_parse(openssl_options, &init_options))
1606   return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
1607
1608 if (init_options)
1609   {
1610   DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
1611   if (!(SSL_CTX_set_options(ctx, init_options)))
1612     return tls_error(string_sprintf(
1613           "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
1614   }
1615 else
1616   DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
1617
1618 /* We'd like to disable session cache unconditionally, but foolish Outlook
1619 Express clients then give up the first TLS connection and make a second one
1620 (which works).  Only when there is an IMAP service on the same machine.
1621 Presumably OE is trying to use the cache for A on B.  Leave it enabled for
1622 now, until we work out a decent way of presenting control to the config.  It
1623 will never be used because we use a new context every time. */
1624 #ifdef notdef
1625 (void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
1626 #endif
1627
1628 /* Initialize with DH parameters if supplied */
1629 /* Initialize ECDH temp key parameter selection */
1630
1631 if (  !init_dh(ctx, dhparam, host, errstr)
1632    || !init_ecdh(ctx, host, errstr)
1633    )
1634   return DEFER;
1635
1636 /* Set up certificate and key (and perhaps OCSP info) */
1637
1638 if ((rc = tls_expand_session_files(ctx, cbinfo, errstr)) != OK)
1639   return rc;
1640
1641 /* If we need to handle SNI or OCSP, do so */
1642
1643 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1644 # ifndef DISABLE_OCSP
1645   if (!(cbinfo->verify_stack = sk_X509_new_null()))
1646     {
1647     DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
1648     return FAIL;
1649     }
1650 # endif
1651
1652 if (!host)              /* server */
1653   {
1654 # ifndef DISABLE_OCSP
1655   /* We check u_ocsp.server.file, not server.response, because we care about if
1656   the option exists, not what the current expansion might be, as SNI might
1657   change the certificate and OCSP file in use between now and the time the
1658   callback is invoked. */
1659   if (cbinfo->u_ocsp.server.file)
1660     {
1661     SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
1662     SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
1663     }
1664 # endif
1665   /* We always do this, so that $tls_sni is available even if not used in
1666   tls_certificate */
1667   SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
1668   SSL_CTX_set_tlsext_servername_arg(ctx, cbinfo);
1669   }
1670 # ifndef DISABLE_OCSP
1671 else                    /* client */
1672   if(ocsp_file)         /* wanting stapling */
1673     {
1674     if (!(cbinfo->u_ocsp.client.verify_store = X509_STORE_new()))
1675       {
1676       DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
1677       return FAIL;
1678       }
1679     SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
1680     SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
1681     }
1682 # endif
1683 #endif
1684
1685 cbinfo->verify_cert_hostnames = NULL;
1686
1687 #ifdef EXIM_HAVE_EPHEM_RSA_KEX
1688 /* Set up the RSA callback */
1689 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
1690 #endif
1691
1692 /* Finally, set the timeout, and we are done */
1693
1694 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
1695 DEBUG(D_tls) debug_printf("Initialized TLS\n");
1696
1697 *cbp = cbinfo;
1698 *ctxp = ctx;
1699
1700 return OK;
1701 }
1702
1703
1704
1705
1706 /*************************************************
1707 *           Get name of cipher in use            *
1708 *************************************************/
1709
1710 /*
1711 Argument:   pointer to an SSL structure for the connection
1712             buffer to use for answer
1713             size of buffer
1714             pointer to number of bits for cipher
1715 Returns:    nothing
1716 */
1717
1718 static void
1719 construct_cipher_name(SSL *ssl, uschar *cipherbuf, int bsize, int *bits)
1720 {
1721 /* With OpenSSL 1.0.0a, 'c' needs to be const but the documentation doesn't
1722 yet reflect that.  It should be a safe change anyway, even 0.9.8 versions have
1723 the accessor functions use const in the prototype. */
1724
1725 const uschar * ver = CUS SSL_get_version(ssl);
1726 const SSL_CIPHER * c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
1727
1728 SSL_CIPHER_get_bits(c, bits);
1729
1730 string_format(cipherbuf, bsize, "%s:%s:%u", ver,
1731   SSL_CIPHER_get_name(c), *bits);
1732
1733 DEBUG(D_tls) debug_printf("Cipher: %s\n", cipherbuf);
1734 }
1735
1736
1737 static void
1738 peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned bsize)
1739 {
1740 /*XXX we might consider a list-of-certs variable for the cert chain.
1741 SSL_get_peer_cert_chain(SSL*).  We'd need a new variable type and support
1742 in list-handling functions, also consider the difference between the entire
1743 chain and the elements sent by the peer. */
1744
1745 /* Will have already noted peercert on a verify fail; possibly not the leaf */
1746 if (!tlsp->peercert)
1747   tlsp->peercert = SSL_get_peer_certificate(ssl);
1748 /* Beware anonymous ciphers which lead to server_cert being NULL */
1749 if (tlsp->peercert)
1750   {
1751   X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, bsize);
1752   peerdn[bsize-1] = '\0';
1753   tlsp->peerdn = peerdn;                /*XXX a static buffer... */
1754   }
1755 else
1756   tlsp->peerdn = NULL;
1757 }
1758
1759
1760
1761
1762
1763 /*************************************************
1764 *        Set up for verifying certificates       *
1765 *************************************************/
1766
1767 #ifndef DISABLE_OCSP
1768 /* Load certs from file, return TRUE on success */
1769
1770 static BOOL
1771 chain_from_pem_file(const uschar * file, STACK_OF(X509) * verify_stack)
1772 {
1773 BIO * bp;
1774 X509 * x;
1775
1776 while (sk_X509_num(verify_stack) > 0)
1777   X509_free(sk_X509_pop(verify_stack));
1778
1779 if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
1780 while ((x = PEM_read_bio_X509(bp, NULL, 0, NULL)))
1781   sk_X509_push(verify_stack, x);
1782 BIO_free(bp);
1783 return TRUE;
1784 }
1785 #endif
1786
1787
1788
1789 /* Called by both client and server startup; on the server possibly
1790 repeated after a Server Name Indication.
1791
1792 Arguments:
1793   sctx          SSL_CTX* to initialise
1794   certs         certs file or NULL
1795   crl           CRL file or NULL
1796   host          NULL in a server; the remote host in a client
1797   optional      TRUE if called from a server for a host in tls_try_verify_hosts;
1798                 otherwise passed as FALSE
1799   cert_vfy_cb   Callback function for certificate verification
1800   errstr        error string pointer
1801
1802 Returns:        OK/DEFER/FAIL
1803 */
1804
1805 static int
1806 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
1807     int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr)
1808 {
1809 uschar *expcerts, *expcrl;
1810
1811 if (!expand_check(certs, US"tls_verify_certificates", &expcerts, errstr))
1812   return DEFER;
1813 DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
1814
1815 if (expcerts && *expcerts)
1816   {
1817   /* Tell the library to use its compiled-in location for the system default
1818   CA bundle. Then add the ones specified in the config, if any. */
1819
1820   if (!SSL_CTX_set_default_verify_paths(sctx))
1821     return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
1822
1823   if (Ustrcmp(expcerts, "system") != 0)
1824     {
1825     struct stat statbuf;
1826
1827     if (Ustat(expcerts, &statbuf) < 0)
1828       {
1829       log_write(0, LOG_MAIN|LOG_PANIC,
1830         "failed to stat %s for certificates", expcerts);
1831       return DEFER;
1832       }
1833     else
1834       {
1835       uschar *file, *dir;
1836       if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
1837         { file = NULL; dir = expcerts; }
1838       else
1839         {
1840         file = expcerts; dir = NULL;
1841 #ifndef DISABLE_OCSP
1842         /* In the server if we will be offering an OCSP proof, load chain from
1843         file for verifying the OCSP proof at load time. */
1844
1845         if (  !host
1846            && statbuf.st_size > 0
1847            && server_static_cbinfo->u_ocsp.server.file
1848            && !chain_from_pem_file(file, server_static_cbinfo->verify_stack)
1849            )
1850           {
1851           log_write(0, LOG_MAIN|LOG_PANIC,
1852             "failed to load cert chain from %s", file);
1853           return DEFER;
1854           }
1855 #endif
1856         }
1857
1858       /* If a certificate file is empty, the next function fails with an
1859       unhelpful error message. If we skip it, we get the correct behaviour (no
1860       certificates are recognized, but the error message is still misleading (it
1861       says no certificate was supplied).  But this is better. */
1862
1863       if (  (!file || statbuf.st_size > 0)
1864          && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
1865         return tls_error(US"SSL_CTX_load_verify_locations", host, NULL, errstr);
1866
1867       /* Load the list of CAs for which we will accept certs, for sending
1868       to the client.  This is only for the one-file tls_verify_certificates
1869       variant.
1870       If a list isn't loaded into the server, but
1871       some verify locations are set, the server end appears to make
1872       a wildcard request for client certs.
1873       Meanwhile, the client library as default behaviour *ignores* the list
1874       we send over the wire - see man SSL_CTX_set_client_cert_cb.
1875       Because of this, and that the dir variant is likely only used for
1876       the public-CA bundle (not for a private CA), not worth fixing.
1877       */
1878       if (file)
1879         {
1880         STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
1881
1882         SSL_CTX_set_client_CA_list(sctx, names);
1883         DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n",
1884                                     sk_X509_NAME_num(names));
1885         }
1886       }
1887     }
1888
1889   /* Handle a certificate revocation list. */
1890
1891 #if OPENSSL_VERSION_NUMBER > 0x00907000L
1892
1893   /* This bit of code is now the version supplied by Lars Mainka. (I have
1894   merely reformatted it into the Exim code style.)
1895
1896   "From here I changed the code to add support for multiple crl's
1897   in pem format in one file or to support hashed directory entries in
1898   pem format instead of a file. This method now uses the library function
1899   X509_STORE_load_locations to add the CRL location to the SSL context.
1900   OpenSSL will then handle the verify against CA certs and CRLs by
1901   itself in the verify callback." */
1902
1903   if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
1904   if (expcrl && *expcrl)
1905     {
1906     struct stat statbufcrl;
1907     if (Ustat(expcrl, &statbufcrl) < 0)
1908       {
1909       log_write(0, LOG_MAIN|LOG_PANIC,
1910         "failed to stat %s for certificates revocation lists", expcrl);
1911       return DEFER;
1912       }
1913     else
1914       {
1915       /* is it a file or directory? */
1916       uschar *file, *dir;
1917       X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
1918       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
1919         {
1920         file = NULL;
1921         dir = expcrl;
1922         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
1923         }
1924       else
1925         {
1926         file = expcrl;
1927         dir = NULL;
1928         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
1929         }
1930       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
1931         return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
1932
1933       /* setting the flags to check against the complete crl chain */
1934
1935       X509_STORE_set_flags(cvstore,
1936         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
1937       }
1938     }
1939
1940 #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
1941
1942   /* If verification is optional, don't fail if no certificate */
1943
1944   SSL_CTX_set_verify(sctx,
1945     SSL_VERIFY_PEER | (optional? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
1946     cert_vfy_cb);
1947   }
1948
1949 return OK;
1950 }
1951
1952
1953
1954 /*************************************************
1955 *       Start a TLS session in a server          *
1956 *************************************************/
1957
1958 /* This is called when Exim is running as a server, after having received
1959 the STARTTLS command. It must respond to that command, and then negotiate
1960 a TLS session.
1961
1962 Arguments:
1963   require_ciphers   allowed ciphers
1964   errstr            pointer to error message
1965
1966 Returns:            OK on success
1967                     DEFER for errors before the start of the negotiation
1968                     FAIL for errors during the negotiation; the server can't
1969                       continue running.
1970 */
1971
1972 int
1973 tls_server_start(const uschar * require_ciphers, uschar ** errstr)
1974 {
1975 int rc;
1976 uschar * expciphers;
1977 tls_ext_ctx_cb * cbinfo;
1978 static uschar peerdn[256];
1979 static uschar cipherbuf[256];
1980
1981 /* Check for previous activation */
1982
1983 if (tls_in.active.sock >= 0)
1984   {
1985   tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
1986   smtp_printf("554 Already in TLS\r\n", FALSE);
1987   return FAIL;
1988   }
1989
1990 /* Initialize the SSL library. If it fails, it will already have logged
1991 the error. */
1992
1993 rc = tls_init(&server_ctx, NULL, tls_dhparam, tls_certificate, tls_privatekey,
1994 #ifndef DISABLE_OCSP
1995     tls_ocsp_file,      /*XXX stack*/
1996 #endif
1997     NULL, &server_static_cbinfo, errstr);
1998 if (rc != OK) return rc;
1999 cbinfo = server_static_cbinfo;
2000
2001 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
2002   return FAIL;
2003
2004 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2005 were historically separated by underscores. So that I can use either form in my
2006 tests, and also for general convenience, we turn underscores into hyphens here.
2007
2008 XXX SSL_CTX_set_cipher_list() is replaced by SSL_CTX_set_ciphersuites()
2009 for TLS 1.3 .  Since we do not call it at present we get the default list:
2010 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
2011 */
2012
2013 if (expciphers)
2014   {
2015   uschar * s = expciphers;
2016   while (*s != 0) { if (*s == '_') *s = '-'; s++; }
2017   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2018   if (!SSL_CTX_set_cipher_list(server_ctx, CS expciphers))
2019     return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL, errstr);
2020   cbinfo->server_cipher_list = expciphers;
2021   }
2022
2023 /* If this is a host for which certificate verification is mandatory or
2024 optional, set up appropriately. */
2025
2026 tls_in.certificate_verified = FALSE;
2027 #ifdef SUPPORT_DANE
2028 tls_in.dane_verified = FALSE;
2029 #endif
2030 server_verify_callback_called = FALSE;
2031
2032 if (verify_check_host(&tls_verify_hosts) == OK)
2033   {
2034   rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2035                         FALSE, verify_callback_server, errstr);
2036   if (rc != OK) return rc;
2037   server_verify_optional = FALSE;
2038   }
2039 else if (verify_check_host(&tls_try_verify_hosts) == OK)
2040   {
2041   rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2042                         TRUE, verify_callback_server, errstr);
2043   if (rc != OK) return rc;
2044   server_verify_optional = TRUE;
2045   }
2046
2047 /* Prepare for new connection */
2048
2049 if (!(server_ssl = SSL_new(server_ctx)))
2050   return tls_error(US"SSL_new", NULL, NULL, errstr);
2051
2052 /* Warning: we used to SSL_clear(ssl) here, it was removed.
2053  *
2054  * With the SSL_clear(), we get strange interoperability bugs with
2055  * OpenSSL 1.0.1b and TLS1.1/1.2.  It looks as though this may be a bug in
2056  * OpenSSL itself, as a clear should not lead to inability to follow protocols.
2057  *
2058  * The SSL_clear() call is to let an existing SSL* be reused, typically after
2059  * session shutdown.  In this case, we have a brand new object and there's no
2060  * obvious reason to immediately clear it.  I'm guessing that this was
2061  * originally added because of incomplete initialisation which the clear fixed,
2062  * in some historic release.
2063  */
2064
2065 /* Set context and tell client to go ahead, except in the case of TLS startup
2066 on connection, where outputting anything now upsets the clients and tends to
2067 make them disconnect. We need to have an explicit fflush() here, to force out
2068 the response. Other smtp_printf() calls do not need it, because in non-TLS
2069 mode, the fflush() happens when smtp_getc() is called. */
2070
2071 SSL_set_session_id_context(server_ssl, sid_ctx, Ustrlen(sid_ctx));
2072 if (!tls_in.on_connect)
2073   {
2074   smtp_printf("220 TLS go ahead\r\n", FALSE);
2075   fflush(smtp_out);
2076   }
2077
2078 /* Now negotiate the TLS session. We put our own timer on it, since it seems
2079 that the OpenSSL library doesn't. */
2080
2081 SSL_set_wfd(server_ssl, fileno(smtp_out));
2082 SSL_set_rfd(server_ssl, fileno(smtp_in));
2083 SSL_set_accept_state(server_ssl);
2084
2085 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
2086
2087 sigalrm_seen = FALSE;
2088 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
2089 rc = SSL_accept(server_ssl);
2090 alarm(0);
2091
2092 if (rc <= 0)
2093   {
2094   (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
2095   return FAIL;
2096   }
2097
2098 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
2099
2100 /* TLS has been set up. Adjust the input functions to read via TLS,
2101 and initialize things. */
2102
2103 peer_cert(server_ssl, &tls_in, peerdn, sizeof(peerdn));
2104
2105 construct_cipher_name(server_ssl, cipherbuf, sizeof(cipherbuf), &tls_in.bits);
2106 tls_in.cipher = cipherbuf;
2107
2108 DEBUG(D_tls)
2109   {
2110   uschar buf[2048];
2111   if (SSL_get_shared_ciphers(server_ssl, CS buf, sizeof(buf)) != NULL)
2112     debug_printf("Shared ciphers: %s\n", buf);
2113   }
2114
2115 /* Record the certificate we presented */
2116   {
2117   X509 * crt = SSL_get_certificate(server_ssl);
2118   tls_in.ourcert = crt ? X509_dup(crt) : NULL;
2119   }
2120
2121 /* Only used by the server-side tls (tls_in), including tls_getc.
2122    Client-side (tls_out) reads (seem to?) go via
2123    smtp_read_response()/ip_recv().
2124    Hence no need to duplicate for _in and _out.
2125  */
2126 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
2127 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
2128 ssl_xfer_eof = ssl_xfer_error = FALSE;
2129
2130 receive_getc = tls_getc;
2131 receive_getbuf = tls_getbuf;
2132 receive_get_cache = tls_get_cache;
2133 receive_ungetc = tls_ungetc;
2134 receive_feof = tls_feof;
2135 receive_ferror = tls_ferror;
2136 receive_smtp_buffered = tls_smtp_buffered;
2137
2138 tls_in.active.sock = fileno(smtp_out);
2139 tls_in.active.tls_ctx = NULL;   /* not using explicit ctx for server-side */
2140 return OK;
2141 }
2142
2143
2144
2145
2146 static int
2147 tls_client_basic_ctx_init(SSL_CTX * ctx,
2148     host_item * host, smtp_transport_options_block * ob, tls_ext_ctx_cb * cbinfo,
2149     uschar ** errstr)
2150 {
2151 int rc;
2152 /* stick to the old behaviour for compatibility if tls_verify_certificates is
2153    set but both tls_verify_hosts and tls_try_verify_hosts is not set. Check only
2154    the specified host patterns if one of them is defined */
2155
2156 if (  (  !ob->tls_verify_hosts
2157       && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
2158       )
2159    || verify_check_given_host(&ob->tls_verify_hosts, host) == OK
2160    )
2161   client_verify_optional = FALSE;
2162 else if (verify_check_given_host(&ob->tls_try_verify_hosts, host) == OK)
2163   client_verify_optional = TRUE;
2164 else
2165   return OK;
2166
2167 if ((rc = setup_certs(ctx, ob->tls_verify_certificates,
2168       ob->tls_crl, host, client_verify_optional, verify_callback_client,
2169       errstr)) != OK)
2170   return rc;
2171
2172 if (verify_check_given_host(&ob->tls_verify_cert_hostnames, host) == OK)
2173   {
2174   cbinfo->verify_cert_hostnames =
2175 #ifdef SUPPORT_I18N
2176     string_domain_utf8_to_alabel(host->name, NULL);
2177 #else
2178     host->name;
2179 #endif
2180   DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
2181                     cbinfo->verify_cert_hostnames);
2182   }
2183 return OK;
2184 }
2185
2186
2187 #ifdef SUPPORT_DANE
2188 static int
2189 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
2190 {
2191 dns_record * rr;
2192 dns_scan dnss;
2193 const char * hostnames[2] = { CS host->name, NULL };
2194 int found = 0;
2195
2196 if (DANESSL_init(ssl, NULL, hostnames) != 1)
2197   return tls_error(US"hostnames load", host, NULL, errstr);
2198
2199 for (rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS);
2200      rr;
2201      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2202     ) if (rr->type == T_TLSA)
2203   {
2204   const uschar * p = rr->data;
2205   uint8_t usage, selector, mtype;
2206   const char * mdname;
2207
2208   usage = *p++;
2209
2210   /* Only DANE-TA(2) and DANE-EE(3) are supported */
2211   if (usage != 2 && usage != 3) continue;
2212
2213   selector = *p++;
2214   mtype = *p++;
2215
2216   switch (mtype)
2217     {
2218     default: continue;  /* Only match-types 0, 1, 2 are supported */
2219     case 0:  mdname = NULL; break;
2220     case 1:  mdname = "sha256"; break;
2221     case 2:  mdname = "sha512"; break;
2222     }
2223
2224   found++;
2225   switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
2226     {
2227     default:
2228       return tls_error(US"tlsa load", host, NULL, errstr);
2229     case 0:     /* action not taken */
2230     case 1:     break;
2231     }
2232
2233   tls_out.tlsa_usage |= 1<<usage;
2234   }
2235
2236 if (found)
2237   return OK;
2238
2239 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
2240 return DEFER;
2241 }
2242 #endif  /*SUPPORT_DANE*/
2243
2244
2245
2246 /*************************************************
2247 *    Start a TLS session in a client             *
2248 *************************************************/
2249
2250 /* Called from the smtp transport after STARTTLS has been accepted.
2251
2252 Argument:
2253   fd               the fd of the connection
2254   host             connected host (for messages and option-tests)
2255   addr             the first address (for some randomness; can be NULL)
2256   tb               transport (always smtp)
2257   tlsa_dnsa        tlsa lookup, if DANE, else null
2258   tlsp             record details of channel configuration here; must be non-NULL
2259   errstr           error string pointer
2260
2261 Returns:           Pointer to TLS session context, or NULL on error
2262 */
2263
2264 void *
2265 tls_client_start(int fd, host_item *host, address_item *addr,
2266   transport_instance * tb,
2267 #ifdef SUPPORT_DANE
2268   dns_answer * tlsa_dnsa,
2269 #endif
2270   tls_support * tlsp, uschar ** errstr)
2271 {
2272 smtp_transport_options_block * ob = tb
2273   ? (smtp_transport_options_block *)tb->options_block
2274   : &smtp_transport_option_defaults;
2275 exim_openssl_client_tls_ctx * exim_client_ctx;
2276 static uschar peerdn[256];
2277 uschar * expciphers;
2278 int rc;
2279 static uschar cipherbuf[256];
2280
2281 #ifndef DISABLE_OCSP
2282 BOOL request_ocsp = FALSE;
2283 BOOL require_ocsp = FALSE;
2284 #endif
2285
2286 rc = store_pool;
2287 store_pool = POOL_PERM;
2288 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx));
2289 store_pool = rc;
2290
2291 #ifdef SUPPORT_DANE
2292 tlsp->tlsa_usage = 0;
2293 #endif
2294
2295 #ifndef DISABLE_OCSP
2296   {
2297 # ifdef SUPPORT_DANE
2298   if (  tlsa_dnsa
2299      && ob->hosts_request_ocsp[0] == '*'
2300      && ob->hosts_request_ocsp[1] == '\0'
2301      )
2302     {
2303     /* Unchanged from default.  Use a safer one under DANE */
2304     request_ocsp = TRUE;
2305     ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
2306                                       "   {= {4}{$tls_out_tlsa_usage}} } "
2307                                  " {*}{}}";
2308     }
2309 # endif
2310
2311   if ((require_ocsp =
2312         verify_check_given_host(&ob->hosts_require_ocsp, host) == OK))
2313     request_ocsp = TRUE;
2314   else
2315 # ifdef SUPPORT_DANE
2316     if (!request_ocsp)
2317 # endif
2318       request_ocsp =
2319         verify_check_given_host(&ob->hosts_request_ocsp, host) == OK;
2320   }
2321 #endif
2322
2323 rc = tls_init(&exim_client_ctx->ctx, host, NULL,
2324     ob->tls_certificate, ob->tls_privatekey,
2325 #ifndef DISABLE_OCSP
2326     (void *)(long)request_ocsp,
2327 #endif
2328     addr, &client_static_cbinfo, errstr);
2329 if (rc != OK) return NULL;
2330
2331 tlsp->certificate_verified = FALSE;
2332 client_verify_callback_called = FALSE;
2333
2334 expciphers = NULL;
2335 #ifdef SUPPORT_DANE
2336 if (tlsa_dnsa)
2337   {
2338   /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
2339   other failures should be treated as problems. */
2340   if (ob->dane_require_tls_ciphers &&
2341       !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
2342         &expciphers, errstr))
2343     return NULL;
2344   if (expciphers && *expciphers == '\0')
2345     expciphers = NULL;
2346   }
2347 #endif
2348 if (!expciphers &&
2349     !expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
2350       &expciphers, errstr))
2351   return NULL;
2352
2353 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2354 are separated by underscores. So that I can use either form in my tests, and
2355 also for general convenience, we turn underscores into hyphens here. */
2356
2357 if (expciphers)
2358   {
2359   uschar *s = expciphers;
2360   while (*s) { if (*s == '_') *s = '-'; s++; }
2361   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2362   if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
2363     {
2364     tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
2365     return NULL;
2366     }
2367   }
2368
2369 #ifdef SUPPORT_DANE
2370 if (tlsa_dnsa)
2371   {
2372   SSL_CTX_set_verify(exim_client_ctx->ctx,
2373     SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
2374     verify_callback_client_dane);
2375
2376   if (!DANESSL_library_init())
2377     {
2378     tls_error(US"library init", host, NULL, errstr);
2379     return NULL;
2380     }
2381   if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
2382     {
2383     tls_error(US"context init", host, NULL, errstr);
2384     return NULL;
2385     }
2386   }
2387 else
2388
2389 #endif
2390
2391   if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
2392         client_static_cbinfo, errstr) != OK)
2393     return NULL;
2394
2395 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
2396   {
2397   tls_error(US"SSL_new", host, NULL, errstr);
2398   return NULL;
2399   }
2400 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
2401 SSL_set_fd(exim_client_ctx->ssl, fd);
2402 SSL_set_connect_state(exim_client_ctx->ssl);
2403
2404 if (ob->tls_sni)
2405   {
2406   if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
2407     return NULL;
2408   if (!tlsp->sni)
2409     {
2410     DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
2411     }
2412   else if (!Ustrlen(tlsp->sni))
2413     tlsp->sni = NULL;
2414   else
2415     {
2416 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2417     DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
2418     SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
2419 #else
2420     log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
2421           tlsp->sni);
2422 #endif
2423     }
2424   }
2425
2426 #ifdef SUPPORT_DANE
2427 if (tlsa_dnsa)
2428   if (dane_tlsa_load(exim_client_ctx->ssl, host, tlsa_dnsa, errstr) != OK)
2429     return NULL;
2430 #endif
2431
2432 #ifndef DISABLE_OCSP
2433 /* Request certificate status at connection-time.  If the server
2434 does OCSP stapling we will get the callback (set in tls_init()) */
2435 # ifdef SUPPORT_DANE
2436 if (request_ocsp)
2437   {
2438   const uschar * s;
2439   if (  ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
2440      || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
2441      )
2442     {   /* Re-eval now $tls_out_tlsa_usage is populated.  If
2443         this means we avoid the OCSP request, we wasted the setup
2444         cost in tls_init(). */
2445     require_ocsp = verify_check_given_host(&ob->hosts_require_ocsp, host) == OK;
2446     request_ocsp = require_ocsp
2447       || verify_check_given_host(&ob->hosts_request_ocsp, host) == OK;
2448     }
2449   }
2450 # endif
2451
2452 if (request_ocsp)
2453   {
2454   SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
2455   client_static_cbinfo->u_ocsp.client.verify_required = require_ocsp;
2456   tlsp->ocsp = OCSP_NOT_RESP;
2457   }
2458 #endif
2459
2460 #ifndef DISABLE_EVENT
2461 client_static_cbinfo->event_action = tb ? tb->event_action : NULL;
2462 #endif
2463
2464 /* There doesn't seem to be a built-in timeout on connection. */
2465
2466 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
2467 sigalrm_seen = FALSE;
2468 alarm(ob->command_timeout);
2469 rc = SSL_connect(exim_client_ctx->ssl);
2470 alarm(0);
2471
2472 #ifdef SUPPORT_DANE
2473 if (tlsa_dnsa)
2474   DANESSL_cleanup(exim_client_ctx->ssl);
2475 #endif
2476
2477 if (rc <= 0)
2478   {
2479   tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
2480   return NULL;
2481   }
2482
2483 DEBUG(D_tls) debug_printf("SSL_connect succeeded\n");
2484
2485 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
2486
2487 construct_cipher_name(exim_client_ctx->ssl, cipherbuf, sizeof(cipherbuf), &tlsp->bits);
2488 tlsp->cipher = cipherbuf;
2489
2490 /* Record the certificate we presented */
2491   {
2492   X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
2493   tlsp->ourcert = crt ? X509_dup(crt) : NULL;
2494   }
2495
2496 tlsp->active.sock = fd;
2497 tlsp->active.tls_ctx = exim_client_ctx;
2498 return exim_client_ctx;
2499 }
2500
2501
2502
2503
2504
2505 static BOOL
2506 tls_refill(unsigned lim)
2507 {
2508 int error;
2509 int inbytes;
2510
2511 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", server_ssl,
2512   ssl_xfer_buffer, ssl_xfer_buffer_size);
2513
2514 if (smtp_receive_timeout > 0) alarm(smtp_receive_timeout);
2515 inbytes = SSL_read(server_ssl, CS ssl_xfer_buffer,
2516                   MIN(ssl_xfer_buffer_size, lim));
2517 error = SSL_get_error(server_ssl, inbytes);
2518 if (smtp_receive_timeout > 0) alarm(0);
2519
2520 if (had_command_timeout)                /* set by signal handler */
2521   smtp_command_timeout_exit();          /* does not return */
2522 if (had_command_sigterm)
2523   smtp_command_sigterm_exit();
2524 if (had_data_timeout)
2525   smtp_data_timeout_exit();
2526 if (had_data_sigint)
2527   smtp_data_sigint_exit();
2528
2529 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
2530 closed down, not that the socket itself has been closed down. Revert to
2531 non-SSL handling. */
2532
2533 switch(error)
2534   {
2535   case SSL_ERROR_NONE:
2536     break;
2537
2538   case SSL_ERROR_ZERO_RETURN:
2539     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2540
2541     receive_getc = smtp_getc;
2542     receive_getbuf = smtp_getbuf;
2543     receive_get_cache = smtp_get_cache;
2544     receive_ungetc = smtp_ungetc;
2545     receive_feof = smtp_feof;
2546     receive_ferror = smtp_ferror;
2547     receive_smtp_buffered = smtp_buffered;
2548
2549     if (SSL_get_shutdown(server_ssl) == SSL_RECEIVED_SHUTDOWN)
2550           SSL_shutdown(server_ssl);
2551
2552 #ifndef DISABLE_OCSP
2553     sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
2554     server_static_cbinfo->verify_stack = NULL;
2555 #endif
2556     SSL_free(server_ssl);
2557     SSL_CTX_free(server_ctx);
2558     server_ctx = NULL;
2559     server_ssl = NULL;
2560     tls_in.active.sock = -1;
2561     tls_in.active.tls_ctx = NULL;
2562     tls_in.bits = 0;
2563     tls_in.cipher = NULL;
2564     tls_in.peerdn = NULL;
2565     tls_in.sni = NULL;
2566
2567     return FALSE;
2568
2569   /* Handle genuine errors */
2570   case SSL_ERROR_SSL:
2571     ERR_error_string(ERR_get_error(), ssl_errstring);
2572     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
2573     ssl_xfer_error = TRUE;
2574     return FALSE;
2575
2576   default:
2577     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
2578     DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
2579       debug_printf(" - syscall %s\n", strerror(errno));
2580     ssl_xfer_error = TRUE;
2581     return FALSE;
2582   }
2583
2584 #ifndef DISABLE_DKIM
2585 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
2586 #endif
2587 ssl_xfer_buffer_hwm = inbytes;
2588 ssl_xfer_buffer_lwm = 0;
2589 return TRUE;
2590 }
2591
2592
2593 /*************************************************
2594 *            TLS version of getc                 *
2595 *************************************************/
2596
2597 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
2598 it refills the buffer via the SSL reading function.
2599
2600 Arguments:  lim         Maximum amount to read/buffer
2601 Returns:    the next character or EOF
2602
2603 Only used by the server-side TLS.
2604 */
2605
2606 int
2607 tls_getc(unsigned lim)
2608 {
2609 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
2610   if (!tls_refill(lim))
2611     return ssl_xfer_error ? EOF : smtp_getc(lim);
2612
2613 /* Something in the buffer; return next uschar */
2614
2615 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
2616 }
2617
2618 uschar *
2619 tls_getbuf(unsigned * len)
2620 {
2621 unsigned size;
2622 uschar * buf;
2623
2624 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
2625   if (!tls_refill(*len))
2626     {
2627     if (!ssl_xfer_error) return smtp_getbuf(len);
2628     *len = 0;
2629     return NULL;
2630     }
2631
2632 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
2633   size = *len;
2634 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
2635 ssl_xfer_buffer_lwm += size;
2636 *len = size;
2637 return buf;
2638 }
2639
2640
2641 void
2642 tls_get_cache()
2643 {
2644 #ifndef DISABLE_DKIM
2645 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
2646 if (n > 0)
2647   dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
2648 #endif
2649 }
2650
2651
2652 BOOL
2653 tls_could_read(void)
2654 {
2655 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm || SSL_pending(server_ssl) > 0;
2656 }
2657
2658
2659 /*************************************************
2660 *          Read bytes from TLS channel           *
2661 *************************************************/
2662
2663 /*
2664 Arguments:
2665   ct_ctx    client context pointer, or NULL for the one global server context
2666   buff      buffer of data
2667   len       size of buffer
2668
2669 Returns:    the number of bytes read
2670             -1 after a failed read, including EOF
2671
2672 Only used by the client-side TLS.
2673 */
2674
2675 int
2676 tls_read(void * ct_ctx, uschar *buff, size_t len)
2677 {
2678 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
2679 int inbytes;
2680 int error;
2681
2682 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
2683   buff, (unsigned int)len);
2684
2685 inbytes = SSL_read(ssl, CS buff, len);
2686 error = SSL_get_error(ssl, inbytes);
2687
2688 if (error == SSL_ERROR_ZERO_RETURN)
2689   {
2690   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2691   return -1;
2692   }
2693 else if (error != SSL_ERROR_NONE)
2694   return -1;
2695
2696 return inbytes;
2697 }
2698
2699
2700
2701
2702
2703 /*************************************************
2704 *         Write bytes down TLS channel           *
2705 *************************************************/
2706
2707 /*
2708 Arguments:
2709   ct_ctx    client context pointer, or NULL for the one global server context
2710   buff      buffer of data
2711   len       number of bytes
2712   more      further data expected soon
2713
2714 Returns:    the number of bytes after a successful write,
2715             -1 after a failed write
2716
2717 Used by both server-side and client-side TLS.
2718 */
2719
2720 int
2721 tls_write(void * ct_ctx, const uschar *buff, size_t len, BOOL more)
2722 {
2723 int outbytes, error, left;
2724 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
2725 static gstring * corked = NULL;
2726
2727 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
2728   buff, (unsigned long)len, more ? ", more" : "");
2729
2730 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
2731 "more" is notified.  This hack is only ok if small amounts are involved AND only
2732 one stream does it, in one context (i.e. no store reset).  Currently it is used
2733 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only. */
2734
2735 if (!ct_ctx && (more || corked))
2736   {
2737   corked = string_catn(corked, buff, len);
2738   if (more)
2739     return len;
2740   buff = CUS corked->s;
2741   len = corked->ptr;
2742   corked = NULL;
2743   }
2744
2745 for (left = len; left > 0;)
2746   {
2747   DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
2748   outbytes = SSL_write(ssl, CS buff, left);
2749   error = SSL_get_error(ssl, outbytes);
2750   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
2751   switch (error)
2752     {
2753     case SSL_ERROR_SSL:
2754       ERR_error_string(ERR_get_error(), ssl_errstring);
2755       log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
2756       return -1;
2757
2758     case SSL_ERROR_NONE:
2759       left -= outbytes;
2760       buff += outbytes;
2761       break;
2762
2763     case SSL_ERROR_ZERO_RETURN:
2764       log_write(0, LOG_MAIN, "SSL channel closed on write");
2765       return -1;
2766
2767     case SSL_ERROR_SYSCALL:
2768       log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
2769         sender_fullhost ? sender_fullhost : US"<unknown>",
2770         strerror(errno));
2771       return -1;
2772
2773     default:
2774       log_write(0, LOG_MAIN, "SSL_write error %d", error);
2775       return -1;
2776     }
2777   }
2778 return len;
2779 }
2780
2781
2782
2783 /*************************************************
2784 *         Close down a TLS session               *
2785 *************************************************/
2786
2787 /* This is also called from within a delivery subprocess forked from the
2788 daemon, to shut down the TLS library, without actually doing a shutdown (which
2789 would tamper with the SSL session in the parent process).
2790
2791 Arguments:
2792   ct_ctx        client TLS context pointer, or NULL for the one global server context
2793   shutdown      1 if TLS close-alert is to be sent,
2794                 2 if also response to be waited for
2795
2796 Returns:     nothing
2797
2798 Used by both server-side and client-side TLS.
2799 */
2800
2801 void
2802 tls_close(void * ct_ctx, int shutdown)
2803 {
2804 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
2805 SSL_CTX **ctxp = o_ctx ? &o_ctx->ctx : &server_ctx;
2806 SSL **sslp =     o_ctx ? &o_ctx->ssl : &server_ssl;
2807 int *fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
2808
2809 if (*fdp < 0) return;  /* TLS was not active */
2810
2811 if (shutdown)
2812   {
2813   int rc;
2814   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
2815     shutdown > 1 ? " (with response-wait)" : "");
2816
2817   if (  (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
2818      && shutdown > 1)
2819     {
2820     alarm(2);
2821     rc = SSL_shutdown(*sslp);           /* wait for response */
2822     alarm(0);
2823     }
2824
2825   if (rc < 0) DEBUG(D_tls)
2826     {
2827     ERR_error_string(ERR_get_error(), ssl_errstring);
2828     debug_printf("SSL_shutdown: %s\n", ssl_errstring);
2829     }
2830   }
2831
2832 #ifndef DISABLE_OCSP
2833 if (!o_ctx)             /* server side */
2834   {
2835   sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
2836   server_static_cbinfo->verify_stack = NULL;
2837   }
2838 #endif
2839
2840 SSL_CTX_free(*ctxp);
2841 SSL_free(*sslp);
2842 *ctxp = NULL;
2843 *sslp = NULL;
2844 *fdp = -1;
2845 }
2846
2847
2848
2849
2850 /*************************************************
2851 *  Let tls_require_ciphers be checked at startup *
2852 *************************************************/
2853
2854 /* The tls_require_ciphers option, if set, must be something which the
2855 library can parse.
2856
2857 Returns:     NULL on success, or error message
2858 */
2859
2860 uschar *
2861 tls_validate_require_cipher(void)
2862 {
2863 SSL_CTX *ctx;
2864 uschar *s, *expciphers, *err;
2865
2866 /* this duplicates from tls_init(), we need a better "init just global
2867 state, for no specific purpose" singleton function of our own */
2868
2869 SSL_load_error_strings();
2870 OpenSSL_add_ssl_algorithms();
2871 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
2872 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
2873 list of available digests. */
2874 EVP_add_digest(EVP_sha256());
2875 #endif
2876
2877 if (!(tls_require_ciphers && *tls_require_ciphers))
2878   return NULL;
2879
2880 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
2881                   &err))
2882   return US"failed to expand tls_require_ciphers";
2883
2884 if (!(expciphers && *expciphers))
2885   return NULL;
2886
2887 /* normalisation ripped from above */
2888 s = expciphers;
2889 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
2890
2891 err = NULL;
2892
2893 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
2894 if (!(ctx = SSL_CTX_new(TLS_server_method())))
2895 #else
2896 if (!(ctx = SSL_CTX_new(SSLv23_server_method())))
2897 #endif
2898   {
2899   ERR_error_string(ERR_get_error(), ssl_errstring);
2900   return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
2901   }
2902
2903 DEBUG(D_tls)
2904   debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
2905
2906 if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
2907   {
2908   ERR_error_string(ERR_get_error(), ssl_errstring);
2909   err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
2910                       expciphers, ssl_errstring);
2911   }
2912
2913 SSL_CTX_free(ctx);
2914
2915 return err;
2916 }
2917
2918
2919
2920
2921 /*************************************************
2922 *         Report the library versions.           *
2923 *************************************************/
2924
2925 /* There have historically been some issues with binary compatibility in
2926 OpenSSL libraries; if Exim (like many other applications) is built against
2927 one version of OpenSSL but the run-time linker picks up another version,
2928 it can result in serious failures, including crashing with a SIGSEGV.  So
2929 report the version found by the compiler and the run-time version.
2930
2931 Note: some OS vendors backport security fixes without changing the version
2932 number/string, and the version date remains unchanged.  The _build_ date
2933 will change, so we can more usefully assist with version diagnosis by also
2934 reporting the build date.
2935
2936 Arguments:   a FILE* to print the results to
2937 Returns:     nothing
2938 */
2939
2940 void
2941 tls_version_report(FILE *f)
2942 {
2943 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
2944            "                          Runtime: %s\n"
2945            "                                 : %s\n",
2946            OPENSSL_VERSION_TEXT,
2947            SSLeay_version(SSLEAY_VERSION),
2948            SSLeay_version(SSLEAY_BUILT_ON));
2949 /* third line is 38 characters for the %s and the line is 73 chars long;
2950 the OpenSSL output includes a "built on: " prefix already. */
2951 }
2952
2953
2954
2955
2956 /*************************************************
2957 *            Random number generation            *
2958 *************************************************/
2959
2960 /* Pseudo-random number generation.  The result is not expected to be
2961 cryptographically strong but not so weak that someone will shoot themselves
2962 in the foot using it as a nonce in input in some email header scheme or
2963 whatever weirdness they'll twist this into.  The result should handle fork()
2964 and avoid repeating sequences.  OpenSSL handles that for us.
2965
2966 Arguments:
2967   max       range maximum
2968 Returns     a random number in range [0, max-1]
2969 */
2970
2971 int
2972 vaguely_random_number(int max)
2973 {
2974 unsigned int r;
2975 int i, needed_len;
2976 static pid_t pidlast = 0;
2977 pid_t pidnow;
2978 uschar *p;
2979 uschar smallbuf[sizeof(r)];
2980
2981 if (max <= 1)
2982   return 0;
2983
2984 pidnow = getpid();
2985 if (pidnow != pidlast)
2986   {
2987   /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
2988   is unique for each thread", this doesn't apparently apply across processes,
2989   so our own warning from vaguely_random_number_fallback() applies here too.
2990   Fix per PostgreSQL. */
2991   if (pidlast != 0)
2992     RAND_cleanup();
2993   pidlast = pidnow;
2994   }
2995
2996 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
2997 if (!RAND_status())
2998   {
2999   randstuff r;
3000   gettimeofday(&r.tv, NULL);
3001   r.p = getpid();
3002
3003   RAND_seed(US (&r), sizeof(r));
3004   }
3005 /* We're after pseudo-random, not random; if we still don't have enough data
3006 in the internal PRNG then our options are limited.  We could sleep and hope
3007 for entropy to come along (prayer technique) but if the system is so depleted
3008 in the first place then something is likely to just keep taking it.  Instead,
3009 we'll just take whatever little bit of pseudo-random we can still manage to
3010 get. */
3011
3012 needed_len = sizeof(r);
3013 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
3014 asked for a number less than 10. */
3015 for (r = max, i = 0; r; ++i)
3016   r >>= 1;
3017 i = (i + 7) / 8;
3018 if (i < needed_len)
3019   needed_len = i;
3020
3021 #ifdef EXIM_HAVE_RAND_PSEUDO
3022 /* We do not care if crypto-strong */
3023 i = RAND_pseudo_bytes(smallbuf, needed_len);
3024 #else
3025 i = RAND_bytes(smallbuf, needed_len);
3026 #endif
3027
3028 if (i < 0)
3029   {
3030   DEBUG(D_all)
3031     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
3032   return vaguely_random_number_fallback(max);
3033   }
3034
3035 r = 0;
3036 for (p = smallbuf; needed_len; --needed_len, ++p)
3037   {
3038   r *= 256;
3039   r += *p;
3040   }
3041
3042 /* We don't particularly care about weighted results; if someone wants
3043 smooth distribution and cares enough then they should submit a patch then. */
3044 return r % max;
3045 }
3046
3047
3048
3049
3050 /*************************************************
3051 *        OpenSSL option parse                    *
3052 *************************************************/
3053
3054 /* Parse one option for tls_openssl_options_parse below
3055
3056 Arguments:
3057   name    one option name
3058   value   place to store a value for it
3059 Returns   success or failure in parsing
3060 */
3061
3062 struct exim_openssl_option {
3063   uschar *name;
3064   long    value;
3065 };
3066 /* We could use a macro to expand, but we need the ifdef and not all the
3067 options document which version they were introduced in.  Policylet: include
3068 all options unless explicitly for DTLS, let the administrator choose which
3069 to apply.
3070
3071 This list is current as of:
3072   ==>  1.0.1b  <==
3073 Plus SSL_OP_SAFARI_ECDHE_ECDSA_BUG from 2013-June patch/discussion on openssl-dev
3074 */
3075 static struct exim_openssl_option exim_openssl_options[] = {
3076 /* KEEP SORTED ALPHABETICALLY! */
3077 #ifdef SSL_OP_ALL
3078   { US"all", SSL_OP_ALL },
3079 #endif
3080 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
3081   { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
3082 #endif
3083 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
3084   { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
3085 #endif
3086 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
3087   { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
3088 #endif
3089 #ifdef SSL_OP_EPHEMERAL_RSA
3090   { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
3091 #endif
3092 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
3093   { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
3094 #endif
3095 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
3096   { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
3097 #endif
3098 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
3099   { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
3100 #endif
3101 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
3102   { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
3103 #endif
3104 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
3105   { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
3106 #endif
3107 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
3108   { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
3109 #endif
3110 #ifdef SSL_OP_NO_COMPRESSION
3111   { US"no_compression", SSL_OP_NO_COMPRESSION },
3112 #endif
3113 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
3114   { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
3115 #endif
3116 #ifdef SSL_OP_NO_SSLv2
3117   { US"no_sslv2", SSL_OP_NO_SSLv2 },
3118 #endif
3119 #ifdef SSL_OP_NO_SSLv3
3120   { US"no_sslv3", SSL_OP_NO_SSLv3 },
3121 #endif
3122 #ifdef SSL_OP_NO_TICKET
3123   { US"no_ticket", SSL_OP_NO_TICKET },
3124 #endif
3125 #ifdef SSL_OP_NO_TLSv1
3126   { US"no_tlsv1", SSL_OP_NO_TLSv1 },
3127 #endif
3128 #ifdef SSL_OP_NO_TLSv1_1
3129 #if SSL_OP_NO_TLSv1_1 == 0x00000400L
3130   /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
3131 #warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
3132 #else
3133   { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
3134 #endif
3135 #endif
3136 #ifdef SSL_OP_NO_TLSv1_2
3137   { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
3138 #endif
3139 #ifdef SSL_OP_SAFARI_ECDHE_ECDSA_BUG
3140   { US"safari_ecdhe_ecdsa_bug", SSL_OP_SAFARI_ECDHE_ECDSA_BUG },
3141 #endif
3142 #ifdef SSL_OP_SINGLE_DH_USE
3143   { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
3144 #endif
3145 #ifdef SSL_OP_SINGLE_ECDH_USE
3146   { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
3147 #endif
3148 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
3149   { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
3150 #endif
3151 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
3152   { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
3153 #endif
3154 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
3155   { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
3156 #endif
3157 #ifdef SSL_OP_TLS_D5_BUG
3158   { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
3159 #endif
3160 #ifdef SSL_OP_TLS_ROLLBACK_BUG
3161   { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
3162 #endif
3163 };
3164 static int exim_openssl_options_size =
3165   sizeof(exim_openssl_options)/sizeof(struct exim_openssl_option);
3166
3167
3168 static BOOL
3169 tls_openssl_one_option_parse(uschar *name, long *value)
3170 {
3171 int first = 0;
3172 int last = exim_openssl_options_size;
3173 while (last > first)
3174   {
3175   int middle = (first + last)/2;
3176   int c = Ustrcmp(name, exim_openssl_options[middle].name);
3177   if (c == 0)
3178     {
3179     *value = exim_openssl_options[middle].value;
3180     return TRUE;
3181     }
3182   else if (c > 0)
3183     first = middle + 1;
3184   else
3185     last = middle;
3186   }
3187 return FALSE;
3188 }
3189
3190
3191
3192
3193 /*************************************************
3194 *        OpenSSL option parsing logic            *
3195 *************************************************/
3196
3197 /* OpenSSL has a number of compatibility options which an administrator might
3198 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
3199 we look like log_selector.
3200
3201 Arguments:
3202   option_spec  the administrator-supplied string of options
3203   results      ptr to long storage for the options bitmap
3204 Returns        success or failure
3205 */
3206
3207 BOOL
3208 tls_openssl_options_parse(uschar *option_spec, long *results)
3209 {
3210 long result, item;
3211 uschar *s, *end;
3212 uschar keep_c;
3213 BOOL adding, item_parsed;
3214
3215 result = SSL_OP_NO_TICKET;
3216 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
3217  * from default because it increases BEAST susceptibility. */
3218 #ifdef SSL_OP_NO_SSLv2
3219 result |= SSL_OP_NO_SSLv2;
3220 #endif
3221 #ifdef SSL_OP_SINGLE_DH_USE
3222 result |= SSL_OP_SINGLE_DH_USE;
3223 #endif
3224
3225 if (!option_spec)
3226   {
3227   *results = result;
3228   return TRUE;
3229   }
3230
3231 for (s=option_spec; *s != '\0'; /**/)
3232   {
3233   while (isspace(*s)) ++s;
3234   if (*s == '\0')
3235     break;
3236   if (*s != '+' && *s != '-')
3237     {
3238     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
3239         "+ or - expected but found \"%s\"\n", s);
3240     return FALSE;
3241     }
3242   adding = *s++ == '+';
3243   for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
3244   keep_c = *end;
3245   *end = '\0';
3246   item_parsed = tls_openssl_one_option_parse(s, &item);
3247   *end = keep_c;
3248   if (!item_parsed)
3249     {
3250     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
3251     return FALSE;
3252     }
3253   DEBUG(D_tls) debug_printf("openssl option, %s from %lx: %lx (%s)\n",
3254       adding ? "adding" : "removing", result, item, s);
3255   if (adding)
3256     result |= item;
3257   else
3258     result &= ~item;
3259   s = end;
3260   }
3261
3262 *results = result;
3263 return TRUE;
3264 }
3265
3266 /* vi: aw ai sw=2
3267 */
3268 /* End of tls-openssl.c */