src/src/tls-openssl.c

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