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