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-only */
   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
2534    {
2535     /* If this routine is not available, we've avoided [in tls_client_start()]
2536     asking for certificate-status under DANE, so this callback won't run for
2537     that combination. It still will for non-DANE. */
2538
2539 #ifdef EXIM_HAVE_OPENSSL_OCSP_RESP_GET0_SIGNER
2540     X509 * signer;
2541
2542     if (  tls_out.dane_verified
2543        && (have_verified_OCSP_signer =
2544         OCSP_resp_get0_signer(bs, &signer, SSL_get0_verified_chain(ssl)) == 1))
2545       {
2546       DEBUG(D_tls)
2547         debug_printf("signer for OCSP basicres is in the verified chain;"
2548                       " shortcut its verification\n");
2549       }
2550     else
2551 #endif
2552       {
2553       STACK_OF(X509) * verified_chain;
2554
2555       verify_store = X509_STORE_new();
2556
2557       SSL_get0_chain_certs(ssl, &verified_chain);
2558       add_chain_to_store(verify_store, verified_chain,
2559                               "'current cert' per SSL_get0_chain_certs()");
2560 #ifdef EXIM_HAVE_SSL_GET0_VERIFIED_CHAIN
2561       verified_chain = SSL_get0_verified_chain(ssl);
2562       add_chain_to_store(verify_store, verified_chain,
2563                               "SSL_get0_verified_chain()");
2564 #endif
2565       }
2566    }
2567
2568     DEBUG(D_tls)
2569       {
2570       debug_printf("Untrusted intermediate cert stack (from SSL_get_peer_cert_chain()):\n");
2571       x509_stack_dump_cert_s_names(SSL_get_peer_cert_chain(ssl));
2572
2573       debug_printf("will use this CA store for verifying basicresp:\n");
2574       x509_store_dump_cert_s_names(verify_store);
2575
2576       /* OCSP_RESPONSE_print(bp, rsp, 0);   extreme debug: stapling content */
2577
2578       debug_printf("certs contained in basicresp:\n");
2579       x509_stack_dump_cert_s_names(
2580 #ifdef EXIM_HAVE_OPESSL_OCSP_RESP_GET0_CERTS
2581         OCSP_resp_get0_certs(bs)
2582 #else
2583         bs->certs
2584 #endif
2585         );
2586
2587 #ifdef EXIM_HAVE_OPENSSL_X509_STORE_GET1_ALL_CERTS
2588 /* could do via X509_STORE_get0_objects(); not worth it just for debug info */
2589        {
2590         X509 * signer;
2591         if (OCSP_resp_get0_signer(bs, &signer, X509_STORE_get1_all_certs(verify_store)) == 1)
2592           {
2593           debug_printf("found signer for basicres:\n");
2594           debug_print_sn(signer);
2595           }
2596         else
2597           {
2598           debug_printf("failed to find signer for basicres:\n");
2599           ERR_print_errors(bp);
2600           }
2601        }
2602 #endif
2603
2604       }
2605
2606     ERR_clear_error();
2607
2608     /* Under DANE the trust-anchor (at least in TA mode) is indicated by the TLSA
2609     record in DNS, and probably is not the root of the chain of certificates. So
2610     accept a partial chain for that case (and hope that anchor is visible for
2611     verifying the OCSP stapling).
2612     XXX for EE mode it won't even be that.  Does that make OCSP useless for EE?
2613
2614     Worse, for LetsEncrypt-mode (ocsp signer is leaf-signer) under DANE, the
2615     data used within OpenSSL for the signer has nil pointers for signing
2616     algorithms - and a crash results.  Avoid this by shortcutting verification,
2617     having determined that the OCSP signer is in the (DANE-)validated set.
2618     */
2619
2620 #ifndef OCSP_PARTIAL_CHAIN      /* defined for 3.0.0 onwards */
2621 # define OCSP_PARTIAL_CHAIN 0
2622 #endif
2623
2624     if ((i = OCSP_basic_verify(bs, SSL_get_peer_cert_chain(ssl),
2625                 verify_store,
2626 #ifdef SUPPORT_DANE
2627                 tls_out.dane_verified
2628                 ? have_verified_OCSP_signer
2629                   ? OCSP_NOVERIFY | OCSP_NOEXPLICIT
2630                   : OCSP_PARTIAL_CHAIN | OCSP_NOEXPLICIT
2631                 :
2632 #endif
2633                 OCSP_NOEXPLICIT)) <= 0)
2634       {
2635       DEBUG(D_tls) debug_printf("OCSP_basic_verify() fail: returned %d\n", i);
2636       if (ERR_peek_error())
2637         {
2638         tls_out.ocsp = OCSP_FAILED;
2639         if (LOGGING(tls_cipher))
2640           {
2641           static uschar peerdn[256];
2642           const uschar * errstr;;
2643
2644 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
2645           ERR_peek_error_all(NULL, NULL, NULL, CCSS &errstr, NULL);
2646           if (!errstr)
2647 #endif
2648             errstr = CUS ERR_reason_error_string(ERR_peek_error());
2649
2650           X509_NAME_oneline(X509_get_subject_name(SSL_get_peer_certificate(ssl)),
2651                                                   CS peerdn, sizeof(peerdn));
2652           log_write(0, LOG_MAIN,
2653                 "[%s] %s Received TLS cert (DN: '%.*s') status response, "
2654                 "itself unverifiable: %s",
2655                 deliver_host_address, deliver_host,
2656                 (int)sizeof(peerdn), peerdn, errstr);
2657           }
2658         DEBUG(D_tls)
2659           {
2660           BIO_printf(bp, "OCSP response verify failure\n");
2661           ERR_print_errors(bp);
2662   {
2663   uschar * s = NULL;
2664   int len = (int) BIO_get_mem_data(bp, CSS &s);
2665   if (len > 0) debug_printf("%.*s", len, s);
2666   BIO_reset(bp);
2667   }
2668           OCSP_RESPONSE_print(bp, rsp, 0);
2669           }
2670         goto failed;
2671         }
2672       else
2673         DEBUG(D_tls) debug_printf("no explicit trust for OCSP signing"
2674           " in the root CA certificate; ignoring\n");
2675       }
2676
2677     DEBUG(D_tls) debug_printf("OCSP response well-formed and signed OK\n");
2678
2679     /*XXX So we have a good stapled OCSP status.  How do we know
2680     it is for the cert of interest?  OpenSSL 1.1.0 has a routine
2681     OCSP_resp_find_status() which matches on a cert id, which presumably
2682     we should use. Making an id needs OCSP_cert_id_new(), which takes
2683     issuerName, issuerKey, serialNumber.  Are they all in the cert?
2684
2685     For now, carry on blindly accepting the resp. */
2686
2687     for (int idx =
2688 #ifdef EXIM_HAVE_OCSP_RESP_COUNT
2689             OCSP_resp_count(bs) - 1;
2690 #else
2691             sk_OCSP_SINGLERESP_num(sresp) - 1;
2692 #endif
2693          idx >= 0; idx--)
2694       {
2695       OCSP_SINGLERESP * single = OCSP_resp_get0(bs, idx);
2696       int status, reason;
2697       ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
2698
2699   /*XXX so I can see putting a loop in here to handle a rsp with >1 singleresp
2700   - but what happens with a GnuTLS-style input?
2701
2702   we could do with a debug label for each singleresp
2703   - it has a certID with a serialNumber, but I see no API to get that
2704   */
2705       status = OCSP_single_get0_status(single, &reason, &rev,
2706                   &thisupd, &nextupd);
2707
2708       DEBUG(D_tls)
2709         {
2710         time_print(bp, "This OCSP Update", thisupd);
2711         if (nextupd) time_print(bp, "Next OCSP Update", nextupd);
2712         }
2713       if (!OCSP_check_validity(thisupd, nextupd,
2714             EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
2715         {
2716         tls_out.ocsp = OCSP_FAILED;
2717         DEBUG(D_tls) ERR_print_errors(bp);
2718         cbinfo->u_ocsp.client.verify_errstr =
2719                     US"(SSL_connect) Server certificate status is out-of-date";
2720         log_write(0, LOG_MAIN, "OCSP dates invalid");
2721         goto failed;
2722         }
2723
2724       DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
2725                     OCSP_cert_status_str(status));
2726       switch(status)
2727         {
2728         case V_OCSP_CERTSTATUS_GOOD:
2729           continue;     /* the idx loop */
2730         case V_OCSP_CERTSTATUS_REVOKED:
2731           cbinfo->u_ocsp.client.verify_errstr =
2732                         US"(SSL_connect) Server certificate revoked";
2733           log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
2734               reason != -1 ? "; reason: " : "",
2735               reason != -1 ? OCSP_crl_reason_str(reason) : "");
2736           DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
2737           break;
2738         default:
2739           cbinfo->u_ocsp.client.verify_errstr =
2740                         US"(SSL_connect) Server certificate has unknown status";
2741           log_write(0, LOG_MAIN,
2742               "Server certificate status unknown, in OCSP stapling");
2743           break;
2744         }
2745
2746       goto failed;
2747       }
2748
2749     i = 1;
2750     tls_out.ocsp = OCSP_VFIED;
2751     goto good;
2752
2753   failed:
2754     tls_out.ocsp = OCSP_FAILED;
2755     i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
2756   good:
2757     {
2758     uschar * s = NULL;
2759     int len = (int) BIO_get_mem_data(bp, CSS &s);
2760     if (len > 0) debug_printf("%.*s", len, s);
2761     }
2762     BIO_free(bp);
2763   }
2764
2765 OCSP_RESPONSE_free(rsp);
2766 return i;
2767 }
2768 #endif  /*!DISABLE_OCSP*/
2769
2770
2771 /*************************************************
2772 *            Initialize for TLS                  *
2773 *************************************************/
2774 /* Called from both server and client code, to do preliminary initialization
2775 of the library.  We allocate and return a context structure.
2776
2777 Arguments:
2778   host            connected host, if client; NULL if server
2779   ob              transport options block, if client; NULL if server
2780   ocsp_file       file of stapling info (server); flag for require ocsp (client)
2781   addr            address if client; NULL if server (for some randomness)
2782   caller_state    place to put pointer to allocated state-struct
2783   errstr          error string pointer
2784
2785 Returns:          OK/DEFER/FAIL
2786 */
2787
2788 static int
2789 tls_init(host_item * host, smtp_transport_options_block * ob,
2790 #ifndef DISABLE_OCSP
2791   uschar *ocsp_file,
2792 #endif
2793   address_item *addr, exim_openssl_state_st ** caller_state,
2794   tls_support * tlsp, uschar ** errstr)
2795 {
2796 SSL_CTX * ctx;
2797 exim_openssl_state_st * state;
2798 int rc;
2799
2800 if (host)                       /* client */
2801   {
2802   state = store_malloc(sizeof(exim_openssl_state_st));
2803   memset(state, 0, sizeof(*state));
2804   state->certificate = ob->tls_certificate;
2805   state->privatekey =  ob->tls_privatekey;
2806   state->is_server = FALSE;
2807   state->dhparam = NULL;
2808   state->lib_state = ob->tls_preload;
2809   }
2810 else                            /* server */
2811   {
2812   state = &state_server;
2813   state->certificate = tls_certificate;
2814   state->privatekey =  tls_privatekey;
2815   state->is_server = TRUE;
2816   state->dhparam = tls_dhparam;
2817   state->lib_state = state_server.lib_state;
2818   }
2819
2820 state->tlsp = tlsp;
2821 state->host = host;
2822
2823 if (!state->lib_state.pri_string)
2824   state->server_cipher_list = NULL;
2825
2826 #ifndef DISABLE_EVENT
2827 state->event_action = NULL;
2828 #endif
2829
2830 tls_openssl_init();
2831
2832 /* It turns out that we need to seed the random number generator this early in
2833 order to get the full complement of ciphers to work. It took me roughly a day
2834 of work to discover this by experiment.
2835
2836 On systems that have /dev/urandom, SSL may automatically seed itself from
2837 there. Otherwise, we have to make something up as best we can. Double check
2838 afterwards.
2839
2840 Although we likely called this before, at daemon startup, this is a chance
2841 to mix in further variable info (time, pid) if needed. */
2842
2843 if (!lib_rand_init(addr))
2844   return tls_error(US"RAND_status", host,
2845     US"unable to seed random number generator", errstr);
2846
2847 /* Apply administrator-supplied work-arounds.
2848 Historically we applied just one requested option,
2849 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
2850 moved to an administrator-controlled list of options to specify and
2851 grandfathered in the first one as the default value for "openssl_options".
2852
2853 No OpenSSL version number checks: the options we accept depend upon the
2854 availability of the option value macros from OpenSSL.  */
2855
2856 if (!init_options)
2857   if (!tls_openssl_options_parse(openssl_options, &init_options))
2858     return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
2859
2860 /* Create a context.
2861 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
2862 negotiation in the different methods; as far as I can tell, the only
2863 *_{server,client}_method which allows negotiation is SSLv23, which exists even
2864 when OpenSSL is built without SSLv2 support.
2865 By disabling with openssl_options, we can let admins re-enable with the
2866 existing knob. */
2867
2868 if (!(ctx = state->lib_state.lib_ctx))
2869   {
2870   if ((rc = lib_ctx_new(&ctx, host, errstr)) != OK)
2871     return rc;
2872   state->lib_state.lib_ctx = ctx;
2873   }
2874
2875 #ifndef DISABLE_TLS_RESUME
2876 tlsp->resumption = RESUME_SUPPORTED;
2877 #endif
2878 if (init_options)
2879   {
2880 #ifndef DISABLE_TLS_RESUME
2881   /* Should the server offer session resumption? */
2882   if (!host && verify_check_host(&tls_resumption_hosts) == OK)
2883     {
2884     DEBUG(D_tls) debug_printf("tls_resumption_hosts overrides openssl_options\n");
2885     init_options &= ~SSL_OP_NO_TICKET;
2886     tlsp->resumption |= RESUME_SERVER_TICKET; /* server will give ticket on request */
2887     tlsp->host_resumable = TRUE;
2888     }
2889 #endif
2890
2891 #ifdef OPENSSL_MIN_PROTO_VERSION
2892   SSL_CTX_set_min_proto_version(ctx, SSL3_VERSION);
2893 #endif
2894   DEBUG(D_tls) debug_printf("setting  SSL CTX options: %016lx\n", init_options);
2895   SSL_CTX_set_options(ctx, init_options);
2896    {
2897     uint64_t readback = SSL_CTX_clear_options(ctx, ~init_options);
2898     if (readback != init_options)
2899       return tls_error(string_sprintf(
2900           "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
2901    }
2902   }
2903 else
2904   DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
2905
2906 /* We'd like to disable session cache unconditionally, but foolish Outlook
2907 Express clients then give up the first TLS connection and make a second one
2908 (which works).  Only when there is an IMAP service on the same machine.
2909 Presumably OE is trying to use the cache for A on B.  Leave it enabled for
2910 now, until we work out a decent way of presenting control to the config.  It
2911 will never be used because we use a new context every time. */
2912 #ifdef notdef
2913 (void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
2914 #endif
2915
2916 /* Initialize with DH parameters if supplied */
2917 /* Initialize ECDH temp key parameter selection */
2918
2919 if (!host)
2920   {
2921   if (state->lib_state.dh)
2922     { DEBUG(D_tls) debug_printf("TLS: DH params were preloaded\n"); }
2923   else
2924     if (!init_dh(ctx, state->dhparam, errstr)) return DEFER;
2925
2926   if (state->lib_state.ecdh)
2927     { DEBUG(D_tls) debug_printf("TLS: ECDH curve was preloaded\n"); }
2928   else
2929     if (!init_ecdh(ctx, errstr)) return DEFER;
2930   }
2931
2932 /* Set up certificate and key (and perhaps OCSP info) */
2933
2934 if (state->lib_state.conn_certs)
2935   {
2936   DEBUG(D_tls)
2937     debug_printf("TLS: %s certs were preloaded\n", host ? "client":"server");
2938   }
2939 else
2940   {
2941 #ifndef DISABLE_OCSP
2942   if (!host)                                    /* server */
2943     {
2944     state->u_ocsp.server.file = ocsp_file;
2945     state->u_ocsp.server.file_expanded = NULL;
2946     state->u_ocsp.server.olist = NULL;
2947     }
2948 #endif
2949   if ((rc = tls_expand_session_files(ctx, state, errstr)) != OK) return rc;
2950   }
2951
2952 /* If we need to handle SNI or OCSP, do so */
2953
2954 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2955 # ifndef DISABLE_OCSP
2956   if (!host && !(state->u_ocsp.server.verify_stack = sk_X509_new_null()))
2957     {
2958     DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
2959     return FAIL;
2960     }
2961 # endif
2962
2963 if (!host)              /* server */
2964   {
2965 # ifndef DISABLE_OCSP
2966   /* We check u_ocsp.server.file, not server.olist, because we care about if
2967   the option exists, not what the current expansion might be, as SNI might
2968   change the certificate and OCSP file in use between now and the time the
2969   callback is invoked. */
2970   if (state->u_ocsp.server.file)
2971     {
2972     SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
2973     SSL_CTX_set_tlsext_status_arg(ctx, state);
2974     }
2975 # endif
2976   /* We always do this, so that $tls_sni is available even if not used in
2977   tls_certificate */
2978   SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
2979   SSL_CTX_set_tlsext_servername_arg(ctx, state);
2980
2981 # ifdef EXIM_HAVE_ALPN
2982   if (tls_alpn && *tls_alpn)
2983     {
2984     uschar * exp_alpn;
2985     if (  expand_check(tls_alpn, US"tls_alpn", &exp_alpn, errstr)
2986        && *exp_alpn && !isblank(*exp_alpn))
2987       {
2988       tls_alpn = exp_alpn;      /* subprocess so ok to overwrite */
2989       SSL_CTX_set_alpn_select_cb(ctx, tls_server_alpn_cb, state);
2990       }
2991     else
2992       tls_alpn = NULL;
2993     }
2994 # endif
2995   }
2996 # ifndef DISABLE_OCSP
2997 else                    /* client */
2998   if(ocsp_file)         /* wanting stapling */
2999     {
3000     if (!(state->u_ocsp.client.verify_store = X509_STORE_new()))
3001       {
3002       DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
3003       return FAIL;
3004       }
3005
3006     SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
3007     SSL_CTX_set_tlsext_status_arg(ctx, state);
3008     }
3009 # endif
3010 #endif  /*EXIM_HAVE_OPENSSL_TLSEXT*/
3011
3012 state->verify_cert_hostnames = NULL;
3013
3014 #ifdef EXIM_HAVE_EPHEM_RSA_KEX
3015 /* Set up the RSA callback */
3016 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
3017 #endif
3018
3019 /* Finally, set the session cache timeout, and we are done.
3020 The period appears to be also used for (server-generated) session tickets */
3021
3022 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
3023 DEBUG(D_tls) debug_printf("Initialized TLS\n");
3024
3025 *caller_state = state;
3026
3027 return OK;
3028 }
3029
3030
3031
3032
3033 /*************************************************
3034 *           Get name of cipher in use            *
3035 *************************************************/
3036
3037 /*
3038 Argument:   pointer to an SSL structure for the connection
3039             pointer to number of bits for cipher
3040 Returns:    pointer to allocated string in perm-pool
3041 */
3042
3043 static uschar *
3044 construct_cipher_name(SSL * ssl, const uschar * ver, int * bits)
3045 {
3046 int pool = store_pool;
3047 /* With OpenSSL 1.0.0a, 'c' needs to be const but the documentation doesn't
3048 yet reflect that.  It should be a safe change anyway, even 0.9.8 versions have
3049 the accessor functions use const in the prototype. */
3050
3051 const SSL_CIPHER * c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
3052 uschar * s;
3053
3054 SSL_CIPHER_get_bits(c, bits);
3055
3056 store_pool = POOL_PERM;
3057 s = string_sprintf("%s:%s:%u", ver, SSL_CIPHER_get_name(c), *bits);
3058 store_pool = pool;
3059 DEBUG(D_tls) debug_printf("Cipher: %s\n", s);
3060 return s;
3061 }
3062
3063
3064 /* Get IETF-standard name for ciphersuite.
3065 Argument:   pointer to an SSL structure for the connection
3066 Returns:    pointer to string
3067 */
3068
3069 static const uschar *
3070 cipher_stdname_ssl(SSL * ssl)
3071 {
3072 #ifdef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
3073 return CUS SSL_CIPHER_standard_name(SSL_get_current_cipher(ssl));
3074 #else
3075 ushort id = 0xffff & SSL_CIPHER_get_id(SSL_get_current_cipher(ssl));
3076 return cipher_stdname(id >> 8, id & 0xff);
3077 #endif
3078 }
3079
3080
3081 static const uschar *
3082 tlsver_name(SSL * ssl)
3083 {
3084 uschar * s, * p;
3085 int pool = store_pool;
3086
3087 store_pool = POOL_PERM;
3088 s = string_copy(US SSL_get_version(ssl));
3089 store_pool = pool;
3090 if ((p = Ustrchr(s, 'v')))      /* TLSv1.2 -> TLS1.2 */
3091   for (;; p++) if (!(*p = p[1])) break;
3092 return CUS s;
3093 }
3094
3095
3096 static void
3097 peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned siz)
3098 {
3099 /*XXX we might consider a list-of-certs variable for the cert chain.
3100 SSL_get_peer_cert_chain(SSL*).  We'd need a new variable type and support
3101 in list-handling functions, also consider the difference between the entire
3102 chain and the elements sent by the peer. */
3103
3104 tlsp->peerdn = NULL;
3105
3106 /* Will have already noted peercert on a verify fail; possibly not the leaf */
3107 if (!tlsp->peercert)
3108   tlsp->peercert = SSL_get_peer_certificate(ssl);
3109 /* Beware anonymous ciphers which lead to server_cert being NULL */
3110 if (tlsp->peercert)
3111   if (!X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, siz))
3112     { DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n"); }
3113   else
3114     {
3115     int oldpool = store_pool;
3116
3117     peerdn[siz-1] = '\0';               /* paranoia */
3118     store_pool = POOL_PERM;
3119     tlsp->peerdn = string_copy(peerdn);
3120     store_pool = oldpool;
3121
3122     /* We used to set CV in the cert-verify callbacks (either plain or dane)
3123     but they don't get called on session-resumption.  So use the official
3124     interface, which uses the resumed value.  Unfortunately this claims verified
3125     when it actually failed but we're in try-verify mode, due to us wanting the
3126     knowlege that it failed so needing to have the callback and forcing a
3127     permissive return.  If we don't force it, the TLS startup is failed.
3128     The extra bit of information is set in verify_override in the cb, stashed
3129     for resumption next to the TLS session, and used here. */
3130
3131     if (!tlsp->verify_override)
3132       tlsp->certificate_verified =
3133 #ifdef SUPPORT_DANE
3134         tlsp->dane_verified ||
3135 #endif
3136         SSL_get_verify_result(ssl) == X509_V_OK;
3137     }
3138 }
3139
3140
3141
3142
3143
3144 /*************************************************
3145 *        Set up for verifying certificates       *
3146 *************************************************/
3147
3148 #ifndef DISABLE_OCSP
3149 /* In the server, load certs from file, return TRUE on success */
3150
3151 static BOOL
3152 chain_from_pem_file(const uschar * file, STACK_OF(X509) ** vp)
3153 {
3154 BIO * bp;
3155 STACK_OF(X509) * verify_stack = *vp;
3156
3157 if (verify_stack)
3158   while (sk_X509_num(verify_stack) > 0)
3159     X509_free(sk_X509_pop(verify_stack));
3160 else
3161   verify_stack = sk_X509_new_null();
3162
3163 if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
3164 for (X509 * x; x = PEM_read_bio_X509(bp, NULL, 0, NULL); )
3165   sk_X509_push(verify_stack, x);
3166 BIO_free(bp);
3167 *vp = verify_stack;
3168 return TRUE;
3169 }
3170 #endif
3171
3172
3173
3174 /* Called by both client and server startup; on the server possibly
3175 repeated after a Server Name Indication.
3176
3177 Arguments:
3178   sctx          SSL_CTX* to initialise
3179   certsp        certs file, returned expanded
3180   crl           CRL file or NULL
3181   host          NULL in a server; the remote host in a client
3182   errstr        error string pointer
3183
3184 Returns:        OK/DEFER/FAIL
3185 */
3186
3187 static int
3188 setup_certs(SSL_CTX * sctx, uschar ** certsp, uschar * crl, host_item * host,
3189     uschar ** errstr)
3190 {
3191 uschar * expcerts, * expcrl;
3192
3193 if (!expand_check(*certsp, US"tls_verify_certificates", &expcerts, errstr))
3194   return DEFER;
3195 DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
3196
3197 *certsp = expcerts;
3198 if (expcerts && *expcerts)
3199   {
3200   /* Tell the library to use its compiled-in location for the system default
3201   CA bundle. Then add the ones specified in the config, if any. */
3202
3203   if (!SSL_CTX_set_default_verify_paths(sctx))
3204     return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
3205
3206   if (Ustrcmp(expcerts, "system") != 0 && Ustrncmp(expcerts, "system,", 7) != 0)
3207     {
3208     struct stat statbuf;
3209
3210     if (Ustat(expcerts, &statbuf) < 0)
3211       {
3212       log_write(0, LOG_MAIN|LOG_PANIC,
3213         "failed to stat %s for certificates", expcerts);
3214       return DEFER;
3215       }
3216     else
3217       {
3218       uschar *file, *dir;
3219       if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
3220         { file = NULL; dir = expcerts; }
3221       else
3222         {
3223         STACK_OF(X509) * verify_stack =
3224 #ifndef DISABLE_OCSP
3225           !host ? state_server.u_ocsp.server.verify_stack :
3226 #endif
3227           NULL;
3228         STACK_OF(X509) ** vp = &verify_stack;
3229
3230         file = expcerts; dir = NULL;
3231 #ifndef DISABLE_OCSP
3232         /* In the server if we will be offering an OCSP proof; load chain from
3233         file for verifying the OCSP proof at load time. */
3234
3235 /*XXX Glitch!   The file here is tls_verify_certs: the chain for verifying the client cert.
3236 This is inconsistent with the need to verify the OCSP proof of the server cert.
3237 */
3238 /* *debug_printf("file for checking server ocsp stapling is: %s\n", file); */
3239         if (  !host
3240            && statbuf.st_size > 0
3241            && state_server.u_ocsp.server.file
3242            && !chain_from_pem_file(file, vp)
3243            )
3244           {
3245           log_write(0, LOG_MAIN|LOG_PANIC,
3246             "failed to load cert chain from %s", file);
3247           return DEFER;
3248           }
3249 #endif
3250         }
3251
3252       /* If a certificate file is empty, the load function fails with an
3253       unhelpful error message. If we skip it, we get the correct behaviour (no
3254       certificates are recognized, but the error message is still misleading (it
3255       says no certificate was supplied).  But this is better. */
3256
3257       if (  (!file || statbuf.st_size > 0)
3258          && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
3259           return tls_error(US"SSL_CTX_load_verify_locations",
3260                             host, NULL, errstr);
3261
3262       /* On the server load the list of CAs for which we will accept certs, for
3263       sending to the client.  This is only for the one-file
3264       tls_verify_certificates variant.
3265       If a list isn't loaded into the server, but some verify locations are set,
3266       the server end appears to make a wildcard request for client certs.
3267       Meanwhile, the client library as default behaviour *ignores* the list
3268       we send over the wire - see man SSL_CTX_set_client_cert_cb.
3269       Because of this, and that the dir variant is likely only used for
3270       the public-CA bundle (not for a private CA), not worth fixing.  */
3271
3272       if (file)
3273         {
3274         STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
3275         int i = sk_X509_NAME_num(names);
3276
3277         if (!host) SSL_CTX_set_client_CA_list(sctx, names);
3278         DEBUG(D_tls) debug_printf("Added %d additional certificate authorit%s\n",
3279                                     i, i>1 ? "ies":"y");
3280         }
3281       else
3282         DEBUG(D_tls)
3283           debug_printf("Added dir for additional certificate authorities\n");
3284       }
3285     }
3286
3287   /* Handle a certificate revocation list. */
3288
3289 #if OPENSSL_VERSION_NUMBER > 0x00907000L
3290
3291   /* This bit of code is now the version supplied by Lars Mainka. (I have
3292   merely reformatted it into the Exim code style.)
3293
3294   "From here I changed the code to add support for multiple crl's
3295   in pem format in one file or to support hashed directory entries in
3296   pem format instead of a file. This method now uses the library function
3297   X509_STORE_load_locations to add the CRL location to the SSL context.
3298   OpenSSL will then handle the verify against CA certs and CRLs by
3299   itself in the verify callback." */
3300
3301   if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
3302   if (expcrl && *expcrl)
3303     {
3304     struct stat statbufcrl;
3305     if (Ustat(expcrl, &statbufcrl) < 0)
3306       {
3307       log_write(0, LOG_MAIN|LOG_PANIC,
3308         "failed to stat %s for certificates revocation lists", expcrl);
3309       return DEFER;
3310       }
3311     else
3312       {
3313       /* is it a file or directory? */
3314       uschar *file, *dir;
3315       X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
3316       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
3317         {
3318         file = NULL;
3319         dir = expcrl;
3320         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
3321         }
3322       else
3323         {
3324         file = expcrl;
3325         dir = NULL;
3326         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
3327         }
3328       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
3329         return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
3330
3331       /* setting the flags to check against the complete crl chain */
3332
3333       X509_STORE_set_flags(cvstore,
3334         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
3335       }
3336     }
3337
3338 #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
3339   }
3340
3341 return OK;
3342 }
3343
3344
3345
3346 static void
3347 tls_dump_keylog(SSL * ssl)
3348 {
3349 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3350   BIO * bp = BIO_new(BIO_s_mem());
3351   uschar * s = NULL;
3352   int len;
3353   SSL_SESSION_print_keylog(bp, SSL_get_session(ssl));
3354   len = (int) BIO_get_mem_data(bp, CSS &s);
3355   if (len > 0) debug_printf("%.*s", len, s);
3356   BIO_free(bp);
3357 #endif
3358 }
3359
3360
3361 /* Channel-binding info for authenticators
3362 See description in https://paquier.xyz/postgresql-2/channel-binding-openssl/
3363 for pre-TLS1.3
3364 */
3365
3366 static void
3367 tls_get_channel_binding(SSL * ssl, tls_support * tlsp, const void * taintval)
3368 {
3369 uschar c, * s;
3370 size_t len;
3371
3372 #ifdef EXIM_HAVE_EXPORT_CHNL_BNGNG
3373 if (SSL_version(ssl) > TLS1_2_VERSION)
3374   {
3375   /* It's not documented by OpenSSL how big the output buffer must be.
3376   The OpenSSL testcases use 80 bytes but don't say why. The GnuTLS impl only
3377   serves out 32B.  RFC 9266 says it is 32B.
3378   Interop fails unless we use the same each end. */
3379   len = 32;
3380
3381   tlsp->channelbind_exporter = TRUE;
3382   taintval = GET_UNTAINTED;
3383   if (SSL_export_keying_material(ssl,
3384         s = store_get((int)len, taintval), len,
3385         "EXPORTER-Channel-Binding", (size_t) 24,
3386         NULL, 0, 0) != 1)
3387     len = 0;
3388   }
3389 else
3390 #endif
3391   {
3392   len = SSL_get_peer_finished(ssl, &c, 0);
3393   len = SSL_get_peer_finished(ssl, s = store_get((int)len, taintval), len);
3394   }
3395
3396 if (len > 0)
3397   {
3398   int old_pool = store_pool;
3399   store_pool = POOL_PERM;
3400     tlsp->channelbinding = b64encode_taint(CUS s, (int)len, taintval);
3401   store_pool = old_pool;
3402   DEBUG(D_tls) debug_printf("Have channel bindings cached for possible auth usage %p %p\n", tlsp->channelbinding, tlsp);
3403   }
3404 }
3405
3406
3407 /*************************************************
3408 *       Start a TLS session in a server          *
3409 *************************************************/
3410 /* This is called when Exim is running as a server, after having received
3411 the STARTTLS command. It must respond to that command, and then negotiate
3412 a TLS session.
3413
3414 Arguments:
3415   errstr            pointer to error message
3416
3417 Returns:            OK on success
3418                     DEFER for errors before the start of the negotiation
3419                     FAIL for errors during the negotiation; the server can't
3420                       continue running.
3421 */
3422
3423 int
3424 tls_server_start(uschar ** errstr)
3425 {
3426 int rc;
3427 uschar * expciphers;
3428 exim_openssl_state_st * dummy_statep;
3429 SSL_CTX * ctx;
3430 SSL * ssl;
3431 static uschar peerdn[256];
3432
3433 /* Check for previous activation */
3434
3435 if (tls_in.active.sock >= 0)
3436   {
3437   tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
3438   smtp_printf("554 Already in TLS\r\n", FALSE);
3439   return FAIL;
3440   }
3441
3442 /* Initialize the SSL library. If it fails, it will already have logged
3443 the error. */
3444
3445 rc = tls_init(NULL, NULL,
3446 #ifndef DISABLE_OCSP
3447     tls_ocsp_file,
3448 #endif
3449     NULL, &dummy_statep, &tls_in, errstr);
3450 if (rc != OK) return rc;
3451 ctx = state_server.lib_state.lib_ctx;
3452
3453 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
3454 were historically separated by underscores. So that I can use either form in my
3455 tests, and also for general convenience, we turn underscores into hyphens here.
3456
3457 XXX SSL_CTX_set_cipher_list() is replaced by SSL_CTX_set_ciphersuites()
3458 for TLS 1.3 .  Since we do not call it at present we get the default list:
3459 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
3460 */
3461
3462 if (state_server.lib_state.pri_string)
3463   { DEBUG(D_tls) debug_printf("TLS: cipher list was preloaded\n"); }
3464 else
3465   {
3466   if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
3467     return FAIL;
3468
3469   if (expciphers)
3470     {
3471     normalise_ciphers(&expciphers, tls_require_ciphers);
3472     if ((rc = server_load_ciphers(ctx, &state_server, expciphers, errstr)) != OK)
3473       return rc;
3474     }
3475   }
3476
3477 /* If this is a host for which certificate verification is mandatory or
3478 optional, set up appropriately. */
3479
3480 tls_in.certificate_verified = FALSE;
3481 #ifdef SUPPORT_DANE
3482 tls_in.dane_verified = FALSE;
3483 #endif
3484 server_verify_callback_called = FALSE;
3485
3486 if (verify_check_host(&tls_verify_hosts) == OK)
3487   server_verify_optional = FALSE;
3488 else if (verify_check_host(&tls_try_verify_hosts) == OK)
3489   server_verify_optional = TRUE;
3490 else
3491   goto skip_certs;
3492
3493  {
3494   uschar * v_certs = tls_verify_certificates;
3495
3496   if (state_server.lib_state.cabundle)
3497     {
3498     DEBUG(D_tls) debug_printf("TLS: CA bundle for server was preloaded\n");
3499     setup_cert_verify(ctx, server_verify_optional, verify_callback_server);
3500     }
3501   else
3502     {
3503     if ((rc = setup_certs(ctx, &v_certs, tls_crl, NULL, errstr)) != OK)
3504       return rc;
3505     if (v_certs && *v_certs)
3506       setup_cert_verify(ctx, server_verify_optional, verify_callback_server);
3507     }
3508  }
3509 skip_certs: ;
3510
3511 #ifndef DISABLE_TLS_RESUME
3512 # if OPENSSL_VERSION_NUMBER < 0x30000000L
3513 SSL_CTX_set_tlsext_ticket_key_cb(ctx, ticket_key_callback);
3514 /* despite working, appears to always return failure, so ignoring */
3515 # else
3516 SSL_CTX_set_tlsext_ticket_key_evp_cb(ctx, ticket_key_callback);
3517 /* despite working, appears to always return failure, so ignoring */
3518 # endif
3519 #endif
3520
3521 #ifdef OPENSSL_HAVE_NUM_TICKETS
3522 # ifndef DISABLE_TLS_RESUME
3523 SSL_CTX_set_num_tickets(ctx, tls_in.host_resumable ? 1 : 0);
3524 # else
3525 SSL_CTX_set_num_tickets(ctx, 0);        /* send no TLS1.3 stateful-tickets */
3526 # endif
3527 #endif
3528
3529
3530 /* Prepare for new connection */
3531
3532 if (!(ssl = SSL_new(ctx)))
3533   return tls_error(US"SSL_new", NULL, NULL, errstr);
3534 state_server.lib_state.lib_ssl = ssl;
3535
3536 /* Warning: we used to SSL_clear(ssl) here, it was removed.
3537  *
3538  * With the SSL_clear(), we get strange interoperability bugs with
3539  * OpenSSL 1.0.1b and TLS1.1/1.2.  It looks as though this may be a bug in
3540  * OpenSSL itself, as a clear should not lead to inability to follow protocols.
3541  *
3542  * The SSL_clear() call is to let an existing SSL* be reused, typically after
3543  * session shutdown.  In this case, we have a brand new object and there's no
3544  * obvious reason to immediately clear it.  I'm guessing that this was
3545  * originally added because of incomplete initialisation which the clear fixed,
3546  * in some historic release.
3547  */
3548
3549 /* Set context and tell client to go ahead, except in the case of TLS startup
3550 on connection, where outputting anything now upsets the clients and tends to
3551 make them disconnect. We need to have an explicit fflush() here, to force out
3552 the response. Other smtp_printf() calls do not need it, because in non-TLS
3553 mode, the fflush() happens when smtp_getc() is called. */
3554
3555 SSL_set_session_id_context(ssl, sid_ctx, Ustrlen(sid_ctx));
3556 if (!tls_in.on_connect)
3557   {
3558   smtp_printf("220 TLS go ahead\r\n", FALSE);
3559   fflush(smtp_out);
3560   }
3561
3562 /* Now negotiate the TLS session. We put our own timer on it, since it seems
3563 that the OpenSSL library doesn't. */
3564
3565 SSL_set_wfd(ssl, fileno(smtp_out));
3566 SSL_set_rfd(ssl, fileno(smtp_in));
3567 SSL_set_accept_state(ssl);
3568
3569 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
3570
3571 ERR_clear_error();
3572 sigalrm_seen = FALSE;
3573 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3574 rc = SSL_accept(ssl);
3575 ALARM_CLR(0);
3576
3577 if (rc <= 0)
3578   {
3579   int error = SSL_get_error(ssl, rc);
3580   switch(error)
3581     {
3582     case SSL_ERROR_NONE:
3583       break;
3584
3585     case SSL_ERROR_ZERO_RETURN:
3586       DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3587       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
3588 #ifndef DISABLE_EVENT
3589       (void) event_raise(event_action, US"tls:fail:connect", *errstr, NULL);
3590 #endif
3591       if (SSL_get_shutdown(ssl) == SSL_RECEIVED_SHUTDOWN)
3592         SSL_shutdown(ssl);
3593
3594       tls_close(NULL, TLS_NO_SHUTDOWN);
3595       return FAIL;
3596
3597     /* Handle genuine errors */
3598     case SSL_ERROR_SSL:
3599       {
3600       uschar * s = NULL;
3601       int r = ERR_GET_REASON(ERR_peek_error());
3602       if (  r == SSL_R_WRONG_VERSION_NUMBER
3603 #ifdef SSL_R_VERSION_TOO_LOW
3604          || r == SSL_R_VERSION_TOO_LOW
3605 #endif
3606          || r == SSL_R_UNKNOWN_PROTOCOL || r == SSL_R_UNSUPPORTED_PROTOCOL)
3607         s = string_sprintf("(%s)", SSL_get_version(ssl));
3608       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : s, errstr);
3609 #ifndef DISABLE_EVENT
3610       (void) event_raise(event_action, US"tls:fail:connect", *errstr, NULL);
3611 #endif
3612       return FAIL;
3613       }
3614
3615     default:
3616       DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
3617       if (error == SSL_ERROR_SYSCALL)
3618         {
3619         if (!errno)
3620           {
3621           *errstr = US"SSL_accept: TCP connection closed by peer";
3622 #ifndef DISABLE_EVENT
3623           (void) event_raise(event_action, US"tls:fail:connect", *errstr, NULL);
3624 #endif
3625           return FAIL;
3626           }
3627         DEBUG(D_tls) debug_printf(" - syscall %s\n", strerror(errno));
3628         }
3629       (void) tls_error(US"SSL_accept", NULL,
3630                       sigalrm_seen ? US"timed out"
3631                       : ERR_peek_error() ? NULL : string_sprintf("ret %d", error),
3632                       errstr);
3633 #ifndef DISABLE_EVENT
3634       (void) event_raise(event_action, US"tls:fail:connect", *errstr, NULL);
3635 #endif
3636       return FAIL;
3637     }
3638   }
3639
3640 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
3641 ERR_clear_error();      /* Even success can leave errors in the stack. Seen with
3642                         anon-authentication ciphersuite negotiated. */
3643
3644 #ifndef DISABLE_TLS_RESUME
3645 if (SSL_session_reused(ssl))
3646   {
3647   tls_in.resumption |= RESUME_USED;
3648   DEBUG(D_tls) debug_printf("Session reused\n");
3649   }
3650 #endif
3651
3652 #ifdef EXIM_HAVE_ALPN
3653 /* If require-alpn, check server_seen_alpn here.  Else abort TLS */
3654 if (!tls_alpn || !*tls_alpn)
3655   { DEBUG(D_tls) debug_printf("TLS: was not watching for ALPN\n"); }
3656 else if (!server_seen_alpn)
3657   if (verify_check_host(&hosts_require_alpn) == OK)
3658     {
3659     /* We'd like to send a definitive Alert but OpenSSL provides no facility */
3660     SSL_shutdown(ssl);
3661     tls_error(US"handshake", NULL, US"ALPN required but not negotiated", errstr);
3662     return FAIL;
3663     }
3664   else
3665     { DEBUG(D_tls) debug_printf("TLS: no ALPN presented in handshake\n"); }
3666 else DEBUG(D_tls)
3667   {
3668   const uschar * name;
3669   unsigned len;
3670   SSL_get0_alpn_selected(ssl, &name, &len);
3671   if (len && name)
3672     debug_printf("ALPN negotiated: '%.*s'\n", (int)*name, name+1);
3673   else
3674     debug_printf("ALPN: no protocol negotiated\n");
3675   }
3676 #endif
3677
3678
3679 /* TLS has been set up. Record data for the connection,
3680 adjust the input functions to read via TLS, and initialize things. */
3681
3682 #ifdef SSL_get_extms_support
3683 /*XXX what does this return for tls1.3 ? */
3684 tls_in.ext_master_secret = SSL_get_extms_support(ssl) == 1;
3685 #endif
3686 peer_cert(ssl, &tls_in, peerdn, sizeof(peerdn));
3687
3688 tls_in.ver = tlsver_name(ssl);
3689 tls_in.cipher = construct_cipher_name(ssl, tls_in.ver, &tls_in.bits);
3690 tls_in.cipher_stdname = cipher_stdname_ssl(ssl);
3691
3692 DEBUG(D_tls)
3693   {
3694   uschar buf[2048];
3695   if (SSL_get_shared_ciphers(ssl, CS buf, sizeof(buf)))
3696     debug_printf("Shared ciphers: %s\n", buf);
3697
3698   tls_dump_keylog(ssl);
3699
3700 #ifdef EXIM_HAVE_SESSION_TICKET
3701   {
3702   SSL_SESSION * ss = SSL_get_session(ssl);
3703   if (SSL_SESSION_has_ticket(ss))       /* 1.1.0 */
3704     debug_printf("The session has a ticket, life %lu seconds\n",
3705       SSL_SESSION_get_ticket_lifetime_hint(ss));
3706   }
3707 #endif
3708   }
3709
3710 /* Record the certificate we presented */
3711   {
3712   X509 * crt = SSL_get_certificate(ssl);
3713   tls_in.ourcert = crt ? X509_dup(crt) : NULL;
3714   }
3715
3716 tls_get_channel_binding(ssl, &tls_in, GET_UNTAINTED);
3717
3718 /* Only used by the server-side tls (tls_in), including tls_getc.
3719    Client-side (tls_out) reads (seem to?) go via
3720    smtp_read_response()/ip_recv().
3721    Hence no need to duplicate for _in and _out.
3722  */
3723 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
3724 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
3725 ssl_xfer_eof = ssl_xfer_error = FALSE;
3726
3727 receive_getc = tls_getc;
3728 receive_getbuf = tls_getbuf;
3729 receive_get_cache = tls_get_cache;
3730 receive_hasc = tls_hasc;
3731 receive_ungetc = tls_ungetc;
3732 receive_feof = tls_feof;
3733 receive_ferror = tls_ferror;
3734
3735 tls_in.active.sock = fileno(smtp_out);
3736 tls_in.active.tls_ctx = NULL;   /* not using explicit ctx for server-side */
3737 return OK;
3738 }
3739
3740
3741
3742
3743 static int
3744 tls_client_basic_ctx_init(SSL_CTX * ctx,
3745     host_item * host, smtp_transport_options_block * ob, exim_openssl_state_st * state,
3746     uschar ** errstr)
3747 {
3748 int rc;
3749
3750 /* Back-compatible old behaviour if tls_verify_certificates is set but both
3751 tls_verify_hosts and tls_try_verify_hosts are not set. Check only the specified
3752 host patterns if one of them is set with content. */
3753
3754 if (  (  (  !ob->tls_verify_hosts || !ob->tls_verify_hosts
3755          || Ustrcmp(ob->tls_try_verify_hosts, ":") == 0
3756          )
3757       && (  !ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts
3758          || Ustrcmp(ob->tls_try_verify_hosts, ":") == 0
3759          )
3760       )
3761    || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
3762    )
3763   client_verify_optional = FALSE;
3764 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
3765   client_verify_optional = TRUE;
3766 else
3767   return OK;
3768
3769  {
3770   uschar * v_certs = ob->tls_verify_certificates;
3771
3772   if (state->lib_state.cabundle)
3773     {
3774     DEBUG(D_tls) debug_printf("TLS: CA bundle for tpt was preloaded\n");
3775     setup_cert_verify(ctx, client_verify_optional, verify_callback_client);
3776     }
3777   else
3778     {
3779     if ((rc = setup_certs(ctx, &v_certs, ob->tls_crl, host, errstr)) != OK)
3780       return rc;
3781     if (v_certs && *v_certs)
3782       setup_cert_verify(ctx, client_verify_optional, verify_callback_client);
3783     }
3784  }
3785
3786 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
3787   {
3788   state->verify_cert_hostnames =
3789 #ifdef SUPPORT_I18N
3790     string_domain_utf8_to_alabel(host->certname, NULL);
3791 #else
3792     host->certname;
3793 #endif
3794   DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
3795                     state->verify_cert_hostnames);
3796   }
3797 return OK;
3798 }
3799
3800
3801 #ifdef SUPPORT_DANE
3802 static int
3803 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
3804 {
3805 dns_scan dnss;
3806 const char * hostnames[2] = { CS host->name, NULL };
3807 int found = 0;
3808
3809 if (DANESSL_init(ssl, NULL, hostnames) != 1)
3810   return tls_error(US"hostnames load", host, NULL, errstr);
3811
3812 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
3813      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
3814     ) if (rr->type == T_TLSA && rr->size > 3)
3815   {
3816   const uschar * p = rr->data;
3817   uint8_t usage, selector, mtype;
3818   const char * mdname;
3819
3820   usage = *p++;
3821
3822   /* Only DANE-TA(2) and DANE-EE(3) are supported */
3823   if (usage != 2 && usage != 3) continue;
3824
3825   selector = *p++;
3826   mtype = *p++;
3827
3828   switch (mtype)
3829     {
3830     default: continue;  /* Only match-types 0, 1, 2 are supported */
3831     case 0:  mdname = NULL; break;
3832     case 1:  mdname = "sha256"; break;
3833     case 2:  mdname = "sha512"; break;
3834     }
3835
3836   found++;
3837   switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
3838     {
3839     default:
3840       return tls_error(US"tlsa load", host, NULL, errstr);
3841     case 0:     /* action not taken */
3842     case 1:     break;
3843     }
3844
3845   tls_out.tlsa_usage |= 1<<usage;
3846   }
3847
3848 if (found)
3849   return OK;
3850
3851 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
3852 return DEFER;
3853 }
3854 #endif  /*SUPPORT_DANE*/
3855
3856
3857
3858 #ifndef DISABLE_TLS_RESUME
3859 /* On the client, get any stashed session for the given IP from hints db
3860 and apply it to the ssl-connection for attempted resumption. */
3861
3862 static void
3863 tls_retrieve_session(tls_support * tlsp, SSL * ssl)
3864 {
3865 if (tlsp->host_resumable)
3866   {
3867   dbdata_tls_session * dt;
3868   int len;
3869   open_db dbblock, * dbm_file;
3870
3871   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
3872   DEBUG(D_tls)
3873     debug_printf("checking for resumable session for %s\n", tlsp->resume_index);
3874   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3875     {
3876     if ((dt = dbfn_read_with_length(dbm_file, tlsp->resume_index, &len)))
3877       {
3878       SSL_SESSION * ss = NULL;
3879       const uschar * sess_asn1 = dt->session;
3880
3881       len -= sizeof(dbdata_tls_session);
3882       if (!(d2i_SSL_SESSION(&ss, &sess_asn1, (long)len)))
3883         {
3884         DEBUG(D_tls)
3885           {
3886           ERR_error_string_n(ERR_get_error(),
3887             ssl_errstring, sizeof(ssl_errstring));
3888           debug_printf("decoding session: %s\n", ssl_errstring);
3889           }
3890         }
3891       else
3892         {
3893         unsigned long lifetime =
3894 #ifdef EXIM_HAVE_SESSION_TICKET
3895           SSL_SESSION_get_ticket_lifetime_hint(ss);
3896 #else                   /* Use, fairly arbitrilarily, what we as server would */
3897           f.running_in_test_harness ? 6 : ssl_session_timeout;
3898 #endif
3899         if (lifetime + dt->time_stamp < time(NULL))
3900           {
3901           DEBUG(D_tls) debug_printf("session expired\n");
3902           dbfn_delete(dbm_file, tlsp->resume_index);
3903           }
3904         else if (SSL_set_session(ssl, ss))
3905           {
3906           DEBUG(D_tls) debug_printf("good session\n");
3907           tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
3908           tlsp->verify_override = dt->verify_override;
3909           tlsp->ocsp = dt->ocsp;
3910           }
3911         else DEBUG(D_tls)
3912           {
3913           ERR_error_string_n(ERR_get_error(),
3914             ssl_errstring, sizeof(ssl_errstring));
3915           debug_printf("applying session to ssl: %s\n", ssl_errstring);
3916           }
3917         }
3918       }
3919     else
3920       DEBUG(D_tls) debug_printf("no session record\n");
3921     dbfn_close(dbm_file);
3922     }
3923   }
3924 }
3925
3926
3927 /* On the client, save the session for later resumption */
3928
3929 static int
3930 tls_save_session_cb(SSL * ssl, SSL_SESSION * ss)
3931 {
3932 exim_openssl_state_st * cbinfo = SSL_get_ex_data(ssl, tls_exdata_idx);
3933 tls_support * tlsp;
3934
3935 DEBUG(D_tls) debug_printf("tls_save_session_cb\n");
3936
3937 if (!cbinfo || !(tlsp = cbinfo->tlsp)->host_resumable) return 0;
3938
3939 # ifdef OPENSSL_HAVE_NUM_TICKETS
3940 if (SSL_SESSION_is_resumable(ss))       /* 1.1.1 */
3941 # endif
3942   {
3943   int len = i2d_SSL_SESSION(ss, NULL);
3944   int dlen = sizeof(dbdata_tls_session) + len;
3945   dbdata_tls_session * dt = store_get(dlen, GET_TAINTED);
3946   uschar * s = dt->session;
3947   open_db dbblock, * dbm_file;
3948
3949   DEBUG(D_tls) debug_printf("session is resumable\n");
3950   tlsp->resumption |= RESUME_SERVER_TICKET;     /* server gave us a ticket */
3951
3952   dt->verify_override = tlsp->verify_override;
3953   dt->ocsp = tlsp->ocsp;
3954   (void) i2d_SSL_SESSION(ss, &s);               /* s gets bumped to end */
3955
3956   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3957     {
3958     dbfn_write(dbm_file, tlsp->resume_index, dt, dlen);
3959     dbfn_close(dbm_file);
3960     DEBUG(D_tls) debug_printf("wrote session (len %u) to db\n",
3961                   (unsigned)dlen);
3962     }
3963   }
3964 return 1;
3965 }
3966
3967
3968 /* Construct a key for session DB lookup, and setup the SSL_CTX for resumption */
3969
3970 static void
3971 tls_client_ctx_resume_prehandshake(
3972   exim_openssl_client_tls_ctx * exim_client_ctx, smtp_connect_args * conn_args,
3973   tls_support * tlsp, smtp_transport_options_block * ob)
3974 {
3975 tlsp->host_resumable = TRUE;
3976 tls_client_resmption_key(tlsp, conn_args, ob);
3977
3978 SSL_CTX_set_session_cache_mode(exim_client_ctx->ctx,
3979       SSL_SESS_CACHE_CLIENT
3980       | SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_NO_AUTO_CLEAR);
3981 SSL_CTX_sess_set_new_cb(exim_client_ctx->ctx, tls_save_session_cb);
3982 }
3983
3984 static BOOL
3985 tls_client_ssl_resume_prehandshake(SSL * ssl, tls_support * tlsp,
3986   host_item * host, uschar ** errstr)
3987 {
3988 if (tlsp->host_resumable)
3989   {
3990   DEBUG(D_tls)
3991     debug_printf("tls_resumption_hosts overrides openssl_options, enabling tickets\n");
3992   SSL_clear_options(ssl, SSL_OP_NO_TICKET);
3993
3994   tls_exdata_idx = SSL_get_ex_new_index(0, 0, 0, 0, 0);
3995   if (!SSL_set_ex_data(ssl, tls_exdata_idx, client_static_state))
3996     {
3997     tls_error(US"set ex_data", host, NULL, errstr);
3998     return FALSE;
3999     }
4000   debug_printf("tls_exdata_idx %d cbinfo %p\n", tls_exdata_idx, client_static_state);
4001   }
4002
4003 tlsp->resumption = RESUME_SUPPORTED;
4004 /* Pick up a previous session, saved on an old ticket */
4005 tls_retrieve_session(tlsp, ssl);
4006 return TRUE;
4007 }
4008
4009 static void
4010 tls_client_resume_posthandshake(exim_openssl_client_tls_ctx * exim_client_ctx,
4011   tls_support * tlsp)
4012 {
4013 if (SSL_session_reused(exim_client_ctx->ssl))
4014   {
4015   DEBUG(D_tls) debug_printf("The session was reused\n");
4016   tlsp->resumption |= RESUME_USED;
4017   }
4018 }
4019 #endif  /* !DISABLE_TLS_RESUME */
4020
4021
4022 #ifdef EXIM_HAVE_ALPN
4023 /* Expand and convert an Exim list to an ALPN list.  False return for fail.
4024 NULL plist return for silent no-ALPN.
4025
4026 Overwite the passed-in list with the expanded version.
4027 */
4028
4029 static BOOL
4030 tls_alpn_plist(uschar ** tls_alpn, const uschar ** plist, unsigned * plen,
4031   uschar ** errstr)
4032 {
4033 uschar * exp_alpn;
4034
4035 if (!expand_check(*tls_alpn, US"tls_alpn", &exp_alpn, errstr))
4036   return FALSE;
4037 *tls_alpn = exp_alpn;
4038
4039 if (!exp_alpn)
4040   {
4041   DEBUG(D_tls) debug_printf("Setting TLS ALPN forced to fail, not sending\n");
4042   *plist = NULL;
4043   }
4044 else
4045   {
4046   /* The server implementation only accepts exactly one protocol name
4047   but it's little extra code complexity in the client. */
4048
4049   const uschar * list = exp_alpn;
4050   uschar * p = store_get(Ustrlen(exp_alpn), exp_alpn), * s, * t;
4051   int sep = 0;
4052   uschar len;
4053
4054   for (t = p; s = string_nextinlist(&list, &sep, NULL, 0); t += len)
4055     {
4056     *t++ = len = (uschar) Ustrlen(s);
4057     memcpy(t, s, len);
4058     }
4059   *plist = (*plen = t - p) ? p : NULL;
4060   }
4061 return TRUE;
4062 }
4063 #endif  /* EXIM_HAVE_ALPN */
4064
4065
4066 /*************************************************
4067 *    Start a TLS session in a client             *
4068 *************************************************/
4069
4070 /* Called from the smtp transport after STARTTLS has been accepted.
4071
4072 Arguments:
4073   cctx          connection context
4074   conn_args     connection details
4075   cookie        datum for randomness; can be NULL
4076   tlsp          record details of TLS channel configuration here; must be non-NULL
4077   errstr        error string pointer
4078
4079 Returns:        TRUE for success with TLS session context set in connection context,
4080                 FALSE on error
4081 */
4082
4083 BOOL
4084 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
4085   void * cookie, tls_support * tlsp, uschar ** errstr)
4086 {
4087 host_item * host = conn_args->host;             /* for msgs and option-tests */
4088 transport_instance * tb = conn_args->tblock;    /* always smtp or NULL */
4089 smtp_transport_options_block * ob = tb
4090   ? (smtp_transport_options_block *)tb->options_block
4091   : &smtp_transport_option_defaults;
4092 exim_openssl_client_tls_ctx * exim_client_ctx;
4093 uschar * expciphers;
4094 int rc;
4095 static uschar peerdn[256];
4096
4097 #ifndef DISABLE_OCSP
4098 BOOL request_ocsp = FALSE;
4099 BOOL require_ocsp = FALSE;
4100 #endif
4101
4102 rc = store_pool;
4103 store_pool = POOL_PERM;
4104 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx), GET_UNTAINTED);
4105 exim_client_ctx->corked = NULL;
4106 store_pool = rc;
4107
4108 #ifdef SUPPORT_DANE
4109 tlsp->tlsa_usage = 0;
4110 #endif
4111
4112 #ifndef DISABLE_OCSP
4113   {
4114 # ifdef SUPPORT_DANE
4115   if (  conn_args->dane
4116      && ob->hosts_request_ocsp[0] == '*'
4117      && ob->hosts_request_ocsp[1] == '\0'
4118      )
4119     {
4120     /* Unchanged from default.  Use a safer one under DANE */
4121     request_ocsp = TRUE;
4122     ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
4123                                       "   {= {4}{$tls_out_tlsa_usage}} } "
4124                                  " {*}{}}";
4125     }
4126 # endif
4127
4128   if ((require_ocsp =
4129         verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK))
4130     request_ocsp = TRUE;
4131   else
4132 # ifdef SUPPORT_DANE
4133     if (!request_ocsp)
4134 # endif
4135       request_ocsp =
4136         verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
4137
4138 # if defined(SUPPORT_DANE) && !defined(EXIM_HAVE_OPENSSL_OCSP_RESP_GET0_SIGNER)
4139   if (conn_args->dane && (require_ocsp || request_ocsp))
4140     {
4141     DEBUG(D_tls) debug_printf("OpenSSL version to early to combine OCSP"
4142                               " and DANE; disabling OCSP\n");
4143     require_ocsp = request_ocsp = FALSE;
4144     }
4145 # endif
4146   }
4147 #endif
4148
4149 rc = tls_init(host, ob,
4150 #ifndef DISABLE_OCSP
4151     (void *)(long)request_ocsp,
4152 #endif
4153     cookie, &client_static_state, tlsp, errstr);
4154 if (rc != OK) return FALSE;
4155
4156 exim_client_ctx->ctx = client_static_state->lib_state.lib_ctx;
4157
4158 tlsp->certificate_verified = FALSE;
4159 client_verify_callback_called = FALSE;
4160
4161 expciphers = NULL;
4162 #ifdef SUPPORT_DANE
4163 if (conn_args->dane)
4164   {
4165   /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
4166   other failures should be treated as problems. */
4167   if (ob->dane_require_tls_ciphers &&
4168       !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
4169         &expciphers, errstr))
4170     return FALSE;
4171   if (expciphers && *expciphers == '\0')
4172     expciphers = NULL;
4173
4174   normalise_ciphers(&expciphers, ob->dane_require_tls_ciphers);
4175   }
4176 #endif
4177 if (!expciphers)
4178   {
4179   if (!expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
4180       &expciphers, errstr))
4181     return FALSE;
4182
4183   /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
4184   are separated by underscores. So that I can use either form in my tests, and
4185   also for general convenience, we turn underscores into hyphens here. */
4186
4187   normalise_ciphers(&expciphers, ob->tls_require_ciphers);
4188   }
4189
4190 if (expciphers)
4191   {
4192   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
4193   if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
4194     {
4195     tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
4196     return FALSE;
4197     }
4198   }
4199
4200 #ifdef SUPPORT_DANE
4201 if (conn_args->dane)
4202   {
4203   SSL_CTX_set_verify(exim_client_ctx->ctx,
4204     SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
4205     verify_callback_client_dane);
4206
4207   if (!DANESSL_library_init())
4208     {
4209     tls_error(US"library init", host, NULL, errstr);
4210     return FALSE;
4211     }
4212   if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
4213     {
4214     tls_error(US"context init", host, NULL, errstr);
4215     return FALSE;
4216     }
4217   DEBUG(D_tls) debug_printf("since dane-mode conn, not loading the usual CA bundle\n");
4218   }
4219 else
4220
4221 #endif
4222
4223 if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
4224       client_static_state, errstr) != OK)
4225   return FALSE;
4226
4227 if (ob->tls_sni)
4228   {
4229   if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
4230     return FALSE;
4231   if (!tlsp->sni)
4232     { DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n"); }
4233   else if (!Ustrlen(tlsp->sni))
4234     tlsp->sni = NULL;
4235   else
4236     {
4237 #ifndef EXIM_HAVE_OPENSSL_TLSEXT
4238     log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
4239           tlsp->sni);
4240     tlsp->sni = NULL;
4241 #endif
4242     }
4243   }
4244
4245 if (ob->tls_alpn)
4246 #ifdef EXIM_HAVE_ALPN
4247   {
4248   const uschar * plist;
4249   unsigned plen;
4250
4251   if (!tls_alpn_plist(&ob->tls_alpn, &plist, &plen, errstr))
4252     return FALSE;
4253   if (plist)
4254     if (SSL_CTX_set_alpn_protos(exim_client_ctx->ctx, plist, plen) != 0)
4255       {
4256       tls_error(US"alpn init", host, NULL, errstr);
4257       return FALSE;
4258       }
4259     else
4260       DEBUG(D_tls) debug_printf("Setting TLS ALPN '%s'\n", ob->tls_alpn);
4261   }
4262 #else
4263   log_write(0, LOG_MAIN, "ALPN unusable with this OpenSSL library version; ignoring \"%s\"\n",
4264           ob->tls_alpn);
4265 #endif
4266
4267 #ifndef DISABLE_TLS_RESUME
4268 /*XXX have_lbserver: another cmdline arg possibly, for continued-conn, but use
4269 will be very low. */
4270
4271 if (!conn_args->have_lbserver)  /* wanted for tls_client_resmption_key() */
4272   { DEBUG(D_tls) debug_printf("resumption not supported on continued-connection\n"); }
4273 else if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
4274   tls_client_ctx_resume_prehandshake(exim_client_ctx, conn_args, tlsp, ob);
4275 #endif
4276
4277
4278 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
4279   {
4280   tls_error(US"SSL_new", host, NULL, errstr);
4281   return FALSE;
4282   }
4283 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
4284 SSL_set_fd(exim_client_ctx->ssl, cctx->sock);
4285 SSL_set_connect_state(exim_client_ctx->ssl);
4286
4287 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
4288 if (tlsp->sni)
4289   {
4290   DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
4291   SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
4292   }
4293 #endif
4294
4295 #ifdef SUPPORT_DANE
4296 if (conn_args->dane)
4297   if (dane_tlsa_load(exim_client_ctx->ssl, host, &conn_args->tlsa_dnsa, errstr) != OK)
4298     return FALSE;
4299 #endif
4300
4301 #ifndef DISABLE_OCSP
4302 /* Request certificate status at connection-time.  If the server
4303 does OCSP stapling we will get the callback (set in tls_init()) */
4304 # ifdef SUPPORT_DANE
4305 if (request_ocsp)
4306   {
4307   const uschar * s;
4308   if (  ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
4309      || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
4310      )
4311     {   /* Re-eval now $tls_out_tlsa_usage is populated.  If
4312         this means we avoid the OCSP request, we wasted the setup
4313         cost in tls_init(). */
4314     require_ocsp = verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
4315     request_ocsp = require_ocsp
4316       || verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
4317     }
4318   }
4319 # endif
4320
4321 if (request_ocsp)
4322   {
4323   SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
4324   client_static_state->u_ocsp.client.verify_required = require_ocsp;
4325   tlsp->ocsp = OCSP_NOT_RESP;
4326   }
4327 #endif
4328
4329 #ifndef DISABLE_TLS_RESUME
4330 if (!tls_client_ssl_resume_prehandshake(exim_client_ctx->ssl, tlsp, host,
4331       errstr))
4332   return FALSE;
4333 #endif
4334
4335 #ifndef DISABLE_EVENT
4336 client_static_state->event_action = tb ? tb->event_action : NULL;
4337 #endif
4338
4339 /* There doesn't seem to be a built-in timeout on connection. */
4340
4341 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
4342 sigalrm_seen = FALSE;
4343 ALARM(ob->command_timeout);
4344 rc = SSL_connect(exim_client_ctx->ssl);
4345 ALARM_CLR(0);
4346
4347 #ifdef SUPPORT_DANE
4348 if (conn_args->dane)
4349   DANESSL_cleanup(exim_client_ctx->ssl);
4350 #endif
4351
4352 if (rc <= 0)
4353   {
4354 #ifndef DISABLE_OCSP
4355   if (client_static_state->u_ocsp.client.verify_errstr)
4356     { if (errstr) *errstr = client_static_state->u_ocsp.client.verify_errstr; }
4357   else
4358 #endif
4359     tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
4360   return FALSE;
4361   }
4362
4363 DEBUG(D_tls)
4364   {
4365   debug_printf("SSL_connect succeeded\n");
4366   tls_dump_keylog(exim_client_ctx->ssl);
4367   }
4368
4369 #ifndef DISABLE_TLS_RESUME
4370 tls_client_resume_posthandshake(exim_client_ctx, tlsp);
4371 #endif
4372
4373 #ifdef EXIM_HAVE_ALPN
4374 if (ob->tls_alpn)       /* We requested. See what was negotiated. */
4375   {
4376   const uschar * name;
4377   unsigned len;
4378
4379   SSL_get0_alpn_selected(exim_client_ctx->ssl, &name, &len);
4380   if (len > 0)
4381     { DEBUG(D_tls) debug_printf("ALPN negotiated %u: '%.*s'\n", len, (int)*name, name+1); }
4382   else if (verify_check_given_host(CUSS &ob->hosts_require_alpn, host) == OK)
4383     {
4384     /* Would like to send a relevant fatal Alert, but OpenSSL has no API */
4385     tls_error(US"handshake", host, US"ALPN required but not negotiated", errstr);
4386     return FALSE;
4387     }
4388   }
4389 #endif
4390
4391 #ifdef SSL_get_extms_support
4392 tlsp->ext_master_secret = SSL_get_extms_support(exim_client_ctx->ssl) == 1;
4393 #endif
4394 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
4395
4396 tlsp->ver = tlsver_name(exim_client_ctx->ssl);
4397 tlsp->cipher = construct_cipher_name(exim_client_ctx->ssl, tlsp->ver, &tlsp->bits);
4398 tlsp->cipher_stdname = cipher_stdname_ssl(exim_client_ctx->ssl);
4399
4400 /* Record the certificate we presented */
4401   {
4402   X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
4403   tlsp->ourcert = crt ? X509_dup(crt) : NULL;
4404   }
4405
4406 /*XXX will this work with continued-TLS? */
4407 tls_get_channel_binding(exim_client_ctx->ssl, tlsp, GET_TAINTED);
4408
4409 tlsp->active.sock = cctx->sock;
4410 tlsp->active.tls_ctx = exim_client_ctx;
4411 cctx->tls_ctx = exim_client_ctx;
4412 return TRUE;
4413 }
4414
4415
4416
4417
4418
4419 static BOOL
4420 tls_refill(unsigned lim)
4421 {
4422 SSL * ssl = state_server.lib_state.lib_ssl;
4423 int error;
4424 int inbytes;
4425
4426 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
4427   ssl_xfer_buffer, ssl_xfer_buffer_size);
4428
4429 ERR_clear_error();
4430 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
4431 inbytes = SSL_read(ssl, CS ssl_xfer_buffer,
4432                   MIN(ssl_xfer_buffer_size, lim));
4433 error = SSL_get_error(ssl, inbytes);
4434 if (smtp_receive_timeout > 0) ALARM_CLR(0);
4435
4436 if (had_command_timeout)                /* set by signal handler */
4437   smtp_command_timeout_exit();          /* does not return */
4438 if (had_command_sigterm)
4439   smtp_command_sigterm_exit();
4440 if (had_data_timeout)
4441   smtp_data_timeout_exit();
4442 if (had_data_sigint)
4443   smtp_data_sigint_exit();
4444
4445 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
4446 closed down, not that the socket itself has been closed down. Revert to
4447 non-SSL handling. */
4448
4449 switch(error)
4450   {
4451   case SSL_ERROR_NONE:
4452     break;
4453
4454   case SSL_ERROR_ZERO_RETURN:
4455     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
4456
4457     if (SSL_get_shutdown(ssl) == SSL_RECEIVED_SHUTDOWN)
4458           SSL_shutdown(ssl);
4459
4460     tls_close(NULL, TLS_NO_SHUTDOWN);
4461     return FALSE;
4462
4463   /* Handle genuine errors */
4464   case SSL_ERROR_SSL:
4465     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4466     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
4467     ssl_xfer_error = TRUE;
4468     return FALSE;
4469
4470   default:
4471     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
4472     DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
4473       debug_printf(" - syscall %s\n", strerror(errno));
4474     ssl_xfer_error = TRUE;
4475     return FALSE;
4476   }
4477
4478 #ifndef DISABLE_DKIM
4479 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
4480 #endif
4481 ssl_xfer_buffer_hwm = inbytes;
4482 ssl_xfer_buffer_lwm = 0;
4483 return TRUE;
4484 }
4485
4486
4487 /*************************************************
4488 *            TLS version of getc                 *
4489 *************************************************/
4490
4491 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
4492 it refills the buffer via the SSL reading function.
4493
4494 Arguments:  lim         Maximum amount to read/buffer
4495 Returns:    the next character or EOF
4496
4497 Only used by the server-side TLS.
4498 */
4499
4500 int
4501 tls_getc(unsigned lim)
4502 {
4503 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
4504   if (!tls_refill(lim))
4505     return ssl_xfer_error ? EOF : smtp_getc(lim);
4506
4507 /* Something in the buffer; return next uschar */
4508
4509 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
4510 }
4511
4512 BOOL
4513 tls_hasc(void)
4514 {
4515 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm;
4516 }
4517
4518 uschar *
4519 tls_getbuf(unsigned * len)
4520 {
4521 unsigned size;
4522 uschar * buf;
4523
4524 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
4525   if (!tls_refill(*len))
4526     {
4527     if (!ssl_xfer_error) return smtp_getbuf(len);
4528     *len = 0;
4529     return NULL;
4530     }
4531
4532 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
4533   size = *len;
4534 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
4535 ssl_xfer_buffer_lwm += size;
4536 *len = size;
4537 return buf;
4538 }
4539
4540
4541 void
4542 tls_get_cache(unsigned lim)
4543 {
4544 #ifndef DISABLE_DKIM
4545 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
4546 if (n > lim)
4547   n = lim;
4548 if (n > 0)
4549   dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
4550 #endif
4551 }
4552
4553
4554 BOOL
4555 tls_could_getc(void)
4556 {
4557 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm
4558     || SSL_pending(state_server.lib_state.lib_ssl) > 0;
4559 }
4560
4561
4562 /*************************************************
4563 *          Read bytes from TLS channel           *
4564 *************************************************/
4565
4566 /*
4567 Arguments:
4568   ct_ctx    client context pointer, or NULL for the one global server context
4569   buff      buffer of data
4570   len       size of buffer
4571
4572 Returns:    the number of bytes read
4573             -1 after a failed read, including EOF
4574
4575 Only used by the client-side TLS.
4576 */
4577
4578 int
4579 tls_read(void * ct_ctx, uschar *buff, size_t len)
4580 {
4581 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl
4582                   : state_server.lib_state.lib_ssl;
4583 int inbytes;
4584 int error;
4585
4586 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
4587   buff, (unsigned int)len);
4588
4589 ERR_clear_error();
4590 inbytes = SSL_read(ssl, CS buff, len);
4591 error = SSL_get_error(ssl, inbytes);
4592
4593 if (error == SSL_ERROR_ZERO_RETURN)
4594   {
4595   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
4596   return -1;
4597   }
4598 else if (error != SSL_ERROR_NONE)
4599   return -1;
4600
4601 return inbytes;
4602 }
4603
4604
4605
4606
4607
4608 /*************************************************
4609 *         Write bytes down TLS channel           *
4610 *************************************************/
4611
4612 /*
4613 Arguments:
4614   ct_ctx    client context pointer, or NULL for the one global server context
4615   buff      buffer of data
4616   len       number of bytes
4617   more      further data expected soon
4618
4619 Returns:    the number of bytes after a successful write,
4620             -1 after a failed write
4621
4622 Used by both server-side and client-side TLS.  Calling with len zero and more unset
4623 will flush buffered writes; buff can be null for this case.
4624 */
4625
4626 int
4627 tls_write(void * ct_ctx, const uschar * buff, size_t len, BOOL more)
4628 {
4629 size_t olen = len;
4630 int outbytes, error;
4631 SSL * ssl = ct_ctx
4632   ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl
4633   : state_server.lib_state.lib_ssl;
4634 static gstring * server_corked = NULL;
4635 gstring ** corkedp = ct_ctx
4636   ? &((exim_openssl_client_tls_ctx *)ct_ctx)->corked : &server_corked;
4637 gstring * corked = *corkedp;
4638
4639 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
4640   buff, (unsigned long)len, more ? ", more" : "");
4641
4642 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
4643 "more" is notified.  This hack is only ok if small amounts are involved AND only
4644 one stream does it, in one context (i.e. no store reset).  Currently it is used
4645 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only.
4646 We support callouts done by the server process by using a separate client
4647 context for the stashed information. */
4648 /* + if PIPE_COMMAND, banner & ehlo-resp for smmtp-on-connect. Suspect there's
4649 a store reset there, so use POOL_PERM. */
4650 /* + if CHUNKING, cmds EHLO,MAIL,RCPT(s),BDAT */
4651
4652 if (more || corked)
4653   {
4654   if (!len) buff = US &error;   /* dummy just so that string_catn is ok */
4655
4656   int save_pool = store_pool;
4657   store_pool = POOL_PERM;
4658
4659   corked = string_catn(corked, buff, len);
4660
4661   store_pool = save_pool;
4662
4663   if (more)
4664     {
4665     *corkedp = corked;
4666     return len;
4667     }
4668   buff = CUS corked->s;
4669   len = corked->ptr;
4670   *corkedp = NULL;
4671   }
4672
4673 for (int left = len; left > 0;)
4674   {
4675   DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
4676   ERR_clear_error();
4677   outbytes = SSL_write(ssl, CS buff, left);
4678   error = SSL_get_error(ssl, outbytes);
4679   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
4680   switch (error)
4681     {
4682     case SSL_ERROR_NONE:        /* the usual case */
4683       left -= outbytes;
4684       buff += outbytes;
4685       break;
4686
4687     case SSL_ERROR_SSL:
4688       ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4689       log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
4690       return -1;
4691
4692     case SSL_ERROR_ZERO_RETURN:
4693       log_write(0, LOG_MAIN, "SSL channel closed on write");
4694       return -1;
4695
4696     case SSL_ERROR_SYSCALL:
4697       if (ct_ctx || errno != ECONNRESET || !f.smtp_in_quit)
4698         log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
4699           sender_fullhost ? sender_fullhost : US"<unknown>",
4700           strerror(errno));
4701       else if (LOGGING(protocol_detail))
4702         log_write(0, LOG_MAIN, "[%s] after QUIT, client reset TCP before"
4703           " SMTP response and TLS close\n", sender_host_address);
4704       else
4705         DEBUG(D_tls) debug_printf("[%s] SSL_write: after QUIT,"
4706           " client reset TCP before TLS close\n", sender_host_address);
4707       return -1;
4708
4709     default:
4710       log_write(0, LOG_MAIN, "SSL_write error %d", error);
4711       return -1;
4712     }
4713   }
4714 return olen;
4715 }
4716
4717
4718
4719 /*
4720 Arguments:
4721   ct_ctx        client TLS context pointer, or NULL for the one global server context
4722 */
4723
4724 void
4725 tls_shutdown_wr(void * ct_ctx)
4726 {
4727 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
4728 SSL ** sslp = o_ctx ? &o_ctx->ssl : (SSL **) &state_server.lib_state.lib_ssl;
4729 int * fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
4730 int rc;
4731
4732 if (*fdp < 0) return;  /* TLS was not active */
4733
4734 tls_write(ct_ctx, NULL, 0, FALSE);      /* flush write buffer */
4735
4736 HDEBUG(D_transport|D_tls|D_acl|D_v) debug_printf_indent("  SMTP(TLS shutdown)>>\n");
4737 rc = SSL_shutdown(*sslp);
4738 if (rc < 0) DEBUG(D_tls)
4739   {
4740   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4741   debug_printf("SSL_shutdown: %s\n", ssl_errstring);
4742   }
4743 }
4744
4745 /*************************************************
4746 *         Close down a TLS session               *
4747 *************************************************/
4748
4749 /* This is also called from within a delivery subprocess forked from the
4750 daemon, to shut down the TLS library, without actually doing a shutdown (which
4751 would tamper with the SSL session in the parent process).
4752
4753 Arguments:
4754   ct_ctx        client TLS context pointer, or NULL for the one global server context
4755   do_shutdown   0 no data-flush or TLS close-alert
4756                 1 if TLS close-alert is to be sent,
4757                 2 if also response to be waited for
4758
4759 Returns:     nothing
4760
4761 Used by both server-side and client-side TLS.
4762 */
4763
4764 void
4765 tls_close(void * ct_ctx, int do_shutdown)
4766 {
4767 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
4768 SSL ** sslp = o_ctx ? &o_ctx->ssl : (SSL **) &state_server.lib_state.lib_ssl;
4769 int * fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
4770
4771 if (*fdp < 0) return;  /* TLS was not active */
4772
4773 if (do_shutdown > TLS_NO_SHUTDOWN)
4774   {
4775   int rc;
4776   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
4777     do_shutdown > TLS_SHUTDOWN_NOWAIT ? " (with response-wait)" : "");
4778
4779   tls_write(ct_ctx, NULL, 0, FALSE);    /* flush write buffer */
4780
4781   if (  (  do_shutdown >= TLS_SHUTDOWN_WONLY
4782         || (rc = SSL_shutdown(*sslp)) == 0      /* send "close notify" alert */
4783         )
4784      && do_shutdown > TLS_SHUTDOWN_NOWAIT
4785      )
4786     {
4787 #ifdef EXIM_TCP_CORK
4788     (void) setsockopt(*fdp, IPPROTO_TCP, EXIM_TCP_CORK, US &off, sizeof(off));
4789 #endif
4790     ALARM(2);
4791     rc = SSL_shutdown(*sslp);                   /* wait for response */
4792     ALARM_CLR(0);
4793     }
4794
4795   if (rc < 0) DEBUG(D_tls)
4796     {
4797     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4798     debug_printf("SSL_shutdown: %s\n", ssl_errstring);
4799     }
4800   }
4801
4802 if (!o_ctx)             /* server side */
4803   {
4804 #ifndef DISABLE_OCSP
4805   sk_X509_pop_free(state_server.u_ocsp.server.verify_stack, X509_free);
4806   state_server.u_ocsp.server.verify_stack = NULL;
4807 #endif
4808
4809   receive_getc =        smtp_getc;
4810   receive_getbuf =      smtp_getbuf;
4811   receive_get_cache =   smtp_get_cache;
4812   receive_hasc =        smtp_hasc;
4813   receive_ungetc =      smtp_ungetc;
4814   receive_feof =        smtp_feof;
4815   receive_ferror =      smtp_ferror;
4816   tls_in.active.tls_ctx = NULL;
4817   tls_in.sni = NULL;
4818   /* Leave bits, peercert, cipher, peerdn, certificate_verified set, for logging */
4819   }
4820
4821 SSL_free(*sslp);
4822 *sslp = NULL;
4823 *fdp = -1;
4824 }
4825
4826
4827
4828
4829 /*************************************************
4830 *  Let tls_require_ciphers be checked at startup *
4831 *************************************************/
4832
4833 /* The tls_require_ciphers option, if set, must be something which the
4834 library can parse.
4835
4836 Returns:     NULL on success, or error message
4837 */
4838
4839 uschar *
4840 tls_validate_require_cipher(void)
4841 {
4842 SSL_CTX * ctx;
4843 uschar * expciphers, * err;
4844
4845 tls_openssl_init();
4846
4847 if (!(tls_require_ciphers && *tls_require_ciphers))
4848   return NULL;
4849
4850 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
4851                   &err))
4852   return US"failed to expand tls_require_ciphers";
4853
4854 if (!(expciphers && *expciphers))
4855   return NULL;
4856
4857 normalise_ciphers(&expciphers, tls_require_ciphers);
4858
4859 err = NULL;
4860 if (lib_ctx_new(&ctx, NULL, &err) == OK)
4861   {
4862   DEBUG(D_tls)
4863     debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
4864
4865   if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
4866     {
4867     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
4868     err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
4869                         expciphers, ssl_errstring);
4870     }
4871
4872   SSL_CTX_free(ctx);
4873   }
4874 return err;
4875 }
4876
4877
4878
4879
4880 /*************************************************
4881 *         Report the library versions.           *
4882 *************************************************/
4883
4884 /* There have historically been some issues with binary compatibility in
4885 OpenSSL libraries; if Exim (like many other applications) is built against
4886 one version of OpenSSL but the run-time linker picks up another version,
4887 it can result in serious failures, including crashing with a SIGSEGV.  So
4888 report the version found by the compiler and the run-time version.
4889
4890 Note: some OS vendors backport security fixes without changing the version
4891 number/string, and the version date remains unchanged.  The _build_ date
4892 will change, so we can more usefully assist with version diagnosis by also
4893 reporting the build date.
4894
4895 Arguments:   string to append to
4896 Returns:     string
4897 */
4898
4899 gstring *
4900 tls_version_report(gstring * g)
4901 {
4902 return string_fmt_append(g,
4903     "Library version: OpenSSL: Compile: %s\n"
4904     "                          Runtime: %s\n"
4905     "                                 : %s\n",
4906              OPENSSL_VERSION_TEXT,
4907              SSLeay_version(SSLEAY_VERSION),
4908              SSLeay_version(SSLEAY_BUILT_ON));
4909   /* third line is 38 characters for the %s and the line is 73 chars long;
4910   the OpenSSL output includes a "built on: " prefix already. */
4911 }
4912
4913
4914
4915
4916 /*************************************************
4917 *            Random number generation            *
4918 *************************************************/
4919
4920 /* Pseudo-random number generation.  The result is not expected to be
4921 cryptographically strong but not so weak that someone will shoot themselves
4922 in the foot using it as a nonce in input in some email header scheme or
4923 whatever weirdness they'll twist this into.  The result should handle fork()
4924 and avoid repeating sequences.  OpenSSL handles that for us.
4925
4926 Arguments:
4927   max       range maximum
4928 Returns     a random number in range [0, max-1]
4929 */
4930
4931 int
4932 vaguely_random_number(int max)
4933 {
4934 unsigned int r;
4935 int i, needed_len;
4936 static pid_t pidlast = 0;
4937 pid_t pidnow;
4938 uschar smallbuf[sizeof(r)];
4939
4940 if (max <= 1)
4941   return 0;
4942
4943 pidnow = getpid();
4944 if (pidnow != pidlast)
4945   {
4946   /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
4947   is unique for each thread", this doesn't apparently apply across processes,
4948   so our own warning from vaguely_random_number_fallback() applies here too.
4949   Fix per PostgreSQL. */
4950   if (pidlast != 0)
4951     RAND_cleanup();
4952   pidlast = pidnow;
4953   }
4954
4955 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
4956 if (!RAND_status())
4957   {
4958   randstuff r;
4959   gettimeofday(&r.tv, NULL);
4960   r.p = getpid();
4961
4962   RAND_seed(US (&r), sizeof(r));
4963   }
4964 /* We're after pseudo-random, not random; if we still don't have enough data
4965 in the internal PRNG then our options are limited.  We could sleep and hope
4966 for entropy to come along (prayer technique) but if the system is so depleted
4967 in the first place then something is likely to just keep taking it.  Instead,
4968 we'll just take whatever little bit of pseudo-random we can still manage to
4969 get. */
4970
4971 needed_len = sizeof(r);
4972 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
4973 asked for a number less than 10. */
4974 for (r = max, i = 0; r; ++i)
4975   r >>= 1;
4976 i = (i + 7) / 8;
4977 if (i < needed_len)
4978   needed_len = i;
4979
4980 #ifdef EXIM_HAVE_RAND_PSEUDO
4981 /* We do not care if crypto-strong */
4982 i = RAND_pseudo_bytes(smallbuf, needed_len);
4983 #else
4984 i = RAND_bytes(smallbuf, needed_len);
4985 #endif
4986
4987 if (i < 0)
4988   {
4989   DEBUG(D_all)
4990     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
4991   return vaguely_random_number_fallback(max);
4992   }
4993
4994 r = 0;
4995 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
4996   r = 256 * r + *p;
4997
4998 /* We don't particularly care about weighted results; if someone wants
4999 smooth distribution and cares enough then they should submit a patch then. */
5000 return r % max;
5001 }
5002
5003
5004
5005
5006 /*************************************************
5007 *        OpenSSL option parse                    *
5008 *************************************************/
5009
5010 /* Parse one option for tls_openssl_options_parse below
5011
5012 Arguments:
5013   name    one option name
5014   value   place to store a value for it
5015 Returns   success or failure in parsing
5016 */
5017
5018
5019
5020 static BOOL
5021 tls_openssl_one_option_parse(uschar *name, long *value)
5022 {
5023 int first = 0;
5024 int last = exim_openssl_options_size;
5025 while (last > first)
5026   {
5027   int middle = (first + last)/2;
5028   int c = Ustrcmp(name, exim_openssl_options[middle].name);
5029   if (c == 0)
5030     {
5031     *value = exim_openssl_options[middle].value;
5032     return TRUE;
5033     }
5034   else if (c > 0)
5035     first = middle + 1;
5036   else
5037     last = middle;
5038   }
5039 return FALSE;
5040 }
5041
5042
5043
5044
5045 /*************************************************
5046 *        OpenSSL option parsing logic            *
5047 *************************************************/
5048
5049 /* OpenSSL has a number of compatibility options which an administrator might
5050 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
5051 we look like log_selector.
5052
5053 Arguments:
5054   option_spec  the administrator-supplied string of options
5055   results      ptr to long storage for the options bitmap
5056 Returns        success or failure
5057 */
5058
5059 BOOL
5060 tls_openssl_options_parse(uschar *option_spec, long *results)
5061 {
5062 long result, item;
5063 uschar * exp, * end;
5064 BOOL adding, item_parsed;
5065
5066 /* Server: send no (<= TLS1.2) session tickets */
5067 result = SSL_OP_NO_TICKET;
5068
5069 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
5070 from default because it increases BEAST susceptibility. */
5071 #ifdef SSL_OP_NO_SSLv2
5072 result |= SSL_OP_NO_SSLv2;
5073 #endif
5074 #ifdef SSL_OP_NO_SSLv3
5075 result |= SSL_OP_NO_SSLv3;
5076 #endif
5077 #ifdef SSL_OP_SINGLE_DH_USE
5078 result |= SSL_OP_SINGLE_DH_USE;
5079 #endif
5080 #ifdef SSL_OP_NO_RENEGOTIATION
5081 result |= SSL_OP_NO_RENEGOTIATION;
5082 #endif
5083
5084 if (!option_spec)
5085   {
5086   *results = result;
5087   return TRUE;
5088   }
5089
5090 if (!expand_check(option_spec, US"openssl_options", &exp, &end))
5091   return FALSE;
5092
5093 for (uschar * s = exp; *s; /**/)
5094   {
5095   while (isspace(*s)) ++s;
5096   if (*s == '\0')
5097     break;
5098   if (*s != '+' && *s != '-')
5099     {
5100     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
5101         "+ or - expected but found \"%s\"\n", s);
5102     return FALSE;
5103     }
5104   adding = *s++ == '+';
5105   for (end = s; *end && !isspace(*end); ) end++;
5106   item_parsed = tls_openssl_one_option_parse(string_copyn(s, end-s), &item);
5107   if (!item_parsed)
5108     {
5109     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
5110     return FALSE;
5111     }
5112   DEBUG(D_tls) debug_printf("openssl option, %s %08lx: %08lx (%s)\n",
5113       adding ? "adding to    " : "removing from", result, item, s);
5114   if (adding)
5115     result |= item;
5116   else
5117     result &= ~item;
5118   s = end;
5119   }
5120
5121 *results = result;
5122 return TRUE;
5123 }
5124
5125 #endif  /*!MACRO_PREDEF*/
5126 /* vi: aw ai sw=2
5127 */
5128 /* End of tls-openssl.c */