src/src/tls-openssl.c

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