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