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