src/src/tls-openssl.c

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