src/src/tls-openssl.c

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