src/src/tls-openssl.c

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