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