src/src/tls-openssl.c

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