src/src/tls-openssl.c

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