src/src/tls-openssl.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2019 */
   6 /* Copyright (c) The Exim Maintainers 2020 */
   7 /* See the file NOTICE for conditions of use and distribution. */
   8
   9 /* Portions Copyright (c) The OpenSSL Project 1999 */
  10
  11 /* This module provides the TLS (aka SSL) support for Exim using the OpenSSL
  12 library. It is #included into the tls.c file when that library is used. The
  13 code herein is based on a patch that was originally contributed by Steve
  14 Haslam. It was adapted from stunnel, a GPL program by Michal Trojnara.
  15
  16 No cryptographic code is included in Exim. All this module does is to call
  17 functions from the OpenSSL library. */
  18
  19
  20 /* Heading stuff */
  21
  22 #include <openssl/lhash.h>
  23 #include <openssl/ssl.h>
  24 #include <openssl/err.h>
  25 #include <openssl/rand.h>
  26 #ifndef OPENSSL_NO_ECDH
  27 # include <openssl/ec.h>
  28 #endif
  29 #ifndef DISABLE_OCSP
  30 # include <openssl/ocsp.h>
  31 #endif
  32 #ifdef SUPPORT_DANE
  33 # include "danessl.h"
  34 #endif
  35
  36
  37 #ifndef DISABLE_OCSP
  38 # define EXIM_OCSP_SKEW_SECONDS (300L)
  39 # define EXIM_OCSP_MAX_AGE (-1L)
  40 #endif
  41
  42 #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
  43 # define EXIM_HAVE_OPENSSL_TLSEXT
  44 #endif
  45 #if OPENSSL_VERSION_NUMBER >= 0x00908000L
  46 # define EXIM_HAVE_RSA_GENKEY_EX
  47 #endif
  48 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
  49 # define EXIM_HAVE_OCSP_RESP_COUNT
  50 # define OPENSSL_AUTO_SHA256
  51 #else
  52 # define EXIM_HAVE_EPHEM_RSA_KEX
  53 # define EXIM_HAVE_RAND_PSEUDO
  54 #endif
  55 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
  56 # define EXIM_HAVE_SHA256
  57 #endif
  58
  59 /* X509_check_host provides sane certificate hostname checking, but was added
  60 to OpenSSL late, after other projects forked off the code-base.  So in
  61 addition to guarding against the base version number, beware that LibreSSL
  62 does not (at this time) support this function.
  63
  64 If LibreSSL gains a different API, perhaps via libtls, then we'll probably
  65 opt to disentangle and ask a LibreSSL user to provide glue for a third
  66 crypto provider for libtls instead of continuing to tie the OpenSSL glue
  67 into even twistier knots.  If LibreSSL gains the same API, we can just
  68 change this guard and punt the issue for a while longer. */
  69
  70 #ifndef LIBRESSL_VERSION_NUMBER
  71 # if OPENSSL_VERSION_NUMBER >= 0x010100000L
  72 #  define EXIM_HAVE_OPENSSL_CHECKHOST
  73 #  define EXIM_HAVE_OPENSSL_DH_BITS
  74 #  define EXIM_HAVE_OPENSSL_TLS_METHOD
  75 #  define EXIM_HAVE_OPENSSL_KEYLOG
  76 #  define EXIM_HAVE_OPENSSL_CIPHER_GET_ID
  77 #  define EXIM_HAVE_SESSION_TICKET
  78 #  define EXIM_HAVE_OPESSL_TRACE
  79 #  define EXIM_HAVE_OPESSL_GET0_SERIAL
  80 #  ifndef DISABLE_OCSP
  81 #   define EXIM_HAVE_OCSP
  82 #  endif
  83 # else
  84 #  define EXIM_NEED_OPENSSL_INIT
  85 # endif
  86 # if OPENSSL_VERSION_NUMBER >= 0x010000000L \
  87     && (OPENSSL_VERSION_NUMBER & 0x0000ff000L) >= 0x000002000L
  88 #  define EXIM_HAVE_OPENSSL_CHECKHOST
  89 # endif
  90 #endif
  91
  92 #if !defined(LIBRESSL_VERSION_NUMBER) \
  93     || LIBRESSL_VERSION_NUMBER >= 0x20010000L
  94 # if !defined(OPENSSL_NO_ECDH)
  95 #  if OPENSSL_VERSION_NUMBER >= 0x0090800fL
  96 #   define EXIM_HAVE_ECDH
  97 #  endif
  98 #  if OPENSSL_VERSION_NUMBER >= 0x10002000L
  99 #   define EXIM_HAVE_OPENSSL_EC_NIST2NID
 100 #  endif
 101 # endif
 102 #endif
 103
 104 #ifndef LIBRESSL_VERSION_NUMBER
 105 # if OPENSSL_VERSION_NUMBER >= 0x010101000L
 106 #  define OPENSSL_HAVE_KEYLOG_CB
 107 #  define OPENSSL_HAVE_NUM_TICKETS
 108 #  define EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
 109 # else
 110 #  define OPENSSL_BAD_SRVR_OURCERT
 111 # endif
 112 #endif
 113
 114 #if !defined(EXIM_HAVE_OPENSSL_TLSEXT) && !defined(DISABLE_OCSP)
 115 # warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
 116 # define DISABLE_OCSP
 117 #endif
 118
 119 #ifndef DISABLE_TLS_RESUME
 120 # if OPENSSL_VERSION_NUMBER < 0x0101010L
 121 #  error OpenSSL version too old for session-resumption
 122 # endif
 123 #endif
 124
 125 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
 126 # include <openssl/x509v3.h>
 127 #endif
 128
 129 #ifndef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
 130 # ifndef EXIM_HAVE_OPENSSL_CIPHER_GET_ID
 131 #  define SSL_CIPHER_get_id(c) (c->id)
 132 # endif
 133 # ifndef MACRO_PREDEF
 134 #  include "tls-cipher-stdname.c"
 135 # endif
 136 #endif
 137
 138 /*************************************************
 139 *        OpenSSL option parse                    *
 140 *************************************************/
 141
 142 typedef struct exim_openssl_option {
 143   uschar *name;
 144   long    value;
 145 } exim_openssl_option;
 146 /* We could use a macro to expand, but we need the ifdef and not all the
 147 options document which version they were introduced in.  Policylet: include
 148 all options unless explicitly for DTLS, let the administrator choose which
 149 to apply.
 150
 151 This list is current as of:
 152   ==>  1.1.1c  <==
 153
 154 XXX could we autobuild this list, as with predefined-macros?
 155 Seems just parsing ssl.h for SSL_OP_.* would be enough (except to exclude DTLS).
 156 Also allow a numeric literal?
 157 */
 158 static exim_openssl_option exim_openssl_options[] = {
 159 /* KEEP SORTED ALPHABETICALLY! */
 160 #ifdef SSL_OP_ALL
 161   { US"all", (long) SSL_OP_ALL },
 162 #endif
 163 #ifdef SSL_OP_ALLOW_NO_DHE_KEX
 164   { US"allow_no_dhe_kex", SSL_OP_ALLOW_NO_DHE_KEX },
 165 #endif
 166 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
 167   { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
 168 #endif
 169 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
 170   { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
 171 #endif
 172 #ifdef SSL_OP_CRYPTOPRO_TLSEXT_BUG
 173   { US"cryptopro_tlsext_bug", SSL_OP_CRYPTOPRO_TLSEXT_BUG },
 174 #endif
 175 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
 176   { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
 177 #endif
 178 #ifdef SSL_OP_ENABLE_MIDDLEBOX_COMPAT
 179   { US"enable_middlebox_compat", SSL_OP_ENABLE_MIDDLEBOX_COMPAT },
 180 #endif
 181 #ifdef SSL_OP_EPHEMERAL_RSA
 182   { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
 183 #endif
 184 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
 185   { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
 186 #endif
 187 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
 188   { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
 189 #endif
 190 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
 191   { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
 192 #endif
 193 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
 194   { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
 195 #endif
 196 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
 197   { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
 198 #endif
 199 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
 200   { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
 201 #endif
 202 #ifdef SSL_OP_NO_ANTI_REPLAY
 203   { US"no_anti_replay", SSL_OP_NO_ANTI_REPLAY },
 204 #endif
 205 #ifdef SSL_OP_NO_COMPRESSION
 206   { US"no_compression", SSL_OP_NO_COMPRESSION },
 207 #endif
 208 #ifdef SSL_OP_NO_ENCRYPT_THEN_MAC
 209   { US"no_encrypt_then_mac", SSL_OP_NO_ENCRYPT_THEN_MAC },
 210 #endif
 211 #ifdef SSL_OP_NO_RENEGOTIATION
 212   { US"no_renegotiation", SSL_OP_NO_RENEGOTIATION },
 213 #endif
 214 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
 215   { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
 216 #endif
 217 #ifdef SSL_OP_NO_SSLv2
 218   { US"no_sslv2", SSL_OP_NO_SSLv2 },
 219 #endif
 220 #ifdef SSL_OP_NO_SSLv3
 221   { US"no_sslv3", SSL_OP_NO_SSLv3 },
 222 #endif
 223 #ifdef SSL_OP_NO_TICKET
 224   { US"no_ticket", SSL_OP_NO_TICKET },
 225 #endif
 226 #ifdef SSL_OP_NO_TLSv1
 227   { US"no_tlsv1", SSL_OP_NO_TLSv1 },
 228 #endif
 229 #ifdef SSL_OP_NO_TLSv1_1
 230 #if SSL_OP_NO_TLSv1_1 == 0x00000400L
 231   /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
 232 #warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
 233 #else
 234   { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
 235 #endif
 236 #endif
 237 #ifdef SSL_OP_NO_TLSv1_2
 238   { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
 239 #endif
 240 #ifdef SSL_OP_NO_TLSv1_3
 241   { US"no_tlsv1_3", SSL_OP_NO_TLSv1_3 },
 242 #endif
 243 #ifdef SSL_OP_PRIORITIZE_CHACHA
 244   { US"prioritize_chacha", SSL_OP_PRIORITIZE_CHACHA },
 245 #endif
 246 #ifdef SSL_OP_SAFARI_ECDHE_ECDSA_BUG
 247   { US"safari_ecdhe_ecdsa_bug", SSL_OP_SAFARI_ECDHE_ECDSA_BUG },
 248 #endif
 249 #ifdef SSL_OP_SINGLE_DH_USE
 250   { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
 251 #endif
 252 #ifdef SSL_OP_SINGLE_ECDH_USE
 253   { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
 254 #endif
 255 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
 256   { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
 257 #endif
 258 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
 259   { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
 260 #endif
 261 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
 262   { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
 263 #endif
 264 #ifdef SSL_OP_TLS_D5_BUG
 265   { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
 266 #endif
 267 #ifdef SSL_OP_TLS_ROLLBACK_BUG
 268   { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
 269 #endif
 270 #ifdef SSL_OP_TLSEXT_PADDING
 271   { US"tlsext_padding", SSL_OP_TLSEXT_PADDING },
 272 #endif
 273 };
 274
 275 #ifndef MACRO_PREDEF
 276 static int exim_openssl_options_size = nelem(exim_openssl_options);
 277 static long init_options = 0;
 278 #endif
 279
 280 #ifdef MACRO_PREDEF
 281 void
 282 options_tls(void)
 283 {
 284 uschar buf[64];
 285
 286 for (struct exim_openssl_option * o = exim_openssl_options;
 287      o < exim_openssl_options + nelem(exim_openssl_options); o++)
 288   {
 289   /* Trailing X is workaround for problem with _OPT_OPENSSL_NO_TLSV1
 290   being a ".ifdef _OPT_OPENSSL_NO_TLSV1_3" match */
 291
 292   spf(buf, sizeof(buf), US"_OPT_OPENSSL_%T_X", o->name);
 293   builtin_macro_create(buf);
 294   }
 295
 296 # ifndef DISABLE_TLS_RESUME
 297 builtin_macro_create_var(US"_RESUME_DECODE", RESUME_DECODE_STRING );
 298 # endif
 299 # ifdef SSL_OP_NO_TLSv1_3
 300 builtin_macro_create(US"_HAVE_TLS1_3");
 301 # endif
 302 # ifdef OPENSSL_BAD_SRVR_OURCERT
 303 builtin_macro_create(US"_TLS_BAD_MULTICERT_IN_OURCERT");
 304 # endif
 305 # ifdef EXIM_HAVE_OCSP
 306 builtin_macro_create(US"_HAVE_TLS_OCSP");
 307 builtin_macro_create(US"_HAVE_TLS_OCSP_LIST");
 308 # endif
 309 }
 310 #else
 311
 312 /******************************************************************************/
 313
 314 /* Structure for collecting random data for seeding. */
 315
 316 typedef struct randstuff {
 317   struct timeval tv;
 318   pid_t          p;
 319 } randstuff;
 320
 321 /* Local static variables */
 322
 323 static BOOL client_verify_callback_called = FALSE;
 324 static BOOL server_verify_callback_called = FALSE;
 325 static const uschar *sid_ctx = US"exim";
 326
 327 /* We have three different contexts to care about.
 328
 329 Simple case: client, `client_ctx`
 330  As a client, we can be doing a callout or cut-through delivery while receiving
 331  a message.  So we have a client context, which should have options initialised
 332  from the SMTP Transport.  We may also concurrently want to make TLS connections
 333  to utility daemons, so client-contexts are allocated and passed around in call
 334  args rather than using a gobal.
 335
 336 Server:
 337  There are two cases: with and without ServerNameIndication from the client.
 338  Given TLS SNI, we can be using different keys, certs and various other
 339  configuration settings, because they're re-expanded with $tls_sni set.  This
 340  allows vhosting with TLS.  This SNI is sent in the handshake.
 341  A client might not send SNI, so we need a fallback, and an initial setup too.
 342  So as a server, we start out using `server_ctx`.
 343  If SNI is sent by the client, then we as server, mid-negotiation, try to clone
 344  `server_sni` from `server_ctx` and then initialise settings by re-expanding
 345  configuration.
 346 */
 347
 348 typedef struct {
 349   SSL_CTX *     ctx;
 350   SSL *         ssl;
 351   gstring *     corked;
 352 } exim_openssl_client_tls_ctx;
 353
 354
 355 /* static SSL_CTX *server_ctx = NULL; */
 356 /* static SSL     *server_ssl = NULL; */
 357
 358 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
 359 static SSL_CTX *server_sni = NULL;
 360 #endif
 361
 362 static char ssl_errstring[256];
 363
 364 static int  ssl_session_timeout = 7200;         /* Two hours */
 365 static BOOL client_verify_optional = FALSE;
 366 static BOOL server_verify_optional = FALSE;
 367
 368 static BOOL reexpand_tls_files_for_sni = FALSE;
 369
 370
 371 typedef struct ocsp_resp {
 372   struct ocsp_resp *    next;
 373   OCSP_RESPONSE *       resp;
 374 } ocsp_resplist;
 375
 376 typedef struct exim_openssl_state {
 377   exim_tlslib_state     lib_state;
 378 #define lib_ctx                 libdata0
 379 #define lib_ssl                 libdata1
 380
 381   tls_support * tlsp;
 382   uschar *      certificate;
 383   uschar *      privatekey;
 384   BOOL          is_server;
 385 #ifndef DISABLE_OCSP
 386   STACK_OF(X509) *verify_stack;         /* chain for verifying the proof */
 387   union {
 388     struct {
 389       uschar        *file;
 390       const uschar  *file_expanded;
 391       ocsp_resplist *olist;
 392     } server;
 393     struct {
 394       X509_STORE    *verify_store;      /* non-null if status requested */
 395       BOOL          verify_required;
 396     } client;
 397   } u_ocsp;
 398 #endif
 399   uschar *      dhparam;
 400   /* these are cached from first expand */
 401   uschar *      server_cipher_list;
 402   /* only passed down to tls_error: */
 403   host_item *   host;
 404   const uschar * verify_cert_hostnames;
 405 #ifndef DISABLE_EVENT
 406   uschar *      event_action;
 407 #endif
 408 } exim_openssl_state_st;
 409
 410 /* should figure out a cleanup of API to handle state preserved per
 411 implementation, for various reasons, which can be void * in the APIs.
 412 For now, we hack around it. */
 413 exim_openssl_state_st *client_static_state = NULL;      /*XXX should not use static; multiple concurrent clients! */
 414 exim_openssl_state_st state_server = {.is_server = TRUE};
 415
 416 static int
 417 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host,
 418     uschar ** errstr );
 419
 420 /* Callbacks */
 421 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
 422 static int tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg);
 423 #endif
 424 #ifndef DISABLE_OCSP
 425 static int tls_server_stapling_cb(SSL *s, void *arg);
 426 #endif
 427
 428
 429
 430 /* Daemon-called, before every connection, key create/rotate */
 431 #ifndef DISABLE_TLS_RESUME
 432 static void tk_init(void);
 433 static int tls_exdata_idx = -1;
 434 #endif
 435
 436 static void
 437 tls_per_lib_daemon_tick(void)
 438 {
 439 #ifndef DISABLE_TLS_RESUME
 440 tk_init();
 441 #endif
 442 }
 443
 444 /* Called once at daemon startup */
 445
 446 static void
 447 tls_per_lib_daemon_init(void)
 448 {
 449 tls_daemon_creds_reload();
 450 }
 451
 452
 453 /*************************************************
 454 *               Handle TLS error                 *
 455 *************************************************/
 456
 457 /* Called from lots of places when errors occur before actually starting to do
 458 the TLS handshake, that is, while the session is still in clear. Always returns
 459 DEFER for a server and FAIL for a client so that most calls can use "return
 460 tls_error(...)" to do this processing and then give an appropriate return. A
 461 single function is used for both server and client, because it is called from
 462 some shared functions.
 463
 464 Argument:
 465   prefix    text to include in the logged error
 466   host      NULL if setting up a server;
 467             the connected host if setting up a client
 468   msg       error message or NULL if we should ask OpenSSL
 469   errstr    pointer to output error message
 470
 471 Returns:    OK/DEFER/FAIL
 472 */
 473
 474 static int
 475 tls_error(uschar * prefix, const host_item * host, uschar * msg, uschar ** errstr)
 476 {
 477 if (!msg)
 478   {
 479   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
 480   msg = US ssl_errstring;
 481   }
 482
 483 msg = string_sprintf("(%s): %s", prefix, msg);
 484 DEBUG(D_tls) debug_printf("TLS error '%s'\n", msg);
 485 if (errstr) *errstr = msg;
 486 return host ? FAIL : DEFER;
 487 }
 488
 489
 490
 491 /**************************************************
 492 * General library initalisation                   *
 493 **************************************************/
 494
 495 static BOOL
 496 lib_rand_init(void * addr)
 497 {
 498 randstuff r;
 499 if (!RAND_status()) return TRUE;
 500
 501 gettimeofday(&r.tv, NULL);
 502 r.p = getpid();
 503 RAND_seed(US (&r), sizeof(r));
 504 RAND_seed(US big_buffer, big_buffer_size);
 505 if (addr) RAND_seed(US addr, sizeof(addr));
 506
 507 return RAND_status();
 508 }
 509
 510
 511 static void
 512 tls_openssl_init(void)
 513 {
 514 static BOOL once = FALSE;
 515 if (once) return;
 516 once = TRUE;
 517
 518 #ifdef EXIM_NEED_OPENSSL_INIT
 519 SSL_load_error_strings();          /* basic set up */
 520 OpenSSL_add_ssl_algorithms();
 521 #endif
 522
 523 #if defined(EXIM_HAVE_SHA256) && !defined(OPENSSL_AUTO_SHA256)
 524 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
 525 list of available digests. */
 526 EVP_add_digest(EVP_sha256());
 527 #endif
 528
 529 (void) lib_rand_init(NULL);
 530 (void) tls_openssl_options_parse(openssl_options, &init_options);
 531 }
 532
 533
 534
 535 /*************************************************
 536 *                Initialize for DH               *
 537 *************************************************/
 538
 539 /* If dhparam is set, expand it, and load up the parameters for DH encryption.
 540
 541 Arguments:
 542   sctx      The current SSL CTX (inbound or outbound)
 543   dhparam   DH parameter file or fixed parameter identity string
 544   host      connected host, if client; NULL if server
 545   errstr    error string pointer
 546
 547 Returns:    TRUE if OK (nothing to set up, or setup worked)
 548 */
 549
 550 static BOOL
 551 init_dh(SSL_CTX *sctx, uschar *dhparam, const host_item *host, uschar ** errstr)
 552 {
 553 BIO *bio;
 554 DH *dh;
 555 uschar *dhexpanded;
 556 const char *pem;
 557 int dh_bitsize;
 558
 559 if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded, errstr))
 560   return FALSE;
 561
 562 if (!dhexpanded || !*dhexpanded)
 563   bio = BIO_new_mem_buf(CS std_dh_prime_default(), -1);
 564 else if (dhexpanded[0] == '/')
 565   {
 566   if (!(bio = BIO_new_file(CS dhexpanded, "r")))
 567     {
 568     tls_error(string_sprintf("could not read dhparams file %s", dhexpanded),
 569           host, US strerror(errno), errstr);
 570     return FALSE;
 571     }
 572   }
 573 else
 574   {
 575   if (Ustrcmp(dhexpanded, "none") == 0)
 576     {
 577     DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
 578     return TRUE;
 579     }
 580
 581   if (!(pem = std_dh_prime_named(dhexpanded)))
 582     {
 583     tls_error(string_sprintf("Unknown standard DH prime \"%s\"", dhexpanded),
 584         host, US strerror(errno), errstr);
 585     return FALSE;
 586     }
 587   bio = BIO_new_mem_buf(CS pem, -1);
 588   }
 589
 590 if (!(dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL)))
 591   {
 592   BIO_free(bio);
 593   tls_error(string_sprintf("Could not read tls_dhparams \"%s\"", dhexpanded),
 594       host, NULL, errstr);
 595   return FALSE;
 596   }
 597
 598 /* note: our default limit of 2236 is not a multiple of 8; the limit comes from
 599  * an NSS limit, and the GnuTLS APIs handle bit-sizes fine, so we went with
 600  * 2236.  But older OpenSSL can only report in bytes (octets), not bits.
 601  * If someone wants to dance at the edge, then they can raise the limit or use
 602  * current libraries. */
 603 #ifdef EXIM_HAVE_OPENSSL_DH_BITS
 604 /* Added in commit 26c79d5641d; `git describe --contains` says OpenSSL_1_1_0-pre1~1022
 605  * This predates OpenSSL_1_1_0 (before a, b, ...) so is in all 1.1.0 */
 606 dh_bitsize = DH_bits(dh);
 607 #else
 608 dh_bitsize = 8 * DH_size(dh);
 609 #endif
 610
 611 /* Even if it is larger, we silently return success rather than cause things
 612  * to fail out, so that a too-large DH will not knock out all TLS; it's a
 613  * debatable choice. */
 614 if (dh_bitsize > tls_dh_max_bits)
 615   {
 616   DEBUG(D_tls)
 617     debug_printf("dhparams file %d bits, is > tls_dh_max_bits limit of %d\n",
 618         dh_bitsize, tls_dh_max_bits);
 619   }
 620 else
 621   {
 622   SSL_CTX_set_tmp_dh(sctx, dh);
 623   DEBUG(D_tls)
 624     debug_printf("Diffie-Hellman initialized from %s with %d-bit prime\n",
 625       dhexpanded ? dhexpanded : US"default", dh_bitsize);
 626   }
 627
 628 DH_free(dh);
 629 BIO_free(bio);
 630
 631 return TRUE;
 632 }
 633
 634
 635
 636
 637 /*************************************************
 638 *               Initialize for ECDH              *
 639 *************************************************/
 640
 641 /* Load parameters for ECDH encryption.
 642
 643 For now, we stick to NIST P-256 because: it's simple and easy to configure;
 644 it avoids any patent issues that might bite redistributors; despite events in
 645 the news and concerns over curve choices, we're not cryptographers, we're not
 646 pretending to be, and this is "good enough" to be better than no support,
 647 protecting against most adversaries.  Given another year or two, there might
 648 be sufficient clarity about a "right" way forward to let us make an informed
 649 decision, instead of a knee-jerk reaction.
 650
 651 Longer-term, we should look at supporting both various named curves and
 652 external files generated with "openssl ecparam", much as we do for init_dh().
 653 We should also support "none" as a value, to explicitly avoid initialisation.
 654
 655 Patches welcome.
 656
 657 Arguments:
 658   sctx      The current SSL CTX (inbound or outbound)
 659   host      connected host, if client; NULL if server
 660   errstr    error string pointer
 661
 662 Returns:    TRUE if OK (nothing to set up, or setup worked)
 663 */
 664
 665 static BOOL
 666 init_ecdh(SSL_CTX * sctx, host_item * host, uschar ** errstr)
 667 {
 668 #ifdef OPENSSL_NO_ECDH
 669 return TRUE;
 670 #else
 671
 672 EC_KEY * ecdh;
 673 uschar * exp_curve;
 674 int nid;
 675 BOOL rv;
 676
 677 if (host)       /* No ECDH setup for clients, only for servers */
 678   return TRUE;
 679
 680 # ifndef EXIM_HAVE_ECDH
 681 DEBUG(D_tls)
 682   debug_printf("No OpenSSL API to define ECDH parameters, skipping\n");
 683 return TRUE;
 684 # else
 685
 686 if (!expand_check(tls_eccurve, US"tls_eccurve", &exp_curve, errstr))
 687   return FALSE;
 688 if (!exp_curve || !*exp_curve)
 689   return TRUE;
 690
 691 /* "auto" needs to be handled carefully.
 692  * OpenSSL <  1.0.2: we do not select anything, but fallback to prime256v1
 693  * OpenSSL <  1.1.0: we have to call SSL_CTX_set_ecdh_auto
 694  *                   (openssl/ssl.h defines SSL_CTRL_SET_ECDH_AUTO)
 695  * OpenSSL >= 1.1.0: we do not set anything, the libray does autoselection
 696  *                   https://github.com/openssl/openssl/commit/fe6ef2472db933f01b59cad82aa925736935984b
 697  */
 698 if (Ustrcmp(exp_curve, "auto") == 0)
 699   {
 700 #if OPENSSL_VERSION_NUMBER < 0x10002000L
 701   DEBUG(D_tls) debug_printf(
 702     "ECDH OpenSSL < 1.0.2: temp key parameter settings: overriding \"auto\" with \"prime256v1\"\n");
 703   exp_curve = US"prime256v1";
 704 #else
 705 # if defined SSL_CTRL_SET_ECDH_AUTO
 706   DEBUG(D_tls) debug_printf(
 707     "ECDH OpenSSL 1.0.2+: temp key parameter settings: autoselection\n");
 708   SSL_CTX_set_ecdh_auto(sctx, 1);
 709   return TRUE;
 710 # else
 711   DEBUG(D_tls) debug_printf(
 712     "ECDH OpenSSL 1.1.0+: temp key parameter settings: default selection\n");
 713   return TRUE;
 714 # endif
 715 #endif
 716   }
 717
 718 DEBUG(D_tls) debug_printf("ECDH: curve '%s'\n", exp_curve);
 719 if (  (nid = OBJ_sn2nid       (CCS exp_curve)) == NID_undef
 720 #   ifdef EXIM_HAVE_OPENSSL_EC_NIST2NID
 721    && (nid = EC_curve_nist2nid(CCS exp_curve)) == NID_undef
 722 #   endif
 723    )
 724   {
 725   tls_error(string_sprintf("Unknown curve name tls_eccurve '%s'", exp_curve),
 726     host, NULL, errstr);
 727   return FALSE;
 728   }
 729
 730 if (!(ecdh = EC_KEY_new_by_curve_name(nid)))
 731   {
 732   tls_error(US"Unable to create ec curve", host, NULL, errstr);
 733   return FALSE;
 734   }
 735
 736 /* The "tmp" in the name here refers to setting a temporary key
 737 not to the stability of the interface. */
 738
 739 if ((rv = SSL_CTX_set_tmp_ecdh(sctx, ecdh) == 0))
 740   tls_error(string_sprintf("Error enabling '%s' curve", exp_curve), host, NULL, errstr);
 741 else
 742   DEBUG(D_tls) debug_printf("ECDH: enabled '%s' curve\n", exp_curve);
 743
 744 EC_KEY_free(ecdh);
 745 return !rv;
 746
 747 # endif /*EXIM_HAVE_ECDH*/
 748 #endif /*OPENSSL_NO_ECDH*/
 749 }
 750
 751
 752
 753 /*************************************************
 754 *        Expand key and cert file specs          *
 755 *************************************************/
 756
 757 /*
 758 Arguments:
 759   s          SSL connection (not used)
 760   export     not used
 761   keylength  keylength
 762
 763 Returns:     pointer to generated key
 764 */
 765
 766 static RSA *
 767 rsa_callback(SSL *s, int export, int keylength)
 768 {
 769 RSA *rsa_key;
 770 #ifdef EXIM_HAVE_RSA_GENKEY_EX
 771 BIGNUM *bn = BN_new();
 772 #endif
 773
 774 DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
 775
 776 #ifdef EXIM_HAVE_RSA_GENKEY_EX
 777 if (  !BN_set_word(bn, (unsigned long)RSA_F4)
 778    || !(rsa_key = RSA_new())
 779    || !RSA_generate_key_ex(rsa_key, keylength, bn, NULL)
 780    )
 781 #else
 782 if (!(rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL)))
 783 #endif
 784
 785   {
 786   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
 787   log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
 788     ssl_errstring);
 789   return NULL;
 790   }
 791 return rsa_key;
 792 }
 793
 794
 795
 796 /* Create and install a selfsigned certificate, for use in server mode */
 797
 798 static int
 799 tls_install_selfsign(SSL_CTX * sctx, uschar ** errstr)
 800 {
 801 X509 * x509 = NULL;
 802 EVP_PKEY * pkey;
 803 RSA * rsa;
 804 X509_NAME * name;
 805 uschar * where;
 806
 807 where = US"allocating pkey";
 808 if (!(pkey = EVP_PKEY_new()))
 809   goto err;
 810
 811 where = US"allocating cert";
 812 if (!(x509 = X509_new()))
 813   goto err;
 814
 815 where = US"generating pkey";
 816 if (!(rsa = rsa_callback(NULL, 0, 2048)))
 817   goto err;
 818
 819 where = US"assigning pkey";
 820 if (!EVP_PKEY_assign_RSA(pkey, rsa))
 821   goto err;
 822
 823 X509_set_version(x509, 2);                              /* N+1 - version 3 */
 824 ASN1_INTEGER_set(X509_get_serialNumber(x509), 1);
 825 X509_gmtime_adj(X509_get_notBefore(x509), 0);
 826 X509_gmtime_adj(X509_get_notAfter(x509), (long)60 * 60);        /* 1 hour */
 827 X509_set_pubkey(x509, pkey);
 828
 829 name = X509_get_subject_name(x509);
 830 X509_NAME_add_entry_by_txt(name, "C",
 831                           MBSTRING_ASC, CUS "UK", -1, -1, 0);
 832 X509_NAME_add_entry_by_txt(name, "O",
 833                           MBSTRING_ASC, CUS "Exim Developers", -1, -1, 0);
 834 X509_NAME_add_entry_by_txt(name, "CN",
 835                           MBSTRING_ASC, CUS smtp_active_hostname, -1, -1, 0);
 836 X509_set_issuer_name(x509, name);
 837
 838 where = US"signing cert";
 839 if (!X509_sign(x509, pkey, EVP_md5()))
 840   goto err;
 841
 842 where = US"installing selfsign cert";
 843 if (!SSL_CTX_use_certificate(sctx, x509))
 844   goto err;
 845
 846 where = US"installing selfsign key";
 847 if (!SSL_CTX_use_PrivateKey(sctx, pkey))
 848   goto err;
 849
 850 return OK;
 851
 852 err:
 853   (void) tls_error(where, NULL, NULL, errstr);
 854   if (x509) X509_free(x509);
 855   if (pkey) EVP_PKEY_free(pkey);
 856   return DEFER;
 857 }
 858
 859
 860
 861
 862
 863
 864
 865 /*************************************************
 866 *           Information callback                 *
 867 *************************************************/
 868
 869 /* The SSL library functions call this from time to time to indicate what they
 870 are doing. We copy the string to the debugging output when TLS debugging has
 871 been requested.
 872
 873 Arguments:
 874   s         the SSL connection
 875   where
 876   ret
 877
 878 Returns:    nothing
 879 */
 880
 881 static void
 882 info_callback(SSL *s, int where, int ret)
 883 {
 884 DEBUG(D_tls)
 885   {
 886   const uschar * str;
 887
 888   if (where & SSL_ST_CONNECT)
 889      str = US"SSL_connect";
 890   else if (where & SSL_ST_ACCEPT)
 891      str = US"SSL_accept";
 892   else
 893      str = US"SSL info (undefined)";
 894
 895   if (where & SSL_CB_LOOP)
 896      debug_printf("%s: %s\n", str, SSL_state_string_long(s));
 897   else if (where & SSL_CB_ALERT)
 898     debug_printf("SSL3 alert %s:%s:%s\n",
 899           str = where & SSL_CB_READ ? US"read" : US"write",
 900           SSL_alert_type_string_long(ret), SSL_alert_desc_string_long(ret));
 901   else if (where & SSL_CB_EXIT)
 902      if (ret == 0)
 903         debug_printf("%s: failed in %s\n", str, SSL_state_string_long(s));
 904      else if (ret < 0)
 905         debug_printf("%s: error in %s\n", str, SSL_state_string_long(s));
 906   else if (where & SSL_CB_HANDSHAKE_START)
 907      debug_printf("%s: hshake start: %s\n", str, SSL_state_string_long(s));
 908   else if (where & SSL_CB_HANDSHAKE_DONE)
 909      debug_printf("%s: hshake done: %s\n", str, SSL_state_string_long(s));
 910   }
 911 }
 912
 913 #ifdef OPENSSL_HAVE_KEYLOG_CB
 914 static void
 915 keylog_callback(const SSL *ssl, const char *line)
 916 {
 917 char * filename;
 918 FILE * fp;
 919 DEBUG(D_tls) debug_printf("%.200s\n", line);
 920 if (!(filename = getenv("SSLKEYLOGFILE"))) return;
 921 if (!(fp = fopen(filename, "a"))) return;
 922 fprintf(fp, "%s\n", line);
 923 fclose(fp);
 924 }
 925 #endif
 926
 927
 928
 929
 930
 931 #ifndef DISABLE_EVENT
 932 static int
 933 verify_event(tls_support * tlsp, X509 * cert, int depth, const uschar * dn,
 934   BOOL *calledp, const BOOL *optionalp, const uschar * what)
 935 {
 936 uschar * ev;
 937 uschar * yield;
 938 X509 * old_cert;
 939
 940 ev = tlsp == &tls_out ? client_static_state->event_action : event_action;
 941 if (ev)
 942   {
 943   DEBUG(D_tls) debug_printf("verify_event: %s %d\n", what, depth);
 944   old_cert = tlsp->peercert;
 945   tlsp->peercert = X509_dup(cert);
 946   /* NB we do not bother setting peerdn */
 947   if ((yield = event_raise(ev, US"tls:cert", string_sprintf("%d", depth))))
 948     {
 949     log_write(0, LOG_MAIN, "[%s] %s verify denied by event-action: "
 950                 "depth=%d cert=%s: %s",
 951               tlsp == &tls_out ? deliver_host_address : sender_host_address,
 952               what, depth, dn, yield);
 953     *calledp = TRUE;
 954     if (!*optionalp)
 955       {
 956       if (old_cert) tlsp->peercert = old_cert;  /* restore 1st failing cert */
 957       return 1;                     /* reject (leaving peercert set) */
 958       }
 959     DEBUG(D_tls) debug_printf("Event-action verify failure overridden "
 960       "(host in tls_try_verify_hosts)\n");
 961     tlsp->verify_override = TRUE;
 962     }
 963   X509_free(tlsp->peercert);
 964   tlsp->peercert = old_cert;
 965   }
 966 return 0;
 967 }
 968 #endif
 969
 970 /*************************************************
 971 *        Callback for verification               *
 972 *************************************************/
 973
 974 /* The SSL library does certificate verification if set up to do so. This
 975 callback has the current yes/no state is in "state". If verification succeeded,
 976 we set the certificate-verified flag. If verification failed, what happens
 977 depends on whether the client is required to present a verifiable certificate
 978 or not.
 979
 980 If verification is optional, we change the state to yes, but still log the
 981 verification error. For some reason (it really would help to have proper
 982 documentation of OpenSSL), this callback function then gets called again, this
 983 time with state = 1.  We must take care not to set the private verified flag on
 984 the second time through.
 985
 986 Note: this function is not called if the client fails to present a certificate
 987 when asked. We get here only if a certificate has been received. Handling of
 988 optional verification for this case is done when requesting SSL to verify, by
 989 setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
 990
 991 May be called multiple times for different issues with a certificate, even
 992 for a given "depth" in the certificate chain.
 993
 994 Arguments:
 995   preverify_ok current yes/no state as 1/0
 996   x509ctx      certificate information.
 997   tlsp         per-direction (client vs. server) support data
 998   calledp      has-been-called flag
 999   optionalp    verification-is-optional flag
1000
1001 Returns:     0 if verification should fail, otherwise 1
1002 */
1003
1004 static int
1005 verify_callback(int preverify_ok, X509_STORE_CTX * x509ctx,
1006   tls_support * tlsp, BOOL * calledp, BOOL * optionalp)
1007 {
1008 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
1009 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
1010 uschar dn[256];
1011
1012 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
1013   {
1014   DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
1015   log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
1016     tlsp == &tls_out ? deliver_host_address : sender_host_address);
1017   return 0;
1018   }
1019 dn[sizeof(dn)-1] = '\0';
1020
1021 tlsp->verify_override = FALSE;
1022 if (preverify_ok == 0)
1023   {
1024   uschar * extra = verify_mode ? string_sprintf(" (during %c-verify for [%s])",
1025       *verify_mode, sender_host_address)
1026     : US"";
1027   log_write(0, LOG_MAIN, "[%s] SSL verify error%s: depth=%d error=%s cert=%s",
1028     tlsp == &tls_out ? deliver_host_address : sender_host_address,
1029     extra, depth,
1030     X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509ctx)), dn);
1031   *calledp = TRUE;
1032   if (!*optionalp)
1033     {
1034     if (!tlsp->peercert)
1035       tlsp->peercert = X509_dup(cert);  /* record failing cert */
1036     return 0;                           /* reject */
1037     }
1038   DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
1039     "tls_try_verify_hosts)\n");
1040   tlsp->verify_override = TRUE;
1041   }
1042
1043 else if (depth != 0)
1044   {
1045   DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d SN=%s\n", depth, dn);
1046 #ifndef DISABLE_OCSP
1047   if (tlsp == &tls_out && client_static_state->u_ocsp.client.verify_store)
1048     {   /* client, wanting stapling  */
1049     /* Add the server cert's signing chain as the one
1050     for the verification of the OCSP stapled information. */
1051
1052     if (!X509_STORE_add_cert(client_static_state->u_ocsp.client.verify_store,
1053                              cert))
1054       ERR_clear_error();
1055     sk_X509_push(client_static_state->verify_stack, cert);
1056     }
1057 #endif
1058 #ifndef DISABLE_EVENT
1059     if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
1060       return 0;                         /* reject, with peercert set */
1061 #endif
1062   }
1063 else
1064   {
1065   const uschar * verify_cert_hostnames;
1066
1067   if (  tlsp == &tls_out
1068      && ((verify_cert_hostnames = client_static_state->verify_cert_hostnames)))
1069         /* client, wanting hostname check */
1070     {
1071
1072 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
1073 # ifndef X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
1074 #  define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0
1075 # endif
1076 # ifndef X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS
1077 #  define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0
1078 # endif
1079     int sep = 0;
1080     const uschar * list = verify_cert_hostnames;
1081     uschar * name;
1082     int rc;
1083     while ((name = string_nextinlist(&list, &sep, NULL, 0)))
1084       if ((rc = X509_check_host(cert, CCS name, 0,
1085                   X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
1086                   | X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS,
1087                   NULL)))
1088         {
1089         if (rc < 0)
1090           {
1091           log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
1092             tlsp == &tls_out ? deliver_host_address : sender_host_address);
1093           name = NULL;
1094           }
1095         break;
1096         }
1097     if (!name)
1098 #else
1099     if (!tls_is_name_for_cert(verify_cert_hostnames, cert))
1100 #endif
1101       {
1102       uschar * extra = verify_mode
1103         ? string_sprintf(" (during %c-verify for [%s])",
1104           *verify_mode, sender_host_address)
1105         : US"";
1106       log_write(0, LOG_MAIN,
1107         "[%s] SSL verify error%s: certificate name mismatch: DN=\"%s\" H=\"%s\"",
1108         tlsp == &tls_out ? deliver_host_address : sender_host_address,
1109         extra, dn, verify_cert_hostnames);
1110       *calledp = TRUE;
1111       if (!*optionalp)
1112         {
1113         if (!tlsp->peercert)
1114           tlsp->peercert = X509_dup(cert);      /* record failing cert */
1115         return 0;                               /* reject */
1116         }
1117       DEBUG(D_tls) debug_printf("SSL verify name failure overridden (host in "
1118         "tls_try_verify_hosts)\n");
1119       tlsp->verify_override = TRUE;
1120       }
1121     }
1122
1123 #ifndef DISABLE_EVENT
1124   if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
1125     return 0;                           /* reject, with peercert set */
1126 #endif
1127
1128   DEBUG(D_tls) debug_printf("SSL%s verify ok: depth=0 SN=%s\n",
1129     *calledp ? "" : " authenticated", dn);
1130   *calledp = TRUE;
1131   }
1132
1133 return 1;   /* accept, at least for this level */
1134 }
1135
1136 static int
1137 verify_callback_client(int preverify_ok, X509_STORE_CTX *x509ctx)
1138 {
1139 return verify_callback(preverify_ok, x509ctx, &tls_out,
1140   &client_verify_callback_called, &client_verify_optional);
1141 }
1142
1143 static int
1144 verify_callback_server(int preverify_ok, X509_STORE_CTX *x509ctx)
1145 {
1146 return verify_callback(preverify_ok, x509ctx, &tls_in,
1147   &server_verify_callback_called, &server_verify_optional);
1148 }
1149
1150
1151 #ifdef SUPPORT_DANE
1152
1153 /* This gets called *by* the dane library verify callback, which interposes
1154 itself.
1155 */
1156 static int
1157 verify_callback_client_dane(int preverify_ok, X509_STORE_CTX * x509ctx)
1158 {
1159 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
1160 uschar dn[256];
1161 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
1162 #ifndef DISABLE_EVENT
1163 BOOL dummy_called, optional = FALSE;
1164 #endif
1165
1166 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
1167   {
1168   DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
1169   log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
1170     deliver_host_address);
1171   return 0;
1172   }
1173 dn[sizeof(dn)-1] = '\0';
1174
1175 DEBUG(D_tls) debug_printf("verify_callback_client_dane: %s depth %d %s\n",
1176   preverify_ok ? "ok":"BAD", depth, dn);
1177
1178 #ifndef DISABLE_EVENT
1179   if (verify_event(&tls_out, cert, depth, dn,
1180           &dummy_called, &optional, US"DANE"))
1181     return 0;                           /* reject, with peercert set */
1182 #endif
1183
1184 if (preverify_ok == 1)
1185   {
1186   tls_out.dane_verified = TRUE;
1187 #ifndef DISABLE_OCSP
1188   if (client_static_state->u_ocsp.client.verify_store)
1189     {   /* client, wanting stapling  */
1190     /* Add the server cert's signing chain as the one
1191     for the verification of the OCSP stapled information. */
1192
1193     if (!X509_STORE_add_cert(client_static_state->u_ocsp.client.verify_store,
1194                              cert))
1195       ERR_clear_error();
1196     sk_X509_push(client_static_state->verify_stack, cert);
1197     }
1198 #endif
1199   }
1200 else
1201   {
1202   int err = X509_STORE_CTX_get_error(x509ctx);
1203   DEBUG(D_tls)
1204     debug_printf(" - err %d '%s'\n", err, X509_verify_cert_error_string(err));
1205   if (err == X509_V_ERR_APPLICATION_VERIFICATION)
1206     preverify_ok = 1;
1207   }
1208 return preverify_ok;
1209 }
1210
1211 #endif  /*SUPPORT_DANE*/
1212
1213
1214 #ifndef DISABLE_OCSP
1215 /*************************************************
1216 *       Load OCSP information into state         *
1217 *************************************************/
1218 /* Called to load the server OCSP response from the given file into memory, once
1219 caller has determined this is needed.  Checks validity.  Debugs a message
1220 if invalid.
1221
1222 ASSUMES: single response, for single cert.
1223
1224 Arguments:
1225   state           various parts of session state
1226   filename        the filename putatively holding an OCSP response
1227   is_pem          file is PEM format; otherwise is DER
1228 */
1229
1230 static void
1231 ocsp_load_response(exim_openssl_state_st * state, const uschar * filename,
1232   BOOL is_pem)
1233 {
1234 BIO * bio;
1235 OCSP_RESPONSE * resp;
1236 OCSP_BASICRESP * basic_response;
1237 OCSP_SINGLERESP * single_response;
1238 ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
1239 STACK_OF(X509) * sk;
1240 unsigned long verify_flags;
1241 int status, reason, i;
1242
1243 DEBUG(D_tls)
1244   debug_printf("tls_ocsp_file (%s)  '%s'\n", is_pem ? "PEM" : "DER", filename);
1245
1246 if (!(bio = BIO_new_file(CS filename, "rb")))
1247   {
1248   DEBUG(D_tls) debug_printf("Failed to open OCSP response file \"%s\"\n",
1249       filename);
1250   return;
1251   }
1252
1253 if (is_pem)
1254   {
1255   uschar * data, * freep;
1256   char * dummy;
1257   long len;
1258   if (!PEM_read_bio(bio, &dummy, &dummy, &data, &len))
1259     {
1260     DEBUG(D_tls) debug_printf("Failed to read PEM file \"%s\"\n",
1261         filename);
1262     return;
1263     }
1264   freep = data;
1265   resp = d2i_OCSP_RESPONSE(NULL, CUSS &data, len);
1266   OPENSSL_free(freep);
1267   }
1268 else
1269   resp = d2i_OCSP_RESPONSE_bio(bio, NULL);
1270 BIO_free(bio);
1271
1272 if (!resp)
1273   {
1274   DEBUG(D_tls) debug_printf("Error reading OCSP response.\n");
1275   return;
1276   }
1277
1278 if ((status = OCSP_response_status(resp)) != OCSP_RESPONSE_STATUS_SUCCESSFUL)
1279   {
1280   DEBUG(D_tls) debug_printf("OCSP response not valid: %s (%d)\n",
1281       OCSP_response_status_str(status), status);
1282   goto bad;
1283   }
1284
1285 #ifdef notdef
1286   {
1287   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
1288   OCSP_RESPONSE_print(bp, resp, 0);  /* extreme debug: stapling content */
1289   BIO_free(bp);
1290   }
1291 #endif
1292
1293 if (!(basic_response = OCSP_response_get1_basic(resp)))
1294   {
1295   DEBUG(D_tls)
1296     debug_printf("OCSP response parse error: unable to extract basic response.\n");
1297   goto bad;
1298   }
1299
1300 sk = state->verify_stack;
1301 verify_flags = OCSP_NOVERIFY; /* check sigs, but not purpose */
1302
1303 /* May need to expose ability to adjust those flags?
1304 OCSP_NOSIGS OCSP_NOVERIFY OCSP_NOCHAIN OCSP_NOCHECKS OCSP_NOEXPLICIT
1305 OCSP_TRUSTOTHER OCSP_NOINTERN */
1306
1307 /* This does a full verify on the OCSP proof before we load it for serving
1308 up; possibly overkill - just date-checks might be nice enough.
1309
1310 OCSP_basic_verify takes a "store" arg, but does not
1311 use it for the chain verification, which is all we do
1312 when OCSP_NOVERIFY is set.  The content from the wire
1313 "basic_response" and a cert-stack "sk" are all that is used.
1314
1315 We have a stack, loaded in setup_certs() if tls_verify_certificates
1316 was a file (not a directory, or "system").  It is unfortunate we
1317 cannot used the connection context store, as that would neatly
1318 handle the "system" case too, but there seems to be no library
1319 function for getting a stack from a store.
1320 [ In OpenSSL 1.1 - ?  X509_STORE_CTX_get0_chain(ctx) ? ]
1321 We do not free the stack since it could be needed a second time for
1322 SNI handling.
1323
1324 Separately we might try to replace using OCSP_basic_verify() - which seems to not
1325 be a public interface into the OpenSSL library (there's no manual entry) -
1326 But what with?  We also use OCSP_basic_verify in the client stapling callback.
1327 And there we NEED it; we must verify that status... unless the
1328 library does it for us anyway?  */
1329
1330 if ((i = OCSP_basic_verify(basic_response, sk, NULL, verify_flags)) < 0)
1331   {
1332   DEBUG(D_tls)
1333     {
1334     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
1335     debug_printf("OCSP response verify failure: %s\n", US ssl_errstring);
1336     }
1337   goto bad;
1338   }
1339
1340 /* Here's the simplifying assumption: there's only one response, for the
1341 one certificate we use, and nothing for anything else in a chain.  If this
1342 proves false, we need to extract a cert id from our issued cert
1343 (tls_certificate) and use that for OCSP_resp_find_status() (which finds the
1344 right cert in the stack and then calls OCSP_single_get0_status()).
1345
1346 I'm hoping to avoid reworking a bunch more of how we handle state here.
1347
1348 XXX that will change when we add support for (TLS1.3) whole-chain stapling
1349 */
1350
1351 if (!(single_response = OCSP_resp_get0(basic_response, 0)))
1352   {
1353   DEBUG(D_tls)
1354     debug_printf("Unable to get first response from OCSP basic response.\n");
1355   goto bad;
1356   }
1357
1358 status = OCSP_single_get0_status(single_response, &reason, &rev, &thisupd, &nextupd);
1359 if (status != V_OCSP_CERTSTATUS_GOOD)
1360   {
1361   DEBUG(D_tls) debug_printf("OCSP response bad cert status: %s (%d) %s (%d)\n",
1362       OCSP_cert_status_str(status), status,
1363       OCSP_crl_reason_str(reason), reason);
1364   goto bad;
1365   }
1366
1367 if (!OCSP_check_validity(thisupd, nextupd, EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1368   {
1369   DEBUG(D_tls) debug_printf("OCSP status invalid times.\n");
1370   goto bad;
1371   }
1372
1373 supply_response:
1374   /* Add the resp to the list used by tls_server_stapling_cb() */
1375   {
1376   ocsp_resplist ** op = &state->u_ocsp.server.olist, * oentry;
1377   while (oentry = *op)
1378     op = &oentry->next;
1379   *op = oentry = store_get(sizeof(ocsp_resplist), FALSE);
1380   oentry->next = NULL;
1381   oentry->resp = resp;
1382   }
1383 return;
1384
1385 bad:
1386   if (f.running_in_test_harness)
1387     {
1388     extern char ** environ;
1389     if (environ) for (uschar ** p = USS environ; *p; p++)
1390       if (Ustrncmp(*p, "EXIM_TESTHARNESS_DISABLE_OCSPVALIDITYCHECK", 42) == 0)
1391         {
1392         DEBUG(D_tls) debug_printf("Supplying known bad OCSP response\n");
1393         goto supply_response;
1394         }
1395     }
1396 return;
1397 }
1398
1399
1400 static void
1401 ocsp_free_response_list(exim_openssl_state_st * cbinfo)
1402 {
1403 for (ocsp_resplist * olist = cbinfo->u_ocsp.server.olist; olist;
1404      olist = olist->next)
1405   OCSP_RESPONSE_free(olist->resp);
1406 cbinfo->u_ocsp.server.olist = NULL;
1407 }
1408 #endif  /*!DISABLE_OCSP*/
1409
1410
1411
1412
1413
1414 static int
1415 tls_add_certfile(SSL_CTX * sctx, exim_openssl_state_st * cbinfo, uschar * file,
1416   uschar ** errstr)
1417 {
1418 DEBUG(D_tls) debug_printf("tls_certificate file '%s'\n", file);
1419 if (!SSL_CTX_use_certificate_chain_file(sctx, CS file))
1420   return tls_error(string_sprintf(
1421     "SSL_CTX_use_certificate_chain_file file=%s", file),
1422       cbinfo->host, NULL, errstr);
1423 return 0;
1424 }
1425
1426 static int
1427 tls_add_pkeyfile(SSL_CTX * sctx, exim_openssl_state_st * cbinfo, uschar * file,
1428   uschar ** errstr)
1429 {
1430 DEBUG(D_tls) debug_printf("tls_privatekey file  '%s'\n", file);
1431 if (!SSL_CTX_use_PrivateKey_file(sctx, CS file, SSL_FILETYPE_PEM))
1432   return tls_error(string_sprintf(
1433     "SSL_CTX_use_PrivateKey_file file=%s", file), cbinfo->host, NULL, errstr);
1434 return 0;
1435 }
1436
1437
1438
1439
1440 /* Called once during tls_init and possibly again during TLS setup, for a
1441 new context, if Server Name Indication was used and tls_sni was seen in
1442 the certificate string.
1443
1444 Arguments:
1445   sctx            the SSL_CTX* to update
1446   state           various parts of session state
1447   errstr          error string pointer
1448
1449 Returns:          OK/DEFER/FAIL
1450 */
1451
1452 static int
1453 tls_expand_session_files(SSL_CTX * sctx, exim_openssl_state_st * state,
1454   uschar ** errstr)
1455 {
1456 uschar * expanded;
1457
1458 if (!state->certificate)
1459   {
1460   if (!state->is_server)                /* client */
1461     return OK;
1462                                         /* server */
1463   if (tls_install_selfsign(sctx, errstr) != OK)
1464     return DEFER;
1465   }
1466 else
1467   {
1468   int err;
1469
1470   if ( !reexpand_tls_files_for_sni
1471      && (  Ustrstr(state->certificate, US"tls_sni")
1472         || Ustrstr(state->certificate, US"tls_in_sni")
1473         || Ustrstr(state->certificate, US"tls_out_sni")
1474      )  )
1475     reexpand_tls_files_for_sni = TRUE;
1476
1477   if (!expand_check(state->certificate, US"tls_certificate", &expanded, errstr))
1478     return DEFER;
1479
1480   if (expanded)
1481     if (state->is_server)
1482       {
1483       const uschar * file_list = expanded;
1484       int sep = 0;
1485       uschar * file;
1486 #ifndef DISABLE_OCSP
1487       const uschar * olist = state->u_ocsp.server.file;
1488       int osep = 0;
1489       uschar * ofile;
1490       BOOL fmt_pem = FALSE;
1491
1492       if (olist)
1493         if (!expand_check(olist, US"tls_ocsp_file", USS &olist, errstr))
1494           return DEFER;
1495       if (olist && !*olist)
1496         olist = NULL;
1497
1498       if (  state->u_ocsp.server.file_expanded && olist
1499          && (Ustrcmp(olist, state->u_ocsp.server.file_expanded) == 0))
1500         {
1501         DEBUG(D_tls) debug_printf(" - value unchanged, using existing values\n");
1502         olist = NULL;
1503         }
1504       else
1505         {
1506         ocsp_free_response_list(state);
1507         state->u_ocsp.server.file_expanded = olist;
1508         }
1509 #endif
1510
1511       while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1512         {
1513         if ((err = tls_add_certfile(sctx, state, file, errstr)))
1514           return err;
1515
1516 #ifndef DISABLE_OCSP
1517         if (olist)
1518           if ((ofile = string_nextinlist(&olist, &osep, NULL, 0)))
1519             {
1520             if (Ustrncmp(ofile, US"PEM ", 4) == 0)
1521               {
1522               fmt_pem = TRUE;
1523               ofile += 4;
1524               }
1525             else if (Ustrncmp(ofile, US"DER ", 4) == 0)
1526               {
1527               fmt_pem = FALSE;
1528               ofile += 4;
1529               }
1530             ocsp_load_response(state, ofile, fmt_pem);
1531             }
1532           else
1533             DEBUG(D_tls) debug_printf("ran out of ocsp file list\n");
1534 #endif
1535         }
1536       }
1537     else        /* would there ever be a need for multiple client certs? */
1538       if ((err = tls_add_certfile(sctx, state, expanded, errstr)))
1539         return err;
1540
1541   if (  state->privatekey
1542      && !expand_check(state->privatekey, US"tls_privatekey", &expanded, errstr))
1543     return DEFER;
1544
1545   /* If expansion was forced to fail, key_expanded will be NULL. If the result
1546   of the expansion is an empty string, ignore it also, and assume the private
1547   key is in the same file as the certificate. */
1548
1549   if (expanded && *expanded)
1550     if (state->is_server)
1551       {
1552       const uschar * file_list = expanded;
1553       int sep = 0;
1554       uschar * file;
1555
1556       while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1557         if ((err = tls_add_pkeyfile(sctx, state, file, errstr)))
1558           return err;
1559       }
1560     else        /* would there ever be a need for multiple client certs? */
1561       if ((err = tls_add_pkeyfile(sctx, state, expanded, errstr)))
1562         return err;
1563   }
1564
1565 return OK;
1566 }
1567
1568
1569
1570
1571 /**************************************************
1572 * One-time init credentials for server and client *
1573 **************************************************/
1574
1575 static int
1576 server_load_ciphers(SSL_CTX * ctx, exim_openssl_state_st * state,
1577   uschar * ciphers, uschar ** errstr)
1578 {
1579 for (uschar * s = ciphers; *s; s++ ) if (*s == '_') *s = '-';
1580 DEBUG(D_tls) debug_printf("required ciphers: %s\n", ciphers);
1581 if (!SSL_CTX_set_cipher_list(ctx, CS ciphers))
1582   return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL, errstr);
1583 state->server_cipher_list = ciphers;
1584 return OK;
1585 }
1586
1587
1588
1589 static int
1590 lib_ctx_new(SSL_CTX ** ctxp, host_item * host, uschar ** errstr)
1591 {
1592 SSL_CTX * ctx;
1593 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
1594 if (!(ctx = SSL_CTX_new(host ? TLS_client_method() : TLS_server_method())))
1595 #else
1596 if (!(ctx = SSL_CTX_new(host ? SSLv23_client_method() : SSLv23_server_method())))
1597 #endif
1598   return tls_error(US"SSL_CTX_new", host, NULL, errstr);
1599
1600 /* Set up the information callback, which outputs if debugging is at a suitable
1601 level. */
1602
1603 DEBUG(D_tls)
1604   {
1605   SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
1606 #if defined(EXIM_HAVE_OPESSL_TRACE) && !defined(OPENSSL_NO_SSL_TRACE)
1607   /* this needs a debug build of OpenSSL */
1608   SSL_CTX_set_msg_callback(ctx, (void (*)())SSL_trace);
1609 #endif
1610 #ifdef OPENSSL_HAVE_KEYLOG_CB
1611   SSL_CTX_set_keylog_callback(ctx, (void (*)())keylog_callback);
1612 #endif
1613   }
1614
1615 /* Automatically re-try reads/writes after renegotiation. */
1616 (void) SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
1617 *ctxp = ctx;
1618 return OK;
1619 }
1620
1621
1622 static void
1623 tls_server_creds_init(void)
1624 {
1625 SSL_CTX * ctx;
1626 uschar * dummy_errstr;
1627
1628 tls_openssl_init();
1629
1630 state_server.lib_state = null_tls_preload;
1631
1632 if (lib_ctx_new(&ctx, NULL, &dummy_errstr) != OK)
1633   return;
1634 state_server.lib_state.lib_ctx = ctx;
1635
1636 /* Preload DH params and EC curve */
1637
1638 if (opt_unset_or_noexpand(tls_dhparam))
1639   {
1640   DEBUG(D_tls) debug_printf("TLS: preloading DH params for server\n");
1641   if (init_dh(ctx, tls_dhparam, NULL, &dummy_errstr))
1642     state_server.lib_state.dh = TRUE;
1643   }
1644 if (opt_unset_or_noexpand(tls_eccurve))
1645   {
1646   DEBUG(D_tls) debug_printf("TLS: preloading ECDH curve for server\n");
1647   if (init_ecdh(ctx, NULL, &dummy_errstr))
1648     state_server.lib_state.ecdh = TRUE;
1649   }
1650
1651 #if defined(EXIM_HAVE_INOTIFY) || defined(EXIM_HAVE_KEVENT)
1652 /* If we can, preload the server-side cert, key and ocsp */
1653
1654 if (  opt_set_and_noexpand(tls_certificate)
1655 # ifndef DISABLE_OCSP
1656    && opt_unset_or_noexpand(tls_ocsp_file)
1657 #endif
1658    && opt_unset_or_noexpand(tls_privatekey))
1659   {
1660   /* Set watches on the filenames.  The implementation does de-duplication
1661   so we can just blindly do them all.  */
1662
1663   if (  tls_set_watch(tls_certificate, TRUE)
1664 # ifndef DISABLE_OCSP
1665      && tls_set_watch(tls_ocsp_file, TRUE)
1666 #endif
1667      && tls_set_watch(tls_privatekey, TRUE))
1668     {
1669     state_server.certificate = tls_certificate;
1670     state_server.privatekey = tls_privatekey;
1671 #ifndef DISABLE_OCSP
1672     state_server.u_ocsp.server.file = tls_ocsp_file;
1673 #endif
1674
1675     DEBUG(D_tls) debug_printf("TLS: preloading server certs\n");
1676     if (tls_expand_session_files(ctx, &state_server, &dummy_errstr) == OK)
1677       state_server.lib_state.conn_certs = TRUE;
1678     }
1679   }
1680 else
1681   DEBUG(D_tls) debug_printf("TLS: not preloading server certs\n");
1682
1683
1684 /* If we can, preload the Authorities for checking client certs against.
1685 Actual choice to do verify is made (tls_{,try_}verify_hosts)
1686 at TLS conn startup */
1687
1688 if (  opt_set_and_noexpand(tls_verify_certificates)
1689    && opt_unset_or_noexpand(tls_crl))
1690   {
1691   /* Watch the default dir also as they are always included */
1692
1693   if (  tls_set_watch(CUS X509_get_default_cert_file(), FALSE)
1694      && tls_set_watch(tls_verify_certificates, FALSE)
1695      && tls_set_watch(tls_crl, FALSE))
1696     {
1697     DEBUG(D_tls) debug_printf("TLS: preloading CA bundle for server\n");
1698
1699     if (setup_certs(ctx, tls_verify_certificates, tls_crl, NULL, &dummy_errstr)
1700         == OK)
1701       state_server.lib_state.cabundle = TRUE;
1702     }
1703   }
1704 else
1705   DEBUG(D_tls) debug_printf("TLS: not preloading CA bundle for server\n");
1706 #endif  /* EXIM_HAVE_INOTIFY */
1707
1708
1709 /* If we can, preload the ciphers control string */
1710
1711 if (opt_set_and_noexpand(tls_require_ciphers))
1712   {
1713   DEBUG(D_tls) debug_printf("TLS: preloading cipher list for server\n");
1714   if (server_load_ciphers(ctx, &state_server, tls_require_ciphers,
1715                           &dummy_errstr) == OK)
1716     state_server.lib_state.pri_string = TRUE;
1717   }
1718 else
1719   DEBUG(D_tls) debug_printf("TLS: not preloading cipher list for server\n");
1720 }
1721
1722
1723
1724
1725 /* Preload whatever creds are static, onto a transport.  The client can then
1726 just copy the pointer as it starts up.
1727 Called from the daemon after a cache-invalidate with watch set; called from
1728 a queue-run startup with watch clear. */
1729
1730 static void
1731 tls_client_creds_init(transport_instance * t, BOOL watch)
1732 {
1733 smtp_transport_options_block * ob = t->options_block;
1734 exim_openssl_state_st tpt_dummy_state;
1735 host_item * dummy_host = (host_item *)1;
1736 uschar * dummy_errstr;
1737 SSL_CTX * ctx;
1738
1739 tls_openssl_init();
1740
1741 ob->tls_preload = null_tls_preload;
1742 if (lib_ctx_new(&ctx, dummy_host, &dummy_errstr) != OK)
1743   return;
1744 ob->tls_preload.lib_ctx = ctx;
1745
1746 tpt_dummy_state.lib_state = ob->tls_preload;
1747
1748 if (opt_unset_or_noexpand(tls_dhparam))
1749   {
1750   DEBUG(D_tls) debug_printf("TLS: preloading DH params for transport '%s'\n", t->name);
1751   if (init_dh(ctx, tls_dhparam, NULL, &dummy_errstr))
1752     ob->tls_preload.dh = TRUE;
1753   }
1754 if (opt_unset_or_noexpand(tls_eccurve))
1755   {
1756   DEBUG(D_tls) debug_printf("TLS: preloading ECDH curve for transport '%s'\n", t->name);
1757   if (init_ecdh(ctx, NULL, &dummy_errstr))
1758     ob->tls_preload.ecdh = TRUE;
1759   }
1760
1761 #if defined(EXIM_HAVE_INOTIFY) || defined(EXIM_HAVE_KEVENT)
1762 if (  opt_set_and_noexpand(ob->tls_certificate)
1763    && opt_unset_or_noexpand(ob->tls_privatekey))
1764   {
1765   if (  !watch
1766      || (  tls_set_watch(ob->tls_certificate, FALSE)
1767         && tls_set_watch(ob->tls_privatekey, FALSE)
1768      )  )
1769     {
1770     uschar * pkey = ob->tls_privatekey;
1771
1772     DEBUG(D_tls)
1773       debug_printf("TLS: preloading client certs for transport '%s'\n",t->name);
1774
1775     if (  tls_add_certfile(ctx, &tpt_dummy_state, ob->tls_certificate,
1776                                     &dummy_errstr) == 0
1777        && tls_add_pkeyfile(ctx, &tpt_dummy_state,
1778                                     pkey ? pkey : ob->tls_certificate,
1779                                     &dummy_errstr) == 0
1780        )
1781       ob->tls_preload.conn_certs = TRUE;
1782     }
1783   }
1784 else
1785   DEBUG(D_tls)
1786     debug_printf("TLS: not preloading client certs, for transport '%s'\n", t->name);
1787
1788
1789 if (  opt_set_and_noexpand(ob->tls_verify_certificates)
1790    && opt_unset_or_noexpand(ob->tls_crl))
1791   {
1792   if (  !watch
1793      ||    tls_set_watch(CUS X509_get_default_cert_file(), FALSE)
1794         && tls_set_watch(ob->tls_verify_certificates, FALSE)
1795         && tls_set_watch(ob->tls_crl, FALSE)
1796      )
1797     {
1798     DEBUG(D_tls)
1799       debug_printf("TLS: preloading CA bundle for transport '%s'\n", t->name);
1800
1801     if (setup_certs(ctx, ob->tls_verify_certificates,
1802           ob->tls_crl, dummy_host, &dummy_errstr) == OK)
1803       ob->tls_preload.cabundle = TRUE;
1804     }
1805   }
1806 else
1807   DEBUG(D_tls)
1808       debug_printf("TLS: not preloading CA bundle, for transport '%s'\n", t->name);
1809
1810 #endif /*EXIM_HAVE_INOTIFY*/
1811 }
1812
1813
1814 #if defined(EXIM_HAVE_INOTIFY) || defined(EXIM_HAVE_KEVENT)
1815 /* Invalidate the creds cached, by dropping the current ones.
1816 Call when we notice one of the source files has changed. */
1817
1818 static void
1819 tls_server_creds_invalidate(void)
1820 {
1821 SSL_CTX_free(state_server.lib_state.lib_ctx);
1822 state_server.lib_state = null_tls_preload;
1823 }
1824
1825
1826 static void
1827 tls_client_creds_invalidate(transport_instance * t)
1828 {
1829 smtp_transport_options_block * ob = t->options_block;
1830 SSL_CTX_free(ob->tls_preload.lib_ctx);
1831 ob->tls_preload = null_tls_preload;
1832 }
1833
1834 #else
1835
1836 static void
1837 tls_server_creds_invalidate(void)
1838 { return; }
1839
1840 static void
1841 tls_client_creds_invalidate(transport_instance * t)
1842 { return; }
1843
1844 #endif  /*EXIM_HAVE_INOTIFY*/
1845
1846
1847 /* Extreme debug
1848 #ifndef DISABLE_OCSP
1849 void
1850 x509_store_dump_cert_s_names(X509_STORE * store)
1851 {
1852 STACK_OF(X509_OBJECT) * roots= store->objs;
1853 static uschar name[256];
1854
1855 for (int i= 0; i < sk_X509_OBJECT_num(roots); i++)
1856   {
1857   X509_OBJECT * tmp_obj= sk_X509_OBJECT_value(roots, i);
1858   if(tmp_obj->type == X509_LU_X509)
1859     {
1860     X509_NAME * sn = X509_get_subject_name(tmp_obj->data.x509);
1861     if (X509_NAME_oneline(sn, CS name, sizeof(name)))
1862       {
1863       name[sizeof(name)-1] = '\0';
1864       debug_printf(" %s\n", name);
1865       }
1866     }
1867   }
1868 }
1869 #endif
1870 */
1871
1872
1873 #ifndef DISABLE_TLS_RESUME
1874 /* Manage the keysets used for encrypting the session tickets, on the server. */
1875
1876 typedef struct {                        /* Session ticket encryption key */
1877   uschar        name[16];
1878
1879   const EVP_CIPHER *    aes_cipher;
1880   uschar                aes_key[32];    /* size needed depends on cipher. aes_128 implies 128/8 = 16? */
1881   const EVP_MD *        hmac_hash;
1882   uschar                hmac_key[16];
1883   time_t                renew;
1884   time_t                expire;
1885 } exim_stek;
1886
1887 static exim_stek exim_tk;       /* current key */
1888 static exim_stek exim_tk_old;   /* previous key */
1889
1890 static void
1891 tk_init(void)
1892 {
1893 time_t t = time(NULL);
1894
1895 if (exim_tk.name[0])
1896   {
1897   if (exim_tk.renew >= t) return;
1898   exim_tk_old = exim_tk;
1899   }
1900
1901 if (f.running_in_test_harness) ssl_session_timeout = 6;
1902
1903 DEBUG(D_tls) debug_printf("OpenSSL: %s STEK\n", exim_tk.name[0] ? "rotating" : "creating");
1904 if (RAND_bytes(exim_tk.aes_key, sizeof(exim_tk.aes_key)) <= 0) return;
1905 if (RAND_bytes(exim_tk.hmac_key, sizeof(exim_tk.hmac_key)) <= 0) return;
1906 if (RAND_bytes(exim_tk.name+1, sizeof(exim_tk.name)-1) <= 0) return;
1907
1908 exim_tk.name[0] = 'E';
1909 exim_tk.aes_cipher = EVP_aes_256_cbc();
1910 exim_tk.hmac_hash = EVP_sha256();
1911 exim_tk.expire = t + ssl_session_timeout;
1912 exim_tk.renew = t + ssl_session_timeout/2;
1913 }
1914
1915 static exim_stek *
1916 tk_current(void)
1917 {
1918 if (!exim_tk.name[0]) return NULL;
1919 return &exim_tk;
1920 }
1921
1922 static exim_stek *
1923 tk_find(const uschar * name)
1924 {
1925 return memcmp(name, exim_tk.name, sizeof(exim_tk.name)) == 0 ? &exim_tk
1926   : memcmp(name, exim_tk_old.name, sizeof(exim_tk_old.name)) == 0 ? &exim_tk_old
1927   : NULL;
1928 }
1929
1930 /* Callback for session tickets, on server */
1931 static int
1932 ticket_key_callback(SSL * ssl, uschar key_name[16],
1933   uschar * iv, EVP_CIPHER_CTX * c_ctx, HMAC_CTX * hctx, int enc)
1934 {
1935 tls_support * tlsp = state_server.tlsp;
1936 exim_stek * key;
1937
1938 if (enc)
1939   {
1940   DEBUG(D_tls) debug_printf("ticket_key_callback: create new session\n");
1941   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
1942
1943   if (RAND_bytes(iv, EVP_MAX_IV_LENGTH) <= 0)
1944     return -1; /* insufficient random */
1945
1946   if (!(key = tk_current()))    /* current key doesn't exist or isn't valid */
1947      return 0;                  /* key couldn't be created */
1948   memcpy(key_name, key->name, 16);
1949   DEBUG(D_tls) debug_printf("STEK expire " TIME_T_FMT "\n", key->expire - time(NULL));
1950
1951   /*XXX will want these dependent on the ssl session strength */
1952   HMAC_Init_ex(hctx, key->hmac_key, sizeof(key->hmac_key),
1953                 key->hmac_hash, NULL);
1954   EVP_EncryptInit_ex(c_ctx, key->aes_cipher, NULL, key->aes_key, iv);
1955
1956   DEBUG(D_tls) debug_printf("ticket created\n");
1957   return 1;
1958   }
1959 else
1960   {
1961   time_t now = time(NULL);
1962
1963   DEBUG(D_tls) debug_printf("ticket_key_callback: retrieve session\n");
1964   tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
1965
1966   if (!(key = tk_find(key_name)) || key->expire < now)
1967     {
1968     DEBUG(D_tls)
1969       {
1970       debug_printf("ticket not usable (%s)\n", key ? "expired" : "not found");
1971       if (key) debug_printf("STEK expire " TIME_T_FMT "\n", key->expire - now);
1972       }
1973     return 0;
1974     }
1975
1976   HMAC_Init_ex(hctx, key->hmac_key, sizeof(key->hmac_key),
1977                 key->hmac_hash, NULL);
1978   EVP_DecryptInit_ex(c_ctx, key->aes_cipher, NULL, key->aes_key, iv);
1979
1980   DEBUG(D_tls) debug_printf("ticket usable, STEK expire " TIME_T_FMT "\n", key->expire - now);
1981
1982   /* The ticket lifetime and renewal are the same as the STEK lifetime and
1983   renewal, which is overenthusiastic.  A factor of, say, 3x longer STEK would
1984   be better.  To do that we'd have to encode ticket lifetime in the name as
1985   we don't yet see the restored session.  Could check posthandshake for TLS1.3
1986   and trigger a new ticket then, but cannot do that for TLS1.2 */
1987   return key->renew < now ? 2 : 1;
1988   }
1989 }
1990 #endif
1991
1992
1993
1994 static void
1995 setup_cert_verify(SSL_CTX * ctx, BOOL optional,
1996     int (*cert_vfy_cb)(int, X509_STORE_CTX *))
1997 {
1998 /* If verification is optional, don't fail if no certificate */
1999
2000 SSL_CTX_set_verify(ctx,
2001     SSL_VERIFY_PEER | (optional ? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
2002     cert_vfy_cb);
2003 }
2004
2005
2006 /*************************************************
2007 *            Callback to handle SNI              *
2008 *************************************************/
2009
2010 /* Called when acting as server during the TLS session setup if a Server Name
2011 Indication extension was sent by the client.
2012
2013 API documentation is OpenSSL s_server.c implementation.
2014
2015 Arguments:
2016   s               SSL* of the current session
2017   ad              unknown (part of OpenSSL API) (unused)
2018   arg             Callback of "our" registered data
2019
2020 Returns:          SSL_TLSEXT_ERR_{OK,ALERT_WARNING,ALERT_FATAL,NOACK}
2021
2022 XXX might need to change to using ClientHello callback,
2023 per https://www.openssl.org/docs/manmaster/man3/SSL_client_hello_cb_fn.html
2024 */
2025
2026 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2027 static int
2028 tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg)
2029 {
2030 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
2031 exim_openssl_state_st *state = (exim_openssl_state_st *) arg;
2032 int rc;
2033 int old_pool = store_pool;
2034 uschar * dummy_errstr;
2035
2036 if (!servername)
2037   return SSL_TLSEXT_ERR_OK;
2038
2039 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", servername,
2040     reexpand_tls_files_for_sni ? "" : " (unused for certificate selection)");
2041
2042 /* Make the extension value available for expansion */
2043 store_pool = POOL_PERM;
2044 tls_in.sni = string_copy_taint(US servername, TRUE);
2045 store_pool = old_pool;
2046
2047 if (!reexpand_tls_files_for_sni)
2048   return SSL_TLSEXT_ERR_OK;
2049
2050 /* Can't find an SSL_CTX_clone() or equivalent, so we do it manually;
2051 not confident that memcpy wouldn't break some internal reference counting.
2052 Especially since there's a references struct member, which would be off. */
2053
2054 if (lib_ctx_new(&server_sni, NULL, &dummy_errstr) != OK)
2055   goto bad;
2056
2057 /* Not sure how many of these are actually needed, since SSL object
2058 already exists.  Might even need this selfsame callback, for reneg? */
2059
2060   {
2061   SSL_CTX * ctx = state_server.lib_state.lib_ctx;
2062   SSL_CTX_set_info_callback(server_sni, SSL_CTX_get_info_callback(ctx));
2063   SSL_CTX_set_mode(server_sni, SSL_CTX_get_mode(ctx));
2064   SSL_CTX_set_options(server_sni, SSL_CTX_get_options(ctx));
2065   SSL_CTX_set_timeout(server_sni, SSL_CTX_get_timeout(ctx));
2066   SSL_CTX_set_tlsext_servername_callback(server_sni, tls_servername_cb);
2067   SSL_CTX_set_tlsext_servername_arg(server_sni, state);
2068   }
2069
2070 if (  !init_dh(server_sni, state->dhparam, NULL, &dummy_errstr)
2071    || !init_ecdh(server_sni, NULL, &dummy_errstr)
2072    )
2073   goto bad;
2074
2075 if (  state->server_cipher_list
2076    && !SSL_CTX_set_cipher_list(server_sni, CS state->server_cipher_list))
2077   goto bad;
2078
2079 #ifndef DISABLE_OCSP
2080 if (state->u_ocsp.server.file)
2081   {
2082   SSL_CTX_set_tlsext_status_cb(server_sni, tls_server_stapling_cb);
2083   SSL_CTX_set_tlsext_status_arg(server_sni, state);
2084   }
2085 #endif
2086
2087   {
2088   uschar * expcerts;
2089   if (  !expand_check(tls_verify_certificates, US"tls_verify_certificates",
2090                   &expcerts, &dummy_errstr)
2091      || (rc = setup_certs(server_sni, expcerts, tls_crl, NULL,
2092                         &dummy_errstr)) != OK)
2093     goto bad;
2094
2095   if (expcerts && *expcerts)
2096     setup_cert_verify(server_sni, FALSE, verify_callback_server);
2097   }
2098
2099 /* do this after setup_certs, because this can require the certs for verifying
2100 OCSP information. */
2101 if ((rc = tls_expand_session_files(server_sni, state, &dummy_errstr)) != OK)
2102   goto bad;
2103
2104 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
2105 SSL_set_SSL_CTX(s, server_sni);
2106 return SSL_TLSEXT_ERR_OK;
2107
2108 bad: return SSL_TLSEXT_ERR_ALERT_FATAL;
2109 }
2110 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
2111
2112
2113
2114
2115 #ifndef DISABLE_OCSP
2116
2117 /*************************************************
2118 *        Callback to handle OCSP Stapling        *
2119 *************************************************/
2120
2121 /* Called when acting as server during the TLS session setup if the client
2122 requests OCSP information with a Certificate Status Request.
2123
2124 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
2125 project.
2126
2127 */
2128
2129 static int
2130 tls_server_stapling_cb(SSL *s, void *arg)
2131 {
2132 const exim_openssl_state_st * state = arg;
2133 ocsp_resplist * olist = state->u_ocsp.server.olist;
2134 uschar * response_der;  /*XXX blob */
2135 int response_der_len;
2136
2137 DEBUG(D_tls)
2138   debug_printf("Received TLS status request (OCSP stapling); %s response list\n",
2139     olist ? "have" : "lack");
2140
2141 tls_in.ocsp = OCSP_NOT_RESP;
2142 if (!olist)
2143   return SSL_TLSEXT_ERR_NOACK;
2144
2145 #ifdef EXIM_HAVE_OPESSL_GET0_SERIAL
2146  {
2147   const X509 * cert_sent = SSL_get_certificate(s);
2148   const ASN1_INTEGER * cert_serial = X509_get0_serialNumber(cert_sent);
2149   const BIGNUM * cert_bn = ASN1_INTEGER_to_BN(cert_serial, NULL);
2150   const X509_NAME * cert_issuer = X509_get_issuer_name(cert_sent);
2151   uschar * chash;
2152   uint chash_len;
2153
2154   for (; olist; olist = olist->next)
2155     {
2156     OCSP_BASICRESP * bs = OCSP_response_get1_basic(olist->resp);
2157     const OCSP_SINGLERESP * single = OCSP_resp_get0(bs, 0);
2158     const OCSP_CERTID * cid = OCSP_SINGLERESP_get0_id(single);
2159     ASN1_INTEGER * res_cert_serial;
2160     const BIGNUM * resp_bn;
2161     ASN1_OCTET_STRING * res_cert_iNameHash;
2162
2163
2164     (void) OCSP_id_get0_info(&res_cert_iNameHash, NULL, NULL, &res_cert_serial,
2165       (OCSP_CERTID *) cid);
2166     resp_bn = ASN1_INTEGER_to_BN(res_cert_serial, NULL);
2167
2168     DEBUG(D_tls)
2169       {
2170       debug_printf("cert serial: %s\n", BN_bn2hex(cert_bn));
2171       debug_printf("resp serial: %s\n", BN_bn2hex(resp_bn));
2172       }
2173
2174     if (BN_cmp(cert_bn, resp_bn) == 0)
2175       {
2176       DEBUG(D_tls) debug_printf("matched serial for ocsp\n");
2177
2178       /*XXX TODO: check the rest of the list for duplicate matches.
2179       If any, need to also check the Issuer Name hash.
2180       Without this, we will provide the wrong status in the case of
2181       duplicate id. */
2182
2183       break;
2184       }
2185     DEBUG(D_tls) debug_printf("not match serial for ocsp\n");
2186     }
2187   if (!olist)
2188     {
2189     DEBUG(D_tls) debug_printf("failed to find match for ocsp\n");
2190     return SSL_TLSEXT_ERR_NOACK;
2191     }
2192  }
2193 #else
2194 if (olist->next)
2195   {
2196   DEBUG(D_tls) debug_printf("OpenSSL version too early to support multi-leaf OCSP\n");
2197   return SSL_TLSEXT_ERR_NOACK;
2198   }
2199 #endif
2200
2201 /*XXX could we do the i2d earlier, rather than during the callback? */
2202 response_der = NULL;
2203 response_der_len = i2d_OCSP_RESPONSE(olist->resp, &response_der);
2204 if (response_der_len <= 0)
2205   return SSL_TLSEXT_ERR_NOACK;
2206
2207 SSL_set_tlsext_status_ocsp_resp(state_server.lib_state.lib_ssl,
2208                                 response_der, response_der_len);
2209 tls_in.ocsp = OCSP_VFIED;
2210 return SSL_TLSEXT_ERR_OK;
2211 }
2212
2213
2214 static void
2215 time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
2216 {
2217 BIO_printf(bp, "\t%s: ", str);
2218 ASN1_GENERALIZEDTIME_print(bp, time);
2219 BIO_puts(bp, "\n");
2220 }
2221
2222 static int
2223 tls_client_stapling_cb(SSL *s, void *arg)
2224 {
2225 exim_openssl_state_st * cbinfo = arg;
2226 const unsigned char * p;
2227 int len;
2228 OCSP_RESPONSE * rsp;
2229 OCSP_BASICRESP * bs;
2230 int i;
2231
2232 DEBUG(D_tls) debug_printf("Received TLS status callback (OCSP stapling):\n");
2233 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
2234 if(!p)
2235  {
2236   /* Expect this when we requested ocsp but got none */
2237   if (cbinfo->u_ocsp.client.verify_required && LOGGING(tls_cipher))
2238     log_write(0, LOG_MAIN, "Required TLS certificate status not received");
2239   else
2240     DEBUG(D_tls) debug_printf(" null\n");
2241   return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
2242  }
2243
2244 if (!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
2245   {
2246   tls_out.ocsp = OCSP_FAILED;   /*XXX should use tlsp-> to permit concurrent outbound */
2247   if (LOGGING(tls_cipher))
2248     log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
2249   else
2250     DEBUG(D_tls) debug_printf(" parse error\n");
2251   return 0;
2252   }
2253
2254 if (!(bs = OCSP_response_get1_basic(rsp)))
2255   {
2256   tls_out.ocsp = OCSP_FAILED;
2257   if (LOGGING(tls_cipher))
2258     log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
2259   else
2260     DEBUG(D_tls) debug_printf(" error parsing response\n");
2261   OCSP_RESPONSE_free(rsp);
2262   return 0;
2263   }
2264
2265 /* We'd check the nonce here if we'd put one in the request. */
2266 /* However that would defeat cacheability on the server so we don't. */
2267
2268 /* This section of code reworked from OpenSSL apps source;
2269    The OpenSSL Project retains copyright:
2270    Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
2271 */
2272   {
2273     BIO * bp = NULL;
2274 #ifndef EXIM_HAVE_OCSP_RESP_COUNT
2275     STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
2276 #endif
2277
2278     DEBUG(D_tls) bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
2279
2280     /*OCSP_RESPONSE_print(bp, rsp, 0);   extreme debug: stapling content */
2281
2282     /* Use the chain that verified the server cert to verify the stapled info */
2283     /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
2284
2285     if ((i = OCSP_basic_verify(bs, cbinfo->verify_stack,
2286               cbinfo->u_ocsp.client.verify_store, OCSP_NOEXPLICIT)) <= 0)
2287       if (ERR_peek_error())
2288         {
2289         tls_out.ocsp = OCSP_FAILED;
2290         if (LOGGING(tls_cipher)) log_write(0, LOG_MAIN,
2291                 "Received TLS cert status response, itself unverifiable: %s",
2292                 ERR_reason_error_string(ERR_peek_error()));
2293         BIO_printf(bp, "OCSP response verify failure\n");
2294         ERR_print_errors(bp);
2295         OCSP_RESPONSE_print(bp, rsp, 0);
2296         goto failed;
2297         }
2298       else
2299         DEBUG(D_tls) debug_printf("no explicit trust for OCSP signing"
2300           " in the root CA certificate; ignoring\n");
2301
2302     DEBUG(D_tls) debug_printf("OCSP response well-formed and signed OK\n");
2303
2304     /*XXX So we have a good stapled OCSP status.  How do we know
2305     it is for the cert of interest?  OpenSSL 1.1.0 has a routine
2306     OCSP_resp_find_status() which matches on a cert id, which presumably
2307     we should use. Making an id needs OCSP_cert_id_new(), which takes
2308     issuerName, issuerKey, serialNumber.  Are they all in the cert?
2309
2310     For now, carry on blindly accepting the resp. */
2311
2312     for (int idx =
2313 #ifdef EXIM_HAVE_OCSP_RESP_COUNT
2314             OCSP_resp_count(bs) - 1;
2315 #else
2316             sk_OCSP_SINGLERESP_num(sresp) - 1;
2317 #endif
2318          idx >= 0; idx--)
2319       {
2320       OCSP_SINGLERESP * single = OCSP_resp_get0(bs, idx);
2321       int status, reason;
2322       ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
2323
2324   /*XXX so I can see putting a loop in here to handle a rsp with >1 singleresp
2325   - but what happens with a GnuTLS-style input?
2326
2327   we could do with a debug label for each singleresp
2328   - it has a certID with a serialNumber, but I see no API to get that
2329   */
2330       status = OCSP_single_get0_status(single, &reason, &rev,
2331                   &thisupd, &nextupd);
2332
2333       DEBUG(D_tls) time_print(bp, "This OCSP Update", thisupd);
2334       DEBUG(D_tls) if(nextupd) time_print(bp, "Next OCSP Update", nextupd);
2335       if (!OCSP_check_validity(thisupd, nextupd,
2336             EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
2337         {
2338         tls_out.ocsp = OCSP_FAILED;
2339         DEBUG(D_tls) ERR_print_errors(bp);
2340         log_write(0, LOG_MAIN, "Server OSCP dates invalid");
2341         goto failed;
2342         }
2343
2344       DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
2345                     OCSP_cert_status_str(status));
2346       switch(status)
2347         {
2348         case V_OCSP_CERTSTATUS_GOOD:
2349           continue;     /* the idx loop */
2350         case V_OCSP_CERTSTATUS_REVOKED:
2351           log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
2352               reason != -1 ? "; reason: " : "",
2353               reason != -1 ? OCSP_crl_reason_str(reason) : "");
2354           DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
2355           break;
2356         default:
2357           log_write(0, LOG_MAIN,
2358               "Server certificate status unknown, in OCSP stapling");
2359           break;
2360         }
2361
2362       goto failed;
2363       }
2364
2365     i = 1;
2366     tls_out.ocsp = OCSP_VFIED;
2367     goto good;
2368
2369   failed:
2370     tls_out.ocsp = OCSP_FAILED;
2371     i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
2372   good:
2373     BIO_free(bp);
2374   }
2375
2376 OCSP_RESPONSE_free(rsp);
2377 return i;
2378 }
2379 #endif  /*!DISABLE_OCSP*/
2380
2381
2382 /*************************************************
2383 *            Initialize for TLS                  *
2384 *************************************************/
2385 /* Called from both server and client code, to do preliminary initialization
2386 of the library.  We allocate and return a context structure.
2387
2388 Arguments:
2389   host            connected host, if client; NULL if server
2390   ob              transport options block, if client; NULL if server
2391   ocsp_file       file of stapling info (server); flag for require ocsp (client)
2392   addr            address if client; NULL if server (for some randomness)
2393   caller_state    place to put pointer to allocated state-struct
2394   errstr          error string pointer
2395
2396 Returns:          OK/DEFER/FAIL
2397 */
2398
2399 static int
2400 tls_init(host_item * host, smtp_transport_options_block * ob,
2401 #ifndef DISABLE_OCSP
2402   uschar *ocsp_file,
2403 #endif
2404   address_item *addr, exim_openssl_state_st ** caller_state,
2405   tls_support * tlsp,
2406   uschar ** errstr)
2407 {
2408 SSL_CTX * ctx;
2409 exim_openssl_state_st * state;
2410 int rc;
2411
2412 if (host)                       /* client */
2413   {
2414   state = store_malloc(sizeof(exim_openssl_state_st));
2415   memset(state, 0, sizeof(*state));
2416   state->certificate = ob->tls_certificate;
2417   state->privatekey =  ob->tls_privatekey;
2418   state->is_server = FALSE;
2419   state->dhparam = NULL;
2420   state->lib_state = ob->tls_preload;
2421   }
2422 else                            /* server */
2423   {
2424   state = &state_server;
2425   state->certificate = tls_certificate;
2426   state->privatekey =  tls_privatekey;
2427   state->is_server = TRUE;
2428   state->dhparam = tls_dhparam;
2429   state->lib_state = state_server.lib_state;
2430   }
2431
2432 state->tlsp = tlsp;
2433 state->host = host;
2434
2435 if (!state->lib_state.pri_string)
2436   state->server_cipher_list = NULL;
2437
2438 #ifndef DISABLE_EVENT
2439 state->event_action = NULL;
2440 #endif
2441
2442 tls_openssl_init();
2443
2444 /* It turns out that we need to seed the random number generator this early in
2445 order to get the full complement of ciphers to work. It took me roughly a day
2446 of work to discover this by experiment.
2447
2448 On systems that have /dev/urandom, SSL may automatically seed itself from
2449 there. Otherwise, we have to make something up as best we can. Double check
2450 afterwards.
2451
2452 Although we likely called this before, at daemon startup, this is a chance
2453 to mix in further variable info (time, pid) if needed. */
2454
2455 if (!lib_rand_init(addr))
2456   return tls_error(US"RAND_status", host,
2457     US"unable to seed random number generator", errstr);
2458
2459 /* Apply administrator-supplied work-arounds.
2460 Historically we applied just one requested option,
2461 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
2462 moved to an administrator-controlled list of options to specify and
2463 grandfathered in the first one as the default value for "openssl_options".
2464
2465 No OpenSSL version number checks: the options we accept depend upon the
2466 availability of the option value macros from OpenSSL.  */
2467
2468 if (!init_options)
2469   if (!tls_openssl_options_parse(openssl_options, &init_options))
2470     return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
2471
2472 /* Create a context.
2473 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
2474 negotiation in the different methods; as far as I can tell, the only
2475 *_{server,client}_method which allows negotiation is SSLv23, which exists even
2476 when OpenSSL is built without SSLv2 support.
2477 By disabling with openssl_options, we can let admins re-enable with the
2478 existing knob. */
2479
2480 if (!(ctx = state->lib_state.lib_ctx))
2481   {
2482   if ((rc = lib_ctx_new(&ctx, host, errstr)) != OK)
2483     return rc;
2484   state->lib_state.lib_ctx = ctx;
2485   }
2486
2487 #ifndef DISABLE_TLS_RESUME
2488 tlsp->resumption = RESUME_SUPPORTED;
2489 #endif
2490 if (init_options)
2491   {
2492 #ifndef DISABLE_TLS_RESUME
2493   /* Should the server offer session resumption? */
2494   if (!host && verify_check_host(&tls_resumption_hosts) == OK)
2495     {
2496     DEBUG(D_tls) debug_printf("tls_resumption_hosts overrides openssl_options\n");
2497     init_options &= ~SSL_OP_NO_TICKET;
2498     tlsp->resumption |= RESUME_SERVER_TICKET; /* server will give ticket on request */
2499     tlsp->host_resumable = TRUE;
2500     }
2501 #endif
2502
2503   DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
2504   if (!(SSL_CTX_set_options(ctx, init_options)))
2505     return tls_error(string_sprintf(
2506           "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
2507   }
2508 else
2509   DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
2510
2511 /* We'd like to disable session cache unconditionally, but foolish Outlook
2512 Express clients then give up the first TLS connection and make a second one
2513 (which works).  Only when there is an IMAP service on the same machine.
2514 Presumably OE is trying to use the cache for A on B.  Leave it enabled for
2515 now, until we work out a decent way of presenting control to the config.  It
2516 will never be used because we use a new context every time. */
2517 #ifdef notdef
2518 (void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
2519 #endif
2520
2521 /* Initialize with DH parameters if supplied */
2522 /* Initialize ECDH temp key parameter selection */
2523
2524 if (state->lib_state.dh)
2525   { DEBUG(D_tls) debug_printf("TLS: DH params were preloaded\n"); }
2526 else
2527   if (!init_dh(ctx, state->dhparam, host, errstr)) return DEFER;
2528
2529 if (state->lib_state.ecdh)
2530   { DEBUG(D_tls) debug_printf("TLS: ECDH curve was preloaded\n"); }
2531 else
2532   if (!init_ecdh(ctx, host, errstr)) return DEFER;
2533
2534 /* Set up certificate and key (and perhaps OCSP info) */
2535
2536 if (state->lib_state.conn_certs)
2537   {
2538   DEBUG(D_tls)
2539     debug_printf("TLS: %s certs were preloaded\n", host ? "client":"server");
2540   }
2541 else
2542   {
2543 #ifndef DISABLE_OCSP
2544   if (!host)
2545     {
2546     state->u_ocsp.server.file = ocsp_file;
2547     state->u_ocsp.server.file_expanded = NULL;
2548     state->u_ocsp.server.olist = NULL;
2549     }
2550 #endif
2551   if ((rc = tls_expand_session_files(ctx, state, errstr)) != OK) return rc;
2552   }
2553
2554 /* If we need to handle SNI or OCSP, do so */
2555
2556 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2557 # ifndef DISABLE_OCSP
2558   if (!(state->verify_stack = sk_X509_new_null()))
2559     {
2560     DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
2561     return FAIL;
2562     }
2563 # endif
2564
2565 if (!host)              /* server */
2566   {
2567 # ifndef DISABLE_OCSP
2568   /* We check u_ocsp.server.file, not server.olist, because we care about if
2569   the option exists, not what the current expansion might be, as SNI might
2570   change the certificate and OCSP file in use between now and the time the
2571   callback is invoked. */
2572   if (state->u_ocsp.server.file)
2573     {
2574     SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
2575     SSL_CTX_set_tlsext_status_arg(ctx, state);
2576     }
2577 # endif
2578   /* We always do this, so that $tls_sni is available even if not used in
2579   tls_certificate */
2580   SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
2581   SSL_CTX_set_tlsext_servername_arg(ctx, state);
2582   }
2583 # ifndef DISABLE_OCSP
2584 else                    /* client */
2585   if(ocsp_file)         /* wanting stapling */
2586     {
2587     if (!(state->u_ocsp.client.verify_store = X509_STORE_new()))
2588       {
2589       DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
2590       return FAIL;
2591       }
2592     SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
2593     SSL_CTX_set_tlsext_status_arg(ctx, state);
2594     }
2595 # endif
2596 #endif
2597
2598 state->verify_cert_hostnames = NULL;
2599
2600 #ifdef EXIM_HAVE_EPHEM_RSA_KEX
2601 /* Set up the RSA callback */
2602 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
2603 #endif
2604
2605 /* Finally, set the session cache timeout, and we are done.
2606 The period appears to be also used for (server-generated) session tickets */
2607
2608 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
2609 DEBUG(D_tls) debug_printf("Initialized TLS\n");
2610
2611 *caller_state = state;
2612
2613 return OK;
2614 }
2615
2616
2617
2618
2619 /*************************************************
2620 *           Get name of cipher in use            *
2621 *************************************************/
2622
2623 /*
2624 Argument:   pointer to an SSL structure for the connection
2625             pointer to number of bits for cipher
2626 Returns:    pointer to allocated string in perm-pool
2627 */
2628
2629 static uschar *
2630 construct_cipher_name(SSL * ssl, const uschar * ver, int * bits)
2631 {
2632 int pool = store_pool;
2633 /* With OpenSSL 1.0.0a, 'c' needs to be const but the documentation doesn't
2634 yet reflect that.  It should be a safe change anyway, even 0.9.8 versions have
2635 the accessor functions use const in the prototype. */
2636
2637 const SSL_CIPHER * c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
2638 uschar * s;
2639
2640 SSL_CIPHER_get_bits(c, bits);
2641
2642 store_pool = POOL_PERM;
2643 s = string_sprintf("%s:%s:%u", ver, SSL_CIPHER_get_name(c), *bits);
2644 store_pool = pool;
2645 DEBUG(D_tls) debug_printf("Cipher: %s\n", s);
2646 return s;
2647 }
2648
2649
2650 /* Get IETF-standard name for ciphersuite.
2651 Argument:   pointer to an SSL structure for the connection
2652 Returns:    pointer to string
2653 */
2654
2655 static const uschar *
2656 cipher_stdname_ssl(SSL * ssl)
2657 {
2658 #ifdef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
2659 return CUS SSL_CIPHER_standard_name(SSL_get_current_cipher(ssl));
2660 #else
2661 ushort id = 0xffff & SSL_CIPHER_get_id(SSL_get_current_cipher(ssl));
2662 return cipher_stdname(id >> 8, id & 0xff);
2663 #endif
2664 }
2665
2666
2667 static const uschar *
2668 tlsver_name(SSL * ssl)
2669 {
2670 uschar * s, * p;
2671 int pool = store_pool;
2672
2673 store_pool = POOL_PERM;
2674 s = string_copy(US SSL_get_version(ssl));
2675 store_pool = pool;
2676 if ((p = Ustrchr(s, 'v')))      /* TLSv1.2 -> TLS1.2 */
2677   for (;; p++) if (!(*p = p[1])) break;
2678 return CUS s;
2679 }
2680
2681
2682 static void
2683 peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned siz)
2684 {
2685 /*XXX we might consider a list-of-certs variable for the cert chain.
2686 SSL_get_peer_cert_chain(SSL*).  We'd need a new variable type and support
2687 in list-handling functions, also consider the difference between the entire
2688 chain and the elements sent by the peer. */
2689
2690 tlsp->peerdn = NULL;
2691
2692 /* Will have already noted peercert on a verify fail; possibly not the leaf */
2693 if (!tlsp->peercert)
2694   tlsp->peercert = SSL_get_peer_certificate(ssl);
2695 /* Beware anonymous ciphers which lead to server_cert being NULL */
2696 if (tlsp->peercert)
2697   if (!X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, siz))
2698     { DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n"); }
2699   else
2700     {
2701     int oldpool = store_pool;
2702
2703     peerdn[siz-1] = '\0';               /* paranoia */
2704     store_pool = POOL_PERM;
2705     tlsp->peerdn = string_copy(peerdn);
2706     store_pool = oldpool;
2707
2708     /* We used to set CV in the cert-verify callbacks (either plain or dane)
2709     but they don't get called on session-resumption.  So use the official
2710     interface, which uses the resumed value.  Unfortunately this claims verified
2711     when it actually failed but we're in try-verify mode, due to us wanting the
2712     knowlege that it failed so needing to have the callback and forcing a
2713     permissive return.  If we don't force it, the TLS startup is failed.
2714     The extra bit of information is set in verify_override in the cb, stashed
2715     for resumption next to the TLS session, and used here. */
2716
2717     if (!tlsp->verify_override)
2718       tlsp->certificate_verified =
2719 #ifdef SUPPORT_DANE
2720         tlsp->dane_verified ||
2721 #endif
2722         SSL_get_verify_result(ssl) == X509_V_OK;
2723     }
2724 }
2725
2726
2727
2728
2729
2730 /*************************************************
2731 *        Set up for verifying certificates       *
2732 *************************************************/
2733
2734 #ifndef DISABLE_OCSP
2735 /* Load certs from file, return TRUE on success */
2736
2737 static BOOL
2738 chain_from_pem_file(const uschar * file, STACK_OF(X509) * verify_stack)
2739 {
2740 BIO * bp;
2741 X509 * x;
2742
2743 while (sk_X509_num(verify_stack) > 0)
2744   X509_free(sk_X509_pop(verify_stack));
2745
2746 if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
2747 while ((x = PEM_read_bio_X509(bp, NULL, 0, NULL)))
2748   sk_X509_push(verify_stack, x);
2749 BIO_free(bp);
2750 return TRUE;
2751 }
2752 #endif
2753
2754
2755
2756 /* Called by both client and server startup; on the server possibly
2757 repeated after a Server Name Indication.
2758
2759 Arguments:
2760   sctx          SSL_CTX* to initialise
2761   certs         certs file, expanded
2762   crl           CRL file or NULL
2763   host          NULL in a server; the remote host in a client
2764   errstr        error string pointer
2765
2766 Returns:        OK/DEFER/FAIL
2767 */
2768
2769 static int
2770 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host,
2771     uschar ** errstr)
2772 {
2773 uschar *expcerts, *expcrl;
2774
2775 if (!expand_check(certs, US"tls_verify_certificates", &expcerts, errstr))
2776   return DEFER;
2777 DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
2778
2779 if (expcerts && *expcerts)
2780   {
2781   /* Tell the library to use its compiled-in location for the system default
2782   CA bundle. Then add the ones specified in the config, if any. */
2783
2784   if (!SSL_CTX_set_default_verify_paths(sctx))
2785     return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
2786
2787   if (Ustrcmp(expcerts, "system") != 0 && Ustrncmp(expcerts, "system,", 7) != 0)
2788     {
2789     struct stat statbuf;
2790
2791     if (Ustat(expcerts, &statbuf) < 0)
2792       {
2793       log_write(0, LOG_MAIN|LOG_PANIC,
2794         "failed to stat %s for certificates", expcerts);
2795       return DEFER;
2796       }
2797     else
2798       {
2799       uschar *file, *dir;
2800       if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
2801         { file = NULL; dir = expcerts; }
2802       else
2803         {
2804         file = expcerts; dir = NULL;
2805 #ifndef DISABLE_OCSP
2806         /* In the server if we will be offering an OCSP proof, load chain from
2807         file for verifying the OCSP proof at load time. */
2808
2809 /*XXX Glitch!   The file here is tls_verify_certs: the chain for verifying the client cert.
2810 This is inconsistent with the need to verify the OCSP proof of the server cert.
2811 */
2812
2813         if (  !host
2814            && statbuf.st_size > 0
2815            && state_server.u_ocsp.server.file
2816            && !chain_from_pem_file(file, state_server.verify_stack)
2817            )
2818           {
2819           log_write(0, LOG_MAIN|LOG_PANIC,
2820             "failed to load cert chain from %s", file);
2821           return DEFER;
2822           }
2823 #endif
2824         }
2825
2826       /* If a certificate file is empty, the load function fails with an
2827       unhelpful error message. If we skip it, we get the correct behaviour (no
2828       certificates are recognized, but the error message is still misleading (it
2829       says no certificate was supplied).  But this is better. */
2830
2831       if (  (!file || statbuf.st_size > 0)
2832          && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
2833           return tls_error(US"SSL_CTX_load_verify_locations",
2834                             host, NULL, errstr);
2835
2836       /* On the server load the list of CAs for which we will accept certs, for
2837       sending to the client.  This is only for the one-file
2838       tls_verify_certificates variant.
2839       If a list isn't loaded into the server, but some verify locations are set,
2840       the server end appears to make a wildcard request for client certs.
2841       Meanwhile, the client library as default behaviour *ignores* the list
2842       we send over the wire - see man SSL_CTX_set_client_cert_cb.
2843       Because of this, and that the dir variant is likely only used for
2844       the public-CA bundle (not for a private CA), not worth fixing.  */
2845
2846       if (file)
2847         {
2848         STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
2849         int i = sk_X509_NAME_num(names);
2850
2851         if (!host) SSL_CTX_set_client_CA_list(sctx, names);
2852         DEBUG(D_tls) debug_printf("Added %d additional certificate authorit%s\n",
2853                                     i, i>1 ? "ies":"y");
2854         }
2855       else
2856         DEBUG(D_tls)
2857           debug_printf("Added dir for additional certificate authorities\n");
2858       }
2859     }
2860
2861   /* Handle a certificate revocation list. */
2862
2863 #if OPENSSL_VERSION_NUMBER > 0x00907000L
2864
2865   /* This bit of code is now the version supplied by Lars Mainka. (I have
2866   merely reformatted it into the Exim code style.)
2867
2868   "From here I changed the code to add support for multiple crl's
2869   in pem format in one file or to support hashed directory entries in
2870   pem format instead of a file. This method now uses the library function
2871   X509_STORE_load_locations to add the CRL location to the SSL context.
2872   OpenSSL will then handle the verify against CA certs and CRLs by
2873   itself in the verify callback." */
2874
2875   if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
2876   if (expcrl && *expcrl)
2877     {
2878     struct stat statbufcrl;
2879     if (Ustat(expcrl, &statbufcrl) < 0)
2880       {
2881       log_write(0, LOG_MAIN|LOG_PANIC,
2882         "failed to stat %s for certificates revocation lists", expcrl);
2883       return DEFER;
2884       }
2885     else
2886       {
2887       /* is it a file or directory? */
2888       uschar *file, *dir;
2889       X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
2890       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
2891         {
2892         file = NULL;
2893         dir = expcrl;
2894         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
2895         }
2896       else
2897         {
2898         file = expcrl;
2899         dir = NULL;
2900         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
2901         }
2902       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
2903         return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
2904
2905       /* setting the flags to check against the complete crl chain */
2906
2907       X509_STORE_set_flags(cvstore,
2908         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
2909       }
2910     }
2911
2912 #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
2913   }
2914
2915 return OK;
2916 }
2917
2918
2919
2920 /*************************************************
2921 *       Start a TLS session in a server          *
2922 *************************************************/
2923 /* This is called when Exim is running as a server, after having received
2924 the STARTTLS command. It must respond to that command, and then negotiate
2925 a TLS session.
2926
2927 Arguments:
2928   errstr            pointer to error message
2929
2930 Returns:            OK on success
2931                     DEFER for errors before the start of the negotiation
2932                     FAIL for errors during the negotiation; the server can't
2933                       continue running.
2934 */
2935
2936 int
2937 tls_server_start(uschar ** errstr)
2938 {
2939 int rc;
2940 uschar * expciphers;
2941 exim_openssl_state_st * dummy_statep;
2942 SSL_CTX * ctx;
2943 SSL * ssl;
2944 static uschar peerdn[256];
2945
2946 /* Check for previous activation */
2947
2948 if (tls_in.active.sock >= 0)
2949   {
2950   tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
2951   smtp_printf("554 Already in TLS\r\n", FALSE);
2952   return FAIL;
2953   }
2954
2955 /* Initialize the SSL library. If it fails, it will already have logged
2956 the error. */
2957
2958 rc = tls_init(NULL, NULL,
2959 #ifndef DISABLE_OCSP
2960     tls_ocsp_file,
2961 #endif
2962     NULL, &dummy_statep, &tls_in, errstr);
2963 if (rc != OK) return rc;
2964 ctx = state_server.lib_state.lib_ctx;
2965
2966 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2967 were historically separated by underscores. So that I can use either form in my
2968 tests, and also for general convenience, we turn underscores into hyphens here.
2969
2970 XXX SSL_CTX_set_cipher_list() is replaced by SSL_CTX_set_ciphersuites()
2971 for TLS 1.3 .  Since we do not call it at present we get the default list:
2972 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
2973 */
2974
2975 if (state_server.lib_state.pri_string)
2976   { DEBUG(D_tls) debug_printf("TLS: cipher list was preloaded\n"); }
2977 else
2978   {
2979   if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
2980     return FAIL;
2981
2982   if (  expciphers
2983      && (rc = server_load_ciphers(ctx, &state_server, expciphers, errstr)) != OK)
2984     return rc;
2985   }
2986
2987 /* If this is a host for which certificate verification is mandatory or
2988 optional, set up appropriately. */
2989
2990 tls_in.certificate_verified = FALSE;
2991 #ifdef SUPPORT_DANE
2992 tls_in.dane_verified = FALSE;
2993 #endif
2994 server_verify_callback_called = FALSE;
2995
2996 if (verify_check_host(&tls_verify_hosts) == OK)
2997   server_verify_optional = FALSE;
2998 else if (verify_check_host(&tls_try_verify_hosts) == OK)
2999   server_verify_optional = TRUE;
3000 else
3001   goto skip_certs;
3002
3003   {
3004   uschar * expcerts;
3005   if (!expand_check(tls_verify_certificates, US"tls_verify_certificates",
3006                     &expcerts, errstr))
3007     return DEFER;
3008   DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
3009
3010   if (state_server.lib_state.cabundle)
3011     { DEBUG(D_tls) debug_printf("TLS: CA bundle for server was preloaded\n"); }
3012   else
3013     if ((rc = setup_certs(ctx, expcerts, tls_crl, NULL, errstr)) != OK)
3014       return rc;
3015
3016   if (expcerts && *expcerts)
3017     setup_cert_verify(ctx, server_verify_optional, verify_callback_server);
3018   }
3019 skip_certs: ;
3020
3021 #ifndef DISABLE_TLS_RESUME
3022 SSL_CTX_set_tlsext_ticket_key_cb(ctx, ticket_key_callback);
3023 /* despite working, appears to always return failure, so ignoring */
3024 #endif
3025 #ifdef OPENSSL_HAVE_NUM_TICKETS
3026 # ifndef DISABLE_TLS_RESUME
3027 SSL_CTX_set_num_tickets(ctx, tls_in.host_resumable ? 1 : 0);
3028 # else
3029 SSL_CTX_set_num_tickets(ctx, 0);        /* send no TLS1.3 stateful-tickets */
3030 # endif
3031 #endif
3032
3033
3034 /* Prepare for new connection */
3035
3036 if (!(ssl = SSL_new(ctx)))
3037   return tls_error(US"SSL_new", NULL, NULL, errstr);
3038 state_server.lib_state.lib_ssl = ssl;
3039
3040 /* Warning: we used to SSL_clear(ssl) here, it was removed.
3041  *
3042  * With the SSL_clear(), we get strange interoperability bugs with
3043  * OpenSSL 1.0.1b and TLS1.1/1.2.  It looks as though this may be a bug in
3044  * OpenSSL itself, as a clear should not lead to inability to follow protocols.
3045  *
3046  * The SSL_clear() call is to let an existing SSL* be reused, typically after
3047  * session shutdown.  In this case, we have a brand new object and there's no
3048  * obvious reason to immediately clear it.  I'm guessing that this was
3049  * originally added because of incomplete initialisation which the clear fixed,
3050  * in some historic release.
3051  */
3052
3053 /* Set context and tell client to go ahead, except in the case of TLS startup
3054 on connection, where outputting anything now upsets the clients and tends to
3055 make them disconnect. We need to have an explicit fflush() here, to force out
3056 the response. Other smtp_printf() calls do not need it, because in non-TLS
3057 mode, the fflush() happens when smtp_getc() is called. */
3058
3059 SSL_set_session_id_context(ssl, sid_ctx, Ustrlen(sid_ctx));
3060 if (!tls_in.on_connect)
3061   {
3062   smtp_printf("220 TLS go ahead\r\n", FALSE);
3063   fflush(smtp_out);
3064   }
3065
3066 /* Now negotiate the TLS session. We put our own timer on it, since it seems
3067 that the OpenSSL library doesn't. */
3068
3069 SSL_set_wfd(ssl, fileno(smtp_out));
3070 SSL_set_rfd(ssl, fileno(smtp_in));
3071 SSL_set_accept_state(ssl);
3072
3073 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
3074
3075 ERR_clear_error();
3076 sigalrm_seen = FALSE;
3077 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3078 rc = SSL_accept(ssl);
3079 ALARM_CLR(0);
3080
3081 if (rc <= 0)
3082   {
3083   int error = SSL_get_error(ssl, rc);
3084   switch(error)
3085     {
3086     case SSL_ERROR_NONE:
3087       break;
3088
3089     case SSL_ERROR_ZERO_RETURN:
3090       DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3091       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
3092
3093       if (SSL_get_shutdown(ssl) == SSL_RECEIVED_SHUTDOWN)
3094             SSL_shutdown(ssl);
3095
3096       tls_close(NULL, TLS_NO_SHUTDOWN);
3097       return FAIL;
3098
3099     /* Handle genuine errors */
3100     case SSL_ERROR_SSL:
3101       {
3102       uschar * s = US"SSL_accept";
3103       int r = ERR_GET_REASON(ERR_peek_error());
3104       if (  r == SSL_R_WRONG_VERSION_NUMBER
3105 #ifdef SSL_R_VERSION_TOO_LOW
3106          || r == SSL_R_VERSION_TOO_LOW
3107 #endif
3108          || r == SSL_R_UNKNOWN_PROTOCOL || r == SSL_R_UNSUPPORTED_PROTOCOL)
3109         s = string_sprintf("%s (%s)", s, SSL_get_version(ssl));
3110       (void) tls_error(s, NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
3111       return FAIL;
3112       }
3113
3114     default:
3115       DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
3116       if (error == SSL_ERROR_SYSCALL)
3117         {
3118         if (!errno)
3119           {
3120           *errstr = US"SSL_accept: TCP connection closed by peer";
3121           return FAIL;
3122           }
3123         DEBUG(D_tls) debug_printf(" - syscall %s\n", strerror(errno));
3124         }
3125       (void) tls_error(US"SSL_accept", NULL,
3126                       sigalrm_seen ? US"timed out"
3127                       : ERR_peek_error() ? NULL : string_sprintf("ret %d", error),
3128                       errstr);
3129       return FAIL;
3130     }
3131   }
3132
3133 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
3134 ERR_clear_error();      /* Even success can leave errors in the stack. Seen with
3135                         anon-authentication ciphersuite negotiated. */
3136
3137 #ifndef DISABLE_TLS_RESUME
3138 if (SSL_session_reused(ssl))
3139   {
3140   tls_in.resumption |= RESUME_USED;
3141   DEBUG(D_tls) debug_printf("Session reused\n");
3142   }
3143 #endif
3144
3145 /* TLS has been set up. Record data for the connection,
3146 adjust the input functions to read via TLS, and initialize things. */
3147
3148 #ifdef SSL_get_extms_support
3149 tls_in.ext_master_secret = SSL_get_extms_support(ssl) == 1;
3150 #endif
3151 peer_cert(ssl, &tls_in, peerdn, sizeof(peerdn));
3152
3153 tls_in.ver = tlsver_name(ssl);
3154 tls_in.cipher = construct_cipher_name(ssl, tls_in.ver, &tls_in.bits);
3155 tls_in.cipher_stdname = cipher_stdname_ssl(ssl);
3156
3157 DEBUG(D_tls)
3158   {
3159   uschar buf[2048];
3160   if (SSL_get_shared_ciphers(ssl, CS buf, sizeof(buf)))
3161     debug_printf("Shared ciphers: %s\n", buf);
3162
3163 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3164   {
3165   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
3166   SSL_SESSION_print_keylog(bp, SSL_get_session(ssl));
3167   BIO_free(bp);
3168   }
3169 #endif
3170
3171 #ifdef EXIM_HAVE_SESSION_TICKET
3172   {
3173   SSL_SESSION * ss = SSL_get_session(ssl);
3174   if (SSL_SESSION_has_ticket(ss))       /* 1.1.0 */
3175     debug_printf("The session has a ticket, life %lu seconds\n",
3176       SSL_SESSION_get_ticket_lifetime_hint(ss));
3177   }
3178 #endif
3179   }
3180
3181 /* Record the certificate we presented */
3182   {
3183   X509 * crt = SSL_get_certificate(ssl);
3184   tls_in.ourcert = crt ? X509_dup(crt) : NULL;
3185   }
3186
3187 /* Channel-binding info for authenticators
3188 See description in https://paquier.xyz/postgresql-2/channel-binding-openssl/ */
3189   {
3190   uschar c, * s;
3191   size_t len = SSL_get_peer_finished(ssl, &c, 0);
3192   int old_pool = store_pool;
3193
3194   SSL_get_peer_finished(ssl, s = store_get((int)len, FALSE), len);
3195   store_pool = POOL_PERM;
3196     tls_in.channelbinding = b64encode_taint(CUS s, (int)len, FALSE);
3197   store_pool = old_pool;
3198   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage %p\n", tls_in.channelbinding);
3199   }
3200
3201 /* Only used by the server-side tls (tls_in), including tls_getc.
3202    Client-side (tls_out) reads (seem to?) go via
3203    smtp_read_response()/ip_recv().
3204    Hence no need to duplicate for _in and _out.
3205  */
3206 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
3207 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
3208 ssl_xfer_eof = ssl_xfer_error = FALSE;
3209
3210 receive_getc = tls_getc;
3211 receive_getbuf = tls_getbuf;
3212 receive_get_cache = tls_get_cache;
3213 receive_ungetc = tls_ungetc;
3214 receive_feof = tls_feof;
3215 receive_ferror = tls_ferror;
3216 receive_smtp_buffered = tls_smtp_buffered;
3217
3218 tls_in.active.sock = fileno(smtp_out);
3219 tls_in.active.tls_ctx = NULL;   /* not using explicit ctx for server-side */
3220 return OK;
3221 }
3222
3223
3224
3225
3226 static int
3227 tls_client_basic_ctx_init(SSL_CTX * ctx,
3228     host_item * host, smtp_transport_options_block * ob, exim_openssl_state_st * state,
3229     uschar ** errstr)
3230 {
3231 int rc;
3232
3233 /* Back-compatible old behaviour if tls_verify_certificates is set but both
3234 tls_verify_hosts and tls_try_verify_hosts are not set. Check only the specified
3235 host patterns if one of them is set with content. */
3236
3237 if (  (  (  !ob->tls_verify_hosts || !ob->tls_verify_hosts
3238          || Ustrcmp(ob->tls_try_verify_hosts, ":") == 0
3239          )
3240       && (  !ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts
3241          || Ustrcmp(ob->tls_try_verify_hosts, ":") == 0
3242          )
3243       )
3244    || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
3245    )
3246   client_verify_optional = FALSE;
3247 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
3248   client_verify_optional = TRUE;
3249 else
3250   return OK;
3251
3252   {
3253   uschar * expcerts;
3254   if (!expand_check(ob->tls_verify_certificates, US"tls_verify_certificates",
3255                     &expcerts, errstr))
3256     return DEFER;
3257   DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
3258
3259   if (state->lib_state.cabundle)
3260     { DEBUG(D_tls) debug_printf("TLS: CA bundle was preloaded\n"); }
3261   else
3262     if ((rc = setup_certs(ctx, expcerts, ob->tls_crl, host, errstr)) != OK)
3263       return rc;
3264
3265   if (expcerts && *expcerts)
3266     setup_cert_verify(ctx, client_verify_optional, verify_callback_client);
3267   }
3268
3269 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
3270   {
3271   state->verify_cert_hostnames =
3272 #ifdef SUPPORT_I18N
3273     string_domain_utf8_to_alabel(host->certname, NULL);
3274 #else
3275     host->certname;
3276 #endif
3277   DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
3278                     state->verify_cert_hostnames);
3279   }
3280 return OK;
3281 }
3282
3283
3284 #ifdef SUPPORT_DANE
3285 static int
3286 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
3287 {
3288 dns_scan dnss;
3289 const char * hostnames[2] = { CS host->name, NULL };
3290 int found = 0;
3291
3292 if (DANESSL_init(ssl, NULL, hostnames) != 1)
3293   return tls_error(US"hostnames load", host, NULL, errstr);
3294
3295 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
3296      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
3297     ) if (rr->type == T_TLSA && rr->size > 3)
3298   {
3299   const uschar * p = rr->data;
3300   uint8_t usage, selector, mtype;
3301   const char * mdname;
3302
3303   usage = *p++;
3304
3305   /* Only DANE-TA(2) and DANE-EE(3) are supported */
3306   if (usage != 2 && usage != 3) continue;
3307
3308   selector = *p++;
3309   mtype = *p++;
3310
3311   switch (mtype)
3312     {
3313     default: continue;  /* Only match-types 0, 1, 2 are supported */
3314     case 0:  mdname = NULL; break;
3315     case 1:  mdname = "sha256"; break;
3316     case 2:  mdname = "sha512"; break;
3317     }
3318
3319   found++;
3320   switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
3321     {
3322     default:
3323       return tls_error(US"tlsa load", host, NULL, errstr);
3324     case 0:     /* action not taken */
3325     case 1:     break;
3326     }
3327
3328   tls_out.tlsa_usage |= 1<<usage;
3329   }
3330
3331 if (found)
3332   return OK;
3333
3334 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
3335 return DEFER;
3336 }
3337 #endif  /*SUPPORT_DANE*/
3338
3339
3340
3341 #ifndef DISABLE_TLS_RESUME
3342 /* On the client, get any stashed session for the given IP from hints db
3343 and apply it to the ssl-connection for attempted resumption. */
3344
3345 static void
3346 tls_retrieve_session(tls_support * tlsp, SSL * ssl, const uschar * key)
3347 {
3348 tlsp->resumption |= RESUME_SUPPORTED;
3349 if (tlsp->host_resumable)
3350   {
3351   dbdata_tls_session * dt;
3352   int len;
3353   open_db dbblock, * dbm_file;
3354
3355   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
3356   DEBUG(D_tls) debug_printf("checking for resumable session for %s\n", key);
3357   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3358     {
3359     /* key for the db is the IP */
3360     if ((dt = dbfn_read_with_length(dbm_file, key, &len)))
3361       {
3362       SSL_SESSION * ss = NULL;
3363       const uschar * sess_asn1 = dt->session;
3364
3365       len -= sizeof(dbdata_tls_session);
3366       if (!(d2i_SSL_SESSION(&ss, &sess_asn1, (long)len)))
3367         {
3368         DEBUG(D_tls)
3369           {
3370           ERR_error_string_n(ERR_get_error(),
3371             ssl_errstring, sizeof(ssl_errstring));
3372           debug_printf("decoding session: %s\n", ssl_errstring);
3373           }
3374         }
3375 #ifdef EXIM_HAVE_SESSION_TICKET
3376       else if ( SSL_SESSION_get_ticket_lifetime_hint(ss) + dt->time_stamp
3377                < time(NULL))
3378         {
3379         DEBUG(D_tls) debug_printf("session expired\n");
3380         dbfn_delete(dbm_file, key);
3381         }
3382 #endif
3383       else if (!SSL_set_session(ssl, ss))
3384         {
3385         DEBUG(D_tls)
3386           {
3387           ERR_error_string_n(ERR_get_error(),
3388             ssl_errstring, sizeof(ssl_errstring));
3389           debug_printf("applying session to ssl: %s\n", ssl_errstring);
3390           }
3391         }
3392       else
3393         {
3394         DEBUG(D_tls) debug_printf("good session\n");
3395         tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
3396         tlsp->verify_override = dt->verify_override;
3397         tlsp->ocsp = dt->ocsp;
3398         }
3399       }
3400     else
3401       DEBUG(D_tls) debug_printf("no session record\n");
3402     dbfn_close(dbm_file);
3403     }
3404   }
3405 }
3406
3407
3408 /* On the client, save the session for later resumption */
3409
3410 static int
3411 tls_save_session_cb(SSL * ssl, SSL_SESSION * ss)
3412 {
3413 exim_openssl_state_st * cbinfo = SSL_get_ex_data(ssl, tls_exdata_idx);
3414 tls_support * tlsp;
3415
3416 DEBUG(D_tls) debug_printf("tls_save_session_cb\n");
3417
3418 if (!cbinfo || !(tlsp = cbinfo->tlsp)->host_resumable) return 0;
3419
3420 # ifdef OPENSSL_HAVE_NUM_TICKETS
3421 if (SSL_SESSION_is_resumable(ss))       /* 1.1.1 */
3422 # endif
3423   {
3424   int len = i2d_SSL_SESSION(ss, NULL);
3425   int dlen = sizeof(dbdata_tls_session) + len;
3426   dbdata_tls_session * dt = store_get(dlen, TRUE);
3427   uschar * s = dt->session;
3428   open_db dbblock, * dbm_file;
3429
3430   DEBUG(D_tls) debug_printf("session is resumable\n");
3431   tlsp->resumption |= RESUME_SERVER_TICKET;     /* server gave us a ticket */
3432
3433   dt->verify_override = tlsp->verify_override;
3434   dt->ocsp = tlsp->ocsp;
3435   (void) i2d_SSL_SESSION(ss, &s);               /* s gets bumped to end */
3436
3437   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3438     {
3439     const uschar * key = cbinfo->host->address;
3440     dbfn_delete(dbm_file, key);
3441     dbfn_write(dbm_file, key, dt, dlen);
3442     dbfn_close(dbm_file);
3443     DEBUG(D_tls) debug_printf("wrote session (len %u) to db\n",
3444                   (unsigned)dlen);
3445     }
3446   }
3447 return 1;
3448 }
3449
3450
3451 static void
3452 tls_client_ctx_resume_prehandshake(
3453   exim_openssl_client_tls_ctx * exim_client_ctx, tls_support * tlsp,
3454   smtp_transport_options_block * ob, host_item * host)
3455 {
3456 /* Should the client request a session resumption ticket? */
3457 if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
3458   {
3459   tlsp->host_resumable = TRUE;
3460
3461   SSL_CTX_set_session_cache_mode(exim_client_ctx->ctx,
3462         SSL_SESS_CACHE_CLIENT
3463         | SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_NO_AUTO_CLEAR);
3464   SSL_CTX_sess_set_new_cb(exim_client_ctx->ctx, tls_save_session_cb);
3465   }
3466 }
3467
3468 static BOOL
3469 tls_client_ssl_resume_prehandshake(SSL * ssl, tls_support * tlsp,
3470   host_item * host, uschar ** errstr)
3471 {
3472 if (tlsp->host_resumable)
3473   {
3474   DEBUG(D_tls)
3475     debug_printf("tls_resumption_hosts overrides openssl_options, enabling tickets\n");
3476   SSL_clear_options(ssl, SSL_OP_NO_TICKET);
3477
3478   tls_exdata_idx = SSL_get_ex_new_index(0, 0, 0, 0, 0);
3479   if (!SSL_set_ex_data(ssl, tls_exdata_idx, client_static_state))
3480     {
3481     tls_error(US"set ex_data", host, NULL, errstr);
3482     return FALSE;
3483     }
3484   debug_printf("tls_exdata_idx %d cbinfo %p\n", tls_exdata_idx, client_static_state);
3485   }
3486
3487 tlsp->resumption = RESUME_SUPPORTED;
3488 /* Pick up a previous session, saved on an old ticket */
3489 tls_retrieve_session(tlsp, ssl, host->address);
3490 return TRUE;
3491 }
3492
3493 static void
3494 tls_client_resume_posthandshake(exim_openssl_client_tls_ctx * exim_client_ctx,
3495   tls_support * tlsp)
3496 {
3497 if (SSL_session_reused(exim_client_ctx->ssl))
3498   {
3499   DEBUG(D_tls) debug_printf("The session was reused\n");
3500   tlsp->resumption |= RESUME_USED;
3501   }
3502 }
3503 #endif  /* !DISABLE_TLS_RESUME */
3504
3505
3506 /*************************************************
3507 *    Start a TLS session in a client             *
3508 *************************************************/
3509
3510 /* Called from the smtp transport after STARTTLS has been accepted.
3511
3512 Arguments:
3513   cctx          connection context
3514   conn_args     connection details
3515   cookie        datum for randomness; can be NULL
3516   tlsp          record details of TLS channel configuration here; must be non-NULL
3517   errstr        error string pointer
3518
3519 Returns:        TRUE for success with TLS session context set in connection context,
3520                 FALSE on error
3521 */
3522
3523 BOOL
3524 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
3525   void * cookie, tls_support * tlsp, uschar ** errstr)
3526 {
3527 host_item * host = conn_args->host;             /* for msgs and option-tests */
3528 transport_instance * tb = conn_args->tblock;    /* always smtp or NULL */
3529 smtp_transport_options_block * ob = tb
3530   ? (smtp_transport_options_block *)tb->options_block
3531   : &smtp_transport_option_defaults;
3532 exim_openssl_client_tls_ctx * exim_client_ctx;
3533 uschar * expciphers;
3534 int rc;
3535 static uschar peerdn[256];
3536
3537 #ifndef DISABLE_OCSP
3538 BOOL request_ocsp = FALSE;
3539 BOOL require_ocsp = FALSE;
3540 #endif
3541
3542 rc = store_pool;
3543 store_pool = POOL_PERM;
3544 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx), FALSE);
3545 exim_client_ctx->corked = NULL;
3546 store_pool = rc;
3547
3548 #ifdef SUPPORT_DANE
3549 tlsp->tlsa_usage = 0;
3550 #endif
3551
3552 #ifndef DISABLE_OCSP
3553   {
3554 # ifdef SUPPORT_DANE
3555   /*XXX this should be moved to caller, to be common across gnutls/openssl */
3556   if (  conn_args->dane
3557      && ob->hosts_request_ocsp[0] == '*'
3558      && ob->hosts_request_ocsp[1] == '\0'
3559      )
3560     {
3561     /* Unchanged from default.  Use a safer one under DANE */
3562     request_ocsp = TRUE;
3563     ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
3564                                       "   {= {4}{$tls_out_tlsa_usage}} } "
3565                                  " {*}{}}";
3566     }
3567 # endif
3568
3569   if ((require_ocsp =
3570         verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK))
3571     request_ocsp = TRUE;
3572   else
3573 # ifdef SUPPORT_DANE
3574     if (!request_ocsp)
3575 # endif
3576       request_ocsp =
3577         verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3578   }
3579 #endif
3580
3581 rc = tls_init(host, ob,
3582 #ifndef DISABLE_OCSP
3583     (void *)(long)request_ocsp,
3584 #endif
3585     cookie, &client_static_state, tlsp, errstr);
3586 if (rc != OK) return FALSE;
3587
3588 exim_client_ctx->ctx = client_static_state->lib_state.lib_ctx;
3589
3590 tlsp->certificate_verified = FALSE;
3591 client_verify_callback_called = FALSE;
3592
3593 expciphers = NULL;
3594 #ifdef SUPPORT_DANE
3595 if (conn_args->dane)
3596   {
3597   /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
3598   other failures should be treated as problems. */
3599   if (ob->dane_require_tls_ciphers &&
3600       !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
3601         &expciphers, errstr))
3602     return FALSE;
3603   if (expciphers && *expciphers == '\0')
3604     expciphers = NULL;
3605   }
3606 #endif
3607 if (!expciphers &&
3608     !expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
3609       &expciphers, errstr))
3610   return FALSE;
3611
3612 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
3613 are separated by underscores. So that I can use either form in my tests, and
3614 also for general convenience, we turn underscores into hyphens here. */
3615
3616 if (expciphers)
3617   {
3618   uschar *s = expciphers;
3619   while (*s) { if (*s == '_') *s = '-'; s++; }
3620   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
3621   if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
3622     {
3623     tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
3624     return FALSE;
3625     }
3626   }
3627
3628 #ifdef SUPPORT_DANE
3629 if (conn_args->dane)
3630   {
3631   SSL_CTX_set_verify(exim_client_ctx->ctx,
3632     SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
3633     verify_callback_client_dane);
3634
3635   if (!DANESSL_library_init())
3636     {
3637     tls_error(US"library init", host, NULL, errstr);
3638     return FALSE;
3639     }
3640   if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
3641     {
3642     tls_error(US"context init", host, NULL, errstr);
3643     return FALSE;
3644     }
3645   }
3646 else
3647
3648 #endif
3649
3650 if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
3651       client_static_state, errstr) != OK)
3652   return FALSE;
3653
3654 #ifndef DISABLE_TLS_RESUME
3655 tls_client_ctx_resume_prehandshake(exim_client_ctx, tlsp, ob, host);
3656 #endif
3657
3658
3659 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
3660   {
3661   tls_error(US"SSL_new", host, NULL, errstr);
3662   return FALSE;
3663   }
3664 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
3665
3666 SSL_set_fd(exim_client_ctx->ssl, cctx->sock);
3667 SSL_set_connect_state(exim_client_ctx->ssl);
3668
3669 if (ob->tls_sni)
3670   {
3671   if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
3672     return FALSE;
3673   if (!tlsp->sni)
3674     {
3675     DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
3676     }
3677   else if (!Ustrlen(tlsp->sni))
3678     tlsp->sni = NULL;
3679   else
3680     {
3681 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
3682     DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
3683     SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
3684 #else
3685     log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
3686           tlsp->sni);
3687 #endif
3688     }
3689   }
3690
3691 #ifdef SUPPORT_DANE
3692 if (conn_args->dane)
3693   if (dane_tlsa_load(exim_client_ctx->ssl, host, &conn_args->tlsa_dnsa, errstr) != OK)
3694     return FALSE;
3695 #endif
3696
3697 #ifndef DISABLE_OCSP
3698 /* Request certificate status at connection-time.  If the server
3699 does OCSP stapling we will get the callback (set in tls_init()) */
3700 # ifdef SUPPORT_DANE
3701 if (request_ocsp)
3702   {
3703   const uschar * s;
3704   if (  ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3705      || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3706      )
3707     {   /* Re-eval now $tls_out_tlsa_usage is populated.  If
3708         this means we avoid the OCSP request, we wasted the setup
3709         cost in tls_init(). */
3710     require_ocsp = verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
3711     request_ocsp = require_ocsp
3712       || verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3713     }
3714   }
3715 # endif
3716
3717 if (request_ocsp)
3718   {
3719   SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
3720   client_static_state->u_ocsp.client.verify_required = require_ocsp;
3721   tlsp->ocsp = OCSP_NOT_RESP;
3722   }
3723 #endif
3724
3725 #ifndef DISABLE_TLS_RESUME
3726 if (!tls_client_ssl_resume_prehandshake(exim_client_ctx->ssl, tlsp, host,
3727       errstr))
3728   return FALSE;
3729 #endif
3730
3731 #ifndef DISABLE_EVENT
3732 client_static_state->event_action = tb ? tb->event_action : NULL;
3733 #endif
3734
3735 /* There doesn't seem to be a built-in timeout on connection. */
3736
3737 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
3738 sigalrm_seen = FALSE;
3739 ALARM(ob->command_timeout);
3740 rc = SSL_connect(exim_client_ctx->ssl);
3741 ALARM_CLR(0);
3742
3743 #ifdef SUPPORT_DANE
3744 if (conn_args->dane)
3745   DANESSL_cleanup(exim_client_ctx->ssl);
3746 #endif
3747
3748 if (rc <= 0)
3749   {
3750   tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
3751   return FALSE;
3752   }
3753
3754 DEBUG(D_tls)
3755   {
3756   debug_printf("SSL_connect succeeded\n");
3757 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3758   {
3759   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
3760   SSL_SESSION_print_keylog(bp, SSL_get_session(exim_client_ctx->ssl));
3761   BIO_free(bp);
3762   }
3763 #endif
3764   }
3765
3766 #ifndef DISABLE_TLS_RESUME
3767 tls_client_resume_posthandshake(exim_client_ctx, tlsp);
3768 #endif
3769
3770 #ifdef SSL_get_extms_support
3771 tlsp->ext_master_secret = SSL_get_extms_support(exim_client_ctx->ssl) == 1;
3772 #endif
3773 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
3774
3775 tlsp->ver = tlsver_name(exim_client_ctx->ssl);
3776 tlsp->cipher = construct_cipher_name(exim_client_ctx->ssl, tlsp->ver, &tlsp->bits);
3777 tlsp->cipher_stdname = cipher_stdname_ssl(exim_client_ctx->ssl);
3778
3779 /* Record the certificate we presented */
3780   {
3781   X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
3782   tlsp->ourcert = crt ? X509_dup(crt) : NULL;
3783   }
3784
3785 /*XXX will this work with continued-TLS? */
3786 /* Channel-binding info for authenticators */
3787   {
3788   uschar c, * s;
3789   size_t len = SSL_get_finished(exim_client_ctx->ssl, &c, 0);
3790   int old_pool = store_pool;
3791
3792   SSL_get_finished(exim_client_ctx->ssl, s = store_get((int)len, TRUE), len);
3793   store_pool = POOL_PERM;
3794     tlsp->channelbinding = b64encode_taint(CUS s, (int)len, TRUE);
3795   store_pool = old_pool;
3796   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage %p %p\n", tlsp->channelbinding, tlsp);
3797   }
3798
3799 tlsp->active.sock = cctx->sock;
3800 tlsp->active.tls_ctx = exim_client_ctx;
3801 cctx->tls_ctx = exim_client_ctx;
3802 return TRUE;
3803 }
3804
3805
3806
3807
3808
3809 static BOOL
3810 tls_refill(unsigned lim)
3811 {
3812 SSL * ssl = state_server.lib_state.lib_ssl;
3813 int error;
3814 int inbytes;
3815
3816 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
3817   ssl_xfer_buffer, ssl_xfer_buffer_size);
3818
3819 ERR_clear_error();
3820 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3821 inbytes = SSL_read(ssl, CS ssl_xfer_buffer,
3822                   MIN(ssl_xfer_buffer_size, lim));
3823 error = SSL_get_error(ssl, inbytes);
3824 if (smtp_receive_timeout > 0) ALARM_CLR(0);
3825
3826 if (had_command_timeout)                /* set by signal handler */
3827   smtp_command_timeout_exit();          /* does not return */
3828 if (had_command_sigterm)
3829   smtp_command_sigterm_exit();
3830 if (had_data_timeout)
3831   smtp_data_timeout_exit();
3832 if (had_data_sigint)
3833   smtp_data_sigint_exit();
3834
3835 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
3836 closed down, not that the socket itself has been closed down. Revert to
3837 non-SSL handling. */
3838
3839 switch(error)
3840   {
3841   case SSL_ERROR_NONE:
3842     break;
3843
3844   case SSL_ERROR_ZERO_RETURN:
3845     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3846
3847     if (SSL_get_shutdown(ssl) == SSL_RECEIVED_SHUTDOWN)
3848           SSL_shutdown(ssl);
3849
3850     tls_close(NULL, TLS_NO_SHUTDOWN);
3851     return FALSE;
3852
3853   /* Handle genuine errors */
3854   case SSL_ERROR_SSL:
3855     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3856     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
3857     ssl_xfer_error = TRUE;
3858     return FALSE;
3859
3860   default:
3861     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
3862     DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
3863       debug_printf(" - syscall %s\n", strerror(errno));
3864     ssl_xfer_error = TRUE;
3865     return FALSE;
3866   }
3867
3868 #ifndef DISABLE_DKIM
3869 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
3870 #endif
3871 ssl_xfer_buffer_hwm = inbytes;
3872 ssl_xfer_buffer_lwm = 0;
3873 return TRUE;
3874 }
3875
3876
3877 /*************************************************
3878 *            TLS version of getc                 *
3879 *************************************************/
3880
3881 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
3882 it refills the buffer via the SSL reading function.
3883
3884 Arguments:  lim         Maximum amount to read/buffer
3885 Returns:    the next character or EOF
3886
3887 Only used by the server-side TLS.
3888 */
3889
3890 int
3891 tls_getc(unsigned lim)
3892 {
3893 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
3894   if (!tls_refill(lim))
3895     return ssl_xfer_error ? EOF : smtp_getc(lim);
3896
3897 /* Something in the buffer; return next uschar */
3898
3899 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
3900 }
3901
3902 uschar *
3903 tls_getbuf(unsigned * len)
3904 {
3905 unsigned size;
3906 uschar * buf;
3907
3908 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
3909   if (!tls_refill(*len))
3910     {
3911     if (!ssl_xfer_error) return smtp_getbuf(len);
3912     *len = 0;
3913     return NULL;
3914     }
3915
3916 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
3917   size = *len;
3918 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
3919 ssl_xfer_buffer_lwm += size;
3920 *len = size;
3921 return buf;
3922 }
3923
3924
3925 void
3926 tls_get_cache()
3927 {
3928 #ifndef DISABLE_DKIM
3929 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
3930 if (n > 0)
3931   dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
3932 #endif
3933 }
3934
3935
3936 BOOL
3937 tls_could_read(void)
3938 {
3939 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm
3940       || SSL_pending(state_server.lib_state.lib_ssl) > 0;
3941 }
3942
3943
3944 /*************************************************
3945 *          Read bytes from TLS channel           *
3946 *************************************************/
3947
3948 /*
3949 Arguments:
3950   ct_ctx    client context pointer, or NULL for the one global server context
3951   buff      buffer of data
3952   len       size of buffer
3953
3954 Returns:    the number of bytes read
3955             -1 after a failed read, including EOF
3956
3957 Only used by the client-side TLS.
3958 */
3959
3960 int
3961 tls_read(void * ct_ctx, uschar *buff, size_t len)
3962 {
3963 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl
3964                   : state_server.lib_state.lib_ssl;
3965 int inbytes;
3966 int error;
3967
3968 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
3969   buff, (unsigned int)len);
3970
3971 ERR_clear_error();
3972 inbytes = SSL_read(ssl, CS buff, len);
3973 error = SSL_get_error(ssl, inbytes);
3974
3975 if (error == SSL_ERROR_ZERO_RETURN)
3976   {
3977   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3978   return -1;
3979   }
3980 else if (error != SSL_ERROR_NONE)
3981   return -1;
3982
3983 return inbytes;
3984 }
3985
3986
3987
3988
3989
3990 /*************************************************
3991 *         Write bytes down TLS channel           *
3992 *************************************************/
3993
3994 /*
3995 Arguments:
3996   ct_ctx    client context pointer, or NULL for the one global server context
3997   buff      buffer of data
3998   len       number of bytes
3999   more      further data expected soon
4000
4001 Returns:    the number of bytes after a successful write,
4002             -1 after a failed write
4003
4004 Used by both server-side and client-side TLS.  Calling with len zero and more unset
4005 will flush buffered writes; buff can be null for this case.
4006 */
4007
4008 int
4009 tls_write(void * ct_ctx, const uschar * buff, size_t len, BOOL more)
4010 {
4011 size_t olen = len;
4012 int outbytes, error;
4013 SSL * ssl = ct_ctx
4014   ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl
4015   : state_server.lib_state.lib_ssl;
4016 static gstring * server_corked = NULL;
4017 gstring ** corkedp = ct_ctx
4018   ? &((exim_openssl_client_tls_ctx *)ct_ctx)->corked : &server_corked;
4019 gstring * corked = *corkedp;
4020
4021 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
4022   buff, (unsigned long)len, more ? ", more" : "");
4023
4024 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
4025 "more" is notified.  This hack is only ok if small amounts are involved AND only
4026 one stream does it, in one context (i.e. no store reset).  Currently it is used
4027 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only.
4028 We support callouts done by the server process by using a separate client
4029 context for the stashed information. */
4030 /* + if PIPE_COMMAND, banner & ehlo-resp for smmtp-on-connect. Suspect there's
4031 a store reset there, so use POOL_PERM. */
4032 /* + if CHUNKING, cmds EHLO,MAIL,RCPT(s),BDAT */
4033
4034 if (more || corked)
4035   {
4036   if (!len) buff = US &error;   /* dummy just so that string_catn is ok */
4037
4038 #ifndef DISABLE_PIPE_CONNECT
4039   int save_pool = store_pool;
4040   store_pool = POOL_PERM;
4041 #endif
4042
4043   corked = string_catn(corked, buff, len);
4044
4045 #ifndef DISABLE_PIPE_CONNECT
4046   store_pool = save_pool;
4047 #endif
4048
4049   if (more)
4050     {
4051     *corkedp = corked;
4052     return len;
4053     }
4054   buff = CUS corked->s;
4055   len = corked->ptr;
4056   *corkedp = NULL;
4057   }
4058
4059 for (int left = len; left > 0;)
4060   {
4061   DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
4062   ERR_clear_error();
4063   outbytes = SSL_write(ssl, CS buff, left);
4064   error = SSL_get_error(ssl, outbytes);
4065   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
4066   switch (error)
4067     {
4068     case SSL_ERROR_NONE:        /* the usual case */
4069       left -= outbytes;
4070       buff += outbytes;
4071       break;
4072
4073     case SSL_ERROR_SSL:
4074       ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4075       log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
4076       return -1;
4077
4078     case SSL_ERROR_ZERO_RETURN:
4079       log_write(0, LOG_MAIN, "SSL channel closed on write");
4080       return -1;
4081
4082     case SSL_ERROR_SYSCALL:
4083       if (ct_ctx || errno != ECONNRESET || !f.smtp_in_quit)
4084         log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
4085           sender_fullhost ? sender_fullhost : US"<unknown>",
4086           strerror(errno));
4087       else if (LOGGING(protocol_detail))
4088         log_write(0, LOG_MAIN, "[%s] after QUIT, client reset TCP before"
4089           " SMTP response and TLS close\n", sender_host_address);
4090       else
4091         DEBUG(D_tls) debug_printf("[%s] SSL_write: after QUIT,"
4092           " client reset TCP before TLS close\n", sender_host_address);
4093       return -1;
4094
4095     default:
4096       log_write(0, LOG_MAIN, "SSL_write error %d", error);
4097       return -1;
4098     }
4099   }
4100 return olen;
4101 }
4102
4103
4104
4105 /*************************************************
4106 *         Close down a TLS session               *
4107 *************************************************/
4108
4109 /* This is also called from within a delivery subprocess forked from the
4110 daemon, to shut down the TLS library, without actually doing a shutdown (which
4111 would tamper with the SSL session in the parent process).
4112
4113 Arguments:
4114   ct_ctx        client TLS context pointer, or NULL for the one global server context
4115   shutdown      1 if TLS close-alert is to be sent,
4116                 2 if also response to be waited for
4117
4118 Returns:     nothing
4119
4120 Used by both server-side and client-side TLS.
4121 */
4122
4123 void
4124 tls_close(void * ct_ctx, int shutdown)
4125 {
4126 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
4127 SSL **sslp = o_ctx ? &o_ctx->ssl : (SSL **) &state_server.lib_state.lib_ssl;
4128 int *fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
4129
4130 if (*fdp < 0) return;  /* TLS was not active */
4131
4132 if (shutdown)
4133   {
4134   int rc;
4135   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
4136     shutdown > 1 ? " (with response-wait)" : "");
4137
4138   if (  (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
4139      && shutdown > 1)
4140     {
4141     ALARM(2);
4142     rc = SSL_shutdown(*sslp);           /* wait for response */
4143     ALARM_CLR(0);
4144     }
4145
4146   if (rc < 0) DEBUG(D_tls)
4147     {
4148     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4149     debug_printf("SSL_shutdown: %s\n", ssl_errstring);
4150     }
4151   }
4152
4153 if (!o_ctx)             /* server side */
4154   {
4155 #ifndef DISABLE_OCSP
4156   sk_X509_pop_free(state_server.verify_stack, X509_free);
4157   state_server.verify_stack = NULL;
4158 #endif
4159
4160   receive_getc =        smtp_getc;
4161   receive_getbuf =      smtp_getbuf;
4162   receive_get_cache =   smtp_get_cache;
4163   receive_ungetc =      smtp_ungetc;
4164   receive_feof =        smtp_feof;
4165   receive_ferror =      smtp_ferror;
4166   receive_smtp_buffered = smtp_buffered;
4167   tls_in.active.tls_ctx = NULL;
4168   tls_in.sni = NULL;
4169   /* Leave bits, peercert, cipher, peerdn, certificate_verified set, for logging */
4170   }
4171
4172 SSL_free(*sslp);
4173 *sslp = NULL;
4174 *fdp = -1;
4175 }
4176
4177
4178
4179
4180 /*************************************************
4181 *  Let tls_require_ciphers be checked at startup *
4182 *************************************************/
4183
4184 /* The tls_require_ciphers option, if set, must be something which the
4185 library can parse.
4186
4187 Returns:     NULL on success, or error message
4188 */
4189
4190 uschar *
4191 tls_validate_require_cipher(void)
4192 {
4193 SSL_CTX *ctx;
4194 uschar *s, *expciphers, *err;
4195
4196 tls_openssl_init();
4197
4198 if (!(tls_require_ciphers && *tls_require_ciphers))
4199   return NULL;
4200
4201 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
4202                   &err))
4203   return US"failed to expand tls_require_ciphers";
4204
4205 if (!(expciphers && *expciphers))
4206   return NULL;
4207
4208 /* normalisation ripped from above */
4209 s = expciphers;
4210 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
4211
4212 err = NULL;
4213
4214 if (lib_ctx_new(&ctx, NULL, &err) == OK)
4215   {
4216   DEBUG(D_tls)
4217     debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
4218
4219   if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
4220     {
4221     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4222     err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
4223                         expciphers, ssl_errstring);
4224     }
4225
4226   SSL_CTX_free(ctx);
4227   }
4228 return err;
4229 }
4230
4231
4232
4233
4234 /*************************************************
4235 *         Report the library versions.           *
4236 *************************************************/
4237
4238 /* There have historically been some issues with binary compatibility in
4239 OpenSSL libraries; if Exim (like many other applications) is built against
4240 one version of OpenSSL but the run-time linker picks up another version,
4241 it can result in serious failures, including crashing with a SIGSEGV.  So
4242 report the version found by the compiler and the run-time version.
4243
4244 Note: some OS vendors backport security fixes without changing the version
4245 number/string, and the version date remains unchanged.  The _build_ date
4246 will change, so we can more usefully assist with version diagnosis by also
4247 reporting the build date.
4248
4249 Arguments:   a FILE* to print the results to
4250 Returns:     nothing
4251 */
4252
4253 void
4254 tls_version_report(FILE *f)
4255 {
4256 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
4257            "                          Runtime: %s\n"
4258            "                                 : %s\n",
4259            OPENSSL_VERSION_TEXT,
4260            SSLeay_version(SSLEAY_VERSION),
4261            SSLeay_version(SSLEAY_BUILT_ON));
4262 /* third line is 38 characters for the %s and the line is 73 chars long;
4263 the OpenSSL output includes a "built on: " prefix already. */
4264 }
4265
4266
4267
4268
4269 /*************************************************
4270 *            Random number generation            *
4271 *************************************************/
4272
4273 /* Pseudo-random number generation.  The result is not expected to be
4274 cryptographically strong but not so weak that someone will shoot themselves
4275 in the foot using it as a nonce in input in some email header scheme or
4276 whatever weirdness they'll twist this into.  The result should handle fork()
4277 and avoid repeating sequences.  OpenSSL handles that for us.
4278
4279 Arguments:
4280   max       range maximum
4281 Returns     a random number in range [0, max-1]
4282 */
4283
4284 int
4285 vaguely_random_number(int max)
4286 {
4287 unsigned int r;
4288 int i, needed_len;
4289 static pid_t pidlast = 0;
4290 pid_t pidnow;
4291 uschar smallbuf[sizeof(r)];
4292
4293 if (max <= 1)
4294   return 0;
4295
4296 pidnow = getpid();
4297 if (pidnow != pidlast)
4298   {
4299   /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
4300   is unique for each thread", this doesn't apparently apply across processes,
4301   so our own warning from vaguely_random_number_fallback() applies here too.
4302   Fix per PostgreSQL. */
4303   if (pidlast != 0)
4304     RAND_cleanup();
4305   pidlast = pidnow;
4306   }
4307
4308 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
4309 if (!RAND_status())
4310   {
4311   randstuff r;
4312   gettimeofday(&r.tv, NULL);
4313   r.p = getpid();
4314
4315   RAND_seed(US (&r), sizeof(r));
4316   }
4317 /* We're after pseudo-random, not random; if we still don't have enough data
4318 in the internal PRNG then our options are limited.  We could sleep and hope
4319 for entropy to come along (prayer technique) but if the system is so depleted
4320 in the first place then something is likely to just keep taking it.  Instead,
4321 we'll just take whatever little bit of pseudo-random we can still manage to
4322 get. */
4323
4324 needed_len = sizeof(r);
4325 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
4326 asked for a number less than 10. */
4327 for (r = max, i = 0; r; ++i)
4328   r >>= 1;
4329 i = (i + 7) / 8;
4330 if (i < needed_len)
4331   needed_len = i;
4332
4333 #ifdef EXIM_HAVE_RAND_PSEUDO
4334 /* We do not care if crypto-strong */
4335 i = RAND_pseudo_bytes(smallbuf, needed_len);
4336 #else
4337 i = RAND_bytes(smallbuf, needed_len);
4338 #endif
4339
4340 if (i < 0)
4341   {
4342   DEBUG(D_all)
4343     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
4344   return vaguely_random_number_fallback(max);
4345   }
4346
4347 r = 0;
4348 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
4349   r = 256 * r + *p;
4350
4351 /* We don't particularly care about weighted results; if someone wants
4352 smooth distribution and cares enough then they should submit a patch then. */
4353 return r % max;
4354 }
4355
4356
4357
4358
4359 /*************************************************
4360 *        OpenSSL option parse                    *
4361 *************************************************/
4362
4363 /* Parse one option for tls_openssl_options_parse below
4364
4365 Arguments:
4366   name    one option name
4367   value   place to store a value for it
4368 Returns   success or failure in parsing
4369 */
4370
4371
4372
4373 static BOOL
4374 tls_openssl_one_option_parse(uschar *name, long *value)
4375 {
4376 int first = 0;
4377 int last = exim_openssl_options_size;
4378 while (last > first)
4379   {
4380   int middle = (first + last)/2;
4381   int c = Ustrcmp(name, exim_openssl_options[middle].name);
4382   if (c == 0)
4383     {
4384     *value = exim_openssl_options[middle].value;
4385     return TRUE;
4386     }
4387   else if (c > 0)
4388     first = middle + 1;
4389   else
4390     last = middle;
4391   }
4392 return FALSE;
4393 }
4394
4395
4396
4397
4398 /*************************************************
4399 *        OpenSSL option parsing logic            *
4400 *************************************************/
4401
4402 /* OpenSSL has a number of compatibility options which an administrator might
4403 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
4404 we look like log_selector.
4405
4406 Arguments:
4407   option_spec  the administrator-supplied string of options
4408   results      ptr to long storage for the options bitmap
4409 Returns        success or failure
4410 */
4411
4412 BOOL
4413 tls_openssl_options_parse(uschar *option_spec, long *results)
4414 {
4415 long result, item;
4416 uschar * exp, * end;
4417 uschar keep_c;
4418 BOOL adding, item_parsed;
4419
4420 /* Server: send no (<= TLS1.2) session tickets */
4421 result = SSL_OP_NO_TICKET;
4422
4423 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
4424 from default because it increases BEAST susceptibility. */
4425 #ifdef SSL_OP_NO_SSLv2
4426 result |= SSL_OP_NO_SSLv2;
4427 #endif
4428 #ifdef SSL_OP_NO_SSLv3
4429 result |= SSL_OP_NO_SSLv3;
4430 #endif
4431 #ifdef SSL_OP_SINGLE_DH_USE
4432 result |= SSL_OP_SINGLE_DH_USE;
4433 #endif
4434 #ifdef SSL_OP_NO_RENEGOTIATION
4435 result |= SSL_OP_NO_RENEGOTIATION;
4436 #endif
4437
4438 if (!option_spec)
4439   {
4440   *results = result;
4441   return TRUE;
4442   }
4443
4444 if (!expand_check(option_spec, US"openssl_options", &exp, &end))
4445   return FALSE;
4446
4447 for (uschar * s = exp; *s; /**/)
4448   {
4449   while (isspace(*s)) ++s;
4450   if (*s == '\0')
4451     break;
4452   if (*s != '+' && *s != '-')
4453     {
4454     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
4455         "+ or - expected but found \"%s\"\n", s);
4456     return FALSE;
4457     }
4458   adding = *s++ == '+';
4459   for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
4460   keep_c = *end;
4461   *end = '\0';
4462   item_parsed = tls_openssl_one_option_parse(s, &item);
4463   *end = keep_c;
4464   if (!item_parsed)
4465     {
4466     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
4467     return FALSE;
4468     }
4469   DEBUG(D_tls) debug_printf("openssl option, %s %08lx: %08lx (%s)\n",
4470       adding ? "adding to    " : "removing from", result, item, s);
4471   if (adding)
4472     result |= item;
4473   else
4474     result &= ~item;
4475   s = end;
4476   }
4477
4478 *results = result;
4479 return TRUE;
4480 }
4481
4482 #endif  /*!MACRO_PREDEF*/
4483 /* vi: aw ai sw=2
4484 */
4485 /* End of tls-openssl.c */