src/src/tls-openssl.c

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