src/src/tls-openssl.c

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