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