src/src/tls-openssl.c

   1 /*************************************************
   2 *     Exim - an Internet mail transport agent    *
   3 *************************************************/
   4
   5 /* Copyright (c) University of Cambridge 1995 - 2019 */
   6 /* See the file NOTICE for conditions of use and distribution. */
   7
   8 /* Portions Copyright (c) The OpenSSL Project 1999 */
   9
  10 /* This module provides the TLS (aka SSL) support for Exim using the OpenSSL
  11 library. It is #included into the tls.c file when that library is used. The
  12 code herein is based on a patch that was originally contributed by Steve
  13 Haslam. It was adapted from stunnel, a GPL program by Michal Trojnara.
  14
  15 No cryptographic code is included in Exim. All this module does is to call
  16 functions from the OpenSSL library. */
  17
  18
  19 /* Heading stuff */
  20
  21 #include <openssl/lhash.h>
  22 #include <openssl/ssl.h>
  23 #include <openssl/err.h>
  24 #include <openssl/rand.h>
  25 #ifndef OPENSSL_NO_ECDH
  26 # include <openssl/ec.h>
  27 #endif
  28 #ifndef DISABLE_OCSP
  29 # include <openssl/ocsp.h>
  30 #endif
  31 #ifdef SUPPORT_DANE
  32 # include "danessl.h"
  33 #endif
  34
  35
  36 #ifndef DISABLE_OCSP
  37 # define EXIM_OCSP_SKEW_SECONDS (300L)
  38 # define EXIM_OCSP_MAX_AGE (-1L)
  39 #endif
  40
  41 #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
  42 # define EXIM_HAVE_OPENSSL_TLSEXT
  43 #endif
  44 #if OPENSSL_VERSION_NUMBER >= 0x00908000L
  45 # define EXIM_HAVE_RSA_GENKEY_EX
  46 #endif
  47 #if OPENSSL_VERSION_NUMBER >= 0x10100000L
  48 # define EXIM_HAVE_OCSP_RESP_COUNT
  49 # define OPENSSL_AUTO_SHA256
  50 #else
  51 # define EXIM_HAVE_EPHEM_RSA_KEX
  52 # define EXIM_HAVE_RAND_PSEUDO
  53 #endif
  54 #if (OPENSSL_VERSION_NUMBER >= 0x0090800fL) && !defined(OPENSSL_NO_SHA256)
  55 # define EXIM_HAVE_SHA256
  56 #endif
  57
  58 /* X509_check_host provides sane certificate hostname checking, but was added
  59 to OpenSSL late, after other projects forked off the code-base.  So in
  60 addition to guarding against the base version number, beware that LibreSSL
  61 does not (at this time) support this function.
  62
  63 If LibreSSL gains a different API, perhaps via libtls, then we'll probably
  64 opt to disentangle and ask a LibreSSL user to provide glue for a third
  65 crypto provider for libtls instead of continuing to tie the OpenSSL glue
  66 into even twistier knots.  If LibreSSL gains the same API, we can just
  67 change this guard and punt the issue for a while longer. */
  68
  69 #ifndef LIBRESSL_VERSION_NUMBER
  70 # if OPENSSL_VERSION_NUMBER >= 0x010100000L
  71 #  define EXIM_HAVE_OPENSSL_CHECKHOST
  72 #  define EXIM_HAVE_OPENSSL_DH_BITS
  73 #  define EXIM_HAVE_OPENSSL_TLS_METHOD
  74 #  define EXIM_HAVE_OPENSSL_KEYLOG
  75 #  define EXIM_HAVE_OPENSSL_CIPHER_GET_ID
  76 #  define EXIM_HAVE_SESSION_TICKET
  77 #  define EXIM_HAVE_OPESSL_TRACE
  78 #  define EXIM_HAVE_OPESSL_GET0_SERIAL
  79 # else
  80 #  define EXIM_NEED_OPENSSL_INIT
  81 # endif
  82 # if OPENSSL_VERSION_NUMBER >= 0x010000000L \
  83     && (OPENSSL_VERSION_NUMBER & 0x0000ff000L) >= 0x000002000L
  84 #  define EXIM_HAVE_OPENSSL_CHECKHOST
  85 # endif
  86 #endif
  87
  88 #if !defined(LIBRESSL_VERSION_NUMBER) \
  89     || LIBRESSL_VERSION_NUMBER >= 0x20010000L
  90 # if !defined(OPENSSL_NO_ECDH)
  91 #  if OPENSSL_VERSION_NUMBER >= 0x0090800fL
  92 #   define EXIM_HAVE_ECDH
  93 #  endif
  94 #  if OPENSSL_VERSION_NUMBER >= 0x10002000L
  95 #   define EXIM_HAVE_OPENSSL_EC_NIST2NID
  96 #  endif
  97 # endif
  98 #endif
  99
 100 #ifndef LIBRESSL_VERSION_NUMBER
 101 # if OPENSSL_VERSION_NUMBER >= 0x010101000L
 102 #  define OPENSSL_HAVE_KEYLOG_CB
 103 #  define OPENSSL_HAVE_NUM_TICKETS
 104 #  define EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
 105 # endif
 106 #endif
 107
 108 #if !defined(EXIM_HAVE_OPENSSL_TLSEXT) && !defined(DISABLE_OCSP)
 109 # warning "OpenSSL library version too old; define DISABLE_OCSP in Makefile"
 110 # define DISABLE_OCSP
 111 #endif
 112
 113 #ifdef EXPERIMENTAL_TLS_RESUME
 114 # if OPENSSL_VERSION_NUMBER < 0x0101010L
 115 #  error OpenSSL version too old for session-resumption
 116 # endif
 117 #endif
 118
 119 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
 120 # include <openssl/x509v3.h>
 121 #endif
 122
 123 #ifndef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
 124 # ifndef EXIM_HAVE_OPENSSL_CIPHER_GET_ID
 125 #  define SSL_CIPHER_get_id(c) (c->id)
 126 # endif
 127 # ifndef MACRO_PREDEF
 128 #  include "tls-cipher-stdname.c"
 129 # endif
 130 #endif
 131
 132 /*************************************************
 133 *        OpenSSL option parse                    *
 134 *************************************************/
 135
 136 typedef struct exim_openssl_option {
 137   uschar *name;
 138   long    value;
 139 } exim_openssl_option;
 140 /* We could use a macro to expand, but we need the ifdef and not all the
 141 options document which version they were introduced in.  Policylet: include
 142 all options unless explicitly for DTLS, let the administrator choose which
 143 to apply.
 144
 145 This list is current as of:
 146   ==>  1.0.1b  <==
 147 Plus SSL_OP_SAFARI_ECDHE_ECDSA_BUG from 2013-June patch/discussion on openssl-dev
 148 Plus SSL_OP_NO_TLSv1_3 for 1.1.2-dev
 149 */
 150 static exim_openssl_option exim_openssl_options[] = {
 151 /* KEEP SORTED ALPHABETICALLY! */
 152 #ifdef SSL_OP_ALL
 153   { US"all", (long) SSL_OP_ALL },
 154 #endif
 155 #ifdef SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION
 156   { US"allow_unsafe_legacy_renegotiation", SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION },
 157 #endif
 158 #ifdef SSL_OP_CIPHER_SERVER_PREFERENCE
 159   { US"cipher_server_preference", SSL_OP_CIPHER_SERVER_PREFERENCE },
 160 #endif
 161 #ifdef SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS
 162   { US"dont_insert_empty_fragments", SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS },
 163 #endif
 164 #ifdef SSL_OP_EPHEMERAL_RSA
 165   { US"ephemeral_rsa", SSL_OP_EPHEMERAL_RSA },
 166 #endif
 167 #ifdef SSL_OP_LEGACY_SERVER_CONNECT
 168   { US"legacy_server_connect", SSL_OP_LEGACY_SERVER_CONNECT },
 169 #endif
 170 #ifdef SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER
 171   { US"microsoft_big_sslv3_buffer", SSL_OP_MICROSOFT_BIG_SSLV3_BUFFER },
 172 #endif
 173 #ifdef SSL_OP_MICROSOFT_SESS_ID_BUG
 174   { US"microsoft_sess_id_bug", SSL_OP_MICROSOFT_SESS_ID_BUG },
 175 #endif
 176 #ifdef SSL_OP_MSIE_SSLV2_RSA_PADDING
 177   { US"msie_sslv2_rsa_padding", SSL_OP_MSIE_SSLV2_RSA_PADDING },
 178 #endif
 179 #ifdef SSL_OP_NETSCAPE_CHALLENGE_BUG
 180   { US"netscape_challenge_bug", SSL_OP_NETSCAPE_CHALLENGE_BUG },
 181 #endif
 182 #ifdef SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG
 183   { US"netscape_reuse_cipher_change_bug", SSL_OP_NETSCAPE_REUSE_CIPHER_CHANGE_BUG },
 184 #endif
 185 #ifdef SSL_OP_NO_COMPRESSION
 186   { US"no_compression", SSL_OP_NO_COMPRESSION },
 187 #endif
 188 #ifdef SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION
 189   { US"no_session_resumption_on_renegotiation", SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION },
 190 #endif
 191 #ifdef SSL_OP_NO_SSLv2
 192   { US"no_sslv2", SSL_OP_NO_SSLv2 },
 193 #endif
 194 #ifdef SSL_OP_NO_SSLv3
 195   { US"no_sslv3", SSL_OP_NO_SSLv3 },
 196 #endif
 197 #ifdef SSL_OP_NO_TICKET
 198   { US"no_ticket", SSL_OP_NO_TICKET },
 199 #endif
 200 #ifdef SSL_OP_NO_TLSv1
 201   { US"no_tlsv1", SSL_OP_NO_TLSv1 },
 202 #endif
 203 #ifdef SSL_OP_NO_TLSv1_1
 204 #if SSL_OP_NO_TLSv1_1 == 0x00000400L
 205   /* Error in chosen value in 1.0.1a; see first item in CHANGES for 1.0.1b */
 206 #warning OpenSSL 1.0.1a uses a bad value for SSL_OP_NO_TLSv1_1, ignoring
 207 #else
 208   { US"no_tlsv1_1", SSL_OP_NO_TLSv1_1 },
 209 #endif
 210 #endif
 211 #ifdef SSL_OP_NO_TLSv1_2
 212   { US"no_tlsv1_2", SSL_OP_NO_TLSv1_2 },
 213 #endif
 214 #ifdef SSL_OP_NO_TLSv1_3
 215   { US"no_tlsv1_3", SSL_OP_NO_TLSv1_3 },
 216 #endif
 217 #ifdef SSL_OP_SAFARI_ECDHE_ECDSA_BUG
 218   { US"safari_ecdhe_ecdsa_bug", SSL_OP_SAFARI_ECDHE_ECDSA_BUG },
 219 #endif
 220 #ifdef SSL_OP_SINGLE_DH_USE
 221   { US"single_dh_use", SSL_OP_SINGLE_DH_USE },
 222 #endif
 223 #ifdef SSL_OP_SINGLE_ECDH_USE
 224   { US"single_ecdh_use", SSL_OP_SINGLE_ECDH_USE },
 225 #endif
 226 #ifdef SSL_OP_SSLEAY_080_CLIENT_DH_BUG
 227   { US"ssleay_080_client_dh_bug", SSL_OP_SSLEAY_080_CLIENT_DH_BUG },
 228 #endif
 229 #ifdef SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG
 230   { US"sslref2_reuse_cert_type_bug", SSL_OP_SSLREF2_REUSE_CERT_TYPE_BUG },
 231 #endif
 232 #ifdef SSL_OP_TLS_BLOCK_PADDING_BUG
 233   { US"tls_block_padding_bug", SSL_OP_TLS_BLOCK_PADDING_BUG },
 234 #endif
 235 #ifdef SSL_OP_TLS_D5_BUG
 236   { US"tls_d5_bug", SSL_OP_TLS_D5_BUG },
 237 #endif
 238 #ifdef SSL_OP_TLS_ROLLBACK_BUG
 239   { US"tls_rollback_bug", SSL_OP_TLS_ROLLBACK_BUG },
 240 #endif
 241 };
 242
 243 #ifndef MACRO_PREDEF
 244 static int exim_openssl_options_size = nelem(exim_openssl_options);
 245 #endif
 246
 247 #ifdef MACRO_PREDEF
 248 void
 249 options_tls(void)
 250 {
 251 uschar buf[64];
 252
 253 for (struct exim_openssl_option * o = exim_openssl_options;
 254      o < exim_openssl_options + nelem(exim_openssl_options); o++)
 255   {
 256   /* Trailing X is workaround for problem with _OPT_OPENSSL_NO_TLSV1
 257   being a ".ifdef _OPT_OPENSSL_NO_TLSV1_3" match */
 258
 259   spf(buf, sizeof(buf), US"_OPT_OPENSSL_%T_X", o->name);
 260   builtin_macro_create(buf);
 261   }
 262
 263 # ifdef EXPERIMENTAL_TLS_RESUME
 264 builtin_macro_create_var(US"_RESUME_DECODE", RESUME_DECODE_STRING );
 265 # endif
 266 # ifdef SSL_OP_NO_TLSv1_3
 267 builtin_macro_create(US"_HAVE_TLS1_3");
 268 # endif
 269 }
 270 #else
 271
 272 /******************************************************************************/
 273
 274 /* Structure for collecting random data for seeding. */
 275
 276 typedef struct randstuff {
 277   struct timeval tv;
 278   pid_t          p;
 279 } randstuff;
 280
 281 /* Local static variables */
 282
 283 static BOOL client_verify_callback_called = FALSE;
 284 static BOOL server_verify_callback_called = FALSE;
 285 static const uschar *sid_ctx = US"exim";
 286
 287 /* We have three different contexts to care about.
 288
 289 Simple case: client, `client_ctx`
 290  As a client, we can be doing a callout or cut-through delivery while receiving
 291  a message.  So we have a client context, which should have options initialised
 292  from the SMTP Transport.  We may also concurrently want to make TLS connections
 293  to utility daemons, so client-contexts are allocated and passed around in call
 294  args rather than using a gobal.
 295
 296 Server:
 297  There are two cases: with and without ServerNameIndication from the client.
 298  Given TLS SNI, we can be using different keys, certs and various other
 299  configuration settings, because they're re-expanded with $tls_sni set.  This
 300  allows vhosting with TLS.  This SNI is sent in the handshake.
 301  A client might not send SNI, so we need a fallback, and an initial setup too.
 302  So as a server, we start out using `server_ctx`.
 303  If SNI is sent by the client, then we as server, mid-negotiation, try to clone
 304  `server_sni` from `server_ctx` and then initialise settings by re-expanding
 305  configuration.
 306 */
 307
 308 typedef struct {
 309   SSL_CTX *     ctx;
 310   SSL *         ssl;
 311   gstring *     corked;
 312 } exim_openssl_client_tls_ctx;
 313
 314 static SSL_CTX *server_ctx = NULL;
 315 static SSL     *server_ssl = NULL;
 316
 317 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
 318 static SSL_CTX *server_sni = NULL;
 319 #endif
 320
 321 static char ssl_errstring[256];
 322
 323 static int  ssl_session_timeout = 7200;         /* Two hours */
 324 static BOOL client_verify_optional = FALSE;
 325 static BOOL server_verify_optional = FALSE;
 326
 327 static BOOL reexpand_tls_files_for_sni = FALSE;
 328
 329
 330 typedef struct ocsp_resp {
 331   struct ocsp_resp *    next;
 332   OCSP_RESPONSE *       resp;
 333 } ocsp_resplist;
 334
 335 typedef struct tls_ext_ctx_cb {
 336   tls_support * tlsp;
 337   uschar *certificate;
 338   uschar *privatekey;
 339   BOOL is_server;
 340 #ifndef DISABLE_OCSP
 341   STACK_OF(X509) *verify_stack;         /* chain for verifying the proof */
 342   union {
 343     struct {
 344       uschar        *file;
 345       const uschar  *file_expanded;
 346       ocsp_resplist *olist;
 347     } server;
 348     struct {
 349       X509_STORE    *verify_store;      /* non-null if status requested */
 350       BOOL          verify_required;
 351     } client;
 352   } u_ocsp;
 353 #endif
 354   uschar *dhparam;
 355   /* these are cached from first expand */
 356   uschar *server_cipher_list;
 357   /* only passed down to tls_error: */
 358   host_item *host;
 359   const uschar * verify_cert_hostnames;
 360 #ifndef DISABLE_EVENT
 361   uschar * event_action;
 362 #endif
 363 } tls_ext_ctx_cb;
 364
 365 /* should figure out a cleanup of API to handle state preserved per
 366 implementation, for various reasons, which can be void * in the APIs.
 367 For now, we hack around it. */
 368 tls_ext_ctx_cb *client_static_cbinfo = NULL;    /*XXX should not use static; multiple concurrent clients! */
 369 tls_ext_ctx_cb *server_static_cbinfo = NULL;
 370
 371 static int
 372 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
 373     int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr );
 374
 375 /* Callbacks */
 376 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
 377 static int tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg);
 378 #endif
 379 #ifndef DISABLE_OCSP
 380 static int tls_server_stapling_cb(SSL *s, void *arg);
 381 #endif
 382
 383
 384
 385 /* Daemon-called, before every connection, key create/rotate */
 386 #ifdef EXPERIMENTAL_TLS_RESUME
 387 static void tk_init(void);
 388 static int tls_exdata_idx = -1;
 389 #endif
 390
 391 void
 392 tls_daemon_init(void)
 393 {
 394 #ifdef EXPERIMENTAL_TLS_RESUME
 395 tk_init();
 396 #endif
 397 return;
 398 }
 399
 400
 401 /*************************************************
 402 *               Handle TLS error                 *
 403 *************************************************/
 404
 405 /* Called from lots of places when errors occur before actually starting to do
 406 the TLS handshake, that is, while the session is still in clear. Always returns
 407 DEFER for a server and FAIL for a client so that most calls can use "return
 408 tls_error(...)" to do this processing and then give an appropriate return. A
 409 single function is used for both server and client, because it is called from
 410 some shared functions.
 411
 412 Argument:
 413   prefix    text to include in the logged error
 414   host      NULL if setting up a server;
 415             the connected host if setting up a client
 416   msg       error message or NULL if we should ask OpenSSL
 417   errstr    pointer to output error message
 418
 419 Returns:    OK/DEFER/FAIL
 420 */
 421
 422 static int
 423 tls_error(uschar * prefix, const host_item * host, uschar * msg, uschar ** errstr)
 424 {
 425 if (!msg)
 426   {
 427   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
 428   msg = US ssl_errstring;
 429   }
 430
 431 msg = string_sprintf("(%s): %s", prefix, msg);
 432 DEBUG(D_tls) debug_printf("TLS error '%s'\n", msg);
 433 if (errstr) *errstr = msg;
 434 return host ? FAIL : DEFER;
 435 }
 436
 437
 438
 439 /*************************************************
 440 *        Callback to generate RSA key            *
 441 *************************************************/
 442
 443 /*
 444 Arguments:
 445   s          SSL connection (not used)
 446   export     not used
 447   keylength  keylength
 448
 449 Returns:     pointer to generated key
 450 */
 451
 452 static RSA *
 453 rsa_callback(SSL *s, int export, int keylength)
 454 {
 455 RSA *rsa_key;
 456 #ifdef EXIM_HAVE_RSA_GENKEY_EX
 457 BIGNUM *bn = BN_new();
 458 #endif
 459
 460 export = export;     /* Shut picky compilers up */
 461 DEBUG(D_tls) debug_printf("Generating %d bit RSA key...\n", keylength);
 462
 463 #ifdef EXIM_HAVE_RSA_GENKEY_EX
 464 if (  !BN_set_word(bn, (unsigned long)RSA_F4)
 465    || !(rsa_key = RSA_new())
 466    || !RSA_generate_key_ex(rsa_key, keylength, bn, NULL)
 467    )
 468 #else
 469 if (!(rsa_key = RSA_generate_key(keylength, RSA_F4, NULL, NULL)))
 470 #endif
 471
 472   {
 473   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
 474   log_write(0, LOG_MAIN|LOG_PANIC, "TLS error (RSA_generate_key): %s",
 475     ssl_errstring);
 476   return NULL;
 477   }
 478 return rsa_key;
 479 }
 480
 481
 482
 483 /* Extreme debug
 484 #ifndef DISABLE_OCSP
 485 void
 486 x509_store_dump_cert_s_names(X509_STORE * store)
 487 {
 488 STACK_OF(X509_OBJECT) * roots= store->objs;
 489 static uschar name[256];
 490
 491 for (int i= 0; i < sk_X509_OBJECT_num(roots); i++)
 492   {
 493   X509_OBJECT * tmp_obj= sk_X509_OBJECT_value(roots, i);
 494   if(tmp_obj->type == X509_LU_X509)
 495     {
 496     X509_NAME * sn = X509_get_subject_name(tmp_obj->data.x509);
 497     if (X509_NAME_oneline(sn, CS name, sizeof(name)))
 498       {
 499       name[sizeof(name)-1] = '\0';
 500       debug_printf(" %s\n", name);
 501       }
 502     }
 503   }
 504 }
 505 #endif
 506 */
 507
 508
 509 #ifndef DISABLE_EVENT
 510 static int
 511 verify_event(tls_support * tlsp, X509 * cert, int depth, const uschar * dn,
 512   BOOL *calledp, const BOOL *optionalp, const uschar * what)
 513 {
 514 uschar * ev;
 515 uschar * yield;
 516 X509 * old_cert;
 517
 518 ev = tlsp == &tls_out ? client_static_cbinfo->event_action : event_action;
 519 if (ev)
 520   {
 521   DEBUG(D_tls) debug_printf("verify_event: %s %d\n", what, depth);
 522   old_cert = tlsp->peercert;
 523   tlsp->peercert = X509_dup(cert);
 524   /* NB we do not bother setting peerdn */
 525   if ((yield = event_raise(ev, US"tls:cert", string_sprintf("%d", depth))))
 526     {
 527     log_write(0, LOG_MAIN, "[%s] %s verify denied by event-action: "
 528                 "depth=%d cert=%s: %s",
 529               tlsp == &tls_out ? deliver_host_address : sender_host_address,
 530               what, depth, dn, yield);
 531     *calledp = TRUE;
 532     if (!*optionalp)
 533       {
 534       if (old_cert) tlsp->peercert = old_cert;  /* restore 1st failing cert */
 535       return 1;                     /* reject (leaving peercert set) */
 536       }
 537     DEBUG(D_tls) debug_printf("Event-action verify failure overridden "
 538       "(host in tls_try_verify_hosts)\n");
 539     tlsp->verify_override = TRUE;
 540     }
 541   X509_free(tlsp->peercert);
 542   tlsp->peercert = old_cert;
 543   }
 544 return 0;
 545 }
 546 #endif
 547
 548 /*************************************************
 549 *        Callback for verification               *
 550 *************************************************/
 551
 552 /* The SSL library does certificate verification if set up to do so. This
 553 callback has the current yes/no state is in "state". If verification succeeded,
 554 we set the certificate-verified flag. If verification failed, what happens
 555 depends on whether the client is required to present a verifiable certificate
 556 or not.
 557
 558 If verification is optional, we change the state to yes, but still log the
 559 verification error. For some reason (it really would help to have proper
 560 documentation of OpenSSL), this callback function then gets called again, this
 561 time with state = 1.  We must take care not to set the private verified flag on
 562 the second time through.
 563
 564 Note: this function is not called if the client fails to present a certificate
 565 when asked. We get here only if a certificate has been received. Handling of
 566 optional verification for this case is done when requesting SSL to verify, by
 567 setting SSL_VERIFY_FAIL_IF_NO_PEER_CERT in the non-optional case.
 568
 569 May be called multiple times for different issues with a certificate, even
 570 for a given "depth" in the certificate chain.
 571
 572 Arguments:
 573   preverify_ok current yes/no state as 1/0
 574   x509ctx      certificate information.
 575   tlsp         per-direction (client vs. server) support data
 576   calledp      has-been-called flag
 577   optionalp    verification-is-optional flag
 578
 579 Returns:     0 if verification should fail, otherwise 1
 580 */
 581
 582 static int
 583 verify_callback(int preverify_ok, X509_STORE_CTX * x509ctx,
 584   tls_support * tlsp, BOOL * calledp, BOOL * optionalp)
 585 {
 586 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
 587 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
 588 uschar dn[256];
 589
 590 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
 591   {
 592   DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
 593   log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
 594     tlsp == &tls_out ? deliver_host_address : sender_host_address);
 595   return 0;
 596   }
 597 dn[sizeof(dn)-1] = '\0';
 598
 599 tlsp->verify_override = FALSE;
 600 if (preverify_ok == 0)
 601   {
 602   uschar * extra = verify_mode ? string_sprintf(" (during %c-verify for [%s])",
 603       *verify_mode, sender_host_address)
 604     : US"";
 605   log_write(0, LOG_MAIN, "[%s] SSL verify error%s: depth=%d error=%s cert=%s",
 606     tlsp == &tls_out ? deliver_host_address : sender_host_address,
 607     extra, depth,
 608     X509_verify_cert_error_string(X509_STORE_CTX_get_error(x509ctx)), dn);
 609   *calledp = TRUE;
 610   if (!*optionalp)
 611     {
 612     if (!tlsp->peercert)
 613       tlsp->peercert = X509_dup(cert);  /* record failing cert */
 614     return 0;                           /* reject */
 615     }
 616   DEBUG(D_tls) debug_printf("SSL verify failure overridden (host in "
 617     "tls_try_verify_hosts)\n");
 618   tlsp->verify_override = TRUE;
 619   }
 620
 621 else if (depth != 0)
 622   {
 623   DEBUG(D_tls) debug_printf("SSL verify ok: depth=%d SN=%s\n", depth, dn);
 624 #ifndef DISABLE_OCSP
 625   if (tlsp == &tls_out && client_static_cbinfo->u_ocsp.client.verify_store)
 626     {   /* client, wanting stapling  */
 627     /* Add the server cert's signing chain as the one
 628     for the verification of the OCSP stapled information. */
 629
 630     if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
 631                              cert))
 632       ERR_clear_error();
 633     sk_X509_push(client_static_cbinfo->verify_stack, cert);
 634     }
 635 #endif
 636 #ifndef DISABLE_EVENT
 637     if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
 638       return 0;                         /* reject, with peercert set */
 639 #endif
 640   }
 641 else
 642   {
 643   const uschar * verify_cert_hostnames;
 644
 645   if (  tlsp == &tls_out
 646      && ((verify_cert_hostnames = client_static_cbinfo->verify_cert_hostnames)))
 647         /* client, wanting hostname check */
 648     {
 649
 650 #ifdef EXIM_HAVE_OPENSSL_CHECKHOST
 651 # ifndef X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
 652 #  define X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS 0
 653 # endif
 654 # ifndef X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS
 655 #  define X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS 0
 656 # endif
 657     int sep = 0;
 658     const uschar * list = verify_cert_hostnames;
 659     uschar * name;
 660     int rc;
 661     while ((name = string_nextinlist(&list, &sep, NULL, 0)))
 662       if ((rc = X509_check_host(cert, CCS name, 0,
 663                   X509_CHECK_FLAG_NO_PARTIAL_WILDCARDS
 664                   | X509_CHECK_FLAG_SINGLE_LABEL_SUBDOMAINS,
 665                   NULL)))
 666         {
 667         if (rc < 0)
 668           {
 669           log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
 670             tlsp == &tls_out ? deliver_host_address : sender_host_address);
 671           name = NULL;
 672           }
 673         break;
 674         }
 675     if (!name)
 676 #else
 677     if (!tls_is_name_for_cert(verify_cert_hostnames, cert))
 678 #endif
 679       {
 680       uschar * extra = verify_mode
 681         ? string_sprintf(" (during %c-verify for [%s])",
 682           *verify_mode, sender_host_address)
 683         : US"";
 684       log_write(0, LOG_MAIN,
 685         "[%s] SSL verify error%s: certificate name mismatch: DN=\"%s\" H=\"%s\"",
 686         tlsp == &tls_out ? deliver_host_address : sender_host_address,
 687         extra, dn, verify_cert_hostnames);
 688       *calledp = TRUE;
 689       if (!*optionalp)
 690         {
 691         if (!tlsp->peercert)
 692           tlsp->peercert = X509_dup(cert);      /* record failing cert */
 693         return 0;                               /* reject */
 694         }
 695       DEBUG(D_tls) debug_printf("SSL verify name failure overridden (host in "
 696         "tls_try_verify_hosts)\n");
 697       tlsp->verify_override = TRUE;
 698       }
 699     }
 700
 701 #ifndef DISABLE_EVENT
 702   if (verify_event(tlsp, cert, depth, dn, calledp, optionalp, US"SSL"))
 703     return 0;                           /* reject, with peercert set */
 704 #endif
 705
 706   DEBUG(D_tls) debug_printf("SSL%s verify ok: depth=0 SN=%s\n",
 707     *calledp ? "" : " authenticated", dn);
 708   *calledp = TRUE;
 709   }
 710
 711 return 1;   /* accept, at least for this level */
 712 }
 713
 714 static int
 715 verify_callback_client(int preverify_ok, X509_STORE_CTX *x509ctx)
 716 {
 717 return verify_callback(preverify_ok, x509ctx, &tls_out,
 718   &client_verify_callback_called, &client_verify_optional);
 719 }
 720
 721 static int
 722 verify_callback_server(int preverify_ok, X509_STORE_CTX *x509ctx)
 723 {
 724 return verify_callback(preverify_ok, x509ctx, &tls_in,
 725   &server_verify_callback_called, &server_verify_optional);
 726 }
 727
 728
 729 #ifdef SUPPORT_DANE
 730
 731 /* This gets called *by* the dane library verify callback, which interposes
 732 itself.
 733 */
 734 static int
 735 verify_callback_client_dane(int preverify_ok, X509_STORE_CTX * x509ctx)
 736 {
 737 X509 * cert = X509_STORE_CTX_get_current_cert(x509ctx);
 738 uschar dn[256];
 739 int depth = X509_STORE_CTX_get_error_depth(x509ctx);
 740 #ifndef DISABLE_EVENT
 741 BOOL dummy_called, optional = FALSE;
 742 #endif
 743
 744 if (!X509_NAME_oneline(X509_get_subject_name(cert), CS dn, sizeof(dn)))
 745   {
 746   DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n");
 747   log_write(0, LOG_MAIN, "[%s] SSL verify error: internal error",
 748     deliver_host_address);
 749   return 0;
 750   }
 751 dn[sizeof(dn)-1] = '\0';
 752
 753 DEBUG(D_tls) debug_printf("verify_callback_client_dane: %s depth %d %s\n",
 754   preverify_ok ? "ok":"BAD", depth, dn);
 755
 756 #ifndef DISABLE_EVENT
 757   if (verify_event(&tls_out, cert, depth, dn,
 758           &dummy_called, &optional, US"DANE"))
 759     return 0;                           /* reject, with peercert set */
 760 #endif
 761
 762 if (preverify_ok == 1)
 763   {
 764   tls_out.dane_verified = TRUE;
 765 #ifndef DISABLE_OCSP
 766   if (client_static_cbinfo->u_ocsp.client.verify_store)
 767     {   /* client, wanting stapling  */
 768     /* Add the server cert's signing chain as the one
 769     for the verification of the OCSP stapled information. */
 770
 771     if (!X509_STORE_add_cert(client_static_cbinfo->u_ocsp.client.verify_store,
 772                              cert))
 773       ERR_clear_error();
 774     sk_X509_push(client_static_cbinfo->verify_stack, cert);
 775     }
 776 #endif
 777   }
 778 else
 779   {
 780   int err = X509_STORE_CTX_get_error(x509ctx);
 781   DEBUG(D_tls)
 782     debug_printf(" - err %d '%s'\n", err, X509_verify_cert_error_string(err));
 783   if (err == X509_V_ERR_APPLICATION_VERIFICATION)
 784     preverify_ok = 1;
 785   }
 786 return preverify_ok;
 787 }
 788
 789 #endif  /*SUPPORT_DANE*/
 790
 791
 792 /*************************************************
 793 *           Information callback                 *
 794 *************************************************/
 795
 796 /* The SSL library functions call this from time to time to indicate what they
 797 are doing. We copy the string to the debugging output when TLS debugging has
 798 been requested.
 799
 800 Arguments:
 801   s         the SSL connection
 802   where
 803   ret
 804
 805 Returns:    nothing
 806 */
 807
 808 static void
 809 info_callback(SSL *s, int where, int ret)
 810 {
 811 DEBUG(D_tls)
 812   {
 813   const uschar * str;
 814
 815   if (where & SSL_ST_CONNECT)
 816      str = US"SSL_connect";
 817   else if (where & SSL_ST_ACCEPT)
 818      str = US"SSL_accept";
 819   else
 820      str = US"SSL info (undefined)";
 821
 822   if (where & SSL_CB_LOOP)
 823      debug_printf("%s: %s\n", str, SSL_state_string_long(s));
 824   else if (where & SSL_CB_ALERT)
 825     debug_printf("SSL3 alert %s:%s:%s\n",
 826           str = where & SSL_CB_READ ? US"read" : US"write",
 827           SSL_alert_type_string_long(ret), SSL_alert_desc_string_long(ret));
 828   else if (where & SSL_CB_EXIT)
 829      if (ret == 0)
 830         debug_printf("%s: failed in %s\n", str, SSL_state_string_long(s));
 831      else if (ret < 0)
 832         debug_printf("%s: error in %s\n", str, SSL_state_string_long(s));
 833   else if (where & SSL_CB_HANDSHAKE_START)
 834      debug_printf("%s: hshake start: %s\n", str, SSL_state_string_long(s));
 835   else if (where & SSL_CB_HANDSHAKE_DONE)
 836      debug_printf("%s: hshake done: %s\n", str, SSL_state_string_long(s));
 837   }
 838 }
 839
 840 #ifdef OPENSSL_HAVE_KEYLOG_CB
 841 static void
 842 keylog_callback(const SSL *ssl, const char *line)
 843 {
 844 char * filename;
 845 FILE * fp;
 846 DEBUG(D_tls) debug_printf("%.200s\n", line);
 847 if (!(filename = getenv("SSLKEYLOGFILE"))) return;
 848 if (!(fp = fopen(filename, "a"))) return;
 849 fprintf(fp, "%s\n", line);
 850 fclose(fp);
 851 }
 852 #endif
 853
 854
 855 #ifdef EXPERIMENTAL_TLS_RESUME
 856 /* Manage the keysets used for encrypting the session tickets, on the server. */
 857
 858 typedef struct {                        /* Session ticket encryption key */
 859   uschar        name[16];
 860
 861   const EVP_CIPHER *    aes_cipher;
 862   uschar                aes_key[32];    /* size needed depends on cipher. aes_128 implies 128/8 = 16? */
 863   const EVP_MD *        hmac_hash;
 864   uschar                hmac_key[16];
 865   time_t                renew;
 866   time_t                expire;
 867 } exim_stek;
 868
 869 static exim_stek exim_tk;       /* current key */
 870 static exim_stek exim_tk_old;   /* previous key */
 871
 872 static void
 873 tk_init(void)
 874 {
 875 time_t t = time(NULL);
 876
 877 if (exim_tk.name[0])
 878   {
 879   if (exim_tk.renew >= t) return;
 880   exim_tk_old = exim_tk;
 881   }
 882
 883 if (f.running_in_test_harness) ssl_session_timeout = 6;
 884
 885 DEBUG(D_tls) debug_printf("OpenSSL: %s STEK\n", exim_tk.name[0] ? "rotating" : "creating");
 886 if (RAND_bytes(exim_tk.aes_key, sizeof(exim_tk.aes_key)) <= 0) return;
 887 if (RAND_bytes(exim_tk.hmac_key, sizeof(exim_tk.hmac_key)) <= 0) return;
 888 if (RAND_bytes(exim_tk.name+1, sizeof(exim_tk.name)-1) <= 0) return;
 889
 890 exim_tk.name[0] = 'E';
 891 exim_tk.aes_cipher = EVP_aes_256_cbc();
 892 exim_tk.hmac_hash = EVP_sha256();
 893 exim_tk.expire = t + ssl_session_timeout;
 894 exim_tk.renew = t + ssl_session_timeout/2;
 895 }
 896
 897 static exim_stek *
 898 tk_current(void)
 899 {
 900 if (!exim_tk.name[0]) return NULL;
 901 return &exim_tk;
 902 }
 903
 904 static exim_stek *
 905 tk_find(const uschar * name)
 906 {
 907 return memcmp(name, exim_tk.name, sizeof(exim_tk.name)) == 0 ? &exim_tk
 908   : memcmp(name, exim_tk_old.name, sizeof(exim_tk_old.name)) == 0 ? &exim_tk_old
 909   : NULL;
 910 }
 911
 912 /* Callback for session tickets, on server */
 913 static int
 914 ticket_key_callback(SSL * ssl, uschar key_name[16],
 915   uschar * iv, EVP_CIPHER_CTX * ctx, HMAC_CTX * hctx, int enc)
 916 {
 917 tls_support * tlsp = server_static_cbinfo->tlsp;
 918 exim_stek * key;
 919
 920 if (enc)
 921   {
 922   DEBUG(D_tls) debug_printf("ticket_key_callback: create new session\n");
 923   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
 924
 925   if (RAND_bytes(iv, EVP_MAX_IV_LENGTH) <= 0)
 926     return -1; /* insufficient random */
 927
 928   if (!(key = tk_current()))    /* current key doesn't exist or isn't valid */
 929      return 0;                  /* key couldn't be created */
 930   memcpy(key_name, key->name, 16);
 931   DEBUG(D_tls) debug_printf("STEK expire " TIME_T_FMT "\n", key->expire - time(NULL));
 932
 933   /*XXX will want these dependent on the ssl session strength */
 934   HMAC_Init_ex(hctx, key->hmac_key, sizeof(key->hmac_key),
 935                 key->hmac_hash, NULL);
 936   EVP_EncryptInit_ex(ctx, key->aes_cipher, NULL, key->aes_key, iv);
 937
 938   DEBUG(D_tls) debug_printf("ticket created\n");
 939   return 1;
 940   }
 941 else
 942   {
 943   time_t now = time(NULL);
 944
 945   DEBUG(D_tls) debug_printf("ticket_key_callback: retrieve session\n");
 946   tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
 947
 948   if (!(key = tk_find(key_name)) || key->expire < now)
 949     {
 950     DEBUG(D_tls)
 951       {
 952       debug_printf("ticket not usable (%s)\n", key ? "expired" : "not found");
 953       if (key) debug_printf("STEK expire " TIME_T_FMT "\n", key->expire - now);
 954       }
 955     return 0;
 956     }
 957
 958   HMAC_Init_ex(hctx, key->hmac_key, sizeof(key->hmac_key),
 959                 key->hmac_hash, NULL);
 960   EVP_DecryptInit_ex(ctx, key->aes_cipher, NULL, key->aes_key, iv);
 961
 962   DEBUG(D_tls) debug_printf("ticket usable, STEK expire " TIME_T_FMT "\n", key->expire - now);
 963
 964   /* The ticket lifetime and renewal are the same as the STEK lifetime and
 965   renewal, which is overenthusiastic.  A factor of, say, 3x longer STEK would
 966   be better.  To do that we'd have to encode ticket lifetime in the name as
 967   we don't yet see the restored session.  Could check posthandshake for TLS1.3
 968   and trigger a new ticket then, but cannot do that for TLS1.2 */
 969   return key->renew < now ? 2 : 1;
 970   }
 971 }
 972 #endif
 973
 974
 975
 976 /*************************************************
 977 *                Initialize for DH               *
 978 *************************************************/
 979
 980 /* If dhparam is set, expand it, and load up the parameters for DH encryption.
 981
 982 Arguments:
 983   sctx      The current SSL CTX (inbound or outbound)
 984   dhparam   DH parameter file or fixed parameter identity string
 985   host      connected host, if client; NULL if server
 986   errstr    error string pointer
 987
 988 Returns:    TRUE if OK (nothing to set up, or setup worked)
 989 */
 990
 991 static BOOL
 992 init_dh(SSL_CTX *sctx, uschar *dhparam, const host_item *host, uschar ** errstr)
 993 {
 994 BIO *bio;
 995 DH *dh;
 996 uschar *dhexpanded;
 997 const char *pem;
 998 int dh_bitsize;
 999
1000 if (!expand_check(dhparam, US"tls_dhparam", &dhexpanded, errstr))
1001   return FALSE;
1002
1003 if (!dhexpanded || !*dhexpanded)
1004   bio = BIO_new_mem_buf(CS std_dh_prime_default(), -1);
1005 else if (dhexpanded[0] == '/')
1006   {
1007   if (!(bio = BIO_new_file(CS dhexpanded, "r")))
1008     {
1009     tls_error(string_sprintf("could not read dhparams file %s", dhexpanded),
1010           host, US strerror(errno), errstr);
1011     return FALSE;
1012     }
1013   }
1014 else
1015   {
1016   if (Ustrcmp(dhexpanded, "none") == 0)
1017     {
1018     DEBUG(D_tls) debug_printf("Requested no DH parameters.\n");
1019     return TRUE;
1020     }
1021
1022   if (!(pem = std_dh_prime_named(dhexpanded)))
1023     {
1024     tls_error(string_sprintf("Unknown standard DH prime \"%s\"", dhexpanded),
1025         host, US strerror(errno), errstr);
1026     return FALSE;
1027     }
1028   bio = BIO_new_mem_buf(CS pem, -1);
1029   }
1030
1031 if (!(dh = PEM_read_bio_DHparams(bio, NULL, NULL, NULL)))
1032   {
1033   BIO_free(bio);
1034   tls_error(string_sprintf("Could not read tls_dhparams \"%s\"", dhexpanded),
1035       host, NULL, errstr);
1036   return FALSE;
1037   }
1038
1039 /* note: our default limit of 2236 is not a multiple of 8; the limit comes from
1040  * an NSS limit, and the GnuTLS APIs handle bit-sizes fine, so we went with
1041  * 2236.  But older OpenSSL can only report in bytes (octets), not bits.
1042  * If someone wants to dance at the edge, then they can raise the limit or use
1043  * current libraries. */
1044 #ifdef EXIM_HAVE_OPENSSL_DH_BITS
1045 /* Added in commit 26c79d5641d; `git describe --contains` says OpenSSL_1_1_0-pre1~1022
1046  * This predates OpenSSL_1_1_0 (before a, b, ...) so is in all 1.1.0 */
1047 dh_bitsize = DH_bits(dh);
1048 #else
1049 dh_bitsize = 8 * DH_size(dh);
1050 #endif
1051
1052 /* Even if it is larger, we silently return success rather than cause things
1053  * to fail out, so that a too-large DH will not knock out all TLS; it's a
1054  * debatable choice. */
1055 if (dh_bitsize > tls_dh_max_bits)
1056   {
1057   DEBUG(D_tls)
1058     debug_printf("dhparams file %d bits, is > tls_dh_max_bits limit of %d\n",
1059         dh_bitsize, tls_dh_max_bits);
1060   }
1061 else
1062   {
1063   SSL_CTX_set_tmp_dh(sctx, dh);
1064   DEBUG(D_tls)
1065     debug_printf("Diffie-Hellman initialized from %s with %d-bit prime\n",
1066       dhexpanded ? dhexpanded : US"default", dh_bitsize);
1067   }
1068
1069 DH_free(dh);
1070 BIO_free(bio);
1071
1072 return TRUE;
1073 }
1074
1075
1076
1077
1078 /*************************************************
1079 *               Initialize for ECDH              *
1080 *************************************************/
1081
1082 /* Load parameters for ECDH encryption.
1083
1084 For now, we stick to NIST P-256 because: it's simple and easy to configure;
1085 it avoids any patent issues that might bite redistributors; despite events in
1086 the news and concerns over curve choices, we're not cryptographers, we're not
1087 pretending to be, and this is "good enough" to be better than no support,
1088 protecting against most adversaries.  Given another year or two, there might
1089 be sufficient clarity about a "right" way forward to let us make an informed
1090 decision, instead of a knee-jerk reaction.
1091
1092 Longer-term, we should look at supporting both various named curves and
1093 external files generated with "openssl ecparam", much as we do for init_dh().
1094 We should also support "none" as a value, to explicitly avoid initialisation.
1095
1096 Patches welcome.
1097
1098 Arguments:
1099   sctx      The current SSL CTX (inbound or outbound)
1100   host      connected host, if client; NULL if server
1101   errstr    error string pointer
1102
1103 Returns:    TRUE if OK (nothing to set up, or setup worked)
1104 */
1105
1106 static BOOL
1107 init_ecdh(SSL_CTX * sctx, host_item * host, uschar ** errstr)
1108 {
1109 #ifdef OPENSSL_NO_ECDH
1110 return TRUE;
1111 #else
1112
1113 EC_KEY * ecdh;
1114 uschar * exp_curve;
1115 int nid;
1116 BOOL rv;
1117
1118 if (host)       /* No ECDH setup for clients, only for servers */
1119   return TRUE;
1120
1121 # ifndef EXIM_HAVE_ECDH
1122 DEBUG(D_tls)
1123   debug_printf("No OpenSSL API to define ECDH parameters, skipping\n");
1124 return TRUE;
1125 # else
1126
1127 if (!expand_check(tls_eccurve, US"tls_eccurve", &exp_curve, errstr))
1128   return FALSE;
1129 if (!exp_curve || !*exp_curve)
1130   return TRUE;
1131
1132 /* "auto" needs to be handled carefully.
1133  * OpenSSL <  1.0.2: we do not select anything, but fallback to prime256v1
1134  * OpenSSL <  1.1.0: we have to call SSL_CTX_set_ecdh_auto
1135  *                   (openssl/ssl.h defines SSL_CTRL_SET_ECDH_AUTO)
1136  * OpenSSL >= 1.1.0: we do not set anything, the libray does autoselection
1137  *                   https://github.com/openssl/openssl/commit/fe6ef2472db933f01b59cad82aa925736935984b
1138  */
1139 if (Ustrcmp(exp_curve, "auto") == 0)
1140   {
1141 #if OPENSSL_VERSION_NUMBER < 0x10002000L
1142   DEBUG(D_tls) debug_printf(
1143     "ECDH OpenSSL < 1.0.2: temp key parameter settings: overriding \"auto\" with \"prime256v1\"\n");
1144   exp_curve = US"prime256v1";
1145 #else
1146 # if defined SSL_CTRL_SET_ECDH_AUTO
1147   DEBUG(D_tls) debug_printf(
1148     "ECDH OpenSSL 1.0.2+ temp key parameter settings: autoselection\n");
1149   SSL_CTX_set_ecdh_auto(sctx, 1);
1150   return TRUE;
1151 # else
1152   DEBUG(D_tls) debug_printf(
1153     "ECDH OpenSSL 1.1.0+ temp key parameter settings: default selection\n");
1154   return TRUE;
1155 # endif
1156 #endif
1157   }
1158
1159 DEBUG(D_tls) debug_printf("ECDH: curve '%s'\n", exp_curve);
1160 if (  (nid = OBJ_sn2nid       (CCS exp_curve)) == NID_undef
1161 #   ifdef EXIM_HAVE_OPENSSL_EC_NIST2NID
1162    && (nid = EC_curve_nist2nid(CCS exp_curve)) == NID_undef
1163 #   endif
1164    )
1165   {
1166   tls_error(string_sprintf("Unknown curve name tls_eccurve '%s'", exp_curve),
1167     host, NULL, errstr);
1168   return FALSE;
1169   }
1170
1171 if (!(ecdh = EC_KEY_new_by_curve_name(nid)))
1172   {
1173   tls_error(US"Unable to create ec curve", host, NULL, errstr);
1174   return FALSE;
1175   }
1176
1177 /* The "tmp" in the name here refers to setting a temporary key
1178 not to the stability of the interface. */
1179
1180 if ((rv = SSL_CTX_set_tmp_ecdh(sctx, ecdh) == 0))
1181   tls_error(string_sprintf("Error enabling '%s' curve", exp_curve), host, NULL, errstr);
1182 else
1183   DEBUG(D_tls) debug_printf("ECDH: enabled '%s' curve\n", exp_curve);
1184
1185 EC_KEY_free(ecdh);
1186 return !rv;
1187
1188 # endif /*EXIM_HAVE_ECDH*/
1189 #endif /*OPENSSL_NO_ECDH*/
1190 }
1191
1192
1193
1194
1195 #ifndef DISABLE_OCSP
1196 /*************************************************
1197 *       Load OCSP information into state         *
1198 *************************************************/
1199 /* Called to load the server OCSP response from the given file into memory, once
1200 caller has determined this is needed.  Checks validity.  Debugs a message
1201 if invalid.
1202
1203 ASSUMES: single response, for single cert.
1204
1205 Arguments:
1206   sctx            the SSL_CTX* to update
1207   cbinfo          various parts of session state
1208   filename        the filename putatively holding an OCSP response
1209
1210 */
1211
1212 static void
1213 ocsp_load_response(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo,
1214   const uschar * filename)
1215 {
1216 BIO * bio;
1217 OCSP_RESPONSE * resp;
1218 OCSP_BASICRESP * basic_response;
1219 OCSP_SINGLERESP * single_response;
1220 ASN1_GENERALIZEDTIME * rev, * thisupd, * nextupd;
1221 STACK_OF(X509) * sk;
1222 unsigned long verify_flags;
1223 int status, reason, i;
1224
1225 DEBUG(D_tls) debug_printf("tls_ocsp_file        '%s'\n", filename);
1226
1227 if (!(bio = BIO_new_file(CS filename, "rb")))
1228   {
1229   DEBUG(D_tls) debug_printf("Failed to open OCSP response file \"%s\"\n",
1230       filename);
1231   return;
1232   }
1233
1234 resp = d2i_OCSP_RESPONSE_bio(bio, NULL);
1235 BIO_free(bio);
1236 if (!resp)
1237   {
1238   DEBUG(D_tls) debug_printf("Error reading OCSP response.\n");
1239   return;
1240   }
1241
1242 if ((status = OCSP_response_status(resp)) != OCSP_RESPONSE_STATUS_SUCCESSFUL)
1243   {
1244   DEBUG(D_tls) debug_printf("OCSP response not valid: %s (%d)\n",
1245       OCSP_response_status_str(status), status);
1246   goto bad;
1247   }
1248
1249 #ifdef notdef
1250   {
1251   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
1252   OCSP_RESPONSE_print(bp, resp, 0);  /* extreme debug: stapling content */
1253   BIO_free(bp);
1254   }
1255 #endif
1256
1257 if (!(basic_response = OCSP_response_get1_basic(resp)))
1258   {
1259   DEBUG(D_tls)
1260     debug_printf("OCSP response parse error: unable to extract basic response.\n");
1261   goto bad;
1262   }
1263
1264 sk = cbinfo->verify_stack;
1265 verify_flags = OCSP_NOVERIFY; /* check sigs, but not purpose */
1266
1267 /* May need to expose ability to adjust those flags?
1268 OCSP_NOSIGS OCSP_NOVERIFY OCSP_NOCHAIN OCSP_NOCHECKS OCSP_NOEXPLICIT
1269 OCSP_TRUSTOTHER OCSP_NOINTERN */
1270
1271 /* This does a full verify on the OCSP proof before we load it for serving
1272 up; possibly overkill - just date-checks might be nice enough.
1273
1274 OCSP_basic_verify takes a "store" arg, but does not
1275 use it for the chain verification, which is all we do
1276 when OCSP_NOVERIFY is set.  The content from the wire
1277 "basic_response" and a cert-stack "sk" are all that is used.
1278
1279 We have a stack, loaded in setup_certs() if tls_verify_certificates
1280 was a file (not a directory, or "system").  It is unfortunate we
1281 cannot used the connection context store, as that would neatly
1282 handle the "system" case too, but there seems to be no library
1283 function for getting a stack from a store.
1284 [ In OpenSSL 1.1 - ?  X509_STORE_CTX_get0_chain(ctx) ? ]
1285 We do not free the stack since it could be needed a second time for
1286 SNI handling.
1287
1288 Separately we might try to replace using OCSP_basic_verify() - which seems to not
1289 be a public interface into the OpenSSL library (there's no manual entry) -
1290 But what with?  We also use OCSP_basic_verify in the client stapling callback.
1291 And there we NEED it; we must verify that status... unless the
1292 library does it for us anyway?  */
1293
1294 if ((i = OCSP_basic_verify(basic_response, sk, NULL, verify_flags)) < 0)
1295   {
1296   DEBUG(D_tls)
1297     {
1298     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
1299     debug_printf("OCSP response verify failure: %s\n", US ssl_errstring);
1300     }
1301   goto bad;
1302   }
1303
1304 /* Here's the simplifying assumption: there's only one response, for the
1305 one certificate we use, and nothing for anything else in a chain.  If this
1306 proves false, we need to extract a cert id from our issued cert
1307 (tls_certificate) and use that for OCSP_resp_find_status() (which finds the
1308 right cert in the stack and then calls OCSP_single_get0_status()).
1309
1310 I'm hoping to avoid reworking a bunch more of how we handle state here.
1311
1312 XXX that will change when we add support for (TLS1.3) whole-chain stapling
1313 */
1314
1315 if (!(single_response = OCSP_resp_get0(basic_response, 0)))
1316   {
1317   DEBUG(D_tls)
1318     debug_printf("Unable to get first response from OCSP basic response.\n");
1319   goto bad;
1320   }
1321
1322 status = OCSP_single_get0_status(single_response, &reason, &rev, &thisupd, &nextupd);
1323 if (status != V_OCSP_CERTSTATUS_GOOD)
1324   {
1325   DEBUG(D_tls) debug_printf("OCSP response bad cert status: %s (%d) %s (%d)\n",
1326       OCSP_cert_status_str(status), status,
1327       OCSP_crl_reason_str(reason), reason);
1328   goto bad;
1329   }
1330
1331 if (!OCSP_check_validity(thisupd, nextupd, EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1332   {
1333   DEBUG(D_tls) debug_printf("OCSP status invalid times.\n");
1334   goto bad;
1335   }
1336
1337 supply_response:
1338   /* Add the resp to the list used by tls_server_stapling_cb() */
1339   {
1340   ocsp_resplist ** op = &cbinfo->u_ocsp.server.olist, * oentry;
1341   while (oentry = *op)
1342     op = &oentry->next;
1343   *op = oentry = store_get(sizeof(ocsp_resplist), FALSE);
1344   oentry->next = NULL;
1345   oentry->resp = resp;
1346   }
1347 return;
1348
1349 bad:
1350   if (f.running_in_test_harness)
1351     {
1352     extern char ** environ;
1353     if (environ) for (uschar ** p = USS environ; *p; p++)
1354       if (Ustrncmp(*p, "EXIM_TESTHARNESS_DISABLE_OCSPVALIDITYCHECK", 42) == 0)
1355         {
1356         DEBUG(D_tls) debug_printf("Supplying known bad OCSP response\n");
1357         goto supply_response;
1358         }
1359     }
1360 return;
1361 }
1362
1363
1364 static void
1365 ocsp_free_response_list(tls_ext_ctx_cb * cbinfo)
1366 {
1367 for (ocsp_resplist * olist = cbinfo->u_ocsp.server.olist; olist;
1368      olist = olist->next)
1369   OCSP_RESPONSE_free(olist->resp);
1370 cbinfo->u_ocsp.server.olist = NULL;
1371 }
1372 #endif  /*!DISABLE_OCSP*/
1373
1374
1375
1376
1377 /* Create and install a selfsigned certificate, for use in server mode */
1378
1379 static int
1380 tls_install_selfsign(SSL_CTX * sctx, uschar ** errstr)
1381 {
1382 X509 * x509 = NULL;
1383 EVP_PKEY * pkey;
1384 RSA * rsa;
1385 X509_NAME * name;
1386 uschar * where;
1387
1388 where = US"allocating pkey";
1389 if (!(pkey = EVP_PKEY_new()))
1390   goto err;
1391
1392 where = US"allocating cert";
1393 if (!(x509 = X509_new()))
1394   goto err;
1395
1396 where = US"generating pkey";
1397 if (!(rsa = rsa_callback(NULL, 0, 2048)))
1398   goto err;
1399
1400 where = US"assigning pkey";
1401 if (!EVP_PKEY_assign_RSA(pkey, rsa))
1402   goto err;
1403
1404 X509_set_version(x509, 2);                              /* N+1 - version 3 */
1405 ASN1_INTEGER_set(X509_get_serialNumber(x509), 1);
1406 X509_gmtime_adj(X509_get_notBefore(x509), 0);
1407 X509_gmtime_adj(X509_get_notAfter(x509), (long)60 * 60);        /* 1 hour */
1408 X509_set_pubkey(x509, pkey);
1409
1410 name = X509_get_subject_name(x509);
1411 X509_NAME_add_entry_by_txt(name, "C",
1412                           MBSTRING_ASC, CUS "UK", -1, -1, 0);
1413 X509_NAME_add_entry_by_txt(name, "O",
1414                           MBSTRING_ASC, CUS "Exim Developers", -1, -1, 0);
1415 X509_NAME_add_entry_by_txt(name, "CN",
1416                           MBSTRING_ASC, CUS smtp_active_hostname, -1, -1, 0);
1417 X509_set_issuer_name(x509, name);
1418
1419 where = US"signing cert";
1420 if (!X509_sign(x509, pkey, EVP_md5()))
1421   goto err;
1422
1423 where = US"installing selfsign cert";
1424 if (!SSL_CTX_use_certificate(sctx, x509))
1425   goto err;
1426
1427 where = US"installing selfsign key";
1428 if (!SSL_CTX_use_PrivateKey(sctx, pkey))
1429   goto err;
1430
1431 return OK;
1432
1433 err:
1434   (void) tls_error(where, NULL, NULL, errstr);
1435   if (x509) X509_free(x509);
1436   if (pkey) EVP_PKEY_free(pkey);
1437   return DEFER;
1438 }
1439
1440
1441
1442
1443 static int
1444 tls_add_certfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1445   uschar ** errstr)
1446 {
1447 DEBUG(D_tls) debug_printf("tls_certificate file '%s'\n", file);
1448 if (!SSL_CTX_use_certificate_chain_file(sctx, CS file))
1449   return tls_error(string_sprintf(
1450     "SSL_CTX_use_certificate_chain_file file=%s", file),
1451       cbinfo->host, NULL, errstr);
1452 return 0;
1453 }
1454
1455 static int
1456 tls_add_pkeyfile(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo, uschar * file,
1457   uschar ** errstr)
1458 {
1459 DEBUG(D_tls) debug_printf("tls_privatekey file  '%s'\n", file);
1460 if (!SSL_CTX_use_PrivateKey_file(sctx, CS file, SSL_FILETYPE_PEM))
1461   return tls_error(string_sprintf(
1462     "SSL_CTX_use_PrivateKey_file file=%s", file), cbinfo->host, NULL, errstr);
1463 return 0;
1464 }
1465
1466
1467 /*************************************************
1468 *        Expand key and cert file specs          *
1469 *************************************************/
1470
1471 /* Called once during tls_init and possibly again during TLS setup, for a
1472 new context, if Server Name Indication was used and tls_sni was seen in
1473 the certificate string.
1474
1475 Arguments:
1476   sctx            the SSL_CTX* to update
1477   cbinfo          various parts of session state
1478   errstr          error string pointer
1479
1480 Returns:          OK/DEFER/FAIL
1481 */
1482
1483 static int
1484 tls_expand_session_files(SSL_CTX * sctx, tls_ext_ctx_cb * cbinfo,
1485   uschar ** errstr)
1486 {
1487 uschar * expanded;
1488
1489 if (!cbinfo->certificate)
1490   {
1491   if (!cbinfo->is_server)               /* client */
1492     return OK;
1493                                         /* server */
1494   if (tls_install_selfsign(sctx, errstr) != OK)
1495     return DEFER;
1496   }
1497 else
1498   {
1499   int err;
1500
1501   if ( !reexpand_tls_files_for_sni
1502      && (  Ustrstr(cbinfo->certificate, US"tls_sni")
1503         || Ustrstr(cbinfo->certificate, US"tls_in_sni")
1504         || Ustrstr(cbinfo->certificate, US"tls_out_sni")
1505      )  )
1506     reexpand_tls_files_for_sni = TRUE;
1507
1508   if (!expand_check(cbinfo->certificate, US"tls_certificate", &expanded, errstr))
1509     return DEFER;
1510
1511   if (expanded)
1512     if (cbinfo->is_server)
1513       {
1514       const uschar * file_list = expanded;
1515       int sep = 0;
1516       uschar * file;
1517 #ifndef DISABLE_OCSP
1518       const uschar * olist = cbinfo->u_ocsp.server.file;
1519       int osep = 0;
1520       uschar * ofile;
1521
1522       if (olist)
1523         if (!expand_check(olist, US"tls_ocsp_file", USS &olist, errstr))
1524           return DEFER;
1525       if (olist && !*olist)
1526         olist = NULL;
1527
1528       if (  cbinfo->u_ocsp.server.file_expanded && olist
1529          && (Ustrcmp(olist, cbinfo->u_ocsp.server.file_expanded) == 0))
1530         {
1531         DEBUG(D_tls) debug_printf(" - value unchanged, using existing values\n");
1532         olist = NULL;
1533         }
1534       else
1535         {
1536         ocsp_free_response_list(cbinfo);
1537         cbinfo->u_ocsp.server.file_expanded = olist;
1538         }
1539 #endif
1540
1541       while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1542         {
1543         if ((err = tls_add_certfile(sctx, cbinfo, file, errstr)))
1544           return err;
1545
1546 #ifndef DISABLE_OCSP
1547         if (olist)
1548           if ((ofile = string_nextinlist(&olist, &osep, NULL, 0)))
1549             ocsp_load_response(sctx, cbinfo, ofile);
1550           else
1551             DEBUG(D_tls) debug_printf("ran out of ocsp file list\n");
1552 #endif
1553         }
1554       }
1555     else        /* would there ever be a need for multiple client certs? */
1556       if ((err = tls_add_certfile(sctx, cbinfo, expanded, errstr)))
1557         return err;
1558
1559   if (  cbinfo->privatekey
1560      && !expand_check(cbinfo->privatekey, US"tls_privatekey", &expanded, errstr))
1561     return DEFER;
1562
1563   /* If expansion was forced to fail, key_expanded will be NULL. If the result
1564   of the expansion is an empty string, ignore it also, and assume the private
1565   key is in the same file as the certificate. */
1566
1567   if (expanded && *expanded)
1568     if (cbinfo->is_server)
1569       {
1570       const uschar * file_list = expanded;
1571       int sep = 0;
1572       uschar * file;
1573
1574       while (file = string_nextinlist(&file_list, &sep, NULL, 0))
1575         if ((err = tls_add_pkeyfile(sctx, cbinfo, file, errstr)))
1576           return err;
1577       }
1578     else        /* would there ever be a need for multiple client certs? */
1579       if ((err = tls_add_pkeyfile(sctx, cbinfo, expanded, errstr)))
1580         return err;
1581   }
1582
1583 return OK;
1584 }
1585
1586
1587
1588
1589 /*************************************************
1590 *            Callback to handle SNI              *
1591 *************************************************/
1592
1593 /* Called when acting as server during the TLS session setup if a Server Name
1594 Indication extension was sent by the client.
1595
1596 API documentation is OpenSSL s_server.c implementation.
1597
1598 Arguments:
1599   s               SSL* of the current session
1600   ad              unknown (part of OpenSSL API) (unused)
1601   arg             Callback of "our" registered data
1602
1603 Returns:          SSL_TLSEXT_ERR_{OK,ALERT_WARNING,ALERT_FATAL,NOACK}
1604
1605 XXX might need to change to using ClientHello callback,
1606 per https://www.openssl.org/docs/manmaster/man3/SSL_client_hello_cb_fn.html
1607 */
1608
1609 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
1610 static int
1611 tls_servername_cb(SSL *s, int *ad ARG_UNUSED, void *arg)
1612 {
1613 const char *servername = SSL_get_servername(s, TLSEXT_NAMETYPE_host_name);
1614 tls_ext_ctx_cb *cbinfo = (tls_ext_ctx_cb *) arg;
1615 int rc;
1616 int old_pool = store_pool;
1617 uschar * dummy_errstr;
1618
1619 if (!servername)
1620   return SSL_TLSEXT_ERR_OK;
1621
1622 DEBUG(D_tls) debug_printf("Received TLS SNI \"%s\"%s\n", servername,
1623     reexpand_tls_files_for_sni ? "" : " (unused for certificate selection)");
1624
1625 /* Make the extension value available for expansion */
1626 store_pool = POOL_PERM;
1627 tls_in.sni = string_copy_taint(US servername, TRUE);
1628 store_pool = old_pool;
1629
1630 if (!reexpand_tls_files_for_sni)
1631   return SSL_TLSEXT_ERR_OK;
1632
1633 /* Can't find an SSL_CTX_clone() or equivalent, so we do it manually;
1634 not confident that memcpy wouldn't break some internal reference counting.
1635 Especially since there's a references struct member, which would be off. */
1636
1637 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
1638 if (!(server_sni = SSL_CTX_new(TLS_server_method())))
1639 #else
1640 if (!(server_sni = SSL_CTX_new(SSLv23_server_method())))
1641 #endif
1642   {
1643   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
1644   DEBUG(D_tls) debug_printf("SSL_CTX_new() failed: %s\n", ssl_errstring);
1645   goto bad;
1646   }
1647
1648 /* Not sure how many of these are actually needed, since SSL object
1649 already exists.  Might even need this selfsame callback, for reneg? */
1650
1651 SSL_CTX_set_info_callback(server_sni, SSL_CTX_get_info_callback(server_ctx));
1652 SSL_CTX_set_mode(server_sni, SSL_CTX_get_mode(server_ctx));
1653 SSL_CTX_set_options(server_sni, SSL_CTX_get_options(server_ctx));
1654 SSL_CTX_set_timeout(server_sni, SSL_CTX_get_timeout(server_ctx));
1655 SSL_CTX_set_tlsext_servername_callback(server_sni, tls_servername_cb);
1656 SSL_CTX_set_tlsext_servername_arg(server_sni, cbinfo);
1657
1658 if (  !init_dh(server_sni, cbinfo->dhparam, NULL, &dummy_errstr)
1659    || !init_ecdh(server_sni, NULL, &dummy_errstr)
1660    )
1661   goto bad;
1662
1663 if (  cbinfo->server_cipher_list
1664    && !SSL_CTX_set_cipher_list(server_sni, CS cbinfo->server_cipher_list))
1665   goto bad;
1666
1667 #ifndef DISABLE_OCSP
1668 if (cbinfo->u_ocsp.server.file)
1669   {
1670   SSL_CTX_set_tlsext_status_cb(server_sni, tls_server_stapling_cb);
1671   SSL_CTX_set_tlsext_status_arg(server_sni, cbinfo);
1672   }
1673 #endif
1674
1675 if ((rc = setup_certs(server_sni, tls_verify_certificates, tls_crl, NULL, FALSE,
1676                       verify_callback_server, &dummy_errstr)) != OK)
1677   goto bad;
1678
1679 /* do this after setup_certs, because this can require the certs for verifying
1680 OCSP information. */
1681 if ((rc = tls_expand_session_files(server_sni, cbinfo, &dummy_errstr)) != OK)
1682   goto bad;
1683
1684 DEBUG(D_tls) debug_printf("Switching SSL context.\n");
1685 SSL_set_SSL_CTX(s, server_sni);
1686 return SSL_TLSEXT_ERR_OK;
1687
1688 bad: return SSL_TLSEXT_ERR_ALERT_FATAL;
1689 }
1690 #endif /* EXIM_HAVE_OPENSSL_TLSEXT */
1691
1692
1693
1694
1695 #ifndef DISABLE_OCSP
1696
1697 /*************************************************
1698 *        Callback to handle OCSP Stapling        *
1699 *************************************************/
1700
1701 /* Called when acting as server during the TLS session setup if the client
1702 requests OCSP information with a Certificate Status Request.
1703
1704 Documentation via openssl s_server.c and the Apache patch from the OpenSSL
1705 project.
1706
1707 */
1708
1709 static int
1710 tls_server_stapling_cb(SSL *s, void *arg)
1711 {
1712 const tls_ext_ctx_cb * cbinfo = (tls_ext_ctx_cb *) arg;
1713 ocsp_resplist * olist = cbinfo->u_ocsp.server.olist;
1714 uschar * response_der;  /*XXX blob */
1715 int response_der_len;
1716
1717 DEBUG(D_tls)
1718   debug_printf("Received TLS status request (OCSP stapling); %s response list\n",
1719     olist ? "have" : "lack");
1720
1721 tls_in.ocsp = OCSP_NOT_RESP;
1722 if (!olist)
1723   return SSL_TLSEXT_ERR_NOACK;
1724
1725 #ifdef EXIM_HAVE_OPESSL_GET0_SERIAL
1726  {
1727   const X509 * cert_sent = SSL_get_certificate(s);
1728   const ASN1_INTEGER * cert_serial = X509_get0_serialNumber(cert_sent);
1729   const BIGNUM * cert_bn = ASN1_INTEGER_to_BN(cert_serial, NULL);
1730   const X509_NAME * cert_issuer = X509_get_issuer_name(cert_sent);
1731   uschar * chash;
1732   uint chash_len;
1733
1734   for (; olist; olist = olist->next)
1735     {
1736     OCSP_BASICRESP * bs = OCSP_response_get1_basic(olist->resp);
1737     const OCSP_SINGLERESP * single = OCSP_resp_get0(bs, 0);
1738     const OCSP_CERTID * cid = OCSP_SINGLERESP_get0_id(single);
1739     ASN1_INTEGER * res_cert_serial;
1740     const BIGNUM * resp_bn;
1741     ASN1_OCTET_STRING * res_cert_iNameHash;
1742
1743
1744     (void) OCSP_id_get0_info(&res_cert_iNameHash, NULL, NULL, &res_cert_serial,
1745       (OCSP_CERTID *) cid);
1746     resp_bn = ASN1_INTEGER_to_BN(res_cert_serial, NULL);
1747
1748     DEBUG(D_tls)
1749       {
1750       debug_printf("cert serial: %s\n", BN_bn2hex(cert_bn));
1751       debug_printf("resp serial: %s\n", BN_bn2hex(resp_bn));
1752       }
1753
1754     if (BN_cmp(cert_bn, resp_bn) == 0)
1755       {
1756       DEBUG(D_tls) debug_printf("matched serial for ocsp\n");
1757
1758       /*XXX TODO: check the rest of the list for duplicate matches.
1759       If any, need to also check the Issuer Name hash.
1760       Without this, we will provide the wrong status in the case of
1761       duplicate id. */
1762
1763       break;
1764       }
1765     DEBUG(D_tls) debug_printf("not match serial for ocsp\n");
1766     }
1767   if (!olist)
1768     {
1769     DEBUG(D_tls) debug_printf("failed to find match for ocsp\n");
1770     return SSL_TLSEXT_ERR_NOACK;
1771     }
1772  }
1773 #else
1774 if (olist->next)
1775   {
1776   DEBUG(D_tls) debug_printf("OpenSSL version too early to support multi-leaf OCSP\n");
1777   return SSL_TLSEXT_ERR_NOACK;
1778   }
1779 #endif
1780
1781 /*XXX could we do the i2d earlier, rather than during the callback? */
1782 response_der = NULL;
1783 response_der_len = i2d_OCSP_RESPONSE(olist->resp, &response_der);
1784 if (response_der_len <= 0)
1785   return SSL_TLSEXT_ERR_NOACK;
1786
1787 SSL_set_tlsext_status_ocsp_resp(server_ssl, response_der, response_der_len);
1788 tls_in.ocsp = OCSP_VFIED;
1789 return SSL_TLSEXT_ERR_OK;
1790 }
1791
1792
1793 static void
1794 time_print(BIO * bp, const char * str, ASN1_GENERALIZEDTIME * time)
1795 {
1796 BIO_printf(bp, "\t%s: ", str);
1797 ASN1_GENERALIZEDTIME_print(bp, time);
1798 BIO_puts(bp, "\n");
1799 }
1800
1801 static int
1802 tls_client_stapling_cb(SSL *s, void *arg)
1803 {
1804 tls_ext_ctx_cb * cbinfo = arg;
1805 const unsigned char * p;
1806 int len;
1807 OCSP_RESPONSE * rsp;
1808 OCSP_BASICRESP * bs;
1809 int i;
1810
1811 DEBUG(D_tls) debug_printf("Received TLS status response (OCSP stapling):");
1812 len = SSL_get_tlsext_status_ocsp_resp(s, &p);
1813 if(!p)
1814  {
1815   /* Expect this when we requested ocsp but got none */
1816   if (cbinfo->u_ocsp.client.verify_required && LOGGING(tls_cipher))
1817     log_write(0, LOG_MAIN, "Received TLS status callback, null content");
1818   else
1819     DEBUG(D_tls) debug_printf(" null\n");
1820   return cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1821  }
1822
1823 if (!(rsp = d2i_OCSP_RESPONSE(NULL, &p, len)))
1824   {
1825   tls_out.ocsp = OCSP_FAILED;   /*XXX should use tlsp-> to permit concurrent outbound */
1826   if (LOGGING(tls_cipher))
1827     log_write(0, LOG_MAIN, "Received TLS cert status response, parse error");
1828   else
1829     DEBUG(D_tls) debug_printf(" parse error\n");
1830   return 0;
1831   }
1832
1833 if (!(bs = OCSP_response_get1_basic(rsp)))
1834   {
1835   tls_out.ocsp = OCSP_FAILED;
1836   if (LOGGING(tls_cipher))
1837     log_write(0, LOG_MAIN, "Received TLS cert status response, error parsing response");
1838   else
1839     DEBUG(D_tls) debug_printf(" error parsing response\n");
1840   OCSP_RESPONSE_free(rsp);
1841   return 0;
1842   }
1843
1844 /* We'd check the nonce here if we'd put one in the request. */
1845 /* However that would defeat cacheability on the server so we don't. */
1846
1847 /* This section of code reworked from OpenSSL apps source;
1848    The OpenSSL Project retains copyright:
1849    Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
1850 */
1851   {
1852     BIO * bp = NULL;
1853     int status, reason;
1854     ASN1_GENERALIZEDTIME *rev, *thisupd, *nextupd;
1855
1856     DEBUG(D_tls) bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
1857
1858     /*OCSP_RESPONSE_print(bp, rsp, 0);   extreme debug: stapling content */
1859
1860     /* Use the chain that verified the server cert to verify the stapled info */
1861     /* DEBUG(D_tls) x509_store_dump_cert_s_names(cbinfo->u_ocsp.client.verify_store); */
1862
1863     if ((i = OCSP_basic_verify(bs, cbinfo->verify_stack,
1864               cbinfo->u_ocsp.client.verify_store, 0)) <= 0)
1865       {
1866       tls_out.ocsp = OCSP_FAILED;
1867       if (LOGGING(tls_cipher)) log_write(0, LOG_MAIN,
1868               "Received TLS cert status response, itself unverifiable: %s",
1869               ERR_reason_error_string(ERR_peek_error()));
1870       BIO_printf(bp, "OCSP response verify failure\n");
1871       ERR_print_errors(bp);
1872       OCSP_RESPONSE_print(bp, rsp, 0);
1873       goto failed;
1874       }
1875
1876     BIO_printf(bp, "OCSP response well-formed and signed OK\n");
1877
1878     /*XXX So we have a good stapled OCSP status.  How do we know
1879     it is for the cert of interest?  OpenSSL 1.1.0 has a routine
1880     OCSP_resp_find_status() which matches on a cert id, which presumably
1881     we should use. Making an id needs OCSP_cert_id_new(), which takes
1882     issuerName, issuerKey, serialNumber.  Are they all in the cert?
1883
1884     For now, carry on blindly accepting the resp. */
1885
1886       {
1887       OCSP_SINGLERESP * single;
1888
1889 #ifdef EXIM_HAVE_OCSP_RESP_COUNT
1890       if (OCSP_resp_count(bs) != 1)
1891 #else
1892       STACK_OF(OCSP_SINGLERESP) * sresp = bs->tbsResponseData->responses;
1893       if (sk_OCSP_SINGLERESP_num(sresp) != 1)
1894 #endif
1895         {
1896         tls_out.ocsp = OCSP_FAILED;
1897         log_write(0, LOG_MAIN, "OCSP stapling "
1898             "with multiple responses not handled");
1899         goto failed;
1900         }
1901       single = OCSP_resp_get0(bs, 0);
1902       status = OCSP_single_get0_status(single, &reason, &rev,
1903                   &thisupd, &nextupd);
1904       }
1905
1906     DEBUG(D_tls) time_print(bp, "This OCSP Update", thisupd);
1907     DEBUG(D_tls) if(nextupd) time_print(bp, "Next OCSP Update", nextupd);
1908     if (!OCSP_check_validity(thisupd, nextupd,
1909           EXIM_OCSP_SKEW_SECONDS, EXIM_OCSP_MAX_AGE))
1910       {
1911       tls_out.ocsp = OCSP_FAILED;
1912       DEBUG(D_tls) ERR_print_errors(bp);
1913       log_write(0, LOG_MAIN, "Server OSCP dates invalid");
1914       }
1915     else
1916       {
1917       DEBUG(D_tls) BIO_printf(bp, "Certificate status: %s\n",
1918                     OCSP_cert_status_str(status));
1919       switch(status)
1920         {
1921         case V_OCSP_CERTSTATUS_GOOD:
1922           tls_out.ocsp = OCSP_VFIED;
1923           i = 1;
1924           goto good;
1925         case V_OCSP_CERTSTATUS_REVOKED:
1926           tls_out.ocsp = OCSP_FAILED;
1927           log_write(0, LOG_MAIN, "Server certificate revoked%s%s",
1928               reason != -1 ? "; reason: " : "",
1929               reason != -1 ? OCSP_crl_reason_str(reason) : "");
1930           DEBUG(D_tls) time_print(bp, "Revocation Time", rev);
1931           break;
1932         default:
1933           tls_out.ocsp = OCSP_FAILED;
1934           log_write(0, LOG_MAIN,
1935               "Server certificate status unknown, in OCSP stapling");
1936           break;
1937         }
1938       }
1939   failed:
1940     i = cbinfo->u_ocsp.client.verify_required ? 0 : 1;
1941   good:
1942     BIO_free(bp);
1943   }
1944
1945 OCSP_RESPONSE_free(rsp);
1946 return i;
1947 }
1948 #endif  /*!DISABLE_OCSP*/
1949
1950
1951 /*************************************************
1952 *            Initialize for TLS                  *
1953 *************************************************/
1954
1955 static void
1956 tls_openssl_init(void)
1957 {
1958 #ifdef EXIM_NEED_OPENSSL_INIT
1959 SSL_load_error_strings();          /* basic set up */
1960 OpenSSL_add_ssl_algorithms();
1961 #endif
1962
1963 #if defined(EXIM_HAVE_SHA256) && !defined(OPENSSL_AUTO_SHA256)
1964 /* SHA256 is becoming ever more popular. This makes sure it gets added to the
1965 list of available digests. */
1966 EVP_add_digest(EVP_sha256());
1967 #endif
1968 }
1969
1970
1971
1972 /* Called from both server and client code, to do preliminary initialization
1973 of the library.  We allocate and return a context structure.
1974
1975 Arguments:
1976   ctxp            returned SSL context
1977   host            connected host, if client; NULL if server
1978   dhparam         DH parameter file
1979   certificate     certificate file
1980   privatekey      private key
1981   ocsp_file       file of stapling info (server); flag for require ocsp (client)
1982   addr            address if client; NULL if server (for some randomness)
1983   cbp             place to put allocated callback context
1984   errstr          error string pointer
1985
1986 Returns:          OK/DEFER/FAIL
1987 */
1988
1989 static int
1990 tls_init(SSL_CTX **ctxp, host_item *host, uschar *dhparam, uschar *certificate,
1991   uschar *privatekey,
1992 #ifndef DISABLE_OCSP
1993   uschar *ocsp_file,
1994 #endif
1995   address_item *addr, tls_ext_ctx_cb ** cbp,
1996   tls_support * tlsp,
1997   uschar ** errstr)
1998 {
1999 SSL_CTX * ctx;
2000 long init_options;
2001 int rc;
2002 tls_ext_ctx_cb * cbinfo;
2003
2004 cbinfo = store_malloc(sizeof(tls_ext_ctx_cb));
2005 cbinfo->tlsp = tlsp;
2006 cbinfo->certificate = certificate;
2007 cbinfo->privatekey = privatekey;
2008 cbinfo->is_server = host==NULL;
2009 #ifndef DISABLE_OCSP
2010 cbinfo->verify_stack = NULL;
2011 if (!host)
2012   {
2013   cbinfo->u_ocsp.server.file = ocsp_file;
2014   cbinfo->u_ocsp.server.file_expanded = NULL;
2015   cbinfo->u_ocsp.server.olist = NULL;
2016   }
2017 else
2018   cbinfo->u_ocsp.client.verify_store = NULL;
2019 #endif
2020 cbinfo->dhparam = dhparam;
2021 cbinfo->server_cipher_list = NULL;
2022 cbinfo->host = host;
2023 #ifndef DISABLE_EVENT
2024 cbinfo->event_action = NULL;
2025 #endif
2026
2027 tls_openssl_init();
2028
2029 /* Create a context.
2030 The OpenSSL docs in 1.0.1b have not been updated to clarify TLS variant
2031 negotiation in the different methods; as far as I can tell, the only
2032 *_{server,client}_method which allows negotiation is SSLv23, which exists even
2033 when OpenSSL is built without SSLv2 support.
2034 By disabling with openssl_options, we can let admins re-enable with the
2035 existing knob. */
2036
2037 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
2038 if (!(ctx = SSL_CTX_new(host ? TLS_client_method() : TLS_server_method())))
2039 #else
2040 if (!(ctx = SSL_CTX_new(host ? SSLv23_client_method() : SSLv23_server_method())))
2041 #endif
2042   return tls_error(US"SSL_CTX_new", host, NULL, errstr);
2043
2044 /* It turns out that we need to seed the random number generator this early in
2045 order to get the full complement of ciphers to work. It took me roughly a day
2046 of work to discover this by experiment.
2047
2048 On systems that have /dev/urandom, SSL may automatically seed itself from
2049 there. Otherwise, we have to make something up as best we can. Double check
2050 afterwards. */
2051
2052 if (!RAND_status())
2053   {
2054   randstuff r;
2055   gettimeofday(&r.tv, NULL);
2056   r.p = getpid();
2057
2058   RAND_seed(US (&r), sizeof(r));
2059   RAND_seed(US big_buffer, big_buffer_size);
2060   if (addr != NULL) RAND_seed(US addr, sizeof(addr));
2061
2062   if (!RAND_status())
2063     return tls_error(US"RAND_status", host,
2064       US"unable to seed random number generator", errstr);
2065   }
2066
2067 /* Set up the information callback, which outputs if debugging is at a suitable
2068 level. */
2069
2070 DEBUG(D_tls)
2071   {
2072   SSL_CTX_set_info_callback(ctx, (void (*)())info_callback);
2073 #if defined(EXIM_HAVE_OPESSL_TRACE) && !defined(OPENSSL_NO_SSL_TRACE)
2074   /* this needs a debug build of OpenSSL */
2075   SSL_CTX_set_msg_callback(ctx, (void (*)())SSL_trace);
2076 #endif
2077 #ifdef OPENSSL_HAVE_KEYLOG_CB
2078   SSL_CTX_set_keylog_callback(ctx, (void (*)())keylog_callback);
2079 #endif
2080   }
2081
2082 /* Automatically re-try reads/writes after renegotiation. */
2083 (void) SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
2084
2085 /* Apply administrator-supplied work-arounds.
2086 Historically we applied just one requested option,
2087 SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS, but when bug 994 requested a second, we
2088 moved to an administrator-controlled list of options to specify and
2089 grandfathered in the first one as the default value for "openssl_options".
2090
2091 No OpenSSL version number checks: the options we accept depend upon the
2092 availability of the option value macros from OpenSSL.  */
2093
2094 if (!tls_openssl_options_parse(openssl_options, &init_options))
2095   return tls_error(US"openssl_options parsing failed", host, NULL, errstr);
2096
2097 #ifdef EXPERIMENTAL_TLS_RESUME
2098 tlsp->resumption = RESUME_SUPPORTED;
2099 #endif
2100 if (init_options)
2101   {
2102 #ifdef EXPERIMENTAL_TLS_RESUME
2103   /* Should the server offer session resumption? */
2104   if (!host && verify_check_host(&tls_resumption_hosts) == OK)
2105     {
2106     DEBUG(D_tls) debug_printf("tls_resumption_hosts overrides openssl_options\n");
2107     init_options &= ~SSL_OP_NO_TICKET;
2108     tlsp->resumption |= RESUME_SERVER_TICKET; /* server will give ticket on request */
2109     tlsp->host_resumable = TRUE;
2110     }
2111 #endif
2112
2113   DEBUG(D_tls) debug_printf("setting SSL CTX options: %#lx\n", init_options);
2114   if (!(SSL_CTX_set_options(ctx, init_options)))
2115     return tls_error(string_sprintf(
2116           "SSL_CTX_set_option(%#lx)", init_options), host, NULL, errstr);
2117   }
2118 else
2119   DEBUG(D_tls) debug_printf("no SSL CTX options to set\n");
2120
2121 /* We'd like to disable session cache unconditionally, but foolish Outlook
2122 Express clients then give up the first TLS connection and make a second one
2123 (which works).  Only when there is an IMAP service on the same machine.
2124 Presumably OE is trying to use the cache for A on B.  Leave it enabled for
2125 now, until we work out a decent way of presenting control to the config.  It
2126 will never be used because we use a new context every time. */
2127 #ifdef notdef
2128 (void) SSL_CTX_set_session_cache_mode(ctx, SSL_SESS_CACHE_OFF);
2129 #endif
2130
2131 /* Initialize with DH parameters if supplied */
2132 /* Initialize ECDH temp key parameter selection */
2133
2134 if (  !init_dh(ctx, dhparam, host, errstr)
2135    || !init_ecdh(ctx, host, errstr)
2136    )
2137   return DEFER;
2138
2139 /* Set up certificate and key (and perhaps OCSP info) */
2140
2141 if ((rc = tls_expand_session_files(ctx, cbinfo, errstr)) != OK)
2142   return rc;
2143
2144 /* If we need to handle SNI or OCSP, do so */
2145
2146 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
2147 # ifndef DISABLE_OCSP
2148   if (!(cbinfo->verify_stack = sk_X509_new_null()))
2149     {
2150     DEBUG(D_tls) debug_printf("failed to create stack for stapling verify\n");
2151     return FAIL;
2152     }
2153 # endif
2154
2155 if (!host)              /* server */
2156   {
2157 # ifndef DISABLE_OCSP
2158   /* We check u_ocsp.server.file, not server.olist, because we care about if
2159   the option exists, not what the current expansion might be, as SNI might
2160   change the certificate and OCSP file in use between now and the time the
2161   callback is invoked. */
2162   if (cbinfo->u_ocsp.server.file)
2163     {
2164     SSL_CTX_set_tlsext_status_cb(ctx, tls_server_stapling_cb);
2165     SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
2166     }
2167 # endif
2168   /* We always do this, so that $tls_sni is available even if not used in
2169   tls_certificate */
2170   SSL_CTX_set_tlsext_servername_callback(ctx, tls_servername_cb);
2171   SSL_CTX_set_tlsext_servername_arg(ctx, cbinfo);
2172   }
2173 # ifndef DISABLE_OCSP
2174 else                    /* client */
2175   if(ocsp_file)         /* wanting stapling */
2176     {
2177     if (!(cbinfo->u_ocsp.client.verify_store = X509_STORE_new()))
2178       {
2179       DEBUG(D_tls) debug_printf("failed to create store for stapling verify\n");
2180       return FAIL;
2181       }
2182     SSL_CTX_set_tlsext_status_cb(ctx, tls_client_stapling_cb);
2183     SSL_CTX_set_tlsext_status_arg(ctx, cbinfo);
2184     }
2185 # endif
2186 #endif
2187
2188 cbinfo->verify_cert_hostnames = NULL;
2189
2190 #ifdef EXIM_HAVE_EPHEM_RSA_KEX
2191 /* Set up the RSA callback */
2192 SSL_CTX_set_tmp_rsa_callback(ctx, rsa_callback);
2193 #endif
2194
2195 /* Finally, set the session cache timeout, and we are done.
2196 The period appears to be also used for (server-generated) session tickets */
2197
2198 SSL_CTX_set_timeout(ctx, ssl_session_timeout);
2199 DEBUG(D_tls) debug_printf("Initialized TLS\n");
2200
2201 *cbp = cbinfo;
2202 *ctxp = ctx;
2203
2204 return OK;
2205 }
2206
2207
2208
2209
2210 /*************************************************
2211 *           Get name of cipher in use            *
2212 *************************************************/
2213
2214 /*
2215 Argument:   pointer to an SSL structure for the connection
2216             pointer to number of bits for cipher
2217 Returns:    pointer to allocated string in perm-pool
2218 */
2219
2220 static uschar *
2221 construct_cipher_name(SSL * ssl, int * bits)
2222 {
2223 int pool = store_pool;
2224 /* With OpenSSL 1.0.0a, 'c' needs to be const but the documentation doesn't
2225 yet reflect that.  It should be a safe change anyway, even 0.9.8 versions have
2226 the accessor functions use const in the prototype. */
2227
2228 const uschar * ver = CUS SSL_get_version(ssl);
2229 const SSL_CIPHER * c = (const SSL_CIPHER *) SSL_get_current_cipher(ssl);
2230 uschar * s;
2231
2232 SSL_CIPHER_get_bits(c, bits);
2233
2234 store_pool = POOL_PERM;
2235 s = string_sprintf("%s:%s:%u", ver, SSL_CIPHER_get_name(c), *bits);
2236 store_pool = pool;
2237 DEBUG(D_tls) debug_printf("Cipher: %s\n", s);
2238 return s;
2239 }
2240
2241
2242 /* Get IETF-standard name for ciphersuite.
2243 Argument:   pointer to an SSL structure for the connection
2244 Returns:    pointer to string
2245 */
2246
2247 static const uschar *
2248 cipher_stdname_ssl(SSL * ssl)
2249 {
2250 #ifdef EXIM_HAVE_OPENSSL_CIPHER_STD_NAME
2251 return CUS SSL_CIPHER_standard_name(SSL_get_current_cipher(ssl));
2252 #else
2253 ushort id = 0xffff & SSL_CIPHER_get_id(SSL_get_current_cipher(ssl));
2254 return cipher_stdname(id >> 8, id & 0xff);
2255 #endif
2256 }
2257
2258
2259 static void
2260 peer_cert(SSL * ssl, tls_support * tlsp, uschar * peerdn, unsigned siz)
2261 {
2262 /*XXX we might consider a list-of-certs variable for the cert chain.
2263 SSL_get_peer_cert_chain(SSL*).  We'd need a new variable type and support
2264 in list-handling functions, also consider the difference between the entire
2265 chain and the elements sent by the peer. */
2266
2267 tlsp->peerdn = NULL;
2268
2269 /* Will have already noted peercert on a verify fail; possibly not the leaf */
2270 if (!tlsp->peercert)
2271   tlsp->peercert = SSL_get_peer_certificate(ssl);
2272 /* Beware anonymous ciphers which lead to server_cert being NULL */
2273 if (tlsp->peercert)
2274   if (!X509_NAME_oneline(X509_get_subject_name(tlsp->peercert), CS peerdn, siz))
2275     { DEBUG(D_tls) debug_printf("X509_NAME_oneline() error\n"); }
2276   else
2277     {
2278     int oldpool = store_pool;
2279
2280     peerdn[siz-1] = '\0';               /* paranoia */
2281     store_pool = POOL_PERM;
2282     tlsp->peerdn = string_copy(peerdn);
2283     store_pool = oldpool;
2284
2285     /* We used to set CV in the cert-verify callbacks (either plain or dane)
2286     but they don't get called on session-resumption.  So use the official
2287     interface, which uses the resumed value.  Unfortunately this claims verified
2288     when it actually failed but we're in try-verify mode, due to us wanting the
2289     knowlege that it failed so needing to have the callback and forcing a
2290     permissive return.  If we don't force it, the TLS startup is failed.
2291     The extra bit of information is set in verify_override in the cb, stashed
2292     for resumption next to the TLS session, and used here. */
2293
2294     if (!tlsp->verify_override)
2295       tlsp->certificate_verified = SSL_get_verify_result(ssl) == X509_V_OK;
2296     }
2297 }
2298
2299
2300
2301
2302
2303 /*************************************************
2304 *        Set up for verifying certificates       *
2305 *************************************************/
2306
2307 #ifndef DISABLE_OCSP
2308 /* Load certs from file, return TRUE on success */
2309
2310 static BOOL
2311 chain_from_pem_file(const uschar * file, STACK_OF(X509) * verify_stack)
2312 {
2313 BIO * bp;
2314 X509 * x;
2315
2316 while (sk_X509_num(verify_stack) > 0)
2317   X509_free(sk_X509_pop(verify_stack));
2318
2319 if (!(bp = BIO_new_file(CS file, "r"))) return FALSE;
2320 while ((x = PEM_read_bio_X509(bp, NULL, 0, NULL)))
2321   sk_X509_push(verify_stack, x);
2322 BIO_free(bp);
2323 return TRUE;
2324 }
2325 #endif
2326
2327
2328
2329 /* Called by both client and server startup; on the server possibly
2330 repeated after a Server Name Indication.
2331
2332 Arguments:
2333   sctx          SSL_CTX* to initialise
2334   certs         certs file or NULL
2335   crl           CRL file or NULL
2336   host          NULL in a server; the remote host in a client
2337   optional      TRUE if called from a server for a host in tls_try_verify_hosts;
2338                 otherwise passed as FALSE
2339   cert_vfy_cb   Callback function for certificate verification
2340   errstr        error string pointer
2341
2342 Returns:        OK/DEFER/FAIL
2343 */
2344
2345 static int
2346 setup_certs(SSL_CTX *sctx, uschar *certs, uschar *crl, host_item *host, BOOL optional,
2347     int (*cert_vfy_cb)(int, X509_STORE_CTX *), uschar ** errstr)
2348 {
2349 uschar *expcerts, *expcrl;
2350
2351 if (!expand_check(certs, US"tls_verify_certificates", &expcerts, errstr))
2352   return DEFER;
2353 DEBUG(D_tls) debug_printf("tls_verify_certificates: %s\n", expcerts);
2354
2355 if (expcerts && *expcerts)
2356   {
2357   /* Tell the library to use its compiled-in location for the system default
2358   CA bundle. Then add the ones specified in the config, if any. */
2359
2360   if (!SSL_CTX_set_default_verify_paths(sctx))
2361     return tls_error(US"SSL_CTX_set_default_verify_paths", host, NULL, errstr);
2362
2363   if (Ustrcmp(expcerts, "system") != 0)
2364     {
2365     struct stat statbuf;
2366
2367     if (Ustat(expcerts, &statbuf) < 0)
2368       {
2369       log_write(0, LOG_MAIN|LOG_PANIC,
2370         "failed to stat %s for certificates", expcerts);
2371       return DEFER;
2372       }
2373     else
2374       {
2375       uschar *file, *dir;
2376       if ((statbuf.st_mode & S_IFMT) == S_IFDIR)
2377         { file = NULL; dir = expcerts; }
2378       else
2379         {
2380         file = expcerts; dir = NULL;
2381 #ifndef DISABLE_OCSP
2382         /* In the server if we will be offering an OCSP proof, load chain from
2383         file for verifying the OCSP proof at load time. */
2384
2385 /*XXX Glitch!   The file here is tls_verify_certs: the chain for verifying the client cert.
2386 This is inconsistent with the need to verify the OCSP proof of the server cert.
2387 */
2388
2389         if (  !host
2390            && statbuf.st_size > 0
2391            && server_static_cbinfo->u_ocsp.server.file
2392            && !chain_from_pem_file(file, server_static_cbinfo->verify_stack)
2393            )
2394           {
2395           log_write(0, LOG_MAIN|LOG_PANIC,
2396             "failed to load cert chain from %s", file);
2397           return DEFER;
2398           }
2399 #endif
2400         }
2401
2402       /* If a certificate file is empty, the next function fails with an
2403       unhelpful error message. If we skip it, we get the correct behaviour (no
2404       certificates are recognized, but the error message is still misleading (it
2405       says no certificate was supplied).  But this is better. */
2406
2407       if (  (!file || statbuf.st_size > 0)
2408          && !SSL_CTX_load_verify_locations(sctx, CS file, CS dir))
2409         return tls_error(US"SSL_CTX_load_verify_locations", host, NULL, errstr);
2410
2411       /* Load the list of CAs for which we will accept certs, for sending
2412       to the client.  This is only for the one-file tls_verify_certificates
2413       variant.
2414       If a list isn't loaded into the server, but some verify locations are set,
2415       the server end appears to make a wildcard request for client certs.
2416       Meanwhile, the client library as default behaviour *ignores* the list
2417       we send over the wire - see man SSL_CTX_set_client_cert_cb.
2418       Because of this, and that the dir variant is likely only used for
2419       the public-CA bundle (not for a private CA), not worth fixing.  */
2420
2421       if (file)
2422         {
2423         STACK_OF(X509_NAME) * names = SSL_load_client_CA_file(CS file);
2424
2425         SSL_CTX_set_client_CA_list(sctx, names);
2426         DEBUG(D_tls) debug_printf("Added %d certificate authorities.\n",
2427                                     sk_X509_NAME_num(names));
2428         }
2429       }
2430     }
2431
2432   /* Handle a certificate revocation list. */
2433
2434 #if OPENSSL_VERSION_NUMBER > 0x00907000L
2435
2436   /* This bit of code is now the version supplied by Lars Mainka. (I have
2437   merely reformatted it into the Exim code style.)
2438
2439   "From here I changed the code to add support for multiple crl's
2440   in pem format in one file or to support hashed directory entries in
2441   pem format instead of a file. This method now uses the library function
2442   X509_STORE_load_locations to add the CRL location to the SSL context.
2443   OpenSSL will then handle the verify against CA certs and CRLs by
2444   itself in the verify callback." */
2445
2446   if (!expand_check(crl, US"tls_crl", &expcrl, errstr)) return DEFER;
2447   if (expcrl && *expcrl)
2448     {
2449     struct stat statbufcrl;
2450     if (Ustat(expcrl, &statbufcrl) < 0)
2451       {
2452       log_write(0, LOG_MAIN|LOG_PANIC,
2453         "failed to stat %s for certificates revocation lists", expcrl);
2454       return DEFER;
2455       }
2456     else
2457       {
2458       /* is it a file or directory? */
2459       uschar *file, *dir;
2460       X509_STORE *cvstore = SSL_CTX_get_cert_store(sctx);
2461       if ((statbufcrl.st_mode & S_IFMT) == S_IFDIR)
2462         {
2463         file = NULL;
2464         dir = expcrl;
2465         DEBUG(D_tls) debug_printf("SSL CRL value is a directory %s\n", dir);
2466         }
2467       else
2468         {
2469         file = expcrl;
2470         dir = NULL;
2471         DEBUG(D_tls) debug_printf("SSL CRL value is a file %s\n", file);
2472         }
2473       if (X509_STORE_load_locations(cvstore, CS file, CS dir) == 0)
2474         return tls_error(US"X509_STORE_load_locations", host, NULL, errstr);
2475
2476       /* setting the flags to check against the complete crl chain */
2477
2478       X509_STORE_set_flags(cvstore,
2479         X509_V_FLAG_CRL_CHECK|X509_V_FLAG_CRL_CHECK_ALL);
2480       }
2481     }
2482
2483 #endif  /* OPENSSL_VERSION_NUMBER > 0x00907000L */
2484
2485   /* If verification is optional, don't fail if no certificate */
2486
2487   SSL_CTX_set_verify(sctx,
2488     SSL_VERIFY_PEER | (optional ? 0 : SSL_VERIFY_FAIL_IF_NO_PEER_CERT),
2489     cert_vfy_cb);
2490   }
2491
2492 return OK;
2493 }
2494
2495
2496
2497 /*************************************************
2498 *       Start a TLS session in a server          *
2499 *************************************************/
2500
2501 /* This is called when Exim is running as a server, after having received
2502 the STARTTLS command. It must respond to that command, and then negotiate
2503 a TLS session.
2504
2505 Arguments:
2506   require_ciphers   allowed ciphers
2507   errstr            pointer to error message
2508
2509 Returns:            OK on success
2510                     DEFER for errors before the start of the negotiation
2511                     FAIL for errors during the negotiation; the server can't
2512                       continue running.
2513 */
2514
2515 int
2516 tls_server_start(const uschar * require_ciphers, uschar ** errstr)
2517 {
2518 int rc;
2519 uschar * expciphers;
2520 tls_ext_ctx_cb * cbinfo;
2521 static uschar peerdn[256];
2522
2523 /* Check for previous activation */
2524
2525 if (tls_in.active.sock >= 0)
2526   {
2527   tls_error(US"STARTTLS received after TLS started", NULL, US"", errstr);
2528   smtp_printf("554 Already in TLS\r\n", FALSE);
2529   return FAIL;
2530   }
2531
2532 /* Initialize the SSL library. If it fails, it will already have logged
2533 the error. */
2534
2535 rc = tls_init(&server_ctx, NULL, tls_dhparam, tls_certificate, tls_privatekey,
2536 #ifndef DISABLE_OCSP
2537     tls_ocsp_file,
2538 #endif
2539     NULL, &server_static_cbinfo, &tls_in, errstr);
2540 if (rc != OK) return rc;
2541 cbinfo = server_static_cbinfo;
2542
2543 if (!expand_check(require_ciphers, US"tls_require_ciphers", &expciphers, errstr))
2544   return FAIL;
2545
2546 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
2547 were historically separated by underscores. So that I can use either form in my
2548 tests, and also for general convenience, we turn underscores into hyphens here.
2549
2550 XXX SSL_CTX_set_cipher_list() is replaced by SSL_CTX_set_ciphersuites()
2551 for TLS 1.3 .  Since we do not call it at present we get the default list:
2552 TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256
2553 */
2554
2555 if (expciphers)
2556   {
2557   for (uschar * s = expciphers; *s; s++ ) if (*s == '_') *s = '-';
2558   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
2559   if (!SSL_CTX_set_cipher_list(server_ctx, CS expciphers))
2560     return tls_error(US"SSL_CTX_set_cipher_list", NULL, NULL, errstr);
2561   cbinfo->server_cipher_list = expciphers;
2562   }
2563
2564 /* If this is a host for which certificate verification is mandatory or
2565 optional, set up appropriately. */
2566
2567 tls_in.certificate_verified = FALSE;
2568 #ifdef SUPPORT_DANE
2569 tls_in.dane_verified = FALSE;
2570 #endif
2571 server_verify_callback_called = FALSE;
2572
2573 if (verify_check_host(&tls_verify_hosts) == OK)
2574   {
2575   rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2576                         FALSE, verify_callback_server, errstr);
2577   if (rc != OK) return rc;
2578   server_verify_optional = FALSE;
2579   }
2580 else if (verify_check_host(&tls_try_verify_hosts) == OK)
2581   {
2582   rc = setup_certs(server_ctx, tls_verify_certificates, tls_crl, NULL,
2583                         TRUE, verify_callback_server, errstr);
2584   if (rc != OK) return rc;
2585   server_verify_optional = TRUE;
2586   }
2587
2588 #ifdef EXPERIMENTAL_TLS_RESUME
2589 SSL_CTX_set_tlsext_ticket_key_cb(server_ctx, ticket_key_callback);
2590 /* despite working, appears to always return failure, so ignoring */
2591 #endif
2592 #ifdef OPENSSL_HAVE_NUM_TICKETS
2593 # ifdef EXPERIMENTAL_TLS_RESUME
2594 SSL_CTX_set_num_tickets(server_ctx, tls_in.host_resumable ? 1 : 0);
2595 # else
2596 SSL_CTX_set_num_tickets(server_ctx, 0); /* send no TLS1.3 stateful-tickets */
2597 # endif
2598 #endif
2599
2600
2601 /* Prepare for new connection */
2602
2603 if (!(server_ssl = SSL_new(server_ctx)))
2604   return tls_error(US"SSL_new", NULL, NULL, errstr);
2605
2606 /* Warning: we used to SSL_clear(ssl) here, it was removed.
2607  *
2608  * With the SSL_clear(), we get strange interoperability bugs with
2609  * OpenSSL 1.0.1b and TLS1.1/1.2.  It looks as though this may be a bug in
2610  * OpenSSL itself, as a clear should not lead to inability to follow protocols.
2611  *
2612  * The SSL_clear() call is to let an existing SSL* be reused, typically after
2613  * session shutdown.  In this case, we have a brand new object and there's no
2614  * obvious reason to immediately clear it.  I'm guessing that this was
2615  * originally added because of incomplete initialisation which the clear fixed,
2616  * in some historic release.
2617  */
2618
2619 /* Set context and tell client to go ahead, except in the case of TLS startup
2620 on connection, where outputting anything now upsets the clients and tends to
2621 make them disconnect. We need to have an explicit fflush() here, to force out
2622 the response. Other smtp_printf() calls do not need it, because in non-TLS
2623 mode, the fflush() happens when smtp_getc() is called. */
2624
2625 SSL_set_session_id_context(server_ssl, sid_ctx, Ustrlen(sid_ctx));
2626 if (!tls_in.on_connect)
2627   {
2628   smtp_printf("220 TLS go ahead\r\n", FALSE);
2629   fflush(smtp_out);
2630   }
2631
2632 /* Now negotiate the TLS session. We put our own timer on it, since it seems
2633 that the OpenSSL library doesn't. */
2634
2635 SSL_set_wfd(server_ssl, fileno(smtp_out));
2636 SSL_set_rfd(server_ssl, fileno(smtp_in));
2637 SSL_set_accept_state(server_ssl);
2638
2639 DEBUG(D_tls) debug_printf("Calling SSL_accept\n");
2640
2641 sigalrm_seen = FALSE;
2642 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
2643 rc = SSL_accept(server_ssl);
2644 ALARM_CLR(0);
2645
2646 if (rc <= 0)
2647   {
2648   int error = SSL_get_error(server_ssl, rc);
2649   switch(error)
2650     {
2651     case SSL_ERROR_NONE:
2652       break;
2653
2654     case SSL_ERROR_ZERO_RETURN:
2655       DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
2656       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
2657
2658       if (SSL_get_shutdown(server_ssl) == SSL_RECEIVED_SHUTDOWN)
2659             SSL_shutdown(server_ssl);
2660
2661       tls_close(NULL, TLS_NO_SHUTDOWN);
2662       return FAIL;
2663
2664     /* Handle genuine errors */
2665     case SSL_ERROR_SSL:
2666       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
2667       return FAIL;
2668
2669     default:
2670       DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
2671       if (error == SSL_ERROR_SYSCALL)
2672         {
2673         if (!errno)
2674           {
2675           *errstr = US"SSL_accept: TCP connection closed by peer";
2676           return FAIL;
2677           }
2678         DEBUG(D_tls) debug_printf(" - syscall %s\n", strerror(errno));
2679         }
2680       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
2681       return FAIL;
2682     }
2683   }
2684
2685 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
2686 ERR_clear_error();      /* Even success can leave errors in the stack. Seen with
2687                         anon-authentication ciphersuite negotiated. */
2688
2689 #ifdef EXPERIMENTAL_TLS_RESUME
2690 if (SSL_session_reused(server_ssl))
2691   {
2692   tls_in.resumption |= RESUME_USED;
2693   DEBUG(D_tls) debug_printf("Session reused\n");
2694   }
2695 #endif
2696
2697 /* TLS has been set up. Adjust the input functions to read via TLS,
2698 and initialize things. */
2699
2700 peer_cert(server_ssl, &tls_in, peerdn, sizeof(peerdn));
2701
2702 tls_in.cipher = construct_cipher_name(server_ssl, &tls_in.bits);
2703 tls_in.cipher_stdname = cipher_stdname_ssl(server_ssl);
2704
2705 DEBUG(D_tls)
2706   {
2707   uschar buf[2048];
2708   if (SSL_get_shared_ciphers(server_ssl, CS buf, sizeof(buf)))
2709     debug_printf("Shared ciphers: %s\n", buf);
2710
2711 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
2712   {
2713   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
2714   SSL_SESSION_print_keylog(bp, SSL_get_session(server_ssl));
2715   BIO_free(bp);
2716   }
2717 #endif
2718
2719 #ifdef EXIM_HAVE_SESSION_TICKET
2720   {
2721   SSL_SESSION * ss = SSL_get_session(server_ssl);
2722   if (SSL_SESSION_has_ticket(ss))       /* 1.1.0 */
2723     debug_printf("The session has a ticket, life %lu seconds\n",
2724       SSL_SESSION_get_ticket_lifetime_hint(ss));
2725   }
2726 #endif
2727   }
2728
2729 /* Record the certificate we presented */
2730   {
2731   X509 * crt = SSL_get_certificate(server_ssl);
2732   tls_in.ourcert = crt ? X509_dup(crt) : NULL;
2733   }
2734
2735 /* Only used by the server-side tls (tls_in), including tls_getc.
2736    Client-side (tls_out) reads (seem to?) go via
2737    smtp_read_response()/ip_recv().
2738    Hence no need to duplicate for _in and _out.
2739  */
2740 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
2741 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
2742 ssl_xfer_eof = ssl_xfer_error = FALSE;
2743
2744 receive_getc = tls_getc;
2745 receive_getbuf = tls_getbuf;
2746 receive_get_cache = tls_get_cache;
2747 receive_ungetc = tls_ungetc;
2748 receive_feof = tls_feof;
2749 receive_ferror = tls_ferror;
2750 receive_smtp_buffered = tls_smtp_buffered;
2751
2752 tls_in.active.sock = fileno(smtp_out);
2753 tls_in.active.tls_ctx = NULL;   /* not using explicit ctx for server-side */
2754 return OK;
2755 }
2756
2757
2758
2759
2760 static int
2761 tls_client_basic_ctx_init(SSL_CTX * ctx,
2762     host_item * host, smtp_transport_options_block * ob, tls_ext_ctx_cb * cbinfo,
2763     uschar ** errstr)
2764 {
2765 int rc;
2766 /* stick to the old behaviour for compatibility if tls_verify_certificates is
2767    set but both tls_verify_hosts and tls_try_verify_hosts is not set. Check only
2768    the specified host patterns if one of them is defined */
2769
2770 if (  (  !ob->tls_verify_hosts
2771       && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
2772       )
2773    || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
2774    )
2775   client_verify_optional = FALSE;
2776 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
2777   client_verify_optional = TRUE;
2778 else
2779   return OK;
2780
2781 if ((rc = setup_certs(ctx, ob->tls_verify_certificates,
2782       ob->tls_crl, host, client_verify_optional, verify_callback_client,
2783       errstr)) != OK)
2784   return rc;
2785
2786 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
2787   {
2788   cbinfo->verify_cert_hostnames =
2789 #ifdef SUPPORT_I18N
2790     string_domain_utf8_to_alabel(host->name, NULL);
2791 #else
2792     host->name;
2793 #endif
2794   DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
2795                     cbinfo->verify_cert_hostnames);
2796   }
2797 return OK;
2798 }
2799
2800
2801 #ifdef SUPPORT_DANE
2802 static int
2803 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
2804 {
2805 dns_scan dnss;
2806 const char * hostnames[2] = { CS host->name, NULL };
2807 int found = 0;
2808
2809 if (DANESSL_init(ssl, NULL, hostnames) != 1)
2810   return tls_error(US"hostnames load", host, NULL, errstr);
2811
2812 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
2813      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2814     ) if (rr->type == T_TLSA && rr->size > 3)
2815   {
2816   const uschar * p = rr->data;
2817   uint8_t usage, selector, mtype;
2818   const char * mdname;
2819
2820   usage = *p++;
2821
2822   /* Only DANE-TA(2) and DANE-EE(3) are supported */
2823   if (usage != 2 && usage != 3) continue;
2824
2825   selector = *p++;
2826   mtype = *p++;
2827
2828   switch (mtype)
2829     {
2830     default: continue;  /* Only match-types 0, 1, 2 are supported */
2831     case 0:  mdname = NULL; break;
2832     case 1:  mdname = "sha256"; break;
2833     case 2:  mdname = "sha512"; break;
2834     }
2835
2836   found++;
2837   switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
2838     {
2839     default:
2840       return tls_error(US"tlsa load", host, NULL, errstr);
2841     case 0:     /* action not taken */
2842     case 1:     break;
2843     }
2844
2845   tls_out.tlsa_usage |= 1<<usage;
2846   }
2847
2848 if (found)
2849   return OK;
2850
2851 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
2852 return DEFER;
2853 }
2854 #endif  /*SUPPORT_DANE*/
2855
2856
2857
2858 #ifdef EXPERIMENTAL_TLS_RESUME
2859 /* On the client, get any stashed session for the given IP from hints db
2860 and apply it to the ssl-connection for attempted resumption. */
2861
2862 static void
2863 tls_retrieve_session(tls_support * tlsp, SSL * ssl, const uschar * key)
2864 {
2865 tlsp->resumption |= RESUME_SUPPORTED;
2866 if (tlsp->host_resumable)
2867   {
2868   dbdata_tls_session * dt;
2869   int len;
2870   open_db dbblock, * dbm_file;
2871
2872   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
2873   DEBUG(D_tls) debug_printf("checking for resumable session for %s\n", key);
2874   if ((dbm_file = dbfn_open(US"tls", O_RDONLY, &dbblock, FALSE, FALSE)))
2875     {
2876     /* key for the db is the IP */
2877     if ((dt = dbfn_read_with_length(dbm_file, key, &len)))
2878       {
2879       SSL_SESSION * ss = NULL;
2880       const uschar * sess_asn1 = dt->session;
2881
2882       len -= sizeof(dbdata_tls_session);
2883       if (!(d2i_SSL_SESSION(&ss, &sess_asn1, (long)len)))
2884         {
2885         DEBUG(D_tls)
2886           {
2887           ERR_error_string_n(ERR_get_error(),
2888             ssl_errstring, sizeof(ssl_errstring));
2889           debug_printf("decoding session: %s\n", ssl_errstring);
2890           }
2891         }
2892 #ifdef EXIM_HAVE_SESSION_TICKET
2893       else if ( SSL_SESSION_get_ticket_lifetime_hint(ss) + dt->time_stamp
2894                < time(NULL))
2895         {
2896         DEBUG(D_tls) debug_printf("session expired\n");
2897         dbfn_delete(dbm_file, key);
2898         }
2899 #endif
2900       else if (!SSL_set_session(ssl, ss))
2901         {
2902         DEBUG(D_tls)
2903           {
2904           ERR_error_string_n(ERR_get_error(),
2905             ssl_errstring, sizeof(ssl_errstring));
2906           debug_printf("applying session to ssl: %s\n", ssl_errstring);
2907           }
2908         }
2909       else
2910         {
2911         DEBUG(D_tls) debug_printf("good session\n");
2912         tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
2913         tlsp->verify_override = dt->verify_override;
2914         tlsp->ocsp = dt->ocsp;
2915         }
2916       }
2917     else
2918       DEBUG(D_tls) debug_printf("no session record\n");
2919     dbfn_close(dbm_file);
2920     }
2921   }
2922 }
2923
2924
2925 /* On the client, save the session for later resumption */
2926
2927 static int
2928 tls_save_session_cb(SSL * ssl, SSL_SESSION * ss)
2929 {
2930 tls_ext_ctx_cb * cbinfo = SSL_get_ex_data(ssl, tls_exdata_idx);
2931 tls_support * tlsp;
2932
2933 DEBUG(D_tls) debug_printf("tls_save_session_cb\n");
2934
2935 if (!cbinfo || !(tlsp = cbinfo->tlsp)->host_resumable) return 0;
2936
2937 # ifdef OPENSSL_HAVE_NUM_TICKETS
2938 if (SSL_SESSION_is_resumable(ss))       /* 1.1.1 */
2939 # endif
2940   {
2941   int len = i2d_SSL_SESSION(ss, NULL);
2942   int dlen = sizeof(dbdata_tls_session) + len;
2943   dbdata_tls_session * dt = store_get(dlen, TRUE);
2944   uschar * s = dt->session;
2945   open_db dbblock, * dbm_file;
2946
2947   DEBUG(D_tls) debug_printf("session is resumable\n");
2948   tlsp->resumption |= RESUME_SERVER_TICKET;     /* server gave us a ticket */
2949
2950   dt->verify_override = tlsp->verify_override;
2951   dt->ocsp = tlsp->ocsp;
2952   (void) i2d_SSL_SESSION(ss, &s);               /* s gets bumped to end */
2953
2954   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
2955     {
2956     const uschar * key = cbinfo->host->address;
2957     dbfn_delete(dbm_file, key);
2958     dbfn_write(dbm_file, key, dt, dlen);
2959     dbfn_close(dbm_file);
2960     DEBUG(D_tls) debug_printf("wrote session (len %u) to db\n",
2961                   (unsigned)dlen);
2962     }
2963   }
2964 return 1;
2965 }
2966
2967
2968 static void
2969 tls_client_ctx_resume_prehandshake(
2970   exim_openssl_client_tls_ctx * exim_client_ctx, tls_support * tlsp,
2971   smtp_transport_options_block * ob, host_item * host)
2972 {
2973 /* Should the client request a session resumption ticket? */
2974 if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
2975   {
2976   tlsp->host_resumable = TRUE;
2977
2978   SSL_CTX_set_session_cache_mode(exim_client_ctx->ctx,
2979         SSL_SESS_CACHE_CLIENT
2980         | SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_NO_AUTO_CLEAR);
2981   SSL_CTX_sess_set_new_cb(exim_client_ctx->ctx, tls_save_session_cb);
2982   }
2983 }
2984
2985 static BOOL
2986 tls_client_ssl_resume_prehandshake(SSL * ssl, tls_support * tlsp,
2987   host_item * host, uschar ** errstr)
2988 {
2989 if (tlsp->host_resumable)
2990   {
2991   DEBUG(D_tls)
2992     debug_printf("tls_resumption_hosts overrides openssl_options, enabling tickets\n");
2993   SSL_clear_options(ssl, SSL_OP_NO_TICKET);
2994
2995   tls_exdata_idx = SSL_get_ex_new_index(0, 0, 0, 0, 0);
2996   if (!SSL_set_ex_data(ssl, tls_exdata_idx, client_static_cbinfo))
2997     {
2998     tls_error(US"set ex_data", host, NULL, errstr);
2999     return FALSE;
3000     }
3001   debug_printf("tls_exdata_idx %d cbinfo %p\n", tls_exdata_idx, client_static_cbinfo);
3002   }
3003
3004 tlsp->resumption = RESUME_SUPPORTED;
3005 /* Pick up a previous session, saved on an old ticket */
3006 tls_retrieve_session(tlsp, ssl, host->address);
3007 return TRUE;
3008 }
3009
3010 static void
3011 tls_client_resume_posthandshake(exim_openssl_client_tls_ctx * exim_client_ctx,
3012   tls_support * tlsp)
3013 {
3014 if (SSL_session_reused(exim_client_ctx->ssl))
3015   {
3016   DEBUG(D_tls) debug_printf("The session was reused\n");
3017   tlsp->resumption |= RESUME_USED;
3018   }
3019 }
3020 #endif  /* EXPERIMENTAL_TLS_RESUME */
3021
3022
3023 /*************************************************
3024 *    Start a TLS session in a client             *
3025 *************************************************/
3026
3027 /* Called from the smtp transport after STARTTLS has been accepted.
3028
3029 Arguments:
3030   cctx          connection context
3031   conn_args     connection details
3032   cookie        datum for randomness; can be NULL
3033   tlsp          record details of TLS channel configuration here; must be non-NULL
3034   errstr        error string pointer
3035
3036 Returns:        TRUE for success with TLS session context set in connection context,
3037                 FALSE on error
3038 */
3039
3040 BOOL
3041 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
3042   void * cookie, tls_support * tlsp, uschar ** errstr)
3043 {
3044 host_item * host = conn_args->host;             /* for msgs and option-tests */
3045 transport_instance * tb = conn_args->tblock;    /* always smtp or NULL */
3046 smtp_transport_options_block * ob = tb
3047   ? (smtp_transport_options_block *)tb->options_block
3048   : &smtp_transport_option_defaults;
3049 exim_openssl_client_tls_ctx * exim_client_ctx;
3050 uschar * expciphers;
3051 int rc;
3052 static uschar peerdn[256];
3053
3054 #ifndef DISABLE_OCSP
3055 BOOL request_ocsp = FALSE;
3056 BOOL require_ocsp = FALSE;
3057 #endif
3058
3059 rc = store_pool;
3060 store_pool = POOL_PERM;
3061 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx), FALSE);
3062 exim_client_ctx->corked = NULL;
3063 store_pool = rc;
3064
3065 #ifdef SUPPORT_DANE
3066 tlsp->tlsa_usage = 0;
3067 #endif
3068
3069 #ifndef DISABLE_OCSP
3070   {
3071 # ifdef SUPPORT_DANE
3072   if (  conn_args->dane
3073      && ob->hosts_request_ocsp[0] == '*'
3074      && ob->hosts_request_ocsp[1] == '\0'
3075      )
3076     {
3077     /* Unchanged from default.  Use a safer one under DANE */
3078     request_ocsp = TRUE;
3079     ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
3080                                       "   {= {4}{$tls_out_tlsa_usage}} } "
3081                                  " {*}{}}";
3082     }
3083 # endif
3084
3085   if ((require_ocsp =
3086         verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK))
3087     request_ocsp = TRUE;
3088   else
3089 # ifdef SUPPORT_DANE
3090     if (!request_ocsp)
3091 # endif
3092       request_ocsp =
3093         verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3094   }
3095 #endif
3096
3097 rc = tls_init(&exim_client_ctx->ctx, host, NULL,
3098     ob->tls_certificate, ob->tls_privatekey,
3099 #ifndef DISABLE_OCSP
3100     (void *)(long)request_ocsp,
3101 #endif
3102     cookie, &client_static_cbinfo, tlsp, errstr);
3103 if (rc != OK) return FALSE;
3104
3105 tlsp->certificate_verified = FALSE;
3106 client_verify_callback_called = FALSE;
3107
3108 expciphers = NULL;
3109 #ifdef SUPPORT_DANE
3110 if (conn_args->dane)
3111   {
3112   /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
3113   other failures should be treated as problems. */
3114   if (ob->dane_require_tls_ciphers &&
3115       !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
3116         &expciphers, errstr))
3117     return FALSE;
3118   if (expciphers && *expciphers == '\0')
3119     expciphers = NULL;
3120   }
3121 #endif
3122 if (!expciphers &&
3123     !expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
3124       &expciphers, errstr))
3125   return FALSE;
3126
3127 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
3128 are separated by underscores. So that I can use either form in my tests, and
3129 also for general convenience, we turn underscores into hyphens here. */
3130
3131 if (expciphers)
3132   {
3133   uschar *s = expciphers;
3134   while (*s) { if (*s == '_') *s = '-'; s++; }
3135   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
3136   if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
3137     {
3138     tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
3139     return FALSE;
3140     }
3141   }
3142
3143 #ifdef SUPPORT_DANE
3144 if (conn_args->dane)
3145   {
3146   SSL_CTX_set_verify(exim_client_ctx->ctx,
3147     SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
3148     verify_callback_client_dane);
3149
3150   if (!DANESSL_library_init())
3151     {
3152     tls_error(US"library init", host, NULL, errstr);
3153     return FALSE;
3154     }
3155   if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
3156     {
3157     tls_error(US"context init", host, NULL, errstr);
3158     return FALSE;
3159     }
3160   }
3161 else
3162
3163 #endif
3164
3165   if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
3166         client_static_cbinfo, errstr) != OK)
3167     return FALSE;
3168
3169 #ifdef EXPERIMENTAL_TLS_RESUME
3170 tls_client_ctx_resume_prehandshake(exim_client_ctx, tlsp, ob, host);
3171 #endif
3172
3173
3174 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
3175   {
3176   tls_error(US"SSL_new", host, NULL, errstr);
3177   return FALSE;
3178   }
3179 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
3180
3181 SSL_set_fd(exim_client_ctx->ssl, cctx->sock);
3182 SSL_set_connect_state(exim_client_ctx->ssl);
3183
3184 if (ob->tls_sni)
3185   {
3186   if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
3187     return FALSE;
3188   if (!tlsp->sni)
3189     {
3190     DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
3191     }
3192   else if (!Ustrlen(tlsp->sni))
3193     tlsp->sni = NULL;
3194   else
3195     {
3196 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
3197     DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
3198     SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
3199 #else
3200     log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
3201           tlsp->sni);
3202 #endif
3203     }
3204   }
3205
3206 #ifdef SUPPORT_DANE
3207 if (conn_args->dane)
3208   if (dane_tlsa_load(exim_client_ctx->ssl, host, &conn_args->tlsa_dnsa, errstr) != OK)
3209     return FALSE;
3210 #endif
3211
3212 #ifndef DISABLE_OCSP
3213 /* Request certificate status at connection-time.  If the server
3214 does OCSP stapling we will get the callback (set in tls_init()) */
3215 # ifdef SUPPORT_DANE
3216 if (request_ocsp)
3217   {
3218   const uschar * s;
3219   if (  ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3220      || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3221      )
3222     {   /* Re-eval now $tls_out_tlsa_usage is populated.  If
3223         this means we avoid the OCSP request, we wasted the setup
3224         cost in tls_init(). */
3225     require_ocsp = verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
3226     request_ocsp = require_ocsp
3227       || verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3228     }
3229   }
3230 # endif
3231
3232 if (request_ocsp)
3233   {
3234   SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
3235   client_static_cbinfo->u_ocsp.client.verify_required = require_ocsp;
3236   tlsp->ocsp = OCSP_NOT_RESP;
3237   }
3238 #endif
3239
3240 #ifdef EXPERIMENTAL_TLS_RESUME
3241 if (!tls_client_ssl_resume_prehandshake(exim_client_ctx->ssl, tlsp, host,
3242       errstr))
3243   return FALSE;
3244 #endif
3245
3246 #ifndef DISABLE_EVENT
3247 client_static_cbinfo->event_action = tb ? tb->event_action : NULL;
3248 #endif
3249
3250 /* There doesn't seem to be a built-in timeout on connection. */
3251
3252 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
3253 sigalrm_seen = FALSE;
3254 ALARM(ob->command_timeout);
3255 rc = SSL_connect(exim_client_ctx->ssl);
3256 ALARM_CLR(0);
3257
3258 #ifdef SUPPORT_DANE
3259 if (conn_args->dane)
3260   DANESSL_cleanup(exim_client_ctx->ssl);
3261 #endif
3262
3263 if (rc <= 0)
3264   {
3265   tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
3266   return FALSE;
3267   }
3268
3269 DEBUG(D_tls)
3270   {
3271   debug_printf("SSL_connect succeeded\n");
3272 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3273   {
3274   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
3275   SSL_SESSION_print_keylog(bp, SSL_get_session(exim_client_ctx->ssl));
3276   BIO_free(bp);
3277   }
3278 #endif
3279   }
3280
3281 #ifdef EXPERIMENTAL_TLS_RESUME
3282 tls_client_resume_posthandshake(exim_client_ctx, tlsp);
3283 #endif
3284
3285 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
3286
3287 tlsp->cipher = construct_cipher_name(exim_client_ctx->ssl, &tlsp->bits);
3288 tlsp->cipher_stdname = cipher_stdname_ssl(exim_client_ctx->ssl);
3289
3290 /* Record the certificate we presented */
3291   {
3292   X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
3293   tlsp->ourcert = crt ? X509_dup(crt) : NULL;
3294   }
3295
3296 tlsp->active.sock = cctx->sock;
3297 tlsp->active.tls_ctx = exim_client_ctx;
3298 cctx->tls_ctx = exim_client_ctx;
3299 return TRUE;
3300 }
3301
3302
3303
3304
3305
3306 static BOOL
3307 tls_refill(unsigned lim)
3308 {
3309 int error;
3310 int inbytes;
3311
3312 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", server_ssl,
3313   ssl_xfer_buffer, ssl_xfer_buffer_size);
3314
3315 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3316 inbytes = SSL_read(server_ssl, CS ssl_xfer_buffer,
3317                   MIN(ssl_xfer_buffer_size, lim));
3318 error = SSL_get_error(server_ssl, inbytes);
3319 if (smtp_receive_timeout > 0) ALARM_CLR(0);
3320
3321 if (had_command_timeout)                /* set by signal handler */
3322   smtp_command_timeout_exit();          /* does not return */
3323 if (had_command_sigterm)
3324   smtp_command_sigterm_exit();
3325 if (had_data_timeout)
3326   smtp_data_timeout_exit();
3327 if (had_data_sigint)
3328   smtp_data_sigint_exit();
3329
3330 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
3331 closed down, not that the socket itself has been closed down. Revert to
3332 non-SSL handling. */
3333
3334 switch(error)
3335   {
3336   case SSL_ERROR_NONE:
3337     break;
3338
3339   case SSL_ERROR_ZERO_RETURN:
3340     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3341
3342     if (SSL_get_shutdown(server_ssl) == SSL_RECEIVED_SHUTDOWN)
3343           SSL_shutdown(server_ssl);
3344
3345     tls_close(NULL, TLS_NO_SHUTDOWN);
3346     return FALSE;
3347
3348   /* Handle genuine errors */
3349   case SSL_ERROR_SSL:
3350     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3351     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
3352     ssl_xfer_error = TRUE;
3353     return FALSE;
3354
3355   default:
3356     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
3357     DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
3358       debug_printf(" - syscall %s\n", strerror(errno));
3359     ssl_xfer_error = TRUE;
3360     return FALSE;
3361   }
3362
3363 #ifndef DISABLE_DKIM
3364 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
3365 #endif
3366 ssl_xfer_buffer_hwm = inbytes;
3367 ssl_xfer_buffer_lwm = 0;
3368 return TRUE;
3369 }
3370
3371
3372 /*************************************************
3373 *            TLS version of getc                 *
3374 *************************************************/
3375
3376 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
3377 it refills the buffer via the SSL reading function.
3378
3379 Arguments:  lim         Maximum amount to read/buffer
3380 Returns:    the next character or EOF
3381
3382 Only used by the server-side TLS.
3383 */
3384
3385 int
3386 tls_getc(unsigned lim)
3387 {
3388 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
3389   if (!tls_refill(lim))
3390     return ssl_xfer_error ? EOF : smtp_getc(lim);
3391
3392 /* Something in the buffer; return next uschar */
3393
3394 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
3395 }
3396
3397 uschar *
3398 tls_getbuf(unsigned * len)
3399 {
3400 unsigned size;
3401 uschar * buf;
3402
3403 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
3404   if (!tls_refill(*len))
3405     {
3406     if (!ssl_xfer_error) return smtp_getbuf(len);
3407     *len = 0;
3408     return NULL;
3409     }
3410
3411 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
3412   size = *len;
3413 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
3414 ssl_xfer_buffer_lwm += size;
3415 *len = size;
3416 return buf;
3417 }
3418
3419
3420 void
3421 tls_get_cache()
3422 {
3423 #ifndef DISABLE_DKIM
3424 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
3425 if (n > 0)
3426   dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
3427 #endif
3428 }
3429
3430
3431 BOOL
3432 tls_could_read(void)
3433 {
3434 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm || SSL_pending(server_ssl) > 0;
3435 }
3436
3437
3438 /*************************************************
3439 *          Read bytes from TLS channel           *
3440 *************************************************/
3441
3442 /*
3443 Arguments:
3444   ct_ctx    client context pointer, or NULL for the one global server context
3445   buff      buffer of data
3446   len       size of buffer
3447
3448 Returns:    the number of bytes read
3449             -1 after a failed read, including EOF
3450
3451 Only used by the client-side TLS.
3452 */
3453
3454 int
3455 tls_read(void * ct_ctx, uschar *buff, size_t len)
3456 {
3457 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
3458 int inbytes;
3459 int error;
3460
3461 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
3462   buff, (unsigned int)len);
3463
3464 inbytes = SSL_read(ssl, CS buff, len);
3465 error = SSL_get_error(ssl, inbytes);
3466
3467 if (error == SSL_ERROR_ZERO_RETURN)
3468   {
3469   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3470   return -1;
3471   }
3472 else if (error != SSL_ERROR_NONE)
3473   return -1;
3474
3475 return inbytes;
3476 }
3477
3478
3479
3480
3481
3482 /*************************************************
3483 *         Write bytes down TLS channel           *
3484 *************************************************/
3485
3486 /*
3487 Arguments:
3488   ct_ctx    client context pointer, or NULL for the one global server context
3489   buff      buffer of data
3490   len       number of bytes
3491   more      further data expected soon
3492
3493 Returns:    the number of bytes after a successful write,
3494             -1 after a failed write
3495
3496 Used by both server-side and client-side TLS.
3497 */
3498
3499 int
3500 tls_write(void * ct_ctx, const uschar *buff, size_t len, BOOL more)
3501 {
3502 size_t olen = len;
3503 int outbytes, error;
3504 SSL * ssl = ct_ctx
3505   ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
3506 static gstring * server_corked = NULL;
3507 gstring ** corkedp = ct_ctx
3508   ? &((exim_openssl_client_tls_ctx *)ct_ctx)->corked : &server_corked;
3509 gstring * corked = *corkedp;
3510
3511 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
3512   buff, (unsigned long)len, more ? ", more" : "");
3513
3514 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
3515 "more" is notified.  This hack is only ok if small amounts are involved AND only
3516 one stream does it, in one context (i.e. no store reset).  Currently it is used
3517 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only.
3518 We support callouts done by the server process by using a separate client
3519 context for the stashed information. */
3520 /* + if PIPE_COMMAND, banner & ehlo-resp for smmtp-on-connect. Suspect there's
3521 a store reset there, so use POOL_PERM. */
3522 /* + if CHUNKING, cmds EHLO,MAIL,RCPT(s),BDAT */
3523
3524 if ((more || corked))
3525   {
3526 #ifdef SUPPORT_PIPE_CONNECT
3527   int save_pool = store_pool;
3528   store_pool = POOL_PERM;
3529 #endif
3530
3531   corked = string_catn(corked, buff, len);
3532
3533 #ifdef SUPPORT_PIPE_CONNECT
3534   store_pool = save_pool;
3535 #endif
3536
3537   if (more)
3538     {
3539     *corkedp = corked;
3540     return len;
3541     }
3542   buff = CUS corked->s;
3543   len = corked->ptr;
3544   *corkedp = NULL;
3545   }
3546
3547 for (int left = len; left > 0;)
3548   {
3549   DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
3550   outbytes = SSL_write(ssl, CS buff, left);
3551   error = SSL_get_error(ssl, outbytes);
3552   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
3553   switch (error)
3554     {
3555     case SSL_ERROR_SSL:
3556       ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3557       log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
3558       return -1;
3559
3560     case SSL_ERROR_NONE:
3561       left -= outbytes;
3562       buff += outbytes;
3563       break;
3564
3565     case SSL_ERROR_ZERO_RETURN:
3566       log_write(0, LOG_MAIN, "SSL channel closed on write");
3567       return -1;
3568
3569     case SSL_ERROR_SYSCALL:
3570       log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
3571         sender_fullhost ? sender_fullhost : US"<unknown>",
3572         strerror(errno));
3573       return -1;
3574
3575     default:
3576       log_write(0, LOG_MAIN, "SSL_write error %d", error);
3577       return -1;
3578     }
3579   }
3580 return olen;
3581 }
3582
3583
3584
3585 /*************************************************
3586 *         Close down a TLS session               *
3587 *************************************************/
3588
3589 /* This is also called from within a delivery subprocess forked from the
3590 daemon, to shut down the TLS library, without actually doing a shutdown (which
3591 would tamper with the SSL session in the parent process).
3592
3593 Arguments:
3594   ct_ctx        client TLS context pointer, or NULL for the one global server context
3595   shutdown      1 if TLS close-alert is to be sent,
3596                 2 if also response to be waited for
3597
3598 Returns:     nothing
3599
3600 Used by both server-side and client-side TLS.
3601 */
3602
3603 void
3604 tls_close(void * ct_ctx, int shutdown)
3605 {
3606 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
3607 SSL_CTX **ctxp = o_ctx ? &o_ctx->ctx : &server_ctx;
3608 SSL **sslp =     o_ctx ? &o_ctx->ssl : &server_ssl;
3609 int *fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
3610
3611 if (*fdp < 0) return;  /* TLS was not active */
3612
3613 if (shutdown)
3614   {
3615   int rc;
3616   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
3617     shutdown > 1 ? " (with response-wait)" : "");
3618
3619   if (  (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
3620      && shutdown > 1)
3621     {
3622     ALARM(2);
3623     rc = SSL_shutdown(*sslp);           /* wait for response */
3624     ALARM_CLR(0);
3625     }
3626
3627   if (rc < 0) DEBUG(D_tls)
3628     {
3629     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3630     debug_printf("SSL_shutdown: %s\n", ssl_errstring);
3631     }
3632   }
3633
3634 if (!o_ctx)             /* server side */
3635   {
3636 #ifndef DISABLE_OCSP
3637   sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
3638   server_static_cbinfo->verify_stack = NULL;
3639 #endif
3640
3641   receive_getc =        smtp_getc;
3642   receive_getbuf =      smtp_getbuf;
3643   receive_get_cache =   smtp_get_cache;
3644   receive_ungetc =      smtp_ungetc;
3645   receive_feof =        smtp_feof;
3646   receive_ferror =      smtp_ferror;
3647   receive_smtp_buffered = smtp_buffered;
3648   tls_in.active.tls_ctx = NULL;
3649   tls_in.sni = NULL;
3650   /* Leave bits, peercert, cipher, peerdn, certificate_verified set, for logging */
3651   }
3652
3653 SSL_CTX_free(*ctxp);
3654 SSL_free(*sslp);
3655 *ctxp = NULL;
3656 *sslp = NULL;
3657 *fdp = -1;
3658 }
3659
3660
3661
3662
3663 /*************************************************
3664 *  Let tls_require_ciphers be checked at startup *
3665 *************************************************/
3666
3667 /* The tls_require_ciphers option, if set, must be something which the
3668 library can parse.
3669
3670 Returns:     NULL on success, or error message
3671 */
3672
3673 uschar *
3674 tls_validate_require_cipher(void)
3675 {
3676 SSL_CTX *ctx;
3677 uschar *s, *expciphers, *err;
3678
3679 tls_openssl_init();
3680
3681 if (!(tls_require_ciphers && *tls_require_ciphers))
3682   return NULL;
3683
3684 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
3685                   &err))
3686   return US"failed to expand tls_require_ciphers";
3687
3688 if (!(expciphers && *expciphers))
3689   return NULL;
3690
3691 /* normalisation ripped from above */
3692 s = expciphers;
3693 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
3694
3695 err = NULL;
3696
3697 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
3698 if (!(ctx = SSL_CTX_new(TLS_server_method())))
3699 #else
3700 if (!(ctx = SSL_CTX_new(SSLv23_server_method())))
3701 #endif
3702   {
3703   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3704   return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
3705   }
3706
3707 DEBUG(D_tls)
3708   debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
3709
3710 if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
3711   {
3712   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3713   err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
3714                       expciphers, ssl_errstring);
3715   }
3716
3717 SSL_CTX_free(ctx);
3718
3719 return err;
3720 }
3721
3722
3723
3724
3725 /*************************************************
3726 *         Report the library versions.           *
3727 *************************************************/
3728
3729 /* There have historically been some issues with binary compatibility in
3730 OpenSSL libraries; if Exim (like many other applications) is built against
3731 one version of OpenSSL but the run-time linker picks up another version,
3732 it can result in serious failures, including crashing with a SIGSEGV.  So
3733 report the version found by the compiler and the run-time version.
3734
3735 Note: some OS vendors backport security fixes without changing the version
3736 number/string, and the version date remains unchanged.  The _build_ date
3737 will change, so we can more usefully assist with version diagnosis by also
3738 reporting the build date.
3739
3740 Arguments:   a FILE* to print the results to
3741 Returns:     nothing
3742 */
3743
3744 void
3745 tls_version_report(FILE *f)
3746 {
3747 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
3748            "                          Runtime: %s\n"
3749            "                                 : %s\n",
3750            OPENSSL_VERSION_TEXT,
3751            SSLeay_version(SSLEAY_VERSION),
3752            SSLeay_version(SSLEAY_BUILT_ON));
3753 /* third line is 38 characters for the %s and the line is 73 chars long;
3754 the OpenSSL output includes a "built on: " prefix already. */
3755 }
3756
3757
3758
3759
3760 /*************************************************
3761 *            Random number generation            *
3762 *************************************************/
3763
3764 /* Pseudo-random number generation.  The result is not expected to be
3765 cryptographically strong but not so weak that someone will shoot themselves
3766 in the foot using it as a nonce in input in some email header scheme or
3767 whatever weirdness they'll twist this into.  The result should handle fork()
3768 and avoid repeating sequences.  OpenSSL handles that for us.
3769
3770 Arguments:
3771   max       range maximum
3772 Returns     a random number in range [0, max-1]
3773 */
3774
3775 int
3776 vaguely_random_number(int max)
3777 {
3778 unsigned int r;
3779 int i, needed_len;
3780 static pid_t pidlast = 0;
3781 pid_t pidnow;
3782 uschar smallbuf[sizeof(r)];
3783
3784 if (max <= 1)
3785   return 0;
3786
3787 pidnow = getpid();
3788 if (pidnow != pidlast)
3789   {
3790   /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
3791   is unique for each thread", this doesn't apparently apply across processes,
3792   so our own warning from vaguely_random_number_fallback() applies here too.
3793   Fix per PostgreSQL. */
3794   if (pidlast != 0)
3795     RAND_cleanup();
3796   pidlast = pidnow;
3797   }
3798
3799 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
3800 if (!RAND_status())
3801   {
3802   randstuff r;
3803   gettimeofday(&r.tv, NULL);
3804   r.p = getpid();
3805
3806   RAND_seed(US (&r), sizeof(r));
3807   }
3808 /* We're after pseudo-random, not random; if we still don't have enough data
3809 in the internal PRNG then our options are limited.  We could sleep and hope
3810 for entropy to come along (prayer technique) but if the system is so depleted
3811 in the first place then something is likely to just keep taking it.  Instead,
3812 we'll just take whatever little bit of pseudo-random we can still manage to
3813 get. */
3814
3815 needed_len = sizeof(r);
3816 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
3817 asked for a number less than 10. */
3818 for (r = max, i = 0; r; ++i)
3819   r >>= 1;
3820 i = (i + 7) / 8;
3821 if (i < needed_len)
3822   needed_len = i;
3823
3824 #ifdef EXIM_HAVE_RAND_PSEUDO
3825 /* We do not care if crypto-strong */
3826 i = RAND_pseudo_bytes(smallbuf, needed_len);
3827 #else
3828 i = RAND_bytes(smallbuf, needed_len);
3829 #endif
3830
3831 if (i < 0)
3832   {
3833   DEBUG(D_all)
3834     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
3835   return vaguely_random_number_fallback(max);
3836   }
3837
3838 r = 0;
3839 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
3840   r = 256 * r + *p;
3841
3842 /* We don't particularly care about weighted results; if someone wants
3843 smooth distribution and cares enough then they should submit a patch then. */
3844 return r % max;
3845 }
3846
3847
3848
3849
3850 /*************************************************
3851 *        OpenSSL option parse                    *
3852 *************************************************/
3853
3854 /* Parse one option for tls_openssl_options_parse below
3855
3856 Arguments:
3857   name    one option name
3858   value   place to store a value for it
3859 Returns   success or failure in parsing
3860 */
3861
3862
3863
3864 static BOOL
3865 tls_openssl_one_option_parse(uschar *name, long *value)
3866 {
3867 int first = 0;
3868 int last = exim_openssl_options_size;
3869 while (last > first)
3870   {
3871   int middle = (first + last)/2;
3872   int c = Ustrcmp(name, exim_openssl_options[middle].name);
3873   if (c == 0)
3874     {
3875     *value = exim_openssl_options[middle].value;
3876     return TRUE;
3877     }
3878   else if (c > 0)
3879     first = middle + 1;
3880   else
3881     last = middle;
3882   }
3883 return FALSE;
3884 }
3885
3886
3887
3888
3889 /*************************************************
3890 *        OpenSSL option parsing logic            *
3891 *************************************************/
3892
3893 /* OpenSSL has a number of compatibility options which an administrator might
3894 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
3895 we look like log_selector.
3896
3897 Arguments:
3898   option_spec  the administrator-supplied string of options
3899   results      ptr to long storage for the options bitmap
3900 Returns        success or failure
3901 */
3902
3903 BOOL
3904 tls_openssl_options_parse(uschar *option_spec, long *results)
3905 {
3906 long result, item;
3907 uschar *end;
3908 uschar keep_c;
3909 BOOL adding, item_parsed;
3910
3911 /* Server: send no (<= TLS1.2) session tickets */
3912 result = SSL_OP_NO_TICKET;
3913
3914 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
3915  * from default because it increases BEAST susceptibility. */
3916 #ifdef SSL_OP_NO_SSLv2
3917 result |= SSL_OP_NO_SSLv2;
3918 #endif
3919 #ifdef SSL_OP_NO_SSLv3
3920 result |= SSL_OP_NO_SSLv3;
3921 #endif
3922 #ifdef SSL_OP_SINGLE_DH_USE
3923 result |= SSL_OP_SINGLE_DH_USE;
3924 #endif
3925
3926 if (!option_spec)
3927   {
3928   *results = result;
3929   return TRUE;
3930   }
3931
3932 for (uschar * s = option_spec; *s; /**/)
3933   {
3934   while (isspace(*s)) ++s;
3935   if (*s == '\0')
3936     break;
3937   if (*s != '+' && *s != '-')
3938     {
3939     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
3940         "+ or - expected but found \"%s\"\n", s);
3941     return FALSE;
3942     }
3943   adding = *s++ == '+';
3944   for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
3945   keep_c = *end;
3946   *end = '\0';
3947   item_parsed = tls_openssl_one_option_parse(s, &item);
3948   *end = keep_c;
3949   if (!item_parsed)
3950     {
3951     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
3952     return FALSE;
3953     }
3954   DEBUG(D_tls) debug_printf("openssl option, %s %8lx: %lx (%s)\n",
3955       adding ? "adding to    " : "removing from", result, item, s);
3956   if (adding)
3957     result |= item;
3958   else
3959     result &= ~item;
3960   s = end;
3961   }
3962
3963 *results = result;
3964 return TRUE;
3965 }
3966
3967 #endif  /*!MACRO_PREDEF*/
3968 /* vi: aw ai sw=2
3969 */
3970 /* End of tls-openssl.c */