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       {
2710       uschar * s = US"SSL_accept";
2711       ulong e = ERR_peek_error();
2712       if (ERR_GET_REASON(e) == SSL_R_WRONG_VERSION_NUMBER)
2713         s = string_sprintf("%s (%s)", s, SSL_get_version(server_ssl));
2714       (void) tls_error(s, NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
2715       return FAIL;
2716       }
2717
2718     default:
2719       DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
2720       if (error == SSL_ERROR_SYSCALL)
2721         {
2722         if (!errno)
2723           {
2724           *errstr = US"SSL_accept: TCP connection closed by peer";
2725           return FAIL;
2726           }
2727         DEBUG(D_tls) debug_printf(" - syscall %s\n", strerror(errno));
2728         }
2729       (void) tls_error(US"SSL_accept", NULL, sigalrm_seen ? US"timed out" : NULL, errstr);
2730       return FAIL;
2731     }
2732   }
2733
2734 DEBUG(D_tls) debug_printf("SSL_accept was successful\n");
2735 ERR_clear_error();      /* Even success can leave errors in the stack. Seen with
2736                         anon-authentication ciphersuite negotiated. */
2737
2738 #ifdef EXPERIMENTAL_TLS_RESUME
2739 if (SSL_session_reused(server_ssl))
2740   {
2741   tls_in.resumption |= RESUME_USED;
2742   DEBUG(D_tls) debug_printf("Session reused\n");
2743   }
2744 #endif
2745
2746 /* TLS has been set up. Adjust the input functions to read via TLS,
2747 and initialize things. */
2748
2749 peer_cert(server_ssl, &tls_in, peerdn, sizeof(peerdn));
2750
2751 tls_in.cipher = construct_cipher_name(server_ssl, &tls_in.bits);
2752 tls_in.cipher_stdname = cipher_stdname_ssl(server_ssl);
2753
2754 DEBUG(D_tls)
2755   {
2756   uschar buf[2048];
2757   if (SSL_get_shared_ciphers(server_ssl, CS buf, sizeof(buf)))
2758     debug_printf("Shared ciphers: %s\n", buf);
2759
2760 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
2761   {
2762   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
2763   SSL_SESSION_print_keylog(bp, SSL_get_session(server_ssl));
2764   BIO_free(bp);
2765   }
2766 #endif
2767
2768 #ifdef EXIM_HAVE_SESSION_TICKET
2769   {
2770   SSL_SESSION * ss = SSL_get_session(server_ssl);
2771   if (SSL_SESSION_has_ticket(ss))       /* 1.1.0 */
2772     debug_printf("The session has a ticket, life %lu seconds\n",
2773       SSL_SESSION_get_ticket_lifetime_hint(ss));
2774   }
2775 #endif
2776   }
2777
2778 /* Record the certificate we presented */
2779   {
2780   X509 * crt = SSL_get_certificate(server_ssl);
2781   tls_in.ourcert = crt ? X509_dup(crt) : NULL;
2782   }
2783
2784 /* Only used by the server-side tls (tls_in), including tls_getc.
2785    Client-side (tls_out) reads (seem to?) go via
2786    smtp_read_response()/ip_recv().
2787    Hence no need to duplicate for _in and _out.
2788  */
2789 if (!ssl_xfer_buffer) ssl_xfer_buffer = store_malloc(ssl_xfer_buffer_size);
2790 ssl_xfer_buffer_lwm = ssl_xfer_buffer_hwm = 0;
2791 ssl_xfer_eof = ssl_xfer_error = FALSE;
2792
2793 receive_getc = tls_getc;
2794 receive_getbuf = tls_getbuf;
2795 receive_get_cache = tls_get_cache;
2796 receive_ungetc = tls_ungetc;
2797 receive_feof = tls_feof;
2798 receive_ferror = tls_ferror;
2799 receive_smtp_buffered = tls_smtp_buffered;
2800
2801 tls_in.active.sock = fileno(smtp_out);
2802 tls_in.active.tls_ctx = NULL;   /* not using explicit ctx for server-side */
2803 return OK;
2804 }
2805
2806
2807
2808
2809 static int
2810 tls_client_basic_ctx_init(SSL_CTX * ctx,
2811     host_item * host, smtp_transport_options_block * ob, tls_ext_ctx_cb * cbinfo,
2812     uschar ** errstr)
2813 {
2814 int rc;
2815 /* stick to the old behaviour for compatibility if tls_verify_certificates is
2816    set but both tls_verify_hosts and tls_try_verify_hosts is not set. Check only
2817    the specified host patterns if one of them is defined */
2818
2819 if (  (  !ob->tls_verify_hosts
2820       && (!ob->tls_try_verify_hosts || !*ob->tls_try_verify_hosts)
2821       )
2822    || verify_check_given_host(CUSS &ob->tls_verify_hosts, host) == OK
2823    )
2824   client_verify_optional = FALSE;
2825 else if (verify_check_given_host(CUSS &ob->tls_try_verify_hosts, host) == OK)
2826   client_verify_optional = TRUE;
2827 else
2828   return OK;
2829
2830 if ((rc = setup_certs(ctx, ob->tls_verify_certificates,
2831       ob->tls_crl, host, client_verify_optional, verify_callback_client,
2832       errstr)) != OK)
2833   return rc;
2834
2835 if (verify_check_given_host(CUSS &ob->tls_verify_cert_hostnames, host) == OK)
2836   {
2837   cbinfo->verify_cert_hostnames =
2838 #ifdef SUPPORT_I18N
2839     string_domain_utf8_to_alabel(host->name, NULL);
2840 #else
2841     host->name;
2842 #endif
2843   DEBUG(D_tls) debug_printf("Cert hostname to check: \"%s\"\n",
2844                     cbinfo->verify_cert_hostnames);
2845   }
2846 return OK;
2847 }
2848
2849
2850 #ifdef SUPPORT_DANE
2851 static int
2852 dane_tlsa_load(SSL * ssl, host_item * host, dns_answer * dnsa, uschar ** errstr)
2853 {
2854 dns_scan dnss;
2855 const char * hostnames[2] = { CS host->name, NULL };
2856 int found = 0;
2857
2858 if (DANESSL_init(ssl, NULL, hostnames) != 1)
2859   return tls_error(US"hostnames load", host, NULL, errstr);
2860
2861 for (dns_record * rr = dns_next_rr(dnsa, &dnss, RESET_ANSWERS); rr;
2862      rr = dns_next_rr(dnsa, &dnss, RESET_NEXT)
2863     ) if (rr->type == T_TLSA && rr->size > 3)
2864   {
2865   const uschar * p = rr->data;
2866   uint8_t usage, selector, mtype;
2867   const char * mdname;
2868
2869   usage = *p++;
2870
2871   /* Only DANE-TA(2) and DANE-EE(3) are supported */
2872   if (usage != 2 && usage != 3) continue;
2873
2874   selector = *p++;
2875   mtype = *p++;
2876
2877   switch (mtype)
2878     {
2879     default: continue;  /* Only match-types 0, 1, 2 are supported */
2880     case 0:  mdname = NULL; break;
2881     case 1:  mdname = "sha256"; break;
2882     case 2:  mdname = "sha512"; break;
2883     }
2884
2885   found++;
2886   switch (DANESSL_add_tlsa(ssl, usage, selector, mdname, p, rr->size - 3))
2887     {
2888     default:
2889       return tls_error(US"tlsa load", host, NULL, errstr);
2890     case 0:     /* action not taken */
2891     case 1:     break;
2892     }
2893
2894   tls_out.tlsa_usage |= 1<<usage;
2895   }
2896
2897 if (found)
2898   return OK;
2899
2900 log_write(0, LOG_MAIN, "DANE error: No usable TLSA records");
2901 return DEFER;
2902 }
2903 #endif  /*SUPPORT_DANE*/
2904
2905
2906
2907 #ifdef EXPERIMENTAL_TLS_RESUME
2908 /* On the client, get any stashed session for the given IP from hints db
2909 and apply it to the ssl-connection for attempted resumption. */
2910
2911 static void
2912 tls_retrieve_session(tls_support * tlsp, SSL * ssl, const uschar * key)
2913 {
2914 tlsp->resumption |= RESUME_SUPPORTED;
2915 if (tlsp->host_resumable)
2916   {
2917   dbdata_tls_session * dt;
2918   int len;
2919   open_db dbblock, * dbm_file;
2920
2921   tlsp->resumption |= RESUME_CLIENT_REQUESTED;
2922   DEBUG(D_tls) debug_printf("checking for resumable session for %s\n", key);
2923   if ((dbm_file = dbfn_open(US"tls", O_RDONLY, &dbblock, FALSE, FALSE)))
2924     {
2925     /* key for the db is the IP */
2926     if ((dt = dbfn_read_with_length(dbm_file, key, &len)))
2927       {
2928       SSL_SESSION * ss = NULL;
2929       const uschar * sess_asn1 = dt->session;
2930
2931       len -= sizeof(dbdata_tls_session);
2932       if (!(d2i_SSL_SESSION(&ss, &sess_asn1, (long)len)))
2933         {
2934         DEBUG(D_tls)
2935           {
2936           ERR_error_string_n(ERR_get_error(),
2937             ssl_errstring, sizeof(ssl_errstring));
2938           debug_printf("decoding session: %s\n", ssl_errstring);
2939           }
2940         }
2941 #ifdef EXIM_HAVE_SESSION_TICKET
2942       else if ( SSL_SESSION_get_ticket_lifetime_hint(ss) + dt->time_stamp
2943                < time(NULL))
2944         {
2945         DEBUG(D_tls) debug_printf("session expired\n");
2946         dbfn_delete(dbm_file, key);
2947         }
2948 #endif
2949       else if (!SSL_set_session(ssl, ss))
2950         {
2951         DEBUG(D_tls)
2952           {
2953           ERR_error_string_n(ERR_get_error(),
2954             ssl_errstring, sizeof(ssl_errstring));
2955           debug_printf("applying session to ssl: %s\n", ssl_errstring);
2956           }
2957         }
2958       else
2959         {
2960         DEBUG(D_tls) debug_printf("good session\n");
2961         tlsp->resumption |= RESUME_CLIENT_SUGGESTED;
2962         tlsp->verify_override = dt->verify_override;
2963         tlsp->ocsp = dt->ocsp;
2964         }
2965       }
2966     else
2967       DEBUG(D_tls) debug_printf("no session record\n");
2968     dbfn_close(dbm_file);
2969     }
2970   }
2971 }
2972
2973
2974 /* On the client, save the session for later resumption */
2975
2976 static int
2977 tls_save_session_cb(SSL * ssl, SSL_SESSION * ss)
2978 {
2979 tls_ext_ctx_cb * cbinfo = SSL_get_ex_data(ssl, tls_exdata_idx);
2980 tls_support * tlsp;
2981
2982 DEBUG(D_tls) debug_printf("tls_save_session_cb\n");
2983
2984 if (!cbinfo || !(tlsp = cbinfo->tlsp)->host_resumable) return 0;
2985
2986 # ifdef OPENSSL_HAVE_NUM_TICKETS
2987 if (SSL_SESSION_is_resumable(ss))       /* 1.1.1 */
2988 # endif
2989   {
2990   int len = i2d_SSL_SESSION(ss, NULL);
2991   int dlen = sizeof(dbdata_tls_session) + len;
2992   dbdata_tls_session * dt = store_get(dlen, TRUE);
2993   uschar * s = dt->session;
2994   open_db dbblock, * dbm_file;
2995
2996   DEBUG(D_tls) debug_printf("session is resumable\n");
2997   tlsp->resumption |= RESUME_SERVER_TICKET;     /* server gave us a ticket */
2998
2999   dt->verify_override = tlsp->verify_override;
3000   dt->ocsp = tlsp->ocsp;
3001   (void) i2d_SSL_SESSION(ss, &s);               /* s gets bumped to end */
3002
3003   if ((dbm_file = dbfn_open(US"tls", O_RDWR, &dbblock, FALSE, FALSE)))
3004     {
3005     const uschar * key = cbinfo->host->address;
3006     dbfn_delete(dbm_file, key);
3007     dbfn_write(dbm_file, key, dt, dlen);
3008     dbfn_close(dbm_file);
3009     DEBUG(D_tls) debug_printf("wrote session (len %u) to db\n",
3010                   (unsigned)dlen);
3011     }
3012   }
3013 return 1;
3014 }
3015
3016
3017 static void
3018 tls_client_ctx_resume_prehandshake(
3019   exim_openssl_client_tls_ctx * exim_client_ctx, tls_support * tlsp,
3020   smtp_transport_options_block * ob, host_item * host)
3021 {
3022 /* Should the client request a session resumption ticket? */
3023 if (verify_check_given_host(CUSS &ob->tls_resumption_hosts, host) == OK)
3024   {
3025   tlsp->host_resumable = TRUE;
3026
3027   SSL_CTX_set_session_cache_mode(exim_client_ctx->ctx,
3028         SSL_SESS_CACHE_CLIENT
3029         | SSL_SESS_CACHE_NO_INTERNAL | SSL_SESS_CACHE_NO_AUTO_CLEAR);
3030   SSL_CTX_sess_set_new_cb(exim_client_ctx->ctx, tls_save_session_cb);
3031   }
3032 }
3033
3034 static BOOL
3035 tls_client_ssl_resume_prehandshake(SSL * ssl, tls_support * tlsp,
3036   host_item * host, uschar ** errstr)
3037 {
3038 if (tlsp->host_resumable)
3039   {
3040   DEBUG(D_tls)
3041     debug_printf("tls_resumption_hosts overrides openssl_options, enabling tickets\n");
3042   SSL_clear_options(ssl, SSL_OP_NO_TICKET);
3043
3044   tls_exdata_idx = SSL_get_ex_new_index(0, 0, 0, 0, 0);
3045   if (!SSL_set_ex_data(ssl, tls_exdata_idx, client_static_cbinfo))
3046     {
3047     tls_error(US"set ex_data", host, NULL, errstr);
3048     return FALSE;
3049     }
3050   debug_printf("tls_exdata_idx %d cbinfo %p\n", tls_exdata_idx, client_static_cbinfo);
3051   }
3052
3053 tlsp->resumption = RESUME_SUPPORTED;
3054 /* Pick up a previous session, saved on an old ticket */
3055 tls_retrieve_session(tlsp, ssl, host->address);
3056 return TRUE;
3057 }
3058
3059 static void
3060 tls_client_resume_posthandshake(exim_openssl_client_tls_ctx * exim_client_ctx,
3061   tls_support * tlsp)
3062 {
3063 if (SSL_session_reused(exim_client_ctx->ssl))
3064   {
3065   DEBUG(D_tls) debug_printf("The session was reused\n");
3066   tlsp->resumption |= RESUME_USED;
3067   }
3068 }
3069 #endif  /* EXPERIMENTAL_TLS_RESUME */
3070
3071
3072 /*************************************************
3073 *    Start a TLS session in a client             *
3074 *************************************************/
3075
3076 /* Called from the smtp transport after STARTTLS has been accepted.
3077
3078 Arguments:
3079   cctx          connection context
3080   conn_args     connection details
3081   cookie        datum for randomness; can be NULL
3082   tlsp          record details of TLS channel configuration here; must be non-NULL
3083   errstr        error string pointer
3084
3085 Returns:        TRUE for success with TLS session context set in connection context,
3086                 FALSE on error
3087 */
3088
3089 BOOL
3090 tls_client_start(client_conn_ctx * cctx, smtp_connect_args * conn_args,
3091   void * cookie, tls_support * tlsp, uschar ** errstr)
3092 {
3093 host_item * host = conn_args->host;             /* for msgs and option-tests */
3094 transport_instance * tb = conn_args->tblock;    /* always smtp or NULL */
3095 smtp_transport_options_block * ob = tb
3096   ? (smtp_transport_options_block *)tb->options_block
3097   : &smtp_transport_option_defaults;
3098 exim_openssl_client_tls_ctx * exim_client_ctx;
3099 uschar * expciphers;
3100 int rc;
3101 static uschar peerdn[256];
3102
3103 #ifndef DISABLE_OCSP
3104 BOOL request_ocsp = FALSE;
3105 BOOL require_ocsp = FALSE;
3106 #endif
3107
3108 rc = store_pool;
3109 store_pool = POOL_PERM;
3110 exim_client_ctx = store_get(sizeof(exim_openssl_client_tls_ctx), FALSE);
3111 exim_client_ctx->corked = NULL;
3112 store_pool = rc;
3113
3114 #ifdef SUPPORT_DANE
3115 tlsp->tlsa_usage = 0;
3116 #endif
3117
3118 #ifndef DISABLE_OCSP
3119   {
3120 # ifdef SUPPORT_DANE
3121   if (  conn_args->dane
3122      && ob->hosts_request_ocsp[0] == '*'
3123      && ob->hosts_request_ocsp[1] == '\0'
3124      )
3125     {
3126     /* Unchanged from default.  Use a safer one under DANE */
3127     request_ocsp = TRUE;
3128     ob->hosts_request_ocsp = US"${if or { {= {0}{$tls_out_tlsa_usage}} "
3129                                       "   {= {4}{$tls_out_tlsa_usage}} } "
3130                                  " {*}{}}";
3131     }
3132 # endif
3133
3134   if ((require_ocsp =
3135         verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK))
3136     request_ocsp = TRUE;
3137   else
3138 # ifdef SUPPORT_DANE
3139     if (!request_ocsp)
3140 # endif
3141       request_ocsp =
3142         verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3143   }
3144 #endif
3145
3146 rc = tls_init(&exim_client_ctx->ctx, host, NULL,
3147     ob->tls_certificate, ob->tls_privatekey,
3148 #ifndef DISABLE_OCSP
3149     (void *)(long)request_ocsp,
3150 #endif
3151     cookie, &client_static_cbinfo, tlsp, errstr);
3152 if (rc != OK) return FALSE;
3153
3154 tlsp->certificate_verified = FALSE;
3155 client_verify_callback_called = FALSE;
3156
3157 expciphers = NULL;
3158 #ifdef SUPPORT_DANE
3159 if (conn_args->dane)
3160   {
3161   /* We fall back to tls_require_ciphers if unset, empty or forced failure, but
3162   other failures should be treated as problems. */
3163   if (ob->dane_require_tls_ciphers &&
3164       !expand_check(ob->dane_require_tls_ciphers, US"dane_require_tls_ciphers",
3165         &expciphers, errstr))
3166     return FALSE;
3167   if (expciphers && *expciphers == '\0')
3168     expciphers = NULL;
3169   }
3170 #endif
3171 if (!expciphers &&
3172     !expand_check(ob->tls_require_ciphers, US"tls_require_ciphers",
3173       &expciphers, errstr))
3174   return FALSE;
3175
3176 /* In OpenSSL, cipher components are separated by hyphens. In GnuTLS, they
3177 are separated by underscores. So that I can use either form in my tests, and
3178 also for general convenience, we turn underscores into hyphens here. */
3179
3180 if (expciphers)
3181   {
3182   uschar *s = expciphers;
3183   while (*s) { if (*s == '_') *s = '-'; s++; }
3184   DEBUG(D_tls) debug_printf("required ciphers: %s\n", expciphers);
3185   if (!SSL_CTX_set_cipher_list(exim_client_ctx->ctx, CS expciphers))
3186     {
3187     tls_error(US"SSL_CTX_set_cipher_list", host, NULL, errstr);
3188     return FALSE;
3189     }
3190   }
3191
3192 #ifdef SUPPORT_DANE
3193 if (conn_args->dane)
3194   {
3195   SSL_CTX_set_verify(exim_client_ctx->ctx,
3196     SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT,
3197     verify_callback_client_dane);
3198
3199   if (!DANESSL_library_init())
3200     {
3201     tls_error(US"library init", host, NULL, errstr);
3202     return FALSE;
3203     }
3204   if (DANESSL_CTX_init(exim_client_ctx->ctx) <= 0)
3205     {
3206     tls_error(US"context init", host, NULL, errstr);
3207     return FALSE;
3208     }
3209   }
3210 else
3211
3212 #endif
3213
3214   if (tls_client_basic_ctx_init(exim_client_ctx->ctx, host, ob,
3215         client_static_cbinfo, errstr) != OK)
3216     return FALSE;
3217
3218 #ifdef EXPERIMENTAL_TLS_RESUME
3219 tls_client_ctx_resume_prehandshake(exim_client_ctx, tlsp, ob, host);
3220 #endif
3221
3222
3223 if (!(exim_client_ctx->ssl = SSL_new(exim_client_ctx->ctx)))
3224   {
3225   tls_error(US"SSL_new", host, NULL, errstr);
3226   return FALSE;
3227   }
3228 SSL_set_session_id_context(exim_client_ctx->ssl, sid_ctx, Ustrlen(sid_ctx));
3229
3230 SSL_set_fd(exim_client_ctx->ssl, cctx->sock);
3231 SSL_set_connect_state(exim_client_ctx->ssl);
3232
3233 if (ob->tls_sni)
3234   {
3235   if (!expand_check(ob->tls_sni, US"tls_sni", &tlsp->sni, errstr))
3236     return FALSE;
3237   if (!tlsp->sni)
3238     {
3239     DEBUG(D_tls) debug_printf("Setting TLS SNI forced to fail, not sending\n");
3240     }
3241   else if (!Ustrlen(tlsp->sni))
3242     tlsp->sni = NULL;
3243   else
3244     {
3245 #ifdef EXIM_HAVE_OPENSSL_TLSEXT
3246     DEBUG(D_tls) debug_printf("Setting TLS SNI \"%s\"\n", tlsp->sni);
3247     SSL_set_tlsext_host_name(exim_client_ctx->ssl, tlsp->sni);
3248 #else
3249     log_write(0, LOG_MAIN, "SNI unusable with this OpenSSL library version; ignoring \"%s\"\n",
3250           tlsp->sni);
3251 #endif
3252     }
3253   }
3254
3255 #ifdef SUPPORT_DANE
3256 if (conn_args->dane)
3257   if (dane_tlsa_load(exim_client_ctx->ssl, host, &conn_args->tlsa_dnsa, errstr) != OK)
3258     return FALSE;
3259 #endif
3260
3261 #ifndef DISABLE_OCSP
3262 /* Request certificate status at connection-time.  If the server
3263 does OCSP stapling we will get the callback (set in tls_init()) */
3264 # ifdef SUPPORT_DANE
3265 if (request_ocsp)
3266   {
3267   const uschar * s;
3268   if (  ((s = ob->hosts_require_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3269      || ((s = ob->hosts_request_ocsp) && Ustrstr(s, US"tls_out_tlsa_usage"))
3270      )
3271     {   /* Re-eval now $tls_out_tlsa_usage is populated.  If
3272         this means we avoid the OCSP request, we wasted the setup
3273         cost in tls_init(). */
3274     require_ocsp = verify_check_given_host(CUSS &ob->hosts_require_ocsp, host) == OK;
3275     request_ocsp = require_ocsp
3276       || verify_check_given_host(CUSS &ob->hosts_request_ocsp, host) == OK;
3277     }
3278   }
3279 # endif
3280
3281 if (request_ocsp)
3282   {
3283   SSL_set_tlsext_status_type(exim_client_ctx->ssl, TLSEXT_STATUSTYPE_ocsp);
3284   client_static_cbinfo->u_ocsp.client.verify_required = require_ocsp;
3285   tlsp->ocsp = OCSP_NOT_RESP;
3286   }
3287 #endif
3288
3289 #ifdef EXPERIMENTAL_TLS_RESUME
3290 if (!tls_client_ssl_resume_prehandshake(exim_client_ctx->ssl, tlsp, host,
3291       errstr))
3292   return FALSE;
3293 #endif
3294
3295 #ifndef DISABLE_EVENT
3296 client_static_cbinfo->event_action = tb ? tb->event_action : NULL;
3297 #endif
3298
3299 /* There doesn't seem to be a built-in timeout on connection. */
3300
3301 DEBUG(D_tls) debug_printf("Calling SSL_connect\n");
3302 sigalrm_seen = FALSE;
3303 ALARM(ob->command_timeout);
3304 rc = SSL_connect(exim_client_ctx->ssl);
3305 ALARM_CLR(0);
3306
3307 #ifdef SUPPORT_DANE
3308 if (conn_args->dane)
3309   DANESSL_cleanup(exim_client_ctx->ssl);
3310 #endif
3311
3312 if (rc <= 0)
3313   {
3314   tls_error(US"SSL_connect", host, sigalrm_seen ? US"timed out" : NULL, errstr);
3315   return FALSE;
3316   }
3317
3318 DEBUG(D_tls)
3319   {
3320   debug_printf("SSL_connect succeeded\n");
3321 #ifdef EXIM_HAVE_OPENSSL_KEYLOG
3322   {
3323   BIO * bp = BIO_new_fp(debug_file, BIO_NOCLOSE);
3324   SSL_SESSION_print_keylog(bp, SSL_get_session(exim_client_ctx->ssl));
3325   BIO_free(bp);
3326   }
3327 #endif
3328   }
3329
3330 #ifdef EXPERIMENTAL_TLS_RESUME
3331 tls_client_resume_posthandshake(exim_client_ctx, tlsp);
3332 #endif
3333
3334 peer_cert(exim_client_ctx->ssl, tlsp, peerdn, sizeof(peerdn));
3335
3336 tlsp->cipher = construct_cipher_name(exim_client_ctx->ssl, &tlsp->bits);
3337 tlsp->cipher_stdname = cipher_stdname_ssl(exim_client_ctx->ssl);
3338
3339 /* Record the certificate we presented */
3340   {
3341   X509 * crt = SSL_get_certificate(exim_client_ctx->ssl);
3342   tlsp->ourcert = crt ? X509_dup(crt) : NULL;
3343   }
3344
3345 tlsp->active.sock = cctx->sock;
3346 tlsp->active.tls_ctx = exim_client_ctx;
3347 cctx->tls_ctx = exim_client_ctx;
3348 return TRUE;
3349 }
3350
3351
3352
3353
3354
3355 static BOOL
3356 tls_refill(unsigned lim)
3357 {
3358 int error;
3359 int inbytes;
3360
3361 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", server_ssl,
3362   ssl_xfer_buffer, ssl_xfer_buffer_size);
3363
3364 if (smtp_receive_timeout > 0) ALARM(smtp_receive_timeout);
3365 inbytes = SSL_read(server_ssl, CS ssl_xfer_buffer,
3366                   MIN(ssl_xfer_buffer_size, lim));
3367 error = SSL_get_error(server_ssl, inbytes);
3368 if (smtp_receive_timeout > 0) ALARM_CLR(0);
3369
3370 if (had_command_timeout)                /* set by signal handler */
3371   smtp_command_timeout_exit();          /* does not return */
3372 if (had_command_sigterm)
3373   smtp_command_sigterm_exit();
3374 if (had_data_timeout)
3375   smtp_data_timeout_exit();
3376 if (had_data_sigint)
3377   smtp_data_sigint_exit();
3378
3379 /* SSL_ERROR_ZERO_RETURN appears to mean that the SSL session has been
3380 closed down, not that the socket itself has been closed down. Revert to
3381 non-SSL handling. */
3382
3383 switch(error)
3384   {
3385   case SSL_ERROR_NONE:
3386     break;
3387
3388   case SSL_ERROR_ZERO_RETURN:
3389     DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3390
3391     if (SSL_get_shutdown(server_ssl) == SSL_RECEIVED_SHUTDOWN)
3392           SSL_shutdown(server_ssl);
3393
3394     tls_close(NULL, TLS_NO_SHUTDOWN);
3395     return FALSE;
3396
3397   /* Handle genuine errors */
3398   case SSL_ERROR_SSL:
3399     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3400     log_write(0, LOG_MAIN, "TLS error (SSL_read): %s", ssl_errstring);
3401     ssl_xfer_error = TRUE;
3402     return FALSE;
3403
3404   default:
3405     DEBUG(D_tls) debug_printf("Got SSL error %d\n", error);
3406     DEBUG(D_tls) if (error == SSL_ERROR_SYSCALL)
3407       debug_printf(" - syscall %s\n", strerror(errno));
3408     ssl_xfer_error = TRUE;
3409     return FALSE;
3410   }
3411
3412 #ifndef DISABLE_DKIM
3413 dkim_exim_verify_feed(ssl_xfer_buffer, inbytes);
3414 #endif
3415 ssl_xfer_buffer_hwm = inbytes;
3416 ssl_xfer_buffer_lwm = 0;
3417 return TRUE;
3418 }
3419
3420
3421 /*************************************************
3422 *            TLS version of getc                 *
3423 *************************************************/
3424
3425 /* This gets the next byte from the TLS input buffer. If the buffer is empty,
3426 it refills the buffer via the SSL reading function.
3427
3428 Arguments:  lim         Maximum amount to read/buffer
3429 Returns:    the next character or EOF
3430
3431 Only used by the server-side TLS.
3432 */
3433
3434 int
3435 tls_getc(unsigned lim)
3436 {
3437 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
3438   if (!tls_refill(lim))
3439     return ssl_xfer_error ? EOF : smtp_getc(lim);
3440
3441 /* Something in the buffer; return next uschar */
3442
3443 return ssl_xfer_buffer[ssl_xfer_buffer_lwm++];
3444 }
3445
3446 uschar *
3447 tls_getbuf(unsigned * len)
3448 {
3449 unsigned size;
3450 uschar * buf;
3451
3452 if (ssl_xfer_buffer_lwm >= ssl_xfer_buffer_hwm)
3453   if (!tls_refill(*len))
3454     {
3455     if (!ssl_xfer_error) return smtp_getbuf(len);
3456     *len = 0;
3457     return NULL;
3458     }
3459
3460 if ((size = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm) > *len)
3461   size = *len;
3462 buf = &ssl_xfer_buffer[ssl_xfer_buffer_lwm];
3463 ssl_xfer_buffer_lwm += size;
3464 *len = size;
3465 return buf;
3466 }
3467
3468
3469 void
3470 tls_get_cache()
3471 {
3472 #ifndef DISABLE_DKIM
3473 int n = ssl_xfer_buffer_hwm - ssl_xfer_buffer_lwm;
3474 if (n > 0)
3475   dkim_exim_verify_feed(ssl_xfer_buffer+ssl_xfer_buffer_lwm, n);
3476 #endif
3477 }
3478
3479
3480 BOOL
3481 tls_could_read(void)
3482 {
3483 return ssl_xfer_buffer_lwm < ssl_xfer_buffer_hwm || SSL_pending(server_ssl) > 0;
3484 }
3485
3486
3487 /*************************************************
3488 *          Read bytes from TLS channel           *
3489 *************************************************/
3490
3491 /*
3492 Arguments:
3493   ct_ctx    client context pointer, or NULL for the one global server context
3494   buff      buffer of data
3495   len       size of buffer
3496
3497 Returns:    the number of bytes read
3498             -1 after a failed read, including EOF
3499
3500 Only used by the client-side TLS.
3501 */
3502
3503 int
3504 tls_read(void * ct_ctx, uschar *buff, size_t len)
3505 {
3506 SSL * ssl = ct_ctx ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
3507 int inbytes;
3508 int error;
3509
3510 DEBUG(D_tls) debug_printf("Calling SSL_read(%p, %p, %u)\n", ssl,
3511   buff, (unsigned int)len);
3512
3513 inbytes = SSL_read(ssl, CS buff, len);
3514 error = SSL_get_error(ssl, inbytes);
3515
3516 if (error == SSL_ERROR_ZERO_RETURN)
3517   {
3518   DEBUG(D_tls) debug_printf("Got SSL_ERROR_ZERO_RETURN\n");
3519   return -1;
3520   }
3521 else if (error != SSL_ERROR_NONE)
3522   return -1;
3523
3524 return inbytes;
3525 }
3526
3527
3528
3529
3530
3531 /*************************************************
3532 *         Write bytes down TLS channel           *
3533 *************************************************/
3534
3535 /*
3536 Arguments:
3537   ct_ctx    client context pointer, or NULL for the one global server context
3538   buff      buffer of data
3539   len       number of bytes
3540   more      further data expected soon
3541
3542 Returns:    the number of bytes after a successful write,
3543             -1 after a failed write
3544
3545 Used by both server-side and client-side TLS.
3546 */
3547
3548 int
3549 tls_write(void * ct_ctx, const uschar *buff, size_t len, BOOL more)
3550 {
3551 size_t olen = len;
3552 int outbytes, error;
3553 SSL * ssl = ct_ctx
3554   ? ((exim_openssl_client_tls_ctx *)ct_ctx)->ssl : server_ssl;
3555 static gstring * server_corked = NULL;
3556 gstring ** corkedp = ct_ctx
3557   ? &((exim_openssl_client_tls_ctx *)ct_ctx)->corked : &server_corked;
3558 gstring * corked = *corkedp;
3559
3560 DEBUG(D_tls) debug_printf("%s(%p, %lu%s)\n", __FUNCTION__,
3561   buff, (unsigned long)len, more ? ", more" : "");
3562
3563 /* Lacking a CORK or MSG_MORE facility (such as GnuTLS has) we copy data when
3564 "more" is notified.  This hack is only ok if small amounts are involved AND only
3565 one stream does it, in one context (i.e. no store reset).  Currently it is used
3566 for the responses to the received SMTP MAIL , RCPT, DATA sequence, only.
3567 We support callouts done by the server process by using a separate client
3568 context for the stashed information. */
3569 /* + if PIPE_COMMAND, banner & ehlo-resp for smmtp-on-connect. Suspect there's
3570 a store reset there, so use POOL_PERM. */
3571 /* + if CHUNKING, cmds EHLO,MAIL,RCPT(s),BDAT */
3572
3573 if ((more || corked))
3574   {
3575 #ifdef SUPPORT_PIPE_CONNECT
3576   int save_pool = store_pool;
3577   store_pool = POOL_PERM;
3578 #endif
3579
3580   corked = string_catn(corked, buff, len);
3581
3582 #ifdef SUPPORT_PIPE_CONNECT
3583   store_pool = save_pool;
3584 #endif
3585
3586   if (more)
3587     {
3588     *corkedp = corked;
3589     return len;
3590     }
3591   buff = CUS corked->s;
3592   len = corked->ptr;
3593   *corkedp = NULL;
3594   }
3595
3596 for (int left = len; left > 0;)
3597   {
3598   DEBUG(D_tls) debug_printf("SSL_write(%p, %p, %d)\n", ssl, buff, left);
3599   outbytes = SSL_write(ssl, CS buff, left);
3600   error = SSL_get_error(ssl, outbytes);
3601   DEBUG(D_tls) debug_printf("outbytes=%d error=%d\n", outbytes, error);
3602   switch (error)
3603     {
3604     case SSL_ERROR_SSL:
3605       ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3606       log_write(0, LOG_MAIN, "TLS error (SSL_write): %s", ssl_errstring);
3607       return -1;
3608
3609     case SSL_ERROR_NONE:
3610       left -= outbytes;
3611       buff += outbytes;
3612       break;
3613
3614     case SSL_ERROR_ZERO_RETURN:
3615       log_write(0, LOG_MAIN, "SSL channel closed on write");
3616       return -1;
3617
3618     case SSL_ERROR_SYSCALL:
3619       log_write(0, LOG_MAIN, "SSL_write: (from %s) syscall: %s",
3620         sender_fullhost ? sender_fullhost : US"<unknown>",
3621         strerror(errno));
3622       return -1;
3623
3624     default:
3625       log_write(0, LOG_MAIN, "SSL_write error %d", error);
3626       return -1;
3627     }
3628   }
3629 return olen;
3630 }
3631
3632
3633
3634 /*************************************************
3635 *         Close down a TLS session               *
3636 *************************************************/
3637
3638 /* This is also called from within a delivery subprocess forked from the
3639 daemon, to shut down the TLS library, without actually doing a shutdown (which
3640 would tamper with the SSL session in the parent process).
3641
3642 Arguments:
3643   ct_ctx        client TLS context pointer, or NULL for the one global server context
3644   shutdown      1 if TLS close-alert is to be sent,
3645                 2 if also response to be waited for
3646
3647 Returns:     nothing
3648
3649 Used by both server-side and client-side TLS.
3650 */
3651
3652 void
3653 tls_close(void * ct_ctx, int shutdown)
3654 {
3655 exim_openssl_client_tls_ctx * o_ctx = ct_ctx;
3656 SSL_CTX **ctxp = o_ctx ? &o_ctx->ctx : &server_ctx;
3657 SSL **sslp =     o_ctx ? &o_ctx->ssl : &server_ssl;
3658 int *fdp = o_ctx ? &tls_out.active.sock : &tls_in.active.sock;
3659
3660 if (*fdp < 0) return;  /* TLS was not active */
3661
3662 if (shutdown)
3663   {
3664   int rc;
3665   DEBUG(D_tls) debug_printf("tls_close(): shutting down TLS%s\n",
3666     shutdown > 1 ? " (with response-wait)" : "");
3667
3668   if (  (rc = SSL_shutdown(*sslp)) == 0 /* send "close notify" alert */
3669      && shutdown > 1)
3670     {
3671     ALARM(2);
3672     rc = SSL_shutdown(*sslp);           /* wait for response */
3673     ALARM_CLR(0);
3674     }
3675
3676   if (rc < 0) DEBUG(D_tls)
3677     {
3678     ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3679     debug_printf("SSL_shutdown: %s\n", ssl_errstring);
3680     }
3681   }
3682
3683 if (!o_ctx)             /* server side */
3684   {
3685 #ifndef DISABLE_OCSP
3686   sk_X509_pop_free(server_static_cbinfo->verify_stack, X509_free);
3687   server_static_cbinfo->verify_stack = NULL;
3688 #endif
3689
3690   receive_getc =        smtp_getc;
3691   receive_getbuf =      smtp_getbuf;
3692   receive_get_cache =   smtp_get_cache;
3693   receive_ungetc =      smtp_ungetc;
3694   receive_feof =        smtp_feof;
3695   receive_ferror =      smtp_ferror;
3696   receive_smtp_buffered = smtp_buffered;
3697   tls_in.active.tls_ctx = NULL;
3698   tls_in.sni = NULL;
3699   /* Leave bits, peercert, cipher, peerdn, certificate_verified set, for logging */
3700   }
3701
3702 SSL_CTX_free(*ctxp);
3703 SSL_free(*sslp);
3704 *ctxp = NULL;
3705 *sslp = NULL;
3706 *fdp = -1;
3707 }
3708
3709
3710
3711
3712 /*************************************************
3713 *  Let tls_require_ciphers be checked at startup *
3714 *************************************************/
3715
3716 /* The tls_require_ciphers option, if set, must be something which the
3717 library can parse.
3718
3719 Returns:     NULL on success, or error message
3720 */
3721
3722 uschar *
3723 tls_validate_require_cipher(void)
3724 {
3725 SSL_CTX *ctx;
3726 uschar *s, *expciphers, *err;
3727
3728 tls_openssl_init();
3729
3730 if (!(tls_require_ciphers && *tls_require_ciphers))
3731   return NULL;
3732
3733 if (!expand_check(tls_require_ciphers, US"tls_require_ciphers", &expciphers,
3734                   &err))
3735   return US"failed to expand tls_require_ciphers";
3736
3737 if (!(expciphers && *expciphers))
3738   return NULL;
3739
3740 /* normalisation ripped from above */
3741 s = expciphers;
3742 while (*s != 0) { if (*s == '_') *s = '-'; s++; }
3743
3744 err = NULL;
3745
3746 #ifdef EXIM_HAVE_OPENSSL_TLS_METHOD
3747 if (!(ctx = SSL_CTX_new(TLS_server_method())))
3748 #else
3749 if (!(ctx = SSL_CTX_new(SSLv23_server_method())))
3750 #endif
3751   {
3752   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3753   return string_sprintf("SSL_CTX_new() failed: %s", ssl_errstring);
3754   }
3755
3756 DEBUG(D_tls)
3757   debug_printf("tls_require_ciphers expands to \"%s\"\n", expciphers);
3758
3759 if (!SSL_CTX_set_cipher_list(ctx, CS expciphers))
3760   {
3761   ERR_error_string_n(ERR_get_error(), ssl_errstring, sizeof(ssl_errstring));
3762   err = string_sprintf("SSL_CTX_set_cipher_list(%s) failed: %s",
3763                       expciphers, ssl_errstring);
3764   }
3765
3766 SSL_CTX_free(ctx);
3767
3768 return err;
3769 }
3770
3771
3772
3773
3774 /*************************************************
3775 *         Report the library versions.           *
3776 *************************************************/
3777
3778 /* There have historically been some issues with binary compatibility in
3779 OpenSSL libraries; if Exim (like many other applications) is built against
3780 one version of OpenSSL but the run-time linker picks up another version,
3781 it can result in serious failures, including crashing with a SIGSEGV.  So
3782 report the version found by the compiler and the run-time version.
3783
3784 Note: some OS vendors backport security fixes without changing the version
3785 number/string, and the version date remains unchanged.  The _build_ date
3786 will change, so we can more usefully assist with version diagnosis by also
3787 reporting the build date.
3788
3789 Arguments:   a FILE* to print the results to
3790 Returns:     nothing
3791 */
3792
3793 void
3794 tls_version_report(FILE *f)
3795 {
3796 fprintf(f, "Library version: OpenSSL: Compile: %s\n"
3797            "                          Runtime: %s\n"
3798            "                                 : %s\n",
3799            OPENSSL_VERSION_TEXT,
3800            SSLeay_version(SSLEAY_VERSION),
3801            SSLeay_version(SSLEAY_BUILT_ON));
3802 /* third line is 38 characters for the %s and the line is 73 chars long;
3803 the OpenSSL output includes a "built on: " prefix already. */
3804 }
3805
3806
3807
3808
3809 /*************************************************
3810 *            Random number generation            *
3811 *************************************************/
3812
3813 /* Pseudo-random number generation.  The result is not expected to be
3814 cryptographically strong but not so weak that someone will shoot themselves
3815 in the foot using it as a nonce in input in some email header scheme or
3816 whatever weirdness they'll twist this into.  The result should handle fork()
3817 and avoid repeating sequences.  OpenSSL handles that for us.
3818
3819 Arguments:
3820   max       range maximum
3821 Returns     a random number in range [0, max-1]
3822 */
3823
3824 int
3825 vaguely_random_number(int max)
3826 {
3827 unsigned int r;
3828 int i, needed_len;
3829 static pid_t pidlast = 0;
3830 pid_t pidnow;
3831 uschar smallbuf[sizeof(r)];
3832
3833 if (max <= 1)
3834   return 0;
3835
3836 pidnow = getpid();
3837 if (pidnow != pidlast)
3838   {
3839   /* Although OpenSSL documents that "OpenSSL makes sure that the PRNG state
3840   is unique for each thread", this doesn't apparently apply across processes,
3841   so our own warning from vaguely_random_number_fallback() applies here too.
3842   Fix per PostgreSQL. */
3843   if (pidlast != 0)
3844     RAND_cleanup();
3845   pidlast = pidnow;
3846   }
3847
3848 /* OpenSSL auto-seeds from /dev/random, etc, but this a double-check. */
3849 if (!RAND_status())
3850   {
3851   randstuff r;
3852   gettimeofday(&r.tv, NULL);
3853   r.p = getpid();
3854
3855   RAND_seed(US (&r), sizeof(r));
3856   }
3857 /* We're after pseudo-random, not random; if we still don't have enough data
3858 in the internal PRNG then our options are limited.  We could sleep and hope
3859 for entropy to come along (prayer technique) but if the system is so depleted
3860 in the first place then something is likely to just keep taking it.  Instead,
3861 we'll just take whatever little bit of pseudo-random we can still manage to
3862 get. */
3863
3864 needed_len = sizeof(r);
3865 /* Don't take 8 times more entropy than needed if int is 8 octets and we were
3866 asked for a number less than 10. */
3867 for (r = max, i = 0; r; ++i)
3868   r >>= 1;
3869 i = (i + 7) / 8;
3870 if (i < needed_len)
3871   needed_len = i;
3872
3873 #ifdef EXIM_HAVE_RAND_PSEUDO
3874 /* We do not care if crypto-strong */
3875 i = RAND_pseudo_bytes(smallbuf, needed_len);
3876 #else
3877 i = RAND_bytes(smallbuf, needed_len);
3878 #endif
3879
3880 if (i < 0)
3881   {
3882   DEBUG(D_all)
3883     debug_printf("OpenSSL RAND_pseudo_bytes() not supported by RAND method, using fallback.\n");
3884   return vaguely_random_number_fallback(max);
3885   }
3886
3887 r = 0;
3888 for (uschar * p = smallbuf; needed_len; --needed_len, ++p)
3889   r = 256 * r + *p;
3890
3891 /* We don't particularly care about weighted results; if someone wants
3892 smooth distribution and cares enough then they should submit a patch then. */
3893 return r % max;
3894 }
3895
3896
3897
3898
3899 /*************************************************
3900 *        OpenSSL option parse                    *
3901 *************************************************/
3902
3903 /* Parse one option for tls_openssl_options_parse below
3904
3905 Arguments:
3906   name    one option name
3907   value   place to store a value for it
3908 Returns   success or failure in parsing
3909 */
3910
3911
3912
3913 static BOOL
3914 tls_openssl_one_option_parse(uschar *name, long *value)
3915 {
3916 int first = 0;
3917 int last = exim_openssl_options_size;
3918 while (last > first)
3919   {
3920   int middle = (first + last)/2;
3921   int c = Ustrcmp(name, exim_openssl_options[middle].name);
3922   if (c == 0)
3923     {
3924     *value = exim_openssl_options[middle].value;
3925     return TRUE;
3926     }
3927   else if (c > 0)
3928     first = middle + 1;
3929   else
3930     last = middle;
3931   }
3932 return FALSE;
3933 }
3934
3935
3936
3937
3938 /*************************************************
3939 *        OpenSSL option parsing logic            *
3940 *************************************************/
3941
3942 /* OpenSSL has a number of compatibility options which an administrator might
3943 reasonably wish to set.  Interpret a list similarly to decode_bits(), so that
3944 we look like log_selector.
3945
3946 Arguments:
3947   option_spec  the administrator-supplied string of options
3948   results      ptr to long storage for the options bitmap
3949 Returns        success or failure
3950 */
3951
3952 BOOL
3953 tls_openssl_options_parse(uschar *option_spec, long *results)
3954 {
3955 long result, item;
3956 uschar * exp, * end;
3957 uschar keep_c;
3958 BOOL adding, item_parsed;
3959
3960 /* Server: send no (<= TLS1.2) session tickets */
3961 result = SSL_OP_NO_TICKET;
3962
3963 /* Prior to 4.80 we or'd in SSL_OP_DONT_INSERT_EMPTY_FRAGMENTS; removed
3964 from default because it increases BEAST susceptibility. */
3965 #ifdef SSL_OP_NO_SSLv2
3966 result |= SSL_OP_NO_SSLv2;
3967 #endif
3968 #ifdef SSL_OP_NO_SSLv3
3969 result |= SSL_OP_NO_SSLv3;
3970 #endif
3971 #ifdef SSL_OP_SINGLE_DH_USE
3972 result |= SSL_OP_SINGLE_DH_USE;
3973 #endif
3974
3975 if (!option_spec)
3976   {
3977   *results = result;
3978   return TRUE;
3979   }
3980
3981 if (!expand_check(option_spec, US"openssl_options", &exp, &end))
3982   return FALSE;
3983
3984 for (uschar * s = exp; *s; /**/)
3985   {
3986   while (isspace(*s)) ++s;
3987   if (*s == '\0')
3988     break;
3989   if (*s != '+' && *s != '-')
3990     {
3991     DEBUG(D_tls) debug_printf("malformed openssl option setting: "
3992         "+ or - expected but found \"%s\"\n", s);
3993     return FALSE;
3994     }
3995   adding = *s++ == '+';
3996   for (end = s; (*end != '\0') && !isspace(*end); ++end) /**/ ;
3997   keep_c = *end;
3998   *end = '\0';
3999   item_parsed = tls_openssl_one_option_parse(s, &item);
4000   *end = keep_c;
4001   if (!item_parsed)
4002     {
4003     DEBUG(D_tls) debug_printf("openssl option setting unrecognised: \"%s\"\n", s);
4004     return FALSE;
4005     }
4006   DEBUG(D_tls) debug_printf("openssl option, %s %8lx: %lx (%s)\n",
4007       adding ? "adding to    " : "removing from", result, item, s);
4008   if (adding)
4009     result |= item;
4010   else
4011     result &= ~item;
4012   s = end;
4013   }
4014
4015 *results = result;
4016 return TRUE;
4017 }
4018
4019 #endif  /*!MACRO_PREDEF*/
4020 /* vi: aw ai sw=2
4021 */
4022 /* End of tls-openssl.c */