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