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_options(server_sni, SSL_CTX_get_options(ctx));
2214   SSL_CTX_set_timeout(server_sni, SSL_CTX_get_timeout(ctx));
2215   SSL_CTX_set_tlsext_servername_callback(server_sni, tls_servername_cb);
2216   SSL_CTX_set_tlsext_servername_arg(server_sni, state);
2217   }
2218
2219 if (  !init_dh(server_sni, state->dhparam, &dummy_errstr)
2220    || !init_ecdh(server_sni, &dummy_errstr)
2221    )
2222   goto bad;
2223
2224 if (  state->server_cipher_list
2225    && !SSL_CTX_set_cipher_list(server_sni, CS state->server_cipher_list))
2226   goto bad;
2227
2228 #ifndef DISABLE_OCSP
2229 if (state->u_ocsp.server.file)
2230   {
2231   SSL_CTX_set_tlsext_status_cb(server_sni, tls_server_stapling_cb);
2232   SSL_CTX_set_tlsext_status_arg(server_sni, state);
2233   }
2234 #endif
2235
2236   {
2237   uschar * expcerts;
2238   if (  !expand_check(tls_verify_certificates, US"tls_verify_certificates",
2239                   &expcerts, &dummy_errstr)
2240      || (rc = setup_certs(server_sni, expcerts, tls_crl, NULL,
2241                         &dummy_errstr)) != OK)
2242     goto bad;
2243
2244   if (expcerts && *expcerts)
2245     setup_cert_verify(server_sni, FALSE, verify_callback_server);
2246   }
2247
2248 /* do this after setup_certs, because this can require the certs for verifying
2249 OCSP information. */
2250 if ((rc = tls_expand_session_files(server_sni, state, &dummy_errstr)) != OK)
2251   goto bad;
2252
2253 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
2254 SSL_set_SSL_CTX(s, server_sni);
2255 return SSL_TLSEXT_ERR_OK;
2256
2257 bad: return SSL_TLSEXT_ERR_ALERT_FATAL;
2258 }
2259 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
2260
2261
2262
2263
2264 #ifdef EXIM_HAVE_ALPN
2265 /*************************************************
2266 *        Callback to handle ALPN                 *
2267 *************************************************/
2268
2269 /* Called on server if tls_alpn nonblank after expansion,
2270 when client offers ALPN, after the SNI callback.
2271 If set and not matching the list then we dump the connection */
2272
2273 static int
2274 tls_server_alpn_cb(SSL *ssl, const uschar ** out, uschar * outlen,
2275   const uschar * in, unsigned int inlen, void * arg)
2276 {
2277 server_seen_alpn = TRUE;
2278 DEBUG(D_tls)
2279   {
2280   debug_printf("Received TLS ALPN offer:");
2281   for (int pos = 0, siz; pos < inlen; pos += siz+1)
2282     {
2283     siz = in[pos];
2284     if (pos + 1 + siz > inlen) siz = inlen - pos - 1;
2285     debug_printf(" '%.*s'", siz, in + pos + 1);
2286     }
2287   debug_printf(".  Our list: '%s'\n", tls_alpn);
2288   }
2289
2290 /* Look for an acceptable ALPN */
2291
2292 if (  inlen > 1         /* at least one name */
2293    && in[0]+1 == inlen  /* filling the vector, so exactly one name */
2294    )
2295   {
2296   const uschar * list = tls_alpn;
2297   int sep = 0;
2298   for (uschar * name; name = string_nextinlist(&list, &sep, NULL, 0); )
2299     if (Ustrncmp(in+1, name, in[0]) == 0)
2300       {
2301       *out = in+1;                      /* we checked for exactly one, so can just point to it */
2302       *outlen = inlen;
2303       return SSL_TLSEXT_ERR_OK;         /* use ALPN */
2304       }
2305   }
2306
2307 /* More than one name from clilent, or name did not match our list. */
2308
2309 /* This will be fatal to the TLS conn; would be nice to kill TCP also.
2310 Maybe as an option in future; for now leave control to the config (must-tls). */
2311
2312 DEBUG(D_tls) debug_printf("TLS ALPN rejected\n");
2313 return SSL_TLSEXT_ERR_ALERT_FATAL;
2314 }
2315 #endif  /* EXIM_HAVE_ALPN */
2316
2317
2318
2319 #ifndef DISABLE_OCSP
2320
2321 /*************************************************
2322 *        Callback to handle OCSP Stapling        *
2323 *************************************************/
2324
2325 /* Called when acting as server during the TLS session setup if the client
2326 requests OCSP information with a Certificate Status Request.
2327
2328 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
2329 project.
2330
2331 */
2332
2333 static int
2334 tls_server_stapling_cb(SSL *s, void *arg)
2335 {
2336 const exim_openssl_state_st * state = arg;
2337 ocsp_resplist * olist = state->u_ocsp.server.olist;
2338 uschar * response_der;  /*XXX blob */
2339 int response_der_len;
2340
2341 DEBUG(D_tls)
2342   debug_printf("Received TLS status request (OCSP stapling); %s response list\n",
2343     olist ? "have" : "lack");
2344
2345 tls_in.ocsp = OCSP_NOT_RESP;
2346 if (!olist)
2347   return SSL_TLSEXT_ERR_NOACK;
2348
2349 #ifdef EXIM_HAVE_OPESSL_GET0_SERIAL
2350  {
2351   const X509 * cert_sent = SSL_get_certificate(s);
2352   const ASN1_INTEGER * cert_serial = X509_get0_serialNumber(cert_sent);
2353   const BIGNUM * cert_bn = ASN1_INTEGER_to_BN(cert_serial, NULL);
2354
2355   for (; olist; olist = olist->next)
2356     {
2357     OCSP_BASICRESP * bs = OCSP_response_get1_basic(olist->resp);
2358     const OCSP_SINGLERESP * single = OCSP_resp_get0(bs, 0);
2359     const OCSP_CERTID * cid = OCSP_SINGLERESP_get0_id(single);
2360     ASN1_INTEGER * res_cert_serial;
2361     const BIGNUM * resp_bn;
2362     ASN1_OCTET_STRING * res_cert_iNameHash;
2363
2364
2365     (void) OCSP_id_get0_info(&res_cert_iNameHash, NULL, NULL, &res_cert_serial,
2366       (OCSP_CERTID *) cid);
2367     resp_bn = ASN1_INTEGER_to_BN(res_cert_serial, NULL);
2368
2369     DEBUG(D_tls)
2370       {
2371       debug_printf("cert serial: %s\n", BN_bn2hex(cert_bn));
2372       debug_printf("resp serial: %s\n", BN_bn2hex(resp_bn));
2373       }
2374
2375     if (BN_cmp(cert_bn, resp_bn) == 0)
2376       {
2377       DEBUG(D_tls) debug_printf("matched serial for ocsp\n");
2378
2379       /*XXX TODO: check the rest of the list for duplicate matches.
2380       If any, need to also check the Issuer Name hash.
2381       Without this, we will provide the wrong status in the case of
2382       duplicate id. */
2383
2384       break;
2385       }
2386     DEBUG(D_tls) debug_printf("not match serial for ocsp\n");
2387     }
2388   if (!olist)
2389     {
2390     DEBUG(D_tls) debug_printf("failed to find match for ocsp\n");
2391     return SSL_TLSEXT_ERR_NOACK;
2392     }
2393  }
2394 #else
2395 if (olist->next)
2396   {
2397   DEBUG(D_tls) debug_printf("OpenSSL version too early to support multi-leaf OCSP\n");
2398   return SSL_TLSEXT_ERR_NOACK;
2399   }
2400 #endif
2401
2402 /*XXX could we do the i2d earlier, rather than during the callback? */
2403 response_der = NULL;
2404 response_der_len = i2d_OCSP_RESPONSE(olist->resp, &response_der);
2405 if (response_der_len <= 0)
2406   return SSL_TLSEXT_ERR_NOACK;
2407
2408 SSL_set_tlsext_status_ocsp_resp(state_server.lib_state.lib_ssl,
2409                                 response_der, response_der_len);
2410 tls_in.ocsp = OCSP_VFIED;
2411 return SSL_TLSEXT_ERR_OK;
2412 }
2413
2414
2415 static void
2416 time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
2417 {
2418 BIO_printf(bp, "\t%s: ", str);
2419 ASN1_GENERALIZEDTIME_print(bp, time);
2420 BIO_puts(bp, "\n");
2421 }
2422
2423 static int
2424 tls_client_stapling_cb(SSL * ssl, void * arg)
2425 {
2426 exim_openssl_state_st * cbinfo = arg;
2427 const unsigned char * p;
2428 int len;
2429 OCSP_RESPONSE * rsp;
2430 OCSP_BASICRESP * bs;
2431 int i;
2432
2433 DEBUG(D_tls) debug_printf("Received TLS status callback (OCSP stapling):\n");
2434 len = SSL_get_tlsext_status_ocsp_resp(ssl, &p);
2435 if(!p)
2436  {                              /* Expect this when we requested ocsp but got none */
2437   if (SSL_session_reused(ssl) && tls_out.ocsp == OCSP_VFIED)
2438     {
2439     DEBUG(D_tls) debug_printf(" null, but resumed; ocsp vfy stored with session is good\n");
2440     return 1;
2441     }
2442   if (cbinfo->u_ocsp.client.verify_required && LOGGING(tls_cipher))
2443     log_write(0, LOG_MAIN, "Required TLS certificate status not received");
2444   else
2445     DEBUG(D_tls) debug_printf(" null\n");
2446   return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
2447  }
2448
2449 if (!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
2450   {
2451   tls_out.ocsp = OCSP_FAILED;   /*XXX should use tlsp-> to permit concurrent outbound */
2452   if (LOGGING(tls_cipher))
2453     log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
2454   else
2455     DEBUG(D_tls) debug_printf(" parse error\n");
2456   return 0;
2457   }
2458
2459 if (!(bs = OCSP_response_get1_basic(rsp)))
2460   {
2461   tls_out.ocsp = OCSP_FAILED;
2462   if (LOGGING(tls_cipher))
2463     log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
2464   else
2465     DEBUG(D_tls) debug_printf(" error parsing response\n");
2466   OCSP_RESPONSE_free(rsp);
2467   return 0;
2468   }
2469
2470 /* We'd check the nonce here if we'd put one in the request. */
2471 /* However that would defeat cacheability on the server so we don't. */
2472
2473 /* This section of code reworked from OpenSSL apps source;
2474    The OpenSSL Project retains copyright:
2475    Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
2476 */
2477   {
2478     BIO * bp = NULL;
2479 #ifndef EXIM_HAVE_OCSP_RESP_COUNT
2480     STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
2481 #endif
2482
2483     DEBUG(D_tls) bp = BIO_new(BIO_s_mem());
2484
2485     /*OCSP_RESPONSE_print(bp, rsp, 0);   extreme debug: stapling content */
2486
2487     /* Use the chain that verified the server cert to verify the stapled info */
2488     /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
2489
2490     if ((i = OCSP_basic_verify(bs, cbinfo->verify_stack,
2491               cbinfo->u_ocsp.client.verify_store, OCSP_NOEXPLICIT)) <= 0)
2492       if (ERR_peek_error())
2493         {
2494         tls_out.ocsp = OCSP_FAILED;
2495         if (LOGGING(tls_cipher))
2496           {
2497           const uschar * errstr = CUS ERR_reason_error_string(ERR_peek_error());
2498           static uschar peerdn[256];
2499           X509_NAME_oneline(X509_get_subject_name(SSL_get_peer_certificate(ssl)),
2500                                                   CS peerdn, sizeof(peerdn));
2501           log_write(0, LOG_MAIN,
2502                 "[%s] %s Received TLS cert (DN: '%.*s') status response, "
2503                 "itself unverifiable: %s",
2504                 sender_host_address, sender_host_name,
2505                 (int)sizeof(peerdn), peerdn,
2506                 errstr);
2507           }
2508         DEBUG(D_tls)
2509           {
2510           BIO_printf(bp, "OCSP response verify failure\n");
2511           ERR_print_errors(bp);
2512           OCSP_RESPONSE_print(bp, rsp, 0);
2513           }
2514         goto failed;
2515         }
2516       else
2517         DEBUG(D_tls) debug_printf("no explicit trust for OCSP signing"
2518           " in the root CA certificate; ignoring\n");
2519
2520     DEBUG(D_tls) debug_printf("OCSP response well-formed and signed OK\n");
2521
2522     /*XXX So we have a good stapled OCSP status.  How do we know
2523     it is for the cert of interest?  OpenSSL 1.1.0 has a routine
2524     OCSP_resp_find_status() which matches on a cert id, which presumably
2525     we should use. Making an id needs OCSP_cert_id_new(), which takes
2526     issuerName, issuerKey, serialNumber.  Are they all in the cert?
2527
2528     For now, carry on blindly accepting the resp. */
2529
2530     for (int idx =
2531 #ifdef EXIM_HAVE_OCSP_RESP_COUNT
2532             OCSP_resp_count(bs) - 1;
2533 #else
2534             sk_OCSP_SINGLERESP_num(sresp) - 1;
2535 #endif
2536          idx >= 0; idx--)
2537       {
2538       OCSP_SINGLERESP * single = OCSP_resp_get0(bs, idx);
2539       int status, reason;
2540       ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
2541
2542   /*XXX so I can see putting a loop in here to handle a rsp with >1 singleresp
2543   - but what happens with a GnuTLS-style input?
2544
2545   we could do with a debug label for each singleresp
2546   - it has a certID with a serialNumber, but I see no API to get that
2547   */
2548       status = OCSP_single_get0_status(single, &reason, &rev,
2549                   &thisupd, &nextupd);
2550
2551       DEBUG(D_tls)
2552         {
2553         time_print(bp, "This OCSP Update", thisupd);
2554         if (nextupd) time_print(bp, "Next OCSP Update", nextupd);
2555         }
2556       if (!OCSP_check_validity(thisupd, nextupd,
2557             EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
2558         {
2559         tls_out.ocsp = OCSP_FAILED;
2560         DEBUG(D_tls) ERR_print_errors(bp);
2561         log_write(0, LOG_MAIN, "OCSP dates invalid");
2562         goto failed;
2563         }
2564
2565       DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
2566                     OCSP_cert_status_str(status));
2567       switch(status)
2568         {
2569         case V_OCSP_CERTSTATUS_GOOD:
2570           continue;     /* the idx loop */
2571         case V_OCSP_CERTSTATUS_REVOKED:
2572           log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
2573               reason != -1 ? "; reason: " : "",
2574               reason != -1 ? OCSP_crl_reason_str(reason) : "");
2575           DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
2576           break;
2577         default:
2578           log_write(0, LOG_MAIN,
2579               "Server certificate status unknown, in OCSP stapling");
2580           break;
2581         }
2582
2583       goto failed;
2584       }
2585
2586     i = 1;
2587     tls_out.ocsp = OCSP_VFIED;
2588     goto good;
2589
2590   failed:
2591     tls_out.ocsp = OCSP_FAILED;
2592     i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
2593   good:
2594     {
2595     uschar * s = NULL;
2596     int len = (int) BIO_get_mem_data(bp, CSS &s);
2597     if (len > 0) debug_printf("%.*s", len, s);
2598     }
2599     BIO_free(bp);
2600   }
2601
2602 OCSP_RESPONSE_free(rsp);
2603 return i;
2604 }
2605 #endif  /*!DISABLE_OCSP*/
2606
2607
2608 /*************************************************
2609 *            Initialize for TLS                  *
2610 *************************************************/
2611 /* Called from both server and client code, to do preliminary initialization
2612 of the library.  We allocate and return a context structure.
2613
2614 Arguments:
2615   host            connected host, if client; NULL if server
2616   ob              transport options block, if client; NULL if server
2617   ocsp_file       file of stapling info (server); flag for require ocsp (client)
2618   addr            address if client; NULL if server (for some randomness)
2619   caller_state    place to put pointer to allocated state-struct
2620   errstr          error string pointer
2621
2622 Returns:          OK/DEFER/FAIL
2623 */
2624
2625 static int
2626 tls_init(host_item * host, smtp_transport_options_block * ob,
2627 #ifndef DISABLE_OCSP
2628   uschar *ocsp_file,
2629 #endif
2630   address_item *addr, exim_openssl_state_st ** caller_state,
2631   tls_support * tlsp,
2632   uschar ** errstr)
2633 {
2634 SSL_CTX * ctx;
2635 exim_openssl_state_st * state;
2636 int rc;
2637
2638 if (host)                       /* client */
2639   {
2640   state = store_malloc(sizeof(exim_openssl_state_st));
2641   memset(state, 0, sizeof(*state));
2642   state->certificate = ob->tls_certificate;
2643   state->privatekey =  ob->tls_privatekey;
2644   state->is_server = FALSE;
2645   state->dhparam = NULL;
2646   state->lib_state = ob->tls_preload;
2647   }
2648 else                            /* server */
2649   {
2650   state = &state_server;
2651   state->certificate = tls_certificate;
2652   state->privatekey =  tls_privatekey;
2653   state->is_server = TRUE;
2654   state->dhparam = tls_dhparam;
2655   state->lib_state = state_server.lib_state;
2656   }
2657
2658 state->tlsp = tlsp;
2659 state->host = host;
2660
2661 if (!state->lib_state.pri_string)
2662   state->server_cipher_list = NULL;
2663
2664 #ifndef DISABLE_EVENT
2665 state->event_action = NULL;
2666 #endif
2667
2668 tls_openssl_init();
2669
2670 /* It turns out that we need to seed the random number generator this early in
2671 order to get the full complement of ciphers to work. It took me roughly a day
2672 of work to discover this by experiment.
2673
2674 On systems that have /dev/urandom, SSL may automatically seed itself from
2675 there. Otherwise, we have to make something up as best we can. Double check
2676 afterwards.
2677
2678 Although we likely called this before, at daemon startup, this is a chance
2679 to mix in further variable info (time, pid) if needed. */
2680
2681 if (!lib_rand_init(addr))
2682   return tls_error(US"RAND_status", host,
2683     US"unable to seed random number generator", errstr);
2684
2685 /* Apply administrator-supplied work-arounds.
2686 Historically we applied just one requested option,
2687 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
2688 moved to an administrator-controlled list of options to specify and
2689 grandfathered in the first one as the default value for "openssl_options".
2690
2691 No OpenSSL version number checks: the options we accept depend upon the
2692 availability of the option value macros from OpenSSL.  */
2693
2694 if (!init_options)
2695   if (!tls_openssl_options_parse(openssl_options, &init_options))
2696     return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
2697
2698 /* Create a context.
2699 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
2700 negotiation in the different methods; as far as I can tell, the only
2701 *_{server,client}_method which allows negotiation is SSLv23, which exists even
2702 when OpenSSL is built without SSLv2 support.
2703 By disabling with openssl_options, we can let admins re-enable with the
2704 existing knob. */
2705
2706 if (!(ctx = state->lib_state.lib_ctx))
2707   {
2708   if ((rc = lib_ctx_new(&ctx, host, errstr)) != OK)
2709     return rc;
2710   state->lib_state.lib_ctx = ctx;
2711   }
2712
2713 #ifndef DISABLE_TLS_RESUME
2714 tlsp->resumption = RESUME_SUPPORTED;
2715 #endif
2716 if (init_options)
2717   {
2718 #ifndef DISABLE_TLS_RESUME
2719   /* Should the server offer session resumption? */
2720   if (!host && verify_check_host(&tls_resumption_hosts) == OK)
2721     {
2722     DEBUG(D_tls) debug_printf("tls_resumption_hosts overrides openssl_options\n");
2723     init_options &= ~SSL_OP_NO_TICKET;
2724     tlsp->resumption |= RESUME_SERVER_TICKET; /* server will give ticket on request */
2725     tlsp->host_resumable = TRUE;
2726     }
2727 #endif
2728
2729   DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
2730   if (!(SSL_CTX_set_options(ctx, init_options)))
2731     return tls_error(string_sprintf(
2732           "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
2733   }
2734 else
2735   DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
2736
2737 /* We'd like to disable session cache unconditionally, but foolish Outlook
2738 Express clients then give up the first TLS connection and make a second one
2739 (which works).  Only when there is an IMAP service on the same machine.
2740 Presumably OE is trying to use the cache for A on B.  Leave it enabled for
2741 now, until we work out a decent way of presenting control to the config.  It
2742 will never be used because we use a new context every time. */
2743 #ifdef notdef
2744 (void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
2745 #endif
2746
2747 /* Initialize with DH parameters if supplied */
2748 /* Initialize ECDH temp key parameter selection */
2749
2750 if (!host)
2751   {
2752   if (state->lib_state.dh)
2753     { DEBUG(D_tls) debug_printf("TLS: DH params were preloaded\n"); }
2754   else
2755     if (!init_dh(ctx, state->dhparam, errstr)) return DEFER;
2756
2757   if (state->lib_state.ecdh)
2758     { DEBUG(D_tls) debug_printf("TLS: ECDH curve was preloaded\n"); }
2759   else
2760     if (!init_ecdh(ctx, errstr)) return DEFER;
2761   }
2762
2763 /* Set up certificate and key (and perhaps OCSP info) */
2764
2765 if (state->lib_state.conn_certs)
2766   {
2767   DEBUG(D_tls)
2768     debug_printf("TLS: %s certs were preloaded\n", host ? "client":"server");
2769   }
2770 else
2771   {
2772 #ifndef DISABLE_OCSP
2773   if (!host)                                    /* server */
2774     {
2775     state->u_ocsp.server.file = ocsp_file;
2776     state->u_ocsp.server.file_expanded = NULL;
2777     state->u_ocsp.server.olist = NULL;
2778     }
2779 #endif
2780   if ((rc = tls_expand_session_files(ctx, state, errstr)) != OK) return rc;
2781   }
2782
2783 /* If we need to handle SNI or OCSP, do so */
2784
2785 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2786 # ifndef DISABLE_OCSP
2787   if (!(state->verify_stack = sk_X509_new_null()))
2788     {
2789     DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
2790     return FAIL;
2791     }
2792 # endif
2793
2794 if (!host)              /* server */
2795   {
2796 # ifndef DISABLE_OCSP
2797   /* We check u_ocsp.server.file, not server.olist, because we care about if
2798   the option exists, not what the current expansion might be, as SNI might
2799   change the certificate and OCSP file in use between now and the time the
2800   callback is invoked. */
2801   if (state->u_ocsp.server.file)
2802     {
2803     SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
2804     SSL_CTX_set_tlsext_status_arg(ctx, state);
2805     }
2806 # endif
2807   /* We always do this, so that $tls_sni is available even if not used in
2808   tls_certificate */
2809   SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
2810   SSL_CTX_set_tlsext_servername_arg(ctx, state);
2811
2812 # ifdef EXIM_HAVE_ALPN
2813   if (tls_alpn && *tls_alpn)
2814     {
2815     uschar * exp_alpn;
2816     if (  expand_check(tls_alpn, US"tls_alpn", &exp_alpn, errstr)
2817        && *exp_alpn && !isblank(*exp_alpn))
2818       {
2819       tls_alpn = exp_alpn;      /* subprocess so ok to overwrite */
2820       SSL_CTX_set_alpn_select_cb(ctx, tls_server_alpn_cb, state);
2821       }
2822     else
2823       tls_alpn = NULL;
2824     }
2825 # endif
2826   }
2827 # ifndef DISABLE_OCSP
2828 else                    /* client */
2829   if(ocsp_file)         /* wanting stapling */
2830     {
2831     if (!(state->u_ocsp.client.verify_store = X509_STORE_new()))
2832       {
2833       DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
2834       return FAIL;
2835       }
2836     SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
2837     SSL_CTX_set_tlsext_status_arg(ctx, state);
2838     }
2839 # endif
2840 #endif
2841
2842 state->verify_cert_hostnames = NULL;
2843
2844 #ifdef EXIM_HAVE_EPHEM_RSA_KEX
2845 /* Set up the RSA callback */
2846 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
2847 #endif
2848
2849 /* Finally, set the session cache timeout, and we are done.
2850 The period appears to be also used for (server-generated) session tickets */
2851
2852 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
2853 DEBUG(D_tls) debug_printf("Initialized TLS\n");
2854
2855 *caller_state = state;
2856
2857 return OK;
2858 }
2859
2860
2861
2862
2863 /*************************************************
2864 *           Get name of cipher in use            *
2865 *************************************************/
2866
2867 /*
2868 Argument:   pointer to an SSL structure for the connection
2869             pointer to number of bits for cipher
2870 Returns:    pointer to allocated string in perm-pool
2871 */
2872
2873 static uschar *
2874 construct_cipher_name(SSL * ssl, const uschar * ver, int * bits)
2875 {
2876 int pool = store_pool;
2877 /* With OpenSSL 1.0.0a, 'c' needs to be const but the documentation doesn't
2878 yet reflect that.  It should be a safe change anyway, even 0.9.8 versions have
2879 the accessor functions use const in the prototype. */
2880
2881 const SSL_CIPHER * c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
2882 uschar * s;
2883
2884 SSL_CIPHER_get_bits(c, bits);
2885
2886 store_pool = POOL_PERM;
2887 s = string_sprintf("%s:%s:%u", ver, SSL_CIPHER_get_name(c), *bits);
2888 store_pool = pool;
2889 DEBUG(D_tls) debug_printf("Cipher: %s\n", s);
2890 return s;
2891 }
2892
2893
2894 /* Get IETF-standard name for ciphersuite.
2895 Argument:   pointer to an SSL structure for the connection
2896 Returns:    pointer to string
2897 */
2898
2899 static const uschar *
2900 cipher_stdname_ssl(SSL * ssl)
2901 {
2902 #ifdef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
2903 return CUS SSL_CIPHER_standard_name(SSL_get_current_cipher(ssl));
2904 #else
2905 ushort id = 0xffff & SSL_CIPHER_get_id(SSL_get_current_cipher(ssl));
2906 return cipher_stdname(id >> 8, id & 0xff);
2907 #endif
2908 }
2909
2910
2911 static const uschar *
2912 tlsver_name(SSL * ssl)
2913 {
2914 uschar * s, * p;
2915 int pool = store_pool;
2916
2917 store_pool = POOL_PERM;
2918 s = string_copy(US SSL_get_version(ssl));
2919 store_pool = pool;
2920 if ((p = Ustrchr(s, 'v')))      /* TLSv1.2 -> TLS1.2 */
2921   for (;; p++) if (!(*p = p[1])) break;
2922 return CUS s;
2923 }
2924
2925
2926 static void
2927 peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned siz)
2928 {
2929 /*XXX we might consider a list-of-certs variable for the cert chain.
2930 SSL_get_peer_cert_chain(SSL*).  We'd need a new variable type and support
2931 in list-handling functions, also consider the difference between the entire
2932 chain and the elements sent by the peer. */
2933
2934 tlsp->peerdn = NULL;
2935
2936 /* Will have already noted peercert on a verify fail; possibly not the leaf */
2937 if (!tlsp->peercert)
2938   tlsp->peercert = SSL_get_peer_certificate(ssl);
2939 /* Beware anonymous ciphers which lead to server_cert being NULL */
2940 if (tlsp->peercert)
2941   if (!X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, siz))
2942     { DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n"); }
2943   else
2944     {
2945     int oldpool = store_pool;
2946
2947     peerdn[siz-1] = '\0';               /* paranoia */
2948     store_pool = POOL_PERM;
2949     tlsp->peerdn = string_copy(peerdn);
2950     store_pool = oldpool;
2951
2952     /* We used to set CV in the cert-verify callbacks (either plain or dane)
2953     but they don't get called on session-resumption.  So use the official
2954     interface, which uses the resumed value.  Unfortunately this claims verified
2955     when it actually failed but we're in try-verify mode, due to us wanting the
2956     knowlege that it failed so needing to have the callback and forcing a
2957     permissive return.  If we don't force it, the TLS startup is failed.
2958     The extra bit of information is set in verify_override in the cb, stashed
2959     for resumption next to the TLS session, and used here. */
2960
2961     if (!tlsp->verify_override)
2962       tlsp->certificate_verified =
2963 #ifdef SUPPORT_DANE
2964         tlsp->dane_verified ||
2965 #endif
2966         SSL_get_verify_result(ssl) == X509_V_OK;
2967     }
2968 }
2969
2970
2971
2972
2973
2974 /*************************************************
2975 *        Set up for verifying certificates       *
2976 *************************************************/
2977
2978 #ifndef DISABLE_OCSP
2979 /* Load certs from file, return TRUE on success */
2980
2981 static BOOL
2982 chain_from_pem_file(const uschar * file, STACK_OF(X509) ** vp)
2983 {
2984 BIO * bp;
2985 STACK_OF(X509) * verify_stack = *vp;
2986
2987 if (verify_stack)
2988   while (sk_X509_num(verify_stack) > 0)
2989     X509_free(sk_X509_pop(verify_stack));
2990 else
2991   verify_stack = sk_X509_new_null();
2992
2993 if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
2994 for (X509 * x; x = PEM_read_bio_X509(bp, NULL, 0, NULL); )
2995   sk_X509_push(verify_stack, x);
2996 BIO_free(bp);
2997 *vp = verify_stack;
2998 return TRUE;
2999 }
3000 #endif
3001
3002
3003
3004 /* Called by both client and server startup; on the server possibly
3005 repeated after a Server Name Indication.
3006
3007 Arguments:
3008   sctx          SSL_CTX* to initialise
3009   certs         certs file, expanded
3010   crl           CRL file or NULL
3011   host          NULL in a server; the remote host in a client
3012   errstr        error string pointer
3013
3014 Returns:        OK/DEFER/FAIL
3015 */
3016
3017 static int
3018 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host,
3019     uschar ** errstr)
3020 {
3021 uschar *expcerts, *expcrl;
3022
3023 if (!expand_check(certs, US"tls_verify_certificates", &expcerts, errstr))
3024   return DEFER;
3025 DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
3026
3027 if (expcerts && *expcerts)
3028   {
3029   /* Tell the library to use its compiled-in location for the system default
3030   CA bundle. Then add the ones specified in the config, if any. */
3031
3032   if (!SSL_CTX_set_default_verify_paths(sctx))
3033     return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
3034
3035   if (Ustrcmp(expcerts, "system") != 0 && Ustrncmp(expcerts, "system,", 7) != 0)
3036     {
3037     struct stat statbuf;
3038
3039     if (Ustat(expcerts, &statbuf) < 0)
3040       {
3041       log_write(0, LOG_MAIN|LOG_PANIC,
3042         "failed to stat %s for certificates", expcerts);
3043       return DEFER;
3044       }
3045     else
3046       {
3047       uschar *file, *dir;
3048       if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
3049         { file = NULL; dir = expcerts; }
3050       else
3051         {
3052         STACK_OF(X509) * verify_stack =
3053 #ifndef DISABLE_OCSP
3054           !host ? state_server.verify_stack :
3055 #endif
3056           NULL;
3057         STACK_OF(X509) ** vp = &verify_stack;
3058
3059         file = expcerts; dir = NULL;
3060 #ifndef DISABLE_OCSP
3061         /* In the server if we will be offering an OCSP proof, load chain from
3062         file for verifying the OCSP proof at load time. */
3063
3064 /*XXX Glitch!   The file here is tls_verify_certs: the chain for verifying the client cert.
3065 This is inconsistent with the need to verify the OCSP proof of the server cert.
3066 */
3067         if (  !host
3068            && statbuf.st_size > 0
3069            && state_server.u_ocsp.server.file
3070            && !chain_from_pem_file(file, vp)
3071            )
3072           {
3073           log_write(0, LOG_MAIN|LOG_PANIC,
3074             "failed to load cert chain from %s", file);
3075           return DEFER;
3076           }
3077 #endif
3078         }
3079
3080       /* If a certificate file is empty, the load function fails with an
3081       unhelpful error message. If we skip it, we get the correct behaviour (no
3082       certificates are recognized, but the error message is still misleading (it
3083       says no certificate was supplied).  But this is better. */
3084
3085       if (  (!file || statbuf.st_size > 0)
3086          && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
3087           return tls_error(US"SSL_CTX_load_verify_locations",
3088                             host, NULL, errstr);
3089
3090       /* On the server load the list of CAs for which we will accept certs, for
3091       sending to the client.  This is only for the one-file
3092       tls_verify_certificates variant.
3093       If a list isn't loaded into the server, but some verify locations are set,
3094       the server end appears to make a wildcard request for client certs.
3095       Meanwhile, the client library as default behaviour *ignores* the list
3096       we send over the wire - see man SSL_CTX_set_client_cert_cb.
3097       Because of this, and that the dir variant is likely only used for
3098       the public-CA bundle (not for a private CA), not worth fixing.  */
3099
3100       if (file)
3101         {
3102         STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
3103         int i = sk_X509_NAME_num(names);
3104
3105         if (!host) SSL_CTX_set_client_CA_list(sctx, names);
3106         DEBUG(D_tls) debug_printf("Added %d additional certificate authorit%s\n",
3107                                     i, i>1 ? "ies":"y");
3108         }
3109       else
3110         DEBUG(D_tls)
3111           debug_printf("Added dir for additional certificate authorities\n");
3112       }
3113     }
3114
3115   /* Handle a certificate revocation list. */
3116
3117 #if OPENSSL_VERSION_NUMBER > 0x00907000L
3118
3119   /* This bit of code is now the version supplied by Lars Mainka. (I have
3120   merely reformatted it into the Exim code style.)
3121
3122   "From here I changed the code to add support for multiple crl's
3123   in pem format in one file or to support hashed directory entries in
3124   pem format instead of a file. This method now uses the library function
3125   X509_STORE_load_locations to add the CRL location to the SSL context.
3126   OpenSSL will then handle the verify against CA certs and CRLs by
3127   itself in the verify callback." */
3128
3129   if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
3130   if (expcrl && *expcrl)
3131     {
3132     struct stat statbufcrl;
3133     if (Ustat(expcrl, &statbufcrl) < 0)
3134       {
3135       log_write(0, LOG_MAIN|LOG_PANIC,
3136         "failed to stat %s for certificates revocation lists", expcrl);
3137       return DEFER;
3138       }
3139     else
3140       {
3141       /* is it a file or directory? */
3142       uschar *file, *dir;
3143       X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
3144       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
3145         {
3146         file = NULL;
3147         dir = expcrl;
3148         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
3149         }
3150       else
3151         {
3152         file = expcrl;
3153         dir = NULL;
3154         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
3155         }
3156       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
3157         return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
3158
3159       /* setting the flags to check against the complete crl chain */
3160
3161       X509_STORE_set_flags(cvstore,
3162         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
3163       }
3164     }
3165
3166 #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
3167   }
3168
3169 return OK;
3170 }
3171
3172
3173
3174 static void
3175 tls_dump_keylog(SSL * ssl)
3176 {
3177 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3178   BIO * bp = BIO_new(BIO_s_mem());
3179   uschar * s = NULL;
3180   int len;
3181   SSL_SESSION_print_keylog(bp, SSL_get_session(ssl));
3182   len = (int) BIO_get_mem_data(bp, CSS &s);
3183   if (len > 0) debug_printf("%.*s", len, s);
3184   BIO_free(bp);
3185 #endif
3186 }
3187
3188
3189 /* Channel-binding info for authenticators
3190 See description in https://paquier.xyz/postgresql-2/channel-binding-openssl/
3191 for pre-TLS1.3
3192 */
3193
3194 static void
3195 tls_get_channel_binding(SSL * ssl, tls_support * tlsp, const void * taintval)
3196 {
3197 uschar c, * s;
3198 size_t len;
3199
3200 #ifdef EXIM_HAVE_EXPORT_CHNL_BNGNG
3201 if (SSL_version(ssl) > TLS1_2_VERSION)
3202   {
3203   /* It's not documented by OpenSSL how big the output buffer must be.
3204   The OpenSSL testcases use 80 bytes but don't say why. The GnuTLS impl only
3205   serves out 32B.  RFC 9266 says it is 32B.
3206   Interop fails unless we use the same each end. */
3207   len = 32;
3208
3209   tlsp->channelbind_exporter = TRUE;
3210   taintval = GET_UNTAINTED;
3211   if (SSL_export_keying_material(ssl,
3212         s = store_get((int)len, taintval), len,
3213         "EXPORTER-Channel-Binding", (size_t) 24,
3214         NULL, 0, 0) != 1)
3215     len = 0;
3216   }
3217 else
3218 #endif
3219   {
3220   len = SSL_get_peer_finished(ssl, &c, 0);
3221   len = SSL_get_peer_finished(ssl, s = store_get((int)len, taintval), len);
3222   }
3223
3224 if (len > 0)
3225   {
3226   int old_pool = store_pool;
3227   store_pool = POOL_PERM;
3228     tlsp->channelbinding = b64encode_taint(CUS s, (int)len, taintval);
3229   store_pool = old_pool;
3230   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage %p %p\n", tlsp->channelbinding, tlsp);
3231   }
3232 }
3233
3234
3235 /*************************************************
3236 *       Start a TLS session in a server          *
3237 *************************************************/
3238 /* This is called when Exim is running as a server, after having received
3239 the STARTTLS command. It must respond to that command, and then negotiate
3240 a TLS session.
3241
3242 Arguments:
3243   errstr            pointer to error message
3244
3245 Returns:            OK on success
3246                     DEFER for errors before the start of the negotiation
3247                     FAIL for errors during the negotiation; the server can't
3248                       continue running.
3249 */
3250
3251 int
3252 tls_server_start(uschar ** errstr)
3253 {
3254 int rc;
3255 uschar * expciphers;
3256 exim_openssl_state_st * dummy_statep;
3257 SSL_CTX * ctx;
3258 SSL * ssl;
3259 static uschar peerdn[256];
3260
3261 /* Check for previous activation */
3262
3263 if (tls_in.active.sock >= 0)
3264   {
3265   tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
3266   smtp_printf("554 Already in TLS\r\n", FALSE);
3267   return FAIL;
3268   }
3269
3270 /* Initialize the SSL library. If it fails, it will already have logged
3271 the error. */
3272
3273 rc = tls_init(NULL, NULL,
3274 #ifndef DISABLE_OCSP
3275     tls_ocsp_file,
3276 #endif
3277     NULL, &dummy_statep, &tls_in, errstr);
3278 if (rc != OK) return rc;
3279 ctx = state_server.lib_state.lib_ctx;
3280
3281 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
3282 were historically separated by underscores. So that I can use either form in my
3283 tests, and also for general convenience, we turn underscores into hyphens here.
3284
3285 XXX SSL_CTX_set_cipher_list() is replaced by SSL_CTX_set_ciphersuites()
3286 for TLS 1.3 .  Since we do not call it at present we get the default list:
3287 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
3288 */
3289
3290 if (state_server.lib_state.pri_string)
3291   { DEBUG(D_tls) debug_printf("TLS: cipher list was preloaded\n"); }
3292 else
3293   {
3294   if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
3295     return FAIL;
3296
3297   if (expciphers)
3298     {
3299     normalise_ciphers(&expciphers, tls_require_ciphers);
3300     if ((rc = server_load_ciphers(ctx, &state_server, expciphers, errstr)) != OK)
3301       return rc;
3302     }
3303   }
3304
3305 /* If this is a host for which certificate verification is mandatory or
3306 optional, set up appropriately. */
3307
3308 tls_in.certificate_verified = FALSE;
3309 #ifdef SUPPORT_DANE
3310 tls_in.dane_verified = FALSE;
3311 #endif
3312 server_verify_callback_called = FALSE;
3313
3314 if (verify_check_host(&tls_verify_hosts) == OK)
3315   server_verify_optional = FALSE;
3316 else if (verify_check_host(&tls_try_verify_hosts) == OK)
3317   server_verify_optional = TRUE;
3318 else
3319   goto skip_certs;
3320
3321  {
3322   uschar * expcerts;
3323   if (!expand_check(tls_verify_certificates, US"tls_verify_certificates",
3324                     &expcerts, errstr))
3325     return DEFER;
3326   DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
3327
3328   if (state_server.lib_state.cabundle)
3329     { DEBUG(D_tls) debug_printf("TLS: CA bundle for server was preloaded\n"); }
3330   else
3331     if ((rc = setup_certs(ctx, expcerts, tls_crl, NULL, errstr)) != OK)
3332       return rc;
3333
3334   if (expcerts && *expcerts)
3335     setup_cert_verify(ctx, server_verify_optional, verify_callback_server);
3336  }
3337 skip_certs: ;
3338
3339 #ifndef DISABLE_TLS_RESUME
3340 # if OPENSSL_VERSION_NUMBER < 0x30000000L
3341 SSL_CTX_set_tlsext_ticket_key_cb(ctx, ticket_key_callback);
3342 /* despite working, appears to always return failure, so ignoring */
3343 # else
3344 SSL_CTX_set_tlsext_ticket_key_evp_cb(ctx, ticket_key_callback);
3345 /* despite working, appears to always return failure, so ignoring */
3346 # endif
3347 #endif
3348
3349 #ifdef OPENSSL_HAVE_NUM_TICKETS
3350 # ifndef DISABLE_TLS_RESUME
3351 SSL_CTX_set_num_tickets(ctx, tls_in.host_resumable ? 1 : 0);
3352 # else
3353 SSL_CTX_set_num_tickets(ctx, 0);        /* send no TLS1.3 stateful-tickets */
3354 # endif
3355 #endif
3356
3357
3358 /* Prepare for new connection */
3359
3360 if (!(ssl = SSL_new(ctx)))
3361   return tls_error(US"SSL_new", NULL, NULL, errstr);
3362 state_server.lib_state.lib_ssl = ssl;
3363
3364 /* Warning: we used to SSL_clear(ssl) here, it was removed.
3365  *
3366  * With the SSL_clear(), we get strange interoperability bugs with
3367  * OpenSSL 1.0.1b and TLS1.1/1.2.  It looks as though this may be a bug in
3368  * OpenSSL itself, as a clear should not lead to inability to follow protocols.
3369  *
3370  * The SSL_clear() call is to let an existing SSL* be reused, typically after
3371  * session shutdown.  In this case, we have a brand new object and there's no
3372  * obvious reason to immediately clear it.  I'm guessing that this was
3373  * originally added because of incomplete initialisation which the clear fixed,
3374  * in some historic release.
3375  */
3376
3377 /* Set context and tell client to go ahead, except in the case of TLS startup
3378 on connection, where outputting anything now upsets the clients and tends to
3379 make them disconnect. We need to have an explicit fflush() here, to force out
3380 the response. Other smtp_printf() calls do not need it, because in non-TLS
3381 mode, the fflush() happens when smtp_getc() is called. */
3382
3383 SSL_set_session_id_context(ssl, sid_ctx, Ustrlen(sid_ctx));
3384 if (!tls_in.on_connect)
3385   {
3386   smtp_printf("220 TLS go ahead\r\n", FALSE);
3387   fflush(smtp_out);
3388   }
3389
3390 /* Now negotiate the TLS session. We put our own timer on it, since it seems
3391 that the OpenSSL library doesn't. */
3392
3393 SSL_set_wfd(ssl, fileno(smtp_out));
3394 SSL_set_rfd(ssl, fileno(smtp_in));
3395 SSL_set_accept_state(ssl);
3396
3397 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
3398
3399 ERR_clear_error();
3400 sigalrm_seen = FALSE;
3401 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3402 rc = SSL_accept(ssl);
3403 ALARM_CLR(0);
3404
3405 if (rc <= 0)
3406   {
3407   int error = SSL_get_error(ssl, rc);
3408   switch(error)
3409     {
3410     case SSL_ERROR_NONE:
3411       break;
3412
3413     case SSL_ERROR_ZERO_RETURN:
3414       DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3415       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
3416 #ifndef DISABLE_EVENT
3417       (void) event_raise(event_action, US"tls:fail:connect", *errstr, NULL);
3418 #endif
3419       if (SSL_get_shutdown(ssl) == SSL_RECEIVED_SHUTDOWN)
3420         SSL_shutdown(ssl);
3421
3422       tls_close(NULL, TLS_NO_SHUTDOWN);
3423       return FAIL;
3424
3425     /* Handle genuine errors */
3426     case SSL_ERROR_SSL:
3427       {
3428       uschar * s = NULL;
3429       int r = ERR_GET_REASON(ERR_peek_error());
3430       if (  r == SSL_R_WRONG_VERSION_NUMBER
3431 #ifdef SSL_R_VERSION_TOO_LOW
3432          || r == SSL_R_VERSION_TOO_LOW
3433 #endif
3434          || r == SSL_R_UNKNOWN_PROTOCOL || r == SSL_R_UNSUPPORTED_PROTOCOL)
3435         s = string_sprintf("(%s)", SSL_get_version(ssl));
3436       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : s, errstr);
3437 #ifndef DISABLE_EVENT
3438       (void) event_raise(event_action, US"tls:fail:connect", *errstr, NULL);
3439 #endif
3440       return FAIL;
3441       }
3442
3443     default:
3444       DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
3445       if (error == SSL_ERROR_SYSCALL)
3446         {
3447         if (!errno)
3448           {
3449           *errstr = US"SSL_accept: TCP connection closed by peer";
3450 #ifndef DISABLE_EVENT
3451           (void) event_raise(event_action, US"tls:fail:connect", *errstr, NULL);
3452 #endif
3453           return FAIL;
3454           }
3455         DEBUG(D_tls) debug_printf(" - syscall %s\n", strerror(errno));
3456         }
3457       (void) tls_error(US"SSL_accept", NULL,
3458                       sigalrm_seen ? US"timed out"
3459                       : ERR_peek_error() ? NULL : string_sprintf("ret %d", error),
3460                       errstr);
3461 #ifndef DISABLE_EVENT
3462       (void) event_raise(event_action, US"tls:fail:connect", *errstr, NULL);
3463 #endif
3464       return FAIL;
3465     }
3466   }
3467
3468 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
3469 ERR_clear_error();      /* Even success can leave errors in the stack. Seen with
3470                         anon-authentication ciphersuite negotiated. */
3471
3472 #ifndef DISABLE_TLS_RESUME
3473 if (SSL_session_reused(ssl))
3474   {
3475   tls_in.resumption |= RESUME_USED;
3476   DEBUG(D_tls) debug_printf("Session reused\n");
3477   }
3478 #endif
3479
3480 #ifdef EXIM_HAVE_ALPN
3481 /* If require-alpn, check server_seen_alpn here.  Else abort TLS */
3482 if (!tls_alpn || !*tls_alpn)
3483   { DEBUG(D_tls) debug_printf("TLS: was not watching for ALPN\n"); }
3484 else if (!server_seen_alpn)
3485   if (verify_check_host(&hosts_require_alpn) == OK)
3486     {
3487     /* We'd like to send a definitive Alert but OpenSSL provides no facility */
3488     SSL_shutdown(ssl);
3489     tls_error(US"handshake", NULL, US"ALPN required but not negotiated", errstr);
3490     return FAIL;
3491     }
3492   else
3493     { DEBUG(D_tls) debug_printf("TLS: no ALPN presented in handshake\n"); }
3494 else DEBUG(D_tls)
3495   {
3496   const uschar * name;
3497   unsigned len;
3498   SSL_get0_alpn_selected(ssl, &name, &len);
3499   if (len && name)
3500     debug_printf("ALPN negotiated: '%.*s'\n", (int)*name, name+1);
3501   else
3502     debug_printf("ALPN: no protocol negotiated\n");
3503   }
3504 #endif
3505
3506
3507 /* TLS has been set up. Record data for the connection,
3508 adjust the input functions to read via TLS, and initialize things. */
3509
3510 #ifdef SSL_get_extms_support
3511 /*XXX what does this return for tls1.3 ? */
3512 tls_in.ext_master_secret = SSL_get_extms_support(ssl) == 1;
3513 #endif
3514 peer_cert(ssl, &tls_in, peerdn, sizeof(peerdn));
3515
3516 tls_in.ver = tlsver_name(ssl);
3517 tls_in.cipher = construct_cipher_name(ssl, tls_in.ver, &tls_in.bits);
3518 tls_in.cipher_stdname = cipher_stdname_ssl(ssl);
3519
3520 DEBUG(D_tls)
3521   {
3522   uschar buf[2048];
3523   if (SSL_get_shared_ciphers(ssl, CS buf, sizeof(buf)))
3524     debug_printf("Shared ciphers: %s\n", buf);
3525
3526   tls_dump_keylog(ssl);
3527
3528 #ifdef EXIM_HAVE_SESSION_TICKET
3529   {
3530   SSL_SESSION * ss = SSL_get_session(ssl);
3531   if (SSL_SESSION_has_ticket(ss))       /* 1.1.0 */
3532     debug_printf("The session has a ticket, life %lu seconds\n",
3533       SSL_SESSION_get_ticket_lifetime_hint(ss));
3534   }
3535 #endif
3536   }
3537
3538 /* Record the certificate we presented */
3539   {
3540   X509 * crt = SSL_get_certificate(ssl);
3541   tls_in.ourcert = crt ? X509_dup(crt) : NULL;
3542   }
3543
3544 tls_get_channel_binding(ssl, &tls_in, GET_UNTAINTED);
3545
3546 /* Only used by the server-side tls (tls_in), including tls_getc.
3547    Client-side (tls_out) reads (seem to?) go via
3548    smtp_read_response()/ip_recv().
3549    Hence no need to duplicate for _in and _out.
3550  */
3551 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
3552 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
3553 ssl_xfer_eof = ssl_xfer_error = FALSE;
3554
3555 receive_getc = tls_getc;
3556 receive_getbuf = tls_getbuf;
3557 receive_get_cache = tls_get_cache;
3558 receive_hasc = tls_hasc;
3559 receive_ungetc = tls_ungetc;
3560 receive_feof = tls_feof;
3561 receive_ferror = tls_ferror;
3562
3563 tls_in.active.sock = fileno(smtp_out);
3564 tls_in.active.tls_ctx = NULL;   /* not using explicit ctx for server-side */
3565 return OK;
3566 }
3567
3568
3569
3570
3571 static int
3572 tls_client_basic_ctx_init(SSL_CTX * ctx,
3573     host_item * host, smtp_transport_options_block * ob, exim_openssl_state_st * state,
3574     uschar ** errstr)
3575 {
3576 int rc;
3577
3578 /* Back-compatible old behaviour if tls_verify_certificates is set but both
3579 tls_verify_hosts and tls_try_verify_hosts are not set. Check only the specified
3580 host patterns if one of them is set with content. */
3581
3582 if (  (  (  !ob->tls_verify_hosts || !ob->tls_verify_hosts
3583          || Ustrcmp(ob->tls_try_verify_hosts, ":") == 0
3584          )
3585       && (  !ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts
3586          || Ustrcmp(ob->tls_try_verify_hosts, ":") == 0
3587          )
3588       )
3589    || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
3590    )
3591   client_verify_optional = FALSE;
3592 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
3593   client_verify_optional = TRUE;
3594 else
3595   return OK;
3596
3597  {
3598   uschar * expcerts;
3599   if (!expand_check(ob->tls_verify_certificates, US"tls_verify_certificates",
3600                     &expcerts, errstr))
3601     return DEFER;
3602   DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
3603
3604   if (state->lib_state.cabundle)
3605     { DEBUG(D_tls) debug_printf("TLS: CA bundle was preloaded\n"); }
3606   else
3607     if ((rc = setup_certs(ctx, expcerts, ob->tls_crl, host, errstr)) != OK)
3608       return rc;
3609
3610   if (expcerts && *expcerts)
3611     setup_cert_verify(ctx, client_verify_optional, verify_callback_client);
3612  }
3613
3614 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
3615   {
3616   state->verify_cert_hostnames =
3617 #ifdef SUPPORT_I18N
3618     string_domain_utf8_to_alabel(host->certname, NULL);
3619 #else
3620     host->certname;
3621 #endif
3622   DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
3623                     state->verify_cert_hostnames);
3624   }
3625 return OK;
3626 }
3627
3628
3629 #ifdef SUPPORT_DANE
3630 static int
3631 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
3632 {
3633 dns_scan dnss;
3634 const char * hostnames[2] = { CS host->name, NULL };
3635 int found = 0;
3636
3637 if (DANESSL_init(ssl, NULL, hostnames) != 1)
3638   return tls_error(US"hostnames load", host, NULL, errstr);
3639
3640 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
3641      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
3642     ) if (rr->type == T_TLSA && rr->size > 3)
3643   {
3644   const uschar * p = rr->data;
3645   uint8_t usage, selector, mtype;
3646   const char * mdname;
3647
3648   usage = *p++;
3649
3650   /* Only DANE-TA(2) and DANE-EE(3) are supported */
3651   if (usage != 2 && usage != 3) continue;
3652
3653   selector = *p++;
3654   mtype = *p++;
3655
3656   switch (mtype)
3657     {
3658     default: continue;  /* Only match-types 0, 1, 2 are supported */
3659     case 0:  mdname = NULL; break;
3660     case 1:  mdname = "sha256"; break;
3661     case 2:  mdname = "sha512"; break;
3662     }
3663
3664   found++;
3665   switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
3666     {
3667     default:
3668       return tls_error(US"tlsa load", host, NULL, errstr);
3669     case 0:     /* action not taken */
3670     case 1:     break;
3671     }
3672
3673   tls_out.tlsa_usage |= 1<<usage;
3674   }
3675
3676 if (found)
3677   return OK;
3678
3679 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
3680 return DEFER;
3681 }
3682 #endif  /*SUPPORT_DANE*/
3683
3684
3685
3686 #ifndef DISABLE_TLS_RESUME
3687 /* On the client, get any stashed session for the given IP from hints db
3688 and apply it to the ssl-connection for attempted resumption. */
3689
3690 static void
3691 tls_retrieve_session(tls_support * tlsp, SSL * ssl)
3692 {
3693 if (tlsp->host_resumable)
3694   {
3695   const uschar * key = tlsp->resume_index;
3696   dbdata_tls_session * dt;
3697   int len;
3698   open_db dbblock, * dbm_file;
3699
3700   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
3701   DEBUG(D_tls)
3702     debug_printf("checking for resumable session for %s\n", tlsp->resume_index);
3703   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3704     {
3705     if ((dt = dbfn_read_with_length(dbm_file, tlsp->resume_index, &len)))
3706       {
3707       SSL_SESSION * ss = NULL;
3708       const uschar * sess_asn1 = dt->session;
3709
3710       len -= sizeof(dbdata_tls_session);
3711       if (!(d2i_SSL_SESSION(&ss, &sess_asn1, (long)len)))
3712         {
3713         DEBUG(D_tls)
3714           {
3715           ERR_error_string_n(ERR_get_error(),
3716             ssl_errstring, sizeof(ssl_errstring));
3717           debug_printf("decoding session: %s\n", ssl_errstring);
3718           }
3719         }
3720       else
3721         {
3722         unsigned long lifetime =
3723 #ifdef EXIM_HAVE_SESSION_TICKET
3724           SSL_SESSION_get_ticket_lifetime_hint(ss);
3725 #else                   /* Use, fairly arbitrilarily, what we as server would */
3726           f.running_in_test_harness ? 6 : ssl_session_timeout;
3727 #endif
3728         if (lifetime + dt->time_stamp < time(NULL))
3729           {
3730           DEBUG(D_tls) debug_printf("session expired\n");
3731           dbfn_delete(dbm_file, tlsp->resume_index);
3732           }
3733         else if (SSL_set_session(ssl, ss))
3734           {
3735           DEBUG(D_tls) debug_printf("good session\n");
3736           tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
3737           tlsp->verify_override = dt->verify_override;
3738           tlsp->ocsp = dt->ocsp;
3739           }
3740         else DEBUG(D_tls)
3741           {
3742           ERR_error_string_n(ERR_get_error(),
3743             ssl_errstring, sizeof(ssl_errstring));
3744           debug_printf("applying session to ssl: %s\n", ssl_errstring);
3745           }
3746         }
3747       }
3748     else
3749       DEBUG(D_tls) debug_printf("no session record\n");
3750     dbfn_close(dbm_file);
3751     }
3752   }
3753 }
3754
3755
3756 /* On the client, save the session for later resumption */
3757
3758 static int
3759 tls_save_session_cb(SSL * ssl, SSL_SESSION * ss)
3760 {
3761 exim_openssl_state_st * cbinfo = SSL_get_ex_data(ssl, tls_exdata_idx);
3762 tls_support * tlsp;
3763
3764 DEBUG(D_tls) debug_printf("tls_save_session_cb\n");
3765
3766 if (!cbinfo || !(tlsp = cbinfo->tlsp)->host_resumable) return 0;
3767
3768 # ifdef OPENSSL_HAVE_NUM_TICKETS
3769 if (SSL_SESSION_is_resumable(ss))       /* 1.1.1 */
3770 # endif
3771   {
3772   int len = i2d_SSL_SESSION(ss, NULL);
3773   int dlen = sizeof(dbdata_tls_session) + len;
3774   dbdata_tls_session * dt = store_get(dlen, GET_TAINTED);
3775   uschar * s = dt->session;
3776   open_db dbblock, * dbm_file;
3777
3778   DEBUG(D_tls) debug_printf("session is resumable\n");
3779   tlsp->resumption |= RESUME_SERVER_TICKET;     /* server gave us a ticket */
3780
3781   dt->verify_override = tlsp->verify_override;
3782   dt->ocsp = tlsp->ocsp;
3783   (void) i2d_SSL_SESSION(ss, &s);               /* s gets bumped to end */
3784
3785   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3786     {
3787     dbfn_write(dbm_file, tlsp->resume_index, dt, dlen);
3788     dbfn_close(dbm_file);
3789     DEBUG(D_tls) debug_printf("wrote session (len %u) to db\n",
3790                   (unsigned)dlen);
3791     }
3792   }
3793 return 1;
3794 }
3795
3796
3797 /* Construct a key for session DB lookup, and setup the SSL_CTX for resumption */
3798
3799 static void
3800 tls_client_ctx_resume_prehandshake(
3801   exim_openssl_client_tls_ctx * exim_client_ctx, smtp_connect_args * conn_args,
3802   tls_support * tlsp, smtp_transport_options_block * ob)
3803 {
3804 tlsp->host_resumable = TRUE;
3805 tls_client_resmption_key(tlsp, conn_args, ob);
3806
3807 SSL_CTX_set_session_cache_mode(exim_client_ctx->ctx,
3808       SSL_SESS_CACHE_CLIENT
3809       | SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_NO_AUTO_CLEAR);
3810 SSL_CTX_sess_set_new_cb(exim_client_ctx->ctx, tls_save_session_cb);
3811 }
3812
3813 static BOOL
3814 tls_client_ssl_resume_prehandshake(SSL * ssl, tls_support * tlsp,
3815   host_item * host, uschar ** errstr)
3816 {
3817 if (tlsp->host_resumable)
3818   {
3819   DEBUG(D_tls)
3820     debug_printf("tls_resumption_hosts overrides openssl_options, enabling tickets\n");
3821   SSL_clear_options(ssl, SSL_OP_NO_TICKET);
3822
3823   tls_exdata_idx = SSL_get_ex_new_index(0, 0, 0, 0, 0);
3824   if (!SSL_set_ex_data(ssl, tls_exdata_idx, client_static_state))
3825     {
3826     tls_error(US"set ex_data", host, NULL, errstr);
3827     return FALSE;
3828     }
3829   debug_printf("tls_exdata_idx %d cbinfo %p\n", tls_exdata_idx, client_static_state);
3830   }
3831
3832 tlsp->resumption = RESUME_SUPPORTED;
3833 /* Pick up a previous session, saved on an old ticket */
3834 tls_retrieve_session(tlsp, ssl);
3835 return TRUE;
3836 }
3837
3838 static void
3839 tls_client_resume_posthandshake(exim_openssl_client_tls_ctx * exim_client_ctx,
3840   tls_support * tlsp)
3841 {
3842 if (SSL_session_reused(exim_client_ctx->ssl))
3843   {
3844   DEBUG(D_tls) debug_printf("The session was reused\n");
3845   tlsp->resumption |= RESUME_USED;
3846   }
3847 }
3848 #endif  /* !DISABLE_TLS_RESUME */
3849
3850
3851 #ifdef EXIM_HAVE_ALPN
3852 /* Expand and convert an Exim list to an ALPN list.  False return for fail.
3853 NULL plist return for silent no-ALPN.
3854
3855 Overwite the passed-in list with the expanded version.
3856 */
3857
3858 static BOOL
3859 tls_alpn_plist(uschar ** tls_alpn, const uschar ** plist, unsigned * plen,
3860   uschar ** errstr)
3861 {
3862 uschar * exp_alpn;
3863
3864 if (!expand_check(*tls_alpn, US"tls_alpn", &exp_alpn, errstr))
3865   return FALSE;
3866 *tls_alpn = exp_alpn;
3867
3868 if (!exp_alpn)
3869   {
3870   DEBUG(D_tls) debug_printf("Setting TLS ALPN forced to fail, not sending\n");
3871   *plist = NULL;
3872   }
3873 else
3874   {
3875   /* The server implementation only accepts exactly one protocol name
3876   but it's little extra code complexity in the client. */
3877
3878   const uschar * list = exp_alpn;
3879   uschar * p = store_get(Ustrlen(exp_alpn), exp_alpn), * s, * t;
3880   int sep = 0;
3881   uschar len;
3882
3883   for (t = p; s = string_nextinlist(&list, &sep, NULL, 0); t += len)
3884     {
3885     *t++ = len = (uschar) Ustrlen(s);
3886     memcpy(t, s, len);
3887     }
3888   *plist = (*plen = t - p) ? p : NULL;
3889   }
3890 return TRUE;
3891 }
3892 #endif  /* EXIM_HAVE_ALPN */
3893
3894
3895 /*************************************************
3896 *    Start a TLS session in a client             *
3897 *************************************************/
3898
3899 /* Called from the smtp transport after STARTTLS has been accepted.
3900
3901 Arguments:
3902   cctx          connection context
3903   conn_args     connection details
3904   cookie        datum for randomness; can be NULL
3905   tlsp          record details of TLS channel configuration here; must be non-NULL
3906   errstr        error string pointer
3907
3908 Returns:        TRUE for success with TLS session context set in connection context,
3909                 FALSE on error
3910 */
3911
3912 BOOL
3913 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
3914   void * cookie, tls_support * tlsp, uschar ** errstr)
3915 {
3916 host_item * host = conn_args->host;             /* for msgs and option-tests */
3917 transport_instance * tb = conn_args->tblock;    /* always smtp or NULL */
3918 smtp_transport_options_block * ob = tb
3919   ? (smtp_transport_options_block *)tb->options_block
3920   : &smtp_transport_option_defaults;
3921 exim_openssl_client_tls_ctx * exim_client_ctx;
3922 uschar * expciphers;
3923 int rc;
3924 static uschar peerdn[256];
3925
3926 #ifndef DISABLE_OCSP
3927 BOOL request_ocsp = FALSE;
3928 BOOL require_ocsp = FALSE;
3929 #endif
3930
3931 rc = store_pool;
3932 store_pool = POOL_PERM;
3933 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx), GET_UNTAINTED);
3934 exim_client_ctx->corked = NULL;
3935 store_pool = rc;
3936
3937 #ifdef SUPPORT_DANE
3938 tlsp->tlsa_usage = 0;
3939 #endif
3940
3941 #ifndef DISABLE_OCSP
3942   {
3943 # ifdef SUPPORT_DANE
3944   /*XXX this should be moved to caller, to be common across gnutls/openssl */
3945   if (  conn_args->dane
3946      && ob->hosts_request_ocsp[0] == '*'
3947      && ob->hosts_request_ocsp[1] == '\0'
3948      )
3949     {
3950     /* Unchanged from default.  Use a safer one under DANE */
3951     request_ocsp = TRUE;
3952     ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
3953                                       "   {= {4}{$tls_out_tlsa_usage}} } "
3954                                  " {*}{}}";
3955     }
3956 # endif
3957
3958   if ((require_ocsp =
3959         verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK))
3960     request_ocsp = TRUE;
3961   else
3962 # ifdef SUPPORT_DANE
3963     if (!request_ocsp)
3964 # endif
3965       request_ocsp =
3966         verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3967   }
3968 #endif
3969
3970 rc = tls_init(host, ob,
3971 #ifndef DISABLE_OCSP
3972     (void *)(long)request_ocsp,
3973 #endif
3974     cookie, &client_static_state, tlsp, errstr);
3975 if (rc != OK) return FALSE;
3976
3977 exim_client_ctx->ctx = client_static_state->lib_state.lib_ctx;
3978
3979 tlsp->certificate_verified = FALSE;
3980 client_verify_callback_called = FALSE;
3981
3982 expciphers = NULL;
3983 #ifdef SUPPORT_DANE
3984 if (conn_args->dane)
3985   {
3986   /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
3987   other failures should be treated as problems. */
3988   if (ob->dane_require_tls_ciphers &&
3989       !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
3990         &expciphers, errstr))
3991     return FALSE;
3992   if (expciphers && *expciphers == '\0')
3993     expciphers = NULL;
3994
3995   normalise_ciphers(&expciphers, ob->dane_require_tls_ciphers);
3996   }
3997 #endif
3998 if (!expciphers)
3999   {
4000   if (!expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
4001       &expciphers, errstr))
4002     return FALSE;
4003
4004   /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
4005   are separated by underscores. So that I can use either form in my tests, and
4006   also for general convenience, we turn underscores into hyphens here. */
4007
4008   normalise_ciphers(&expciphers, ob->tls_require_ciphers);
4009   }
4010
4011 if (expciphers)
4012   {
4013   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
4014   if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
4015     {
4016     tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
4017     return FALSE;
4018     }
4019   }
4020
4021 #ifdef SUPPORT_DANE
4022 if (conn_args->dane)
4023   {
4024   SSL_CTX_set_verify(exim_client_ctx->ctx,
4025     SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
4026     verify_callback_client_dane);
4027
4028   if (!DANESSL_library_init())
4029     {
4030     tls_error(US"library init", host, NULL, errstr);
4031     return FALSE;
4032     }
4033   if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
4034     {
4035     tls_error(US"context init", host, NULL, errstr);
4036     return FALSE;
4037     }
4038   }
4039 else
4040
4041 #endif
4042
4043 if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
4044       client_static_state, errstr) != OK)
4045   return FALSE;
4046
4047 if (ob->tls_sni)
4048   {
4049   if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
4050     return FALSE;
4051   if (!tlsp->sni)
4052     { DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n"); }
4053   else if (!Ustrlen(tlsp->sni))
4054     tlsp->sni = NULL;
4055   else
4056     {
4057 #ifndef EXIM_HAVE_OPENSSL_TLSEXT
4058     log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
4059           tlsp->sni);
4060     tlsp->sni = NULL;
4061 #endif
4062     }
4063   }
4064
4065 if (ob->tls_alpn)
4066 #ifdef EXIM_HAVE_ALPN
4067   {
4068   const uschar * plist;
4069   unsigned plen;
4070
4071   if (!tls_alpn_plist(&ob->tls_alpn, &plist, &plen, errstr))
4072     return FALSE;
4073   if (plist)
4074     if (SSL_CTX_set_alpn_protos(exim_client_ctx->ctx, plist, plen) != 0)
4075       {
4076       tls_error(US"alpn init", host, NULL, errstr);
4077       return FALSE;
4078       }
4079     else
4080       DEBUG(D_tls) debug_printf("Setting TLS ALPN '%s'\n", ob->tls_alpn);
4081   }
4082 #else
4083   log_write(0, LOG_MAIN, "ALPN unusable with this OpenSSL library version; ignoring \"%s\"\n",
4084           ob->tls_alpn);
4085 #endif
4086
4087 #ifndef DISABLE_TLS_RESUME
4088 /*XXX have_lbserver: another cmdline arg possibly, for continued-conn, but use
4089 will be very low. */
4090
4091 if (!conn_args->have_lbserver)  /* wanted for tls_client_resmption_key() */
4092   { DEBUG(D_tls) debug_printf("resumption not supported on continued-connection\n"); }
4093 else if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
4094   tls_client_ctx_resume_prehandshake(exim_client_ctx, conn_args, tlsp, ob);
4095 #endif
4096
4097
4098 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
4099   {
4100   tls_error(US"SSL_new", host, NULL, errstr);
4101   return FALSE;
4102   }
4103 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
4104 SSL_set_fd(exim_client_ctx->ssl, cctx->sock);
4105 SSL_set_connect_state(exim_client_ctx->ssl);
4106
4107 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
4108 if (tlsp->sni)
4109   {
4110   DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
4111   SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
4112   }
4113 #endif
4114
4115 #ifdef SUPPORT_DANE
4116 if (conn_args->dane)
4117   if (dane_tlsa_load(exim_client_ctx->ssl, host, &conn_args->tlsa_dnsa, errstr) != OK)
4118     return FALSE;
4119 #endif
4120
4121 #ifndef DISABLE_OCSP
4122 /* Request certificate status at connection-time.  If the server
4123 does OCSP stapling we will get the callback (set in tls_init()) */
4124 # ifdef SUPPORT_DANE
4125 if (request_ocsp)
4126   {
4127   const uschar * s;
4128   if (  ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
4129      || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
4130      )
4131     {   /* Re-eval now $tls_out_tlsa_usage is populated.  If
4132         this means we avoid the OCSP request, we wasted the setup
4133         cost in tls_init(). */
4134     require_ocsp = verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
4135     request_ocsp = require_ocsp
4136       || verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
4137     }
4138   }
4139 # endif
4140
4141 if (request_ocsp)
4142   {
4143   SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
4144   client_static_state->u_ocsp.client.verify_required = require_ocsp;
4145   tlsp->ocsp = OCSP_NOT_RESP;
4146   }
4147 #endif
4148
4149 #ifndef DISABLE_TLS_RESUME
4150 if (!tls_client_ssl_resume_prehandshake(exim_client_ctx->ssl, tlsp, host,
4151       errstr))
4152   return FALSE;
4153 #endif
4154
4155 #ifndef DISABLE_EVENT
4156 client_static_state->event_action = tb ? tb->event_action : NULL;
4157 #endif
4158
4159 /* There doesn't seem to be a built-in timeout on connection. */
4160
4161 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
4162 sigalrm_seen = FALSE;
4163 ALARM(ob->command_timeout);
4164 rc = SSL_connect(exim_client_ctx->ssl);
4165 ALARM_CLR(0);
4166
4167 #ifdef SUPPORT_DANE
4168 if (conn_args->dane)
4169   DANESSL_cleanup(exim_client_ctx->ssl);
4170 #endif
4171
4172 if (rc <= 0)
4173   {
4174   tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
4175   return FALSE;
4176   }
4177
4178 DEBUG(D_tls)
4179   {
4180   debug_printf("SSL_connect succeeded\n");
4181   tls_dump_keylog(exim_client_ctx->ssl);
4182   }
4183
4184 #ifndef DISABLE_TLS_RESUME
4185 tls_client_resume_posthandshake(exim_client_ctx, tlsp);
4186 #endif
4187
4188 #ifdef EXIM_HAVE_ALPN
4189 if (ob->tls_alpn)       /* We requested. See what was negotiated. */
4190   {
4191   const uschar * name;
4192   unsigned len;
4193
4194   SSL_get0_alpn_selected(exim_client_ctx->ssl, &name, &len);
4195   if (len > 0)
4196     { DEBUG(D_tls) debug_printf("ALPN negotiated %u: '%.*s'\n", len, (int)*name, name+1); }
4197   else if (verify_check_given_host(CUSS &ob->hosts_require_alpn, host) == OK)
4198     {
4199     /* Would like to send a relevant fatal Alert, but OpenSSL has no API */
4200     tls_error(US"handshake", host, US"ALPN required but not negotiated", errstr);
4201     return FALSE;
4202     }
4203   }
4204 #endif
4205
4206 #ifdef SSL_get_extms_support
4207 tlsp->ext_master_secret = SSL_get_extms_support(exim_client_ctx->ssl) == 1;
4208 #endif
4209 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
4210
4211 tlsp->ver = tlsver_name(exim_client_ctx->ssl);
4212 tlsp->cipher = construct_cipher_name(exim_client_ctx->ssl, tlsp->ver, &tlsp->bits);
4213 tlsp->cipher_stdname = cipher_stdname_ssl(exim_client_ctx->ssl);
4214
4215 /* Record the certificate we presented */
4216   {
4217   X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
4218   tlsp->ourcert = crt ? X509_dup(crt) : NULL;
4219   }
4220
4221 /*XXX will this work with continued-TLS? */
4222 tls_get_channel_binding(exim_client_ctx->ssl, tlsp, GET_TAINTED);
4223
4224 tlsp->active.sock = cctx->sock;
4225 tlsp->active.tls_ctx = exim_client_ctx;
4226 cctx->tls_ctx = exim_client_ctx;
4227 return TRUE;
4228 }
4229
4230
4231
4232
4233
4234 static BOOL
4235 tls_refill(unsigned lim)
4236 {
4237 SSL * ssl = state_server.lib_state.lib_ssl;
4238 int error;
4239 int inbytes;
4240
4241 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
4242   ssl_xfer_buffer, ssl_xfer_buffer_size);
4243
4244 ERR_clear_error();
4245 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
4246 inbytes = SSL_read(ssl, CS ssl_xfer_buffer,
4247                   MIN(ssl_xfer_buffer_size, lim));
4248 error = SSL_get_error(ssl, inbytes);
4249 if (smtp_receive_timeout > 0) ALARM_CLR(0);
4250
4251 if (had_command_timeout)                /* set by signal handler */
4252   smtp_command_timeout_exit();          /* does not return */
4253 if (had_command_sigterm)
4254   smtp_command_sigterm_exit();
4255 if (had_data_timeout)
4256   smtp_data_timeout_exit();
4257 if (had_data_sigint)
4258   smtp_data_sigint_exit();
4259
4260 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
4261 closed down, not that the socket itself has been closed down. Revert to
4262 non-SSL handling. */
4263
4264 switch(error)
4265   {
4266   case SSL_ERROR_NONE:
4267     break;
4268
4269   case SSL_ERROR_ZERO_RETURN:
4270     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
4271
4272     if (SSL_get_shutdown(ssl) == SSL_RECEIVED_SHUTDOWN)
4273           SSL_shutdown(ssl);
4274
4275     tls_close(NULL, TLS_NO_SHUTDOWN);
4276     return FALSE;
4277
4278   /* Handle genuine errors */
4279   case SSL_ERROR_SSL:
4280     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4281     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
4282     ssl_xfer_error = TRUE;
4283     return FALSE;
4284
4285   default:
4286     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
4287     DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
4288       debug_printf(" - syscall %s\n", strerror(errno));
4289     ssl_xfer_error = TRUE;
4290     return FALSE;
4291   }
4292
4293 #ifndef DISABLE_DKIM
4294 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
4295 #endif
4296 ssl_xfer_buffer_hwm = inbytes;
4297 ssl_xfer_buffer_lwm = 0;
4298 return TRUE;
4299 }
4300
4301
4302 /*************************************************
4303 *            TLS version of getc                 *
4304 *************************************************/
4305
4306 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
4307 it refills the buffer via the SSL reading function.
4308
4309 Arguments:  lim         Maximum amount to read/buffer
4310 Returns:    the next character or EOF
4311
4312 Only used by the server-side TLS.
4313 */
4314
4315 int
4316 tls_getc(unsigned lim)
4317 {
4318 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
4319   if (!tls_refill(lim))
4320     return ssl_xfer_error ? EOF : smtp_getc(lim);
4321
4322 /* Something in the buffer; return next uschar */
4323
4324 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
4325 }
4326
4327 BOOL
4328 tls_hasc(void)
4329 {
4330 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm;
4331 }
4332
4333 uschar *
4334 tls_getbuf(unsigned * len)
4335 {
4336 unsigned size;
4337 uschar * buf;
4338
4339 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
4340   if (!tls_refill(*len))
4341     {
4342     if (!ssl_xfer_error) return smtp_getbuf(len);
4343     *len = 0;
4344     return NULL;
4345     }
4346
4347 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
4348   size = *len;
4349 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
4350 ssl_xfer_buffer_lwm += size;
4351 *len = size;
4352 return buf;
4353 }
4354
4355
4356 void
4357 tls_get_cache(unsigned lim)
4358 {
4359 #ifndef DISABLE_DKIM
4360 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
4361 debug_printf("tls_get_cache\n");
4362 if (n > lim)
4363   n = lim;
4364 if (n > 0)
4365   dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
4366 #endif
4367 }
4368
4369
4370 BOOL
4371 tls_could_getc(void)
4372 {
4373 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm
4374     || SSL_pending(state_server.lib_state.lib_ssl) > 0;
4375 }
4376
4377
4378 /*************************************************
4379 *          Read bytes from TLS channel           *
4380 *************************************************/
4381
4382 /*
4383 Arguments:
4384   ct_ctx    client context pointer, or NULL for the one global server context
4385   buff      buffer of data
4386   len       size of buffer
4387
4388 Returns:    the number of bytes read
4389             -1 after a failed read, including EOF
4390
4391 Only used by the client-side TLS.
4392 */
4393
4394 int
4395 tls_read(void * ct_ctx, uschar *buff, size_t len)
4396 {
4397 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl
4398                   : state_server.lib_state.lib_ssl;
4399 int inbytes;
4400 int error;
4401
4402 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
4403   buff, (unsigned int)len);
4404
4405 ERR_clear_error();
4406 inbytes = SSL_read(ssl, CS buff, len);
4407 error = SSL_get_error(ssl, inbytes);
4408
4409 if (error == SSL_ERROR_ZERO_RETURN)
4410   {
4411   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
4412   return -1;
4413   }
4414 else if (error != SSL_ERROR_NONE)
4415   return -1;
4416
4417 return inbytes;
4418 }
4419
4420
4421
4422
4423
4424 /*************************************************
4425 *         Write bytes down TLS channel           *
4426 *************************************************/
4427
4428 /*
4429 Arguments:
4430   ct_ctx    client context pointer, or NULL for the one global server context
4431   buff      buffer of data
4432   len       number of bytes
4433   more      further data expected soon
4434
4435 Returns:    the number of bytes after a successful write,
4436             -1 after a failed write
4437
4438 Used by both server-side and client-side TLS.  Calling with len zero and more unset
4439 will flush buffered writes; buff can be null for this case.
4440 */
4441
4442 int
4443 tls_write(void * ct_ctx, const uschar * buff, size_t len, BOOL more)
4444 {
4445 size_t olen = len;
4446 int outbytes, error;
4447 SSL * ssl = ct_ctx
4448   ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl
4449   : state_server.lib_state.lib_ssl;
4450 static gstring * server_corked = NULL;
4451 gstring ** corkedp = ct_ctx
4452   ? &((exim_openssl_client_tls_ctx *)ct_ctx)->corked : &server_corked;
4453 gstring * corked = *corkedp;
4454
4455 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
4456   buff, (unsigned long)len, more ? ", more" : "");
4457
4458 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
4459 "more" is notified.  This hack is only ok if small amounts are involved AND only
4460 one stream does it, in one context (i.e. no store reset).  Currently it is used
4461 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only.
4462 We support callouts done by the server process by using a separate client
4463 context for the stashed information. */
4464 /* + if PIPE_COMMAND, banner & ehlo-resp for smmtp-on-connect. Suspect there's
4465 a store reset there, so use POOL_PERM. */
4466 /* + if CHUNKING, cmds EHLO,MAIL,RCPT(s),BDAT */
4467
4468 if (more || corked)
4469   {
4470   if (!len) buff = US &error;   /* dummy just so that string_catn is ok */
4471
4472   int save_pool = store_pool;
4473   store_pool = POOL_PERM;
4474
4475   corked = string_catn(corked, buff, len);
4476
4477   store_pool = save_pool;
4478
4479   if (more)
4480     {
4481     *corkedp = corked;
4482     return len;
4483     }
4484   buff = CUS corked->s;
4485   len = corked->ptr;
4486   *corkedp = NULL;
4487   }
4488
4489 for (int left = len; left > 0;)
4490   {
4491   DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
4492   ERR_clear_error();
4493   outbytes = SSL_write(ssl, CS buff, left);
4494   error = SSL_get_error(ssl, outbytes);
4495   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
4496   switch (error)
4497     {
4498     case SSL_ERROR_NONE:        /* the usual case */
4499       left -= outbytes;
4500       buff += outbytes;
4501       break;
4502
4503     case SSL_ERROR_SSL:
4504       ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4505       log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
4506       return -1;
4507
4508     case SSL_ERROR_ZERO_RETURN:
4509       log_write(0, LOG_MAIN, "SSL channel closed on write");
4510       return -1;
4511
4512     case SSL_ERROR_SYSCALL:
4513       if (ct_ctx || errno != ECONNRESET || !f.smtp_in_quit)
4514         log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
4515           sender_fullhost ? sender_fullhost : US"<unknown>",
4516           strerror(errno));
4517       else if (LOGGING(protocol_detail))
4518         log_write(0, LOG_MAIN, "[%s] after QUIT, client reset TCP before"
4519           " SMTP response and TLS close\n", sender_host_address);
4520       else
4521         DEBUG(D_tls) debug_printf("[%s] SSL_write: after QUIT,"
4522           " client reset TCP before TLS close\n", sender_host_address);
4523       return -1;
4524
4525     default:
4526       log_write(0, LOG_MAIN, "SSL_write error %d", error);
4527       return -1;
4528     }
4529   }
4530 return olen;
4531 }
4532
4533
4534
4535 /*
4536 Arguments:
4537   ct_ctx        client TLS context pointer, or NULL for the one global server context
4538 */
4539
4540 void
4541 tls_shutdown_wr(void * ct_ctx)
4542 {
4543 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
4544 SSL ** sslp = o_ctx ? &o_ctx->ssl : (SSL **) &state_server.lib_state.lib_ssl;
4545 int * fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
4546 int rc;
4547
4548 if (*fdp < 0) return;  /* TLS was not active */
4549
4550 tls_write(ct_ctx, NULL, 0, FALSE);      /* flush write buffer */
4551
4552 HDEBUG(D_transport|D_tls|D_acl|D_v) debug_printf_indent("  SMTP(TLS shutdown)>>\n");
4553 rc = SSL_shutdown(*sslp);
4554 if (rc < 0) DEBUG(D_tls)
4555   {
4556   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4557   debug_printf("SSL_shutdown: %s\n", ssl_errstring);
4558   }
4559 }
4560
4561 /*************************************************
4562 *         Close down a TLS session               *
4563 *************************************************/
4564
4565 /* This is also called from within a delivery subprocess forked from the
4566 daemon, to shut down the TLS library, without actually doing a shutdown (which
4567 would tamper with the SSL session in the parent process).
4568
4569 Arguments:
4570   ct_ctx        client TLS context pointer, or NULL for the one global server context
4571   do_shutdown   0 no data-flush or TLS close-alert
4572                 1 if TLS close-alert is to be sent,
4573                 2 if also response to be waited for
4574
4575 Returns:     nothing
4576
4577 Used by both server-side and client-side TLS.
4578 */
4579
4580 void
4581 tls_close(void * ct_ctx, int do_shutdown)
4582 {
4583 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
4584 SSL ** sslp = o_ctx ? &o_ctx->ssl : (SSL **) &state_server.lib_state.lib_ssl;
4585 int * fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
4586
4587 if (*fdp < 0) return;  /* TLS was not active */
4588
4589 if (do_shutdown > TLS_NO_SHUTDOWN)
4590   {
4591   int rc;
4592   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
4593     do_shutdown > TLS_SHUTDOWN_NOWAIT ? " (with response-wait)" : "");
4594
4595   tls_write(ct_ctx, NULL, 0, FALSE);    /* flush write buffer */
4596
4597   if (  (  do_shutdown >= TLS_SHUTDOWN_WONLY
4598         || (rc = SSL_shutdown(*sslp)) == 0      /* send "close notify" alert */
4599         )
4600      && do_shutdown > TLS_SHUTDOWN_NOWAIT
4601      )
4602     {
4603 #ifdef EXIM_TCP_CORK
4604     (void) setsockopt(*fdp, IPPROTO_TCP, EXIM_TCP_CORK, US &off, sizeof(off));
4605 #endif
4606     ALARM(2);
4607     rc = SSL_shutdown(*sslp);                   /* wait for response */
4608     ALARM_CLR(0);
4609     }
4610
4611   if (rc < 0) DEBUG(D_tls)
4612     {
4613     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4614     debug_printf("SSL_shutdown: %s\n", ssl_errstring);
4615     }
4616   }
4617
4618 if (!o_ctx)             /* server side */
4619   {
4620 #ifndef DISABLE_OCSP
4621   sk_X509_pop_free(state_server.verify_stack, X509_free);
4622   state_server.verify_stack = NULL;
4623 #endif
4624
4625   receive_getc =        smtp_getc;
4626   receive_getbuf =      smtp_getbuf;
4627   receive_get_cache =   smtp_get_cache;
4628   receive_hasc =        smtp_hasc;
4629   receive_ungetc =      smtp_ungetc;
4630   receive_feof =        smtp_feof;
4631   receive_ferror =      smtp_ferror;
4632   tls_in.active.tls_ctx = NULL;
4633   tls_in.sni = NULL;
4634   /* Leave bits, peercert, cipher, peerdn, certificate_verified set, for logging */
4635   }
4636
4637 SSL_free(*sslp);
4638 *sslp = NULL;
4639 *fdp = -1;
4640 }
4641
4642
4643
4644
4645 /*************************************************
4646 *  Let tls_require_ciphers be checked at startup *
4647 *************************************************/
4648
4649 /* The tls_require_ciphers option, if set, must be something which the
4650 library can parse.
4651
4652 Returns:     NULL on success, or error message
4653 */
4654
4655 uschar *
4656 tls_validate_require_cipher(void)
4657 {
4658 SSL_CTX * ctx;
4659 uschar * expciphers, * err;
4660
4661 tls_openssl_init();
4662
4663 if (!(tls_require_ciphers && *tls_require_ciphers))
4664   return NULL;
4665
4666 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
4667                   &err))
4668   return US"failed to expand tls_require_ciphers";
4669
4670 if (!(expciphers && *expciphers))
4671   return NULL;
4672
4673 normalise_ciphers(&expciphers, tls_require_ciphers);
4674
4675 err = NULL;
4676 if (lib_ctx_new(&ctx, NULL, &err) == OK)
4677   {
4678   DEBUG(D_tls)
4679     debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
4680
4681   if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
4682     {
4683     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4684     err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
4685                         expciphers, ssl_errstring);
4686     }
4687
4688   SSL_CTX_free(ctx);
4689   }
4690 return err;
4691 }
4692
4693
4694
4695
4696 /*************************************************
4697 *         Report the library versions.           *
4698 *************************************************/
4699
4700 /* There have historically been some issues with binary compatibility in
4701 OpenSSL libraries; if Exim (like many other applications) is built against
4702 one version of OpenSSL but the run-time linker picks up another version,
4703 it can result in serious failures, including crashing with a SIGSEGV.  So
4704 report the version found by the compiler and the run-time version.
4705
4706 Note: some OS vendors backport security fixes without changing the version
4707 number/string, and the version date remains unchanged.  The _build_ date
4708 will change, so we can more usefully assist with version diagnosis by also
4709 reporting the build date.
4710
4711 Arguments:   string to append to
4712 Returns:     string
4713 */
4714
4715 gstring *
4716 tls_version_report(gstring * g)
4717 {
4718 return string_fmt_append(g,
4719     "Library version: OpenSSL: Compile: %s\n"
4720     "                          Runtime: %s\n"
4721     "                                 : %s\n",
4722              OPENSSL_VERSION_TEXT,
4723              SSLeay_version(SSLEAY_VERSION),
4724              SSLeay_version(SSLEAY_BUILT_ON));
4725   /* third line is 38 characters for the %s and the line is 73 chars long;
4726   the OpenSSL output includes a "built on: " prefix already. */
4727 }
4728
4729
4730
4731
4732 /*************************************************
4733 *            Random number generation            *
4734 *************************************************/
4735
4736 /* Pseudo-random number generation.  The result is not expected to be
4737 cryptographically strong but not so weak that someone will shoot themselves
4738 in the foot using it as a nonce in input in some email header scheme or
4739 whatever weirdness they'll twist this into.  The result should handle fork()
4740 and avoid repeating sequences.  OpenSSL handles that for us.
4741
4742 Arguments:
4743   max       range maximum
4744 Returns     a random number in range [0, max-1]
4745 */
4746
4747 int
4748 vaguely_random_number(int max)
4749 {
4750 unsigned int r;
4751 int i, needed_len;
4752 static pid_t pidlast = 0;
4753 pid_t pidnow;
4754 uschar smallbuf[sizeof(r)];
4755
4756 if (max <= 1)
4757   return 0;
4758
4759 pidnow = getpid();
4760 if (pidnow != pidlast)
4761   {
4762   /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
4763   is unique for each thread", this doesn't apparently apply across processes,
4764   so our own warning from vaguely_random_number_fallback() applies here too.
4765   Fix per PostgreSQL. */
4766   if (pidlast != 0)
4767     RAND_cleanup();
4768   pidlast = pidnow;
4769   }
4770
4771 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
4772 if (!RAND_status())
4773   {
4774   randstuff r;
4775   gettimeofday(&r.tv, NULL);
4776   r.p = getpid();
4777
4778   RAND_seed(US (&r), sizeof(r));
4779   }
4780 /* We're after pseudo-random, not random; if we still don't have enough data
4781 in the internal PRNG then our options are limited.  We could sleep and hope
4782 for entropy to come along (prayer technique) but if the system is so depleted
4783 in the first place then something is likely to just keep taking it.  Instead,
4784 we'll just take whatever little bit of pseudo-random we can still manage to
4785 get. */
4786
4787 needed_len = sizeof(r);
4788 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
4789 asked for a number less than 10. */
4790 for (r = max, i = 0; r; ++i)
4791   r >>= 1;
4792 i = (i + 7) / 8;
4793 if (i < needed_len)
4794   needed_len = i;
4795
4796 #ifdef EXIM_HAVE_RAND_PSEUDO
4797 /* We do not care if crypto-strong */
4798 i = RAND_pseudo_bytes(smallbuf, needed_len);
4799 #else
4800 i = RAND_bytes(smallbuf, needed_len);
4801 #endif
4802
4803 if (i < 0)
4804   {
4805   DEBUG(D_all)
4806     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
4807   return vaguely_random_number_fallback(max);
4808   }
4809
4810 r = 0;
4811 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
4812   r = 256 * r + *p;
4813
4814 /* We don't particularly care about weighted results; if someone wants
4815 smooth distribution and cares enough then they should submit a patch then. */
4816 return r % max;
4817 }
4818
4819
4820
4821
4822 /*************************************************
4823 *        OpenSSL option parse                    *
4824 *************************************************/
4825
4826 /* Parse one option for tls_openssl_options_parse below
4827
4828 Arguments:
4829   name    one option name
4830   value   place to store a value for it
4831 Returns   success or failure in parsing
4832 */
4833
4834
4835
4836 static BOOL
4837 tls_openssl_one_option_parse(uschar *name, long *value)
4838 {
4839 int first = 0;
4840 int last = exim_openssl_options_size;
4841 while (last > first)
4842   {
4843   int middle = (first + last)/2;
4844   int c = Ustrcmp(name, exim_openssl_options[middle].name);
4845   if (c == 0)
4846     {
4847     *value = exim_openssl_options[middle].value;
4848     return TRUE;
4849     }
4850   else if (c > 0)
4851     first = middle + 1;
4852   else
4853     last = middle;
4854   }
4855 return FALSE;
4856 }
4857
4858
4859
4860
4861 /*************************************************
4862 *        OpenSSL option parsing logic            *
4863 *************************************************/
4864
4865 /* OpenSSL has a number of compatibility options which an administrator might
4866 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
4867 we look like log_selector.
4868
4869 Arguments:
4870   option_spec  the administrator-supplied string of options
4871   results      ptr to long storage for the options bitmap
4872 Returns        success or failure
4873 */
4874
4875 BOOL
4876 tls_openssl_options_parse(uschar *option_spec, long *results)
4877 {
4878 long result, item;
4879 uschar * exp, * end;
4880 BOOL adding, item_parsed;
4881
4882 /* Server: send no (<= TLS1.2) session tickets */
4883 result = SSL_OP_NO_TICKET;
4884
4885 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
4886 from default because it increases BEAST susceptibility. */
4887 #ifdef SSL_OP_NO_SSLv2
4888 result |= SSL_OP_NO_SSLv2;
4889 #endif
4890 #ifdef SSL_OP_NO_SSLv3
4891 result |= SSL_OP_NO_SSLv3;
4892 #endif
4893 #ifdef SSL_OP_SINGLE_DH_USE
4894 result |= SSL_OP_SINGLE_DH_USE;
4895 #endif
4896 #ifdef SSL_OP_NO_RENEGOTIATION
4897 result |= SSL_OP_NO_RENEGOTIATION;
4898 #endif
4899
4900 if (!option_spec)
4901   {
4902   *results = result;
4903   return TRUE;
4904   }
4905
4906 if (!expand_check(option_spec, US"openssl_options", &exp, &end))
4907   return FALSE;
4908
4909 for (uschar * s = exp; *s; /**/)
4910   {
4911   while (isspace(*s)) ++s;
4912   if (*s == '\0')
4913     break;
4914   if (*s != '+' && *s != '-')
4915     {
4916     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
4917         "+ or - expected but found \"%s\"\n", s);
4918     return FALSE;
4919     }
4920   adding = *s++ == '+';
4921   for (end = s; *end && !isspace(*end); ) end++;
4922   item_parsed = tls_openssl_one_option_parse(string_copyn(s, end-s), &item);
4923   if (!item_parsed)
4924     {
4925     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
4926     return FALSE;
4927     }
4928   DEBUG(D_tls) debug_printf("openssl option, %s %08lx: %08lx (%s)\n",
4929       adding ? "adding to    " : "removing from", result, item, s);
4930   if (adding)
4931     result |= item;
4932   else
4933     result &= ~item;
4934   s = end;
4935   }
4936
4937 *results = result;
4938 return TRUE;
4939 }
4940
4941 #endif  /*!MACRO_PREDEF*/
4942 /* vi: aw ai sw=2
4943 */
4944 /* End of tls-openssl.c */