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