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