src/src/tls-openssl.c

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