src/src/tls-openssl.c

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