src/src/tls-openssl.c

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